archived stringclasses 2
values | author stringlengths 3 20 | author_fullname stringlengths 4 12 ⌀ | body stringlengths 0 22.5k | comment_type stringclasses 1
value | controversiality stringclasses 2
values | created_utc stringlengths 10 10 | edited stringlengths 4 12 | gilded stringclasses 7
values | id stringlengths 1 7 | link_id stringlengths 7 10 | locked stringclasses 2
values | name stringlengths 4 10 ⌀ | parent_id stringlengths 5 10 | permalink stringlengths 41 91 ⌀ | retrieved_on stringlengths 10 10 ⌀ | score stringlengths 1 4 | subreddit_id stringclasses 1
value | subreddit_name_prefixed stringclasses 1
value | subreddit_type stringclasses 1
value | total_awards_received stringclasses 19
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
True | rockum | null | Microsoft is making good money from android: http://venturebeat.com/2011/05/27/microsoft-android-revenue/
| null | 0 | 1316932415 | False | 0 | c2mep5w | t3_ko2wv | null | t1_c2mep5w | t1_c2lym5h | null | 1427643956 | 1 | t5_2fwo | null | null | null |
True | perrygeo | null | And most bugs tend to be fairly complex and are likely only caught by extensive integration tests.
Unit tests only test that your code can handle the edge cases that you've anticipated beforehand... and if you've already anticipated them, you've coded defensively against them. | null | 0 | 1316932612 | False | 0 | c2mepp3 | t3_kq001 | null | t1_c2mepp3 | t1_c2mal7f | null | 1427643963 | 1 | t5_2fwo | null | null | null |
True | adrianmonk | null | There are a bunch of ways to accomplish that. For example, check for it in code reviews. Or require tests in a commit hook in your source repo. Or fail builds on your continuous integration server if coverage is too low or if there are classes with zero tests. Or define a release process that says any software that gets changed needs to get re-tested, and that if the QA department has to do it manually that gets charged to the project. | null | 0 | 1316932685 | False | 0 | c2mepwn | t3_kq001 | null | t1_c2mepwn | t1_c2ma2w5 | null | 1427643967 | 1 | t5_2fwo | null | null | null |
True | keithb | null | So, it depends on what you want, but the first published discussion of TDD that I saw was on the C2 wiki in the mid 90's and it wasn't a _de novo_ invention then. 20 years is not a stretch. | null | 0 | 1316932821 | False | 0 | c2meq9f | t3_kq001 | null | t1_c2meq9f | t1_c2mcm2k | null | 1427643971 | 2 | t5_2fwo | null | null | null |
True | fremandn | null | I have the opposite problem. I can't read anything I want to read on an e-ink display as I can't pan and zoom quickly enough. I hope they can get e-ink refresh rates to be in the 10s of hz range soon. | null | 0 | 1316933182 | False | 0 | c2mer6h | t3_kqixo | null | t1_c2mer6h | t1_c2me74l | null | 1427643982 | 2 | t5_2fwo | null | null | null |
True | mycall | null | > Giant Global Graph
3G is already taken. | null | 0 | 1316933262 | False | 0 | c2mereg | t3_koj7a | null | t1_c2mereg | t3_koj7a | null | 1427643985 | 1 | t5_2fwo | null | null | null |
True | buckynutz | null | thanks for asking, i was wondering the same thing! | null | 0 | 1316933478 | False | 0 | c2mery2 | t3_kqixo | null | t1_c2mery2 | t1_c2meb2w | null | 1427643992 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | ok, well... that is a fair objection, and with 64 bits ints, it is even a reasonable compromise. But with 32 bit ints, it's quite shortsighted..
| null | 0 | 1316933479 | False | 0 | c2mery4 | t3_kq27q | null | t1_c2mery4 | t1_c2mbvcb | null | 1427643992 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | A hundred and fifty mil? Wow, that's almost enough for a rounding error in a Microsoft, Google or Apple quarterly revenue report. | null | 0 | 1316933601 | False | 0 | c2mes8p | t3_ko2wv | null | t1_c2mes8p | t1_c2mep5w | null | 1427643997 | 1 | t5_2fwo | null | null | null |
True | ealf | null | I heard someone (HP maybe?) was selling some sort of system for depositing pigment onto a cheap, flexible substrate. The device itself is a bit bulky, but the substrate (being entirely passive) is so cheap that you can use it in WO/RM mode: you pre-render the screen contents at various positions in the file, and then you leave the device behind and *bring the passive substrate*. The interactivity is even more limited than on a Kindle, but the contrast is a little better. | null | 0 | 1316933842 | False | 0 | c2mesun | t3_kqixo | null | t1_c2mesun | t1_c2me74l | null | 1427644006 | 73 | t5_2fwo | null | null | null |
True | coriolis1987 | null | > well thought out tests can save you a ton of time and get you better code
No, well thought out tests can save YOU a ton of time and get YOU better code. I don't know you, but TDD-bigotry is usually a tell-tale sign of bigots who are new to two important software engineering methods:
* thinking -- not only well thought out tests save time, understanding the actual problem saves time; for TDD bigots, TDD *introduced* them to analyzing the task at hand before coding
* automatic regression tests -- tests are your friend, and diligent programmers have practiced automatic testing since the first hackers chipped 0s and 1s from flints; whether you write your tests before, during or after the actual production code does not matter. What DOES matter is that tests are there, eventually, in order to demonstrate that the code actually works.
Don't get me wrong. I'm not saying that you or TDD sucks, I'm saying that bigotry is wrong. Every programmer (like every chef, every tennis coach, every costume designer, etc.) has his or her own tried and trusted methods. I tinker with problems on paper, keep notes while coding, give little lectures about my darlings and doubts while showering and refactor when stuck -- all that works. However, it would be nonsensical to declare those techniques an industry standard or demand it from all co-workers.
* "You don't give lectures about your program under the shower? What kind of software engineer are you?"
* "You use 2B pencils instead of 3Bs for drawing tables and class hierarchies at the *Café Drechsler*? No wonder your code is incomprehensible and does not work."
* "What's that? You don't smoke up for writing documentation? I'm glad that you are not my co-worker!"
Etc.
TDD is better than no thinking and better than no tests, but noone should demand TDD from other programmers if they are productive, creative and insightful with other methods and ship automatic tests with their code.
As for "simple CRUD actions": no logic is too simple for automatic tests -- unit tests, for example.
| null | 0 | 1316934106 | False | 0 | c2metiw | t3_kq001 | null | t1_c2metiw | t1_c2m9mji | null | 1427644015 | 3 | t5_2fwo | null | null | null |
True | remain_calm | null | I don't disagree with this, but I would like to point out that writing tests that describe expected behavior, knowing that you have no idea how to generate expected behavior is a great way of developing your understanding of a system.
Many (most?) engineering jobs involve working with systems that you have not built. Naturally your understanding is week. I would describe tests in such a common scenario not as crutches, but as stones, cobbled one by one to build the path of understanding.
| null | 0 | 1316934122 | False | 0 | c2metk8 | t3_kq001 | null | t1_c2metk8 | t1_c2mb1cj | null | 1427644015 | 2 | t5_2fwo | null | null | null |
True | adrianmonk | null | One of the big sources of reliability problems is in interfacing with external reality. Whether that's library code or servers or customer/partner systems I don't have access to, it often seems that the potential for failure is in not being able to know for sure how external things will behave.
Sort of related is that when writing glue code, I don't see unit tests as that useful. Unit tests are all about testing pieces of code in isolation, but glue code doesn't *do anything* in isolation. Its only purpose is to do things in combination with other things.
Partly it depends on what kind of software you're writing. If you're writing a compression program or a database, then you control everything, and you can write tests to test just about everything. If you're writing some software to generate a data file in a particular format that will get sent via FTP to someone who will then load it into some system you'll never touch... | null | 0 | 1316934211 | False | 0 | c2mett9 | t3_kq001 | null | t1_c2mett9 | t1_c2m9sun | null | 1427644023 | 1 | t5_2fwo | null | null | null |
True | kubalaa | null | Wouldn't a "fix" for HTTP pipelining look more or less like SPDY? | null | 0 | 1316935002 | False | 0 | c2mevs3 | t3_kp1b5 | null | t1_c2mevs3 | t1_c2mafmb | null | 1427644044 | 1 | t5_2fwo | null | null | null |
True | HeadphoneWarrior | null | I think the cost of the manufacture of this outmoded *product* would be prohibitive in the long run, not to mention the initial startup and continuing maintenance costs being significantly higher than the purchase of a kindle.
Add to that the heft of the end product, and the fact that each time you receive a new .mobi archive, this process must be repeated requiring a not-insignificant quantum of time, and again, adding more weight to your carrying cases (versus negligible and none at all, respectively for the kindle), I believe that the kindle does slightly edge it.
For the record, I hate the environment too, and I can't wait to grind out all the trees for substrate. No point in letting them gather numbers to attack. | null | 0 | 1316935474 | False | 0 | c2mewxc | t3_kqixo | null | t1_c2mewxc | t1_c2mesun | null | 1427644059 | 13 | t5_2fwo | null | null | null |
True | axnjackson11 | null | So I'm not all that tech smart, so what does this do? | null | 0 | 1316935854 | False | 0 | c2mexug | t3_kqixo | null | t1_c2mexug | t3_kqixo | null | 1427644071 | 3 | t5_2fwo | null | null | null |
True | vvv | null | > TODO: read the damn book!
I like it. | null | 0 | 1316936077 | False | 0 | c2meyde | t3_kqixo | null | t1_c2meyde | t3_kqixo | null | 1427644079 | 7 | t5_2fwo | null | null | null |
True | zaph0d | null | That reader macro is #=. It exists, but it's not documented (perhaps intentionally). | null | 0 | 1316936088 | False | 0 | c2meyel | t3_kpk8d | null | t1_c2meyel | t1_c2m8sqc | null | 1427644079 | 4 | t5_2fwo | null | null | null |
True | jtxx000 | null | Yours is certainly a pragmatic approach, but I suspect that whoever wrote that quote would agree with Leslie Lamport's paper [The Future of Computing: Logic or Biology](http://research.microsoft.com/en-us/um/people/lamport/pubs/future-of-computing.pdf) [pdf]. In theory, I agree with Lamport -- the hack-and-test approach is a fundamentally bad way to write software. Sadly, with many codebases in the wild, it's often the most cost-effective way to go. | null | 0 | 1316936464 | False | 0 | c2mez8s | t3_kq001 | null | t1_c2mez8s | t1_c2metk8 | null | 1427644089 | 1 | t5_2fwo | null | null | null |
True | gonemad16 | null | do people actually use D for real development? | null | 0 | 1316936671 | False | 0 | c2mezoe | t3_kqoz2 | null | t1_c2mezoe | t3_kqoz2 | null | 1427644096 | 12 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | There is a number of compelling uses, I dumped Scheme for it:
* Immutable datastructures, omg, have I wanted these in Scheme
* datastructures in the first place. the list can only go this far, I wanted dictionaries with O(1) access time, kthx
* solid support for functional programming. My Clojure code is much more functional then Scheme before because I don't have to deal with stupid cons-lists.
* extensive ecosystem. I want a library, I get it. Unlike Scheme where it is "ohh, yeah, this library works, but only with a version of Scheme48 from '95"
* Less cluttered parentheses. While I am not too thrilled about `[` `]` (but R6RS has them too and there they are quite useless) and `{` `}` I like that `let` does not need a crapload of `(` `)` just because it likes to nest everything everywhere.
That said, I disliked Clojure before I gave it a go and it blew me away completely. | null | 0 | 1316936801 | False | 0 | c2mezya | t3_kpk8d | null | t1_c2mezya | t1_c2m9ok5 | null | 1427644099 | 8 | t5_2fwo | null | null | null |
True | Peaker | null | I once created a small PyDict modification that allowed "exporting" a dict item such that updates to that key will update the exported item, and the exported item can be accessed either normally by dict and key, or by O(1) dereferencing the exported-item ptr...
It had no noticeable performance change in ordinary code (at worst 1-2% slower) and 50% faster globals/__builtins__ access which sped some code up by close to that). It was pretty much ignored on the pydev-list, though, so it is weird to me they suddenly take interest in optimizing globals/builtins access of 3 particular consts. | null | 0 | 1316937178 | False | 0 | c2mf0ri | t3_kos4z | null | t1_c2mf0ri | t1_c2mcfae | null | 1427644109 | 1 | t5_2fwo | null | null | null |
True | ealf | null | I agree, it is not perfect. Producing the raw materials for the substrate is responsible for the release of massive amounts of oxidizing agent into the atmosphere. | null | 0 | 1316937189 | False | 0 | c2mf0si | t3_kqixo | null | t1_c2mf0si | t1_c2mewxc | null | 1427644109 | 7 | t5_2fwo | null | null | null |
True | WotIsAUserName | null | It depends on the coder - some will write rubbish tests and it doesn't matter whether done first or last as both the code and tests are poor. Others will add tests/change implementation as they see limitations during coding | null | 0 | 1316937238 | False | 0 | c2mf0w3 | t3_kq001 | null | t1_c2mf0w3 | t1_c2mbdhr | null | 1427644117 | 1 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | It's less about one big data structure taking up so much space, it is about 140k connections, where each one has to hold at least some state. As flexd comculated it is 240 kilobyte per connection where I would argue that this is not much at all. | null | 0 | 1316937292 | False | 0 | c2mf0zu | t3_kq27q | null | t1_c2mf0zu | t1_c2ma0km | null | 1427644113 | 2 | t5_2fwo | null | null | null |
True | urmyheartBeatStopR | null | They won't listen to you. They need to be backward compatible for legacy systems, so they can have guarantee money/revenue all the time. All their patches for their db are like 1.5gb+. | null | 0 | 1316937670 | False | 0 | c2mf1rv | t3_kq27q | null | t1_c2mf1rv | t1_c2mc1zb | null | 1427644123 | 0 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | > These are people refusing to accept that their tool may not be what's best for the job, demanding that the priority be raised upstream
While I see your point, in this case I feel it is well justified. 1 GB today is well, a joke. I have 4 GB in my 6 year old laptop, 8 in my current laptop, and don't talk about servers.
Imagine the uploar if if only supported 10 MB. Would you file a bug on this case? Or 1 MB, noone would ever use it. For some applications, the 32 Bit address space is already too small and servers (like the ones Node.js runs on) often have huge amounts of RAM.
After all, Node.js is a server app. If it was a learning tool, intended to teaching 8-year olds programming, I'd totally agree, not the right tool. But it might be actually a good tool if you want a lot of highly concurrent connections, that was even the point of Node.
Oh, I'll create a startup where we use Hypercard and PShttpd to serve thousands of connections :) | null | 0 | 1316937735 | False | 0 | c2mf1wj | t3_kq27q | null | t1_c2mf1wj | t1_c2mb2a1 | null | 1427644124 | 3 | t5_2fwo | null | null | null |
True | CuriouslyStrongTeeth | null | [Refinements](http://yehudakatz.com/2010/11/30/ruby-2-0-refinements-in-practice/) is what they are called. They are a possibility for Ruby 2.0, and look very nice. | null | 0 | 1316937885 | False | 0 | c2mf28f | t3_kq27q | null | t1_c2mf28f | t1_c2mdkz1 | null | 1428192944 | 2 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | Yeah, at that point you can also use JavaScript libraries. The point was about the language. Everyone can write libraries.
(And I like JS, C and especially Vala). | null | 0 | 1316937913 | False | 0 | c2mf2as | t3_kq27q | null | t1_c2mf2as | t1_c2mcq69 | null | 1427644140 | 1 | t5_2fwo | null | null | null |
True | checksinthemail | null | I was procrastinating from programming and wanted to laugh; watched 3 minutes of the video and didn't laugh.
For that schtick but funnier, try http://twitter.com/#!/BroDotJS
**ObProgramming:**
if (x !== x) {
console.log('wrong universe');
}
| null | 0 | 1316937926 | False | 0 | c2mf2bv | t3_kptyd | null | t1_c2mf2bv | t1_c2m7g95 | null | 1427644140 | -1 | t5_2fwo | null | null | null |
True | urmyheartBeatStopR | null | Whatever, Oracle went douchey, kill support options and made it more expensive. I've moved to PostgreSQL. PostgreSQL is much better and powerful than MySQL. Just go PostgreSQL, there's rollup with cubic, intersect, and except which last time I check MySQL doesn't support. | null | 0 | 1316938038 | False | 0 | c2mf2k9 | t3_kpecl | null | t1_c2mf2k9 | t3_kpecl | null | 1427644135 | 1 | t5_2fwo | null | null | null |
True | urmyheartBeatStopR | null | Legacy system. We got an old system that's using Oracle. We can't actually afford to transfer the SQL to another db because some of those are coded in god damn Oracle's Forms and Reports. I wish that shit burn in hell.
It's a bloated piece of shit with patches that are 1.5 gb. | null | 0 | 1316938287 | False | 0 | c2mf31l | t3_ko20r | null | t1_c2mf31l | t1_c2lv155 | null | 1427644149 | 1 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | > No real/high performance collection classes.
Like most languages. Exceptions include Scala, Clojure and Erlang. What gets used in High Performance Computing? Fortran and C. And C does not have high performance classes, just a bunch of libraries that are so awkward and ugly, you have to be quite resistant to pain.
> No real namespacing.
You can use dictionaries/objects/maps for that at which point you get a module system that feels similar to Python.
> No module system.
CommonJS specifies modules. And even non-conformant implementations provide a way to `require` code. What comes out looks similar to Python: `import lxml` vs `xml2js = require('xml2js')`.
> Goofy assignment/comparison rules that can produce subtle bugs.
Yeah, I'm not fond of it either. I use CoffeeScript mostly which uses the strict comparison operators which makes it better, though sometimes the weak typing still bites your ass.
> No library format.
What do you mean by that?
> No way to precompile and manage artifacts.
Well, most "dynamic" languages don't have ways to precompile stuff. No, I don't accept `.pyc` files as answer. | null | 0 | 1316938386 | False | 0 | c2mf38s | t3_kq27q | null | t1_c2mf38s | t1_c2m9k9d | null | 1427644144 | -1 | t5_2fwo | null | null | null |
True | piderman | null | I must say that with the sepia colouring and low brightness reading on an iPad-kindle is very comfortable. Of course I can't upload .mobi files to the device but that's another discussion :p | null | 0 | 1316938853 | False | 0 | c2mf44c | t3_kqixo | null | t1_c2mf44c | t1_c2me74l | null | 1427644159 | 2 | t5_2fwo | null | null | null |
True | bobindashadows | null | Node is a downstream project that picked the V8 VM to power it because it was a powerful browser VM. The people complaining aren't even the node.js developers, but people who use Node as a platform. Sad that the platform they picked (node.js) is run by a browser VM, and unwilling to admit this, they bitch 2 levels upstream about how the browser VM isn't accommodating their servers.
While the Chromium team has gone to great lengths to accomodate the Node crowd, they're under no obligation to do so. That's why the commenters' indignation and entitlement is so ridiculous. They picked a platform powered by a browser VM - in fact that's a huge selling point of node.js - and now they're flipping out because said platform has limitations imposed by the design of a browser VM. | null | 0 | 1316938856 | False | 0 | c2mf44f | t3_kq27q | null | t1_c2mf44f | t1_c2mf1wj | null | 1427644159 | 13 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | Ok, in a browser like Chrome where you have multiple processes this might be less of a problem, but I can see that in the future even a browser V8 might need more then 1 GB. After all, artificial limitations is something we try to avoid, right?
And I don't really care about the commenter, well, his entitlement is definitely ridiculous, but the core of his request, expanding the memory limit is valid. And a good thing that it was fixed, everyone profits! | null | 0 | 1316939120 | False | 0 | c2mf4n9 | t3_kq27q | null | t1_c2mf4n9 | t1_c2mf44f | null | 1427644164 | -3 | t5_2fwo | null | null | null |
True | joesb | null | So he hares every methodology (because it will always has some blind advocates). And he hates every suggestion in the world because someone may apply and promote in inappropriate situation. | null | 0 | 1316939963 | False | 0 | c2mf69l | t3_kq001 | null | t1_c2mf69l | t1_c2macfv | null | 1427644191 | 0 | t5_2fwo | null | null | null |
True | gcross | null | tl;dr: it is perfectly fine to use an array as a stack, you just shouldn't implement the pop operation using array slicing since this will result in extraneous copying | null | 0 | 1316939998 | False | 0 | c2mf6bw | t3_kqoz2 | null | t1_c2mf6bw | t3_kqoz2 | null | 1427644184 | 30 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316940893 | False | 0 | c2mf81s | t3_kq27q | null | t1_c2mf81s | t1_c2mbvcb | null | 1427644206 | 2 | t5_2fwo | null | null | null |
True | ramilehti | null | Virtualbox OSE is useless for any serious deployments. It's a toy, a demo, a marketing tool. Nothing more. | null | 0 | 1316941518 | False | 0 | c2mf935 | t3_kpecl | null | t1_c2mf935 | t1_c2m6tm0 | null | 1427644218 | -3 | t5_2fwo | null | null | null |
True | alien_bob | null | It's a version of SICP (Structure and Interpretation of Computer Programs) suitable for reading on the Kindle (well more suitable than the pdf available from MIT's website) | null | 0 | 1316942164 | False | 0 | c2mfa3z | t3_kqixo | null | t1_c2mfa3z | t1_c2mexug | null | 1427644232 | 6 | t5_2fwo | null | null | null |
True | eggnet | null | On the Internet backbone, and on routers configured by real network engineers, yes.
Generally backbone flows are hashed. Those hashing functions look at source and destination ports as well as hosts.
Per packet load balancing is generally performed by the ignorant, to be blunt. There are exceptions but none that are relevant to this conversation. | null | 0 | 1316943095 | False | 0 | c2mfbkf | t3_kp1b5 | null | t1_c2mfbkf | t1_c2mbuck | null | 1427644251 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | I've always wondered why notary public embossers didn't include some sort of bates stamping mechanism... | null | 0 | 1316943362 | False | 0 | c2mfbzv | t3_kqr0x | null | t1_c2mfbzv | t3_kqr0x | null | 1427644256 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316943397 | False | 0 | c2mfc1m | t3_kpqzv | null | t1_c2mfc1m | t1_c2ma3gr | null | 1427644257 | 2 | t5_2fwo | null | null | null |
True | annoymind | null | > Currently V8 uses int variables/fields to track various limits inside memory management subsystem.
This was the first thing I noticed when they released v8. You could clearly see that there was no common coding guideline regarding the use of integers and some classes were using int, others size_t, and some uint32_t or int32_t. You should really use size_t and be consistent, to avoid unnecessary limits and avoid (security) bugs regarding integer overflow/underflow.
| null | 0 | 1316943610 | False | 0 | c2mfccg | t3_kq27q | null | t1_c2mfccg | t3_kq27q | null | 1427644261 | 6 | t5_2fwo | null | null | null |
True | jmdavis | null | Yes. Some people do. Obviously not as many as use more entrenched languages such as C++ or Java, but D is big enough that there are companies which use it for real work. | null | 0 | 1316943711 | False | 0 | c2mfci9 | t3_kqoz2 | null | t1_c2mfci9 | t1_c2mezoe | null | 1427644263 | 13 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | Yep, those started out as simple languages, at least as significant simplification compared to their predecessors. | null | 0 | 1316943717 | False | 0 | c2mfcim | t3_kos4z | null | t1_c2mfcim | t1_c2mdghq | null | 1427644263 | -3 | t5_2fwo | null | null | null |
True | plzsendmetehcodez | null | Hmm, the "spamps"... what's that? Stamps for snail mail spam? | null | 0 | 1316943793 | False | 0 | c2mfcmr | t3_kqr0x | null | t1_c2mfcmr | t3_kqr0x | null | 1427644263 | 0 | t5_2fwo | null | null | null |
True | deoxxa | null | How exactly is this programming? | null | 0 | 1316943885 | False | 0 | c2mfcrd | t3_kqr0x | null | t1_c2mfcrd | t3_kqr0x | null | 1427644267 | 2 | t5_2fwo | null | null | null |
True | asegura | null | Right. Do for example:
stack.length = stack.length - 1;
(or `stack.length--;?)
EDIT: OK, it's more tricky. `stack.assumeSafeAppend();`possibly helping or a more elaborate stack logic. The article linked in another post below explains a lot.
Anyway I then thought, well, why not the obvious: there must be a nice `Stack!(T)` in the library. Probably in `std.container`. But I can't find it. No List, Queue, Deque or Stack. (?) Am I missing something? | null | 0 | 1316944071 | True | 0 | c2mfd1g | t3_kqoz2 | null | t1_c2mfd1g | t1_c2mf6bw | null | 1427644270 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | > Your contractor is a strawman.
No, he's an allegory, actually, and a damn relevant one. I hear ideology after ideology from the contractors... the good ones figure out how THEY fit on THIS team - they figure out how the individuals work and and contribute good knowledge and become part of the family. We don't have any Guiding Philosophies we can put in a book other than "get your work done, and do it well" - and yet all of us manage to pull that off in spades. We all code in our own unique ways, and we're all familiar with each other idiosyncrasies, and yet we manage to put everything together at the end and it WORKS - and always ahead of schedule and with more features than were asked for. That's just how we roll. The key isn't "a paradigm", it's having a damn good manager. | null | 0 | 1316944166 | False | 0 | c2mfd6q | t3_kq001 | null | t1_c2mfd6q | t1_c2mcsen | null | 1427644273 | 7 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316944322 | False | 0 | c2mfdeo | t3_kos4z | null | t1_c2mfdeo | t1_c2lzq65 | null | 1427644275 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316944520 | False | 0 | c2mfdph | t3_kos4z | null | t1_c2mfdph | t1_c2m3wjz | null | 1427644278 | 1 | t5_2fwo | null | null | null |
True | jmdavis | null | That's the same as stack = stack[0 .. $-1]. It will still result in extraneous copying when you push onto the stack again by concatenating. The problem is that the runtime keeps track of the end of the farthest slice in a block of memory, and because the array was at a longer length before, when you append to it again, the runtime sees that there might be a slice which includes one past the end of the slice that you're appending to, and it won't extend one slice into another, so it will allocate a new block of memory and move the array there.
You really need to wrap the array in a struct which manages it as a stack rather than simply concatenating to an array to push onto it and shortening its length or slicing it to pop off an element. | null | 0 | 1316944599 | False | 0 | c2mfdtq | t3_kqoz2 | null | t1_c2mfdtq | t1_c2mfd1g | null | 1427644280 | 9 | t5_2fwo | null | null | null |
True | f2u | null | Where does the `info()` method come from? Is it really part of the standard array type? | null | 0 | 1316944610 | False | 0 | c2mfdub | t3_kqoz2 | null | t1_c2mfdub | t3_kqoz2 | null | 1427644280 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | In your example you can get the same exact benefit by writing the test afterwards. | null | 0 | 1316944686 | False | 0 | c2mfdy8 | t3_kq001 | null | t1_c2mfdy8 | t1_c2m9mji | null | 1427644282 | 2 | t5_2fwo | null | null | null |
True | haoest | null | To switch case of a letter you can simply bit switch the 5th bit too, which is just adding or subtracting 32. Just saying. | null | 0 | 1316944701 | False | 0 | c2mfdyu | t3_klrrx | null | t1_c2mfdyu | t1_c2lmtmt | null | 1427644282 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | You're doing it wrong if testing after the fact means the tests don't get done. I'd be more concerned the actual code just ends up in a poorer state if you needed to write tests first to ensure they're done. | null | 0 | 1316944780 | False | 0 | c2mfe2j | t3_kq001 | null | t1_c2mfe2j | t1_c2ma2w5 | null | 1427644283 | 2 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | D has no collections for pointers? | null | 0 | 1316944928 | False | 0 | c2mfeaj | t3_kqoz2 | null | t1_c2mfeaj | t1_c2mf6bw | null | 1427644286 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >I pointed out the flaw in using that list for your argument: most of what's in there is either a tool or packaging, and doesn't represent something really "held back" from community PG.
Most but not all. By your own admission there are some things that are held back which is why you used the word "most".
>That's the reason I asked you for a specific example, so that way readers can determine for themselves whether its compelling enough to justify your point.
I gave you list. You admitted that "most" but not all of the items were available. | null | 0 | 1316944947 | False | 0 | c2mfebc | t3_kpecl | null | t1_c2mfebc | t1_c2mehqr | null | 1427644286 | 1 | t5_2fwo | null | null | null |
True | last_useful_man | null | Well [Oz](http://www.mozart-oz.org/features.html) has all of those paradigms and more, and fewer keywords (57). /pointless | null | 0 | 1316944981 | False | 0 | c2mfect | t3_kos4z | null | t1_c2mfect | t1_c2m3wjz | null | 1427644287 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >After asking twice, I'm still waiting for a response to my FreeBSDPlus point.
That point is not relevant. I am not going to pursue every straw man you put up.
| null | 0 | 1316944986 | False | 0 | c2mfed4 | t3_kpecl | null | t1_c2mfed4 | t1_c2mehdr | null | 1427644287 | 2 | t5_2fwo | null | null | null |
True | asegura | null | OK, I now understand better. So, it's a bit more complex than I thought.
Wouldn't that be solved if D used reference counting instead of what it now uses? in that case it could know that there are zero other references to this array and make no copies. Reference counts would also allow deterministic immediate destruction/freeing when out of references. It has its downsides too, though.
| null | 0 | 1316945465 | False | 0 | c2mfeze | t3_kqoz2 | null | t1_c2mfeze | t1_c2mfdtq | null | 1427644295 | 2 | t5_2fwo | null | null | null |
True | jmdavis | null | D uses a garbage collector, not reference counting, with whatever pros and cons that that brings. And with the current implementation, D's slices don't require much overhead and on the whole work quite well. Reference counting would definitely complicate them. If you want more details on how arrays and slices work, I'd advise reading [this article](http://www.dsource.org/projects/dcollections/wiki/ArrayArticle). | null | 0 | 1316945724 | False | 0 | c2mffbs | t3_kqoz2 | null | t1_c2mffbs | t1_c2mfeze | null | 1427644299 | 6 | t5_2fwo | null | null | null |
True | minisu | null | Learning Oz (the language that runs in Mozart) was mandatory at my university. It reminds me of Erlang, but it's more multi purpose. I think it tries to cover all paradigms in one language (distributed, OO, functional, declarative, you name it). | null | 0 | 1316945781 | False | 0 | c2mffep | t3_kpwjl | null | t1_c2mffep | t3_kpwjl | null | 1427644301 | 2 | t5_2fwo | null | null | null |
True | throwaway-o | null | But they will not run as fast as the C libraries. | null | 0 | 1316945917 | False | 0 | c2mfflu | t3_kq27q | null | t1_c2mfflu | t1_c2mf2as | null | 1427644303 | 2 | t5_2fwo | null | null | null |
True | Leonidas_from_XIV | null | With JIT and other advanced techniques? That's not out of the question, see the JVM, JuaJIT, PyPy, V8 advancements, TraceMonkey etc. | null | 0 | 1316946217 | False | 0 | c2mfg0u | t3_kq27q | null | t1_c2mfg0u | t1_c2mfflu | null | 1427644309 | -1 | t5_2fwo | null | null | null |
True | Tommstein | null | So many words, and yet not a single reference to Silverlight, which is what the rest of us were talking about. Incredible .... | null | 0 | 1316946700 | False | 0 | c2mfgpo | t3_ko2wv | null | t1_c2mfgpo | t1_c2m1jrz | null | 1427644317 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316946741 | True | 0 | c2mfgr2 | t3_kqixo | null | t1_c2mfgr2 | t1_c2mesun | null | 1427644318 | 0 | t5_2fwo | null | null | null |
True | rcsheets | null | So obviously we can all find out [what the hell a Bates stamp is](http://en.wikipedia.org/wiki/Bates_numbering) easily enough, but why should we consider ourselves lucky if we've never heard of them before? And what does this have to do with programming? | null | 0 | 1316946867 | False | 0 | c2mfgx4 | t3_kqr0x | null | t1_c2mfgx4 | t3_kqr0x | null | 1427644320 | 1 | t5_2fwo | null | null | null |
True | officemonkey | null | I used to think that way, but I have read all five books in the "Game of Thrones" series on the Kindle app on my iPod touch. It was surprisingly easy. | null | 0 | 1316946888 | False | 0 | c2mfgy0 | t3_kqixo | null | t1_c2mfgy0 | t1_c2me74l | null | 1427644320 | 3 | t5_2fwo | null | null | null |
True | throwaway-o | null | Still, not as fast as the C libraries (and definitely not as memory-efficient either). See: GCC, CLANG... | null | 0 | 1316946911 | False | 0 | c2mfgz3 | t3_kq27q | null | t1_c2mfgz3 | t1_c2mfg0u | null | 1427644321 | 0 | t5_2fwo | null | null | null |
True | Abscissa256 | null | From the top of the source, where it says:
void info(ref int[] stack) {...}
It's a feature of D called Universal Function Call Syntax (or something like that, I think). It's just like C#'s extension methods, except you don't have to explicitly mark them as extention methods (I wasn't originally happy about D making them implicit, but I've come to like it quite a lot).
Unfortunately, it only works for arrays ATM, but my understanding is that it's supposed to get extended to other types. | null | 0 | 1316947015 | False | 0 | c2mfh4b | t3_kqoz2 | null | t1_c2mfh4b | t1_c2mfdub | null | 1427644323 | 8 | t5_2fwo | null | null | null |
True | matthieum | null | Mixing tabs and spaces can work, and is the only way to do things like:
struct Example {
void foo(std::map<SomeKey, SomeValue> const& initialValues,
std::map<SomeKey, SomeValue>& completedValues) const;
};
You cannot align the two `std::map` here without mixing tabs and spaces.
However since both are visualized as white space, it's hard to tell where the tabs end, and soon you've got a mess... | null | 0 | 1316947043 | False | 0 | c2mfh5l | t3_kooiy | null | t1_c2mfh5l | t1_c2mbgw5 | null | 1427644323 | 1 | t5_2fwo | null | null | null |
True | bugrit | null | You can store pointers in arrays fine, that's not the issue. Check out jmdavis response: http://www.reddit.com/r/programming/comments/kqoz2/dont_use_d_arrays_as_stacks/c2mfdtq | null | 0 | 1316947073 | False | 0 | c2mfh79 | t3_kqoz2 | null | t1_c2mfh79 | t1_c2mfeaj | null | 1427644326 | 3 | t5_2fwo | null | null | null |
True | asegura | null | Interesting read. Thanks. | null | 0 | 1316947121 | False | 0 | c2mfha2 | t3_kqoz2 | null | t1_c2mfha2 | t1_c2mffbs | null | 1427644327 | 2 | t5_2fwo | null | null | null |
True | matthieum | null | I agree with the *if possible*. However since switching programming languages usually imply switching mindsets (as they all have different capabilities and idioms), I would argue that you should perhaps also switch your workflow. It might be hard. | null | 0 | 1316947160 | False | 0 | c2mfhcd | t3_kooiy | null | t1_c2mfhcd | t1_c2mbzz6 | null | 1427644328 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316947495 | False | 0 | c2mfhsq | t3_kq27q | null | t1_c2mfhsq | t1_c2mdgpd | null | 1427644335 | 1 | t5_2fwo | null | null | null |
True | nickik | null | For clojure there is hiccup. Its up on github. | null | 0 | 1316947654 | False | 0 | c2mfhzs | t3_kos4z | null | t1_c2mfhzs | t1_c2mdj5q | null | 1427644342 | 1 | t5_2fwo | null | null | null |
True | jmdavis | null | It may or may not be extended beyond arrays. There is definitely interest in it being extended beyond arrays, but there are a number of implementation issues that arise from it (particularly with regards to ambiguities) which don't exist with arrays. Those issues will have to be sorted out before UFCS can be extended to other types, so it's unknown at this point whether it will ever extend beyond arrays. | null | 0 | 1316947694 | False | 0 | c2mfi1o | t3_kqoz2 | null | t1_c2mfi1o | t1_c2mfh4b | null | 1427644343 | 3 | t5_2fwo | null | null | null |
True | Abscissa256 | null | I've heard about it being used in some DNA research for computations. Also, apparently, one of the special effects programs used by the Surrogates movie was written in D (again, from what I've heard).
There's a guy who's very active on the D newsgroups that does web development for people, and he does it all in D. I'm migrating towards using it for web dev, too (It's hard for me because I have to deal with clients who go and pick their own junky shared web hosts, which often prohibit anything but PHP).
The original version of the Wii game Blast Works was a PC freeware game called Tumiki Fighters that (along with at least a couple other games) was written by Kenta Cho waaay back in a very early version of D.
That's just off the top of my head. | null | 0 | 1316948008 | False | 0 | c2mfigb | t3_kqoz2 | null | t1_c2mfigb | t1_c2mezoe | null | 1427644347 | 6 | t5_2fwo | null | null | null |
True | matthieum | null | It's a tradeoff. People bitch against Firefox because it uses several hundreds of megs! Therefore going with a 1GB limit for the *javascript* only seems like a reasonnable limit, client-side. And based on this limit, you use 32-bits integers instead of 64-bits one, which may let you gain some significant spaces / speed because of the memory gain.
Of course, in their place I would have gone with a 32 bits *unsigned* integers, and would have had a 4GB limit, but it's not much higher. | null | 0 | 1316948388 | False | 0 | c2mfix1 | t3_kq27q | null | t1_c2mfix1 | t1_c2mbfad | null | 1427644350 | 1 | t5_2fwo | null | null | null |
True | stesch | null | Nobody wants to use it, but the people who decide about such things think it's cool. | null | 0 | 1316949140 | False | 0 | c2mfjtq | t3_kqriv | null | t1_c2mfjtq | t3_kqriv | null | 1427644365 | 1 | t5_2fwo | null | null | null |
True | matthiasB | null | How was C++ a simplification compared to C? | null | 0 | 1316949261 | False | 0 | c2mfjz1 | t3_kos4z | null | t1_c2mfjz1 | t1_c2mfcim | null | 1427644367 | 6 | t5_2fwo | null | null | null |
True | sreguera | null | Just remembered [this article from Dijkstra](http://www.cs.utexas.edu/~EWD/transcriptions/EWD09xx/EWD936.html) about anthropomorphism in science, esp. computing.
TL;DR: Not a fan. | null | 0 | 1316949963 | False | 0 | c2mfkx3 | t3_kp71h | null | t1_c2mfkx3 | t1_c2mb94d | null | 1428192933 | 5 | t5_2fwo | null | null | null |
True | elazarl | null | Hmmm... good point.
Although I think you can still allocate them on the stack in an `alloca` like fashion. Although it's dynamic, it's lifetime is bound to the current scope, so it still makes sense to allocate it on the stack. Although indeed, when you'll run out of stack, funny things will occur... | null | 0 | 1316950290 | False | 0 | c2mfldl | t3_jybjy | null | t1_c2mfldl | t1_c2i4htl | null | 1427644391 | 1 | t5_2fwo | null | null | null |
True | MatmaRex | null | If you want something like this in a language other than Lisp, there's Markaby for Ruby. (https://rubygems.org/gems/markaby)
html do
body do
h1 "header"
p "some text"
end
end
Ain't it amazing what some heavy metaprogramming abuse can do. ;) | null | 0 | 1316950695 | False | 0 | c2mflwd | t3_kos4z | null | t1_c2mflwd | t1_c2mdj5q | null | 1427644397 | 2 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | > I'd ask the same about Python, Ruby or even Java. When you're getting to that level of memory consumption, it's time to work in a language that gives you more control over memory management.
You can't possible infer that someone needs more control over memory management from them needing a large amount of memory. For instance, what if they need the large amount of memory for a single large array that will be allocated once and then manipulated? | null | 0 | 1316950923 | False | 0 | c2mfm8e | t3_kq27q | null | t1_c2mfm8e | t1_c2ma0km | null | 1427644400 | 3 | t5_2fwo | null | null | null |
True | expertunderachiever | null | None of our requirements stated we needed Haskell. The whole point of me bringing that up was that it was a prime example of someone getting all excited over some new [or different] language that they wanted to use over a standard like C for no good reason.
As for "portable enough" we code to C90. Far more distros come with proper C90 support than the latest and greatest of Haskell. | null | 0 | 1316951061 | False | 0 | c2mfmf7 | t3_kos4z | null | t1_c2mfmf7 | t1_c2mcyc3 | null | 1427644401 | 1 | t5_2fwo | null | null | null |
True | Malthan | null | Reading on an LCD is awesome when you're reading in the dark. | null | 0 | 1316951961 | False | 0 | c2mfnm7 | t3_kqixo | null | t1_c2mfnm7 | t1_c2me74l | null | 1427644414 | 1 | t5_2fwo | null | null | null |
True | MarshallBanana | null | I see the Phong reflection model is just a stub. Please keep it that way, Phong lighting really has no place in modern 3D graphics. | null | 0 | 1316952387 | False | 0 | c2mfo8f | t3_kqqd5 | null | t1_c2mfo8f | t3_kqqd5 | null | 1427644419 | -6 | t5_2fwo | null | null | null |
True | mhd420 | null | Who ever thought that this would be a good proggit submission? | null | 0 | 1316952547 | False | 0 | c2mfog5 | t3_kqriv | null | t1_c2mfog5 | t3_kqriv | null | 1427644420 | 3 | t5_2fwo | null | null | null |
True | Fabien4 | null | > reading in the dark.
I just can't do that. My eyes are dead in less than ten minutes.
(And no, I can't watch TV in the dark either.) | null | 0 | 1316953165 | False | 0 | c2mfpat | t3_kqixo | null | t1_c2mfpat | t1_c2mfnm7 | null | 1427644431 | 1 | t5_2fwo | null | null | null |
True | jmdavis | null | No, you're not missing anything. std.container is still very much a work in progress and is fairly sparse at the moment. The main delay for getting more container types in there is that the custom allocator scheme that they're going to use needs to be sorted out first (which is being worked on but isn't done yet). Once that's sorted out, std.container will be further fleshed out and will end up with a full complement of container types. | null | 0 | 1316953538 | False | 0 | c2mfpth | t3_kqoz2 | null | t1_c2mfpth | t1_c2mfd1g | null | 1427644437 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | Let's try it this way: are you familiar, or can you quickly familiarize yourself with [LINQ in Visual Basic](http://msdn.microsoft.com/en-us/library/bb763068\(v=vs.90\).aspx)? It's not supposed to require a functional programming expert with strong background in category theory or to do that...
Now excuse me but I'll use C# syntax, learning VB myself is too unpleasant =(.
So. When you have `var lst = int[] {1, 2, 3};` and `var result = from x in lst select x + 1;`, the latter is translated to `var result = lst.Select(x => x + 1);`. Literally translated, that's how LINQ queries are implemented, they are converted to usual method calls (which can be implemented by [extension methods](http://en.wikipedia.org/wiki/Extension_method)).
This illustrates an important concept, by the way: it is useful to back up your nice syntactic sugar by a description of how it actually works in form of plain method/function calls.
Then, `var result2 = from x in lst from y in lst select x * 10 + y;` performs two nested loops and returns "11, 12, 13, 21, 22, 23, 31, 32, 33", as a flat list, not a list of lists. It is translated into
var result2 = lst.SelectMany(x => lst.Select(y => x * 10 + y));
Select is a Functor's `fmap` (takes a function from T1 to T2), SelectMany is a Monadic `bind` (takes a function from T1 to IMonad<T2>).
For longer chains it's SelectMany, SelectMany, ..., SelectMany, Select. Because you need to use SelectMany to be composable, but it would be silly to do create and return a single-element array on the last step (`lst.SelectMany(y => new int[] {x * 10 + y})`).
> Why does the functor in your adding example end up wrapping the result twice?
`y => x * 10 + y` has type `int -> int`.
`x => lst.Select(y => x * 10 + y)` has type `int -> IEnumerable<int>`.
If we fed it into Select again (which takes a function `T -> R` and returns `IEnumerable<R>`), we'll get an `IEnumerable<IEnumerable<int>>` instead of the `IEnumerable<int>` that we want.
> Where on earth does this maybe stuff come into play? What are something and nothing for?
In proper languages, when your function is declared as returning an `int`, it's not allowed to return `null`. But sometimes you need to do just that, to return an answer or a special value signifying the absence of an answer. So `Maybe something` is equivalent to `List something` that can only contain 0 or 1 elements. `something` is the type of the elements. `Nothing` is a special value, a "null".
Even when C# implements it's own [Nullable<T>](http://msdn.microsoft.com/en-us/library/1t3y8s4s\(VS.80\).aspx) with its own special syntax unrelated to LINQ, it is [instructive](http://blogs.msdn.com/b/wesdyer/archive/2008/01/11/the-marvels-of-monads.aspx) to understand how it can be implemented with LINQ, so that we had to write `from x in Maybe<int>(10) from y in Maybe<int>.Nothing select x + y`. | null | 0 | 1316953591 | False | 0 | c2mfpvr | t3_kogj4 | null | t1_c2mfpvr | t1_c2mdm60 | null | 1427644438 | 2 | t5_2fwo | null | null | null |
True | Abscissa256 | null | std.container is very new. The whole range system had to be hammered out first, and I think there was something else with manual memory management that needed to be worked out. But my understanding is that std.container is going to start getting stuff soon.
There is already the DCollections library, though: http://www.dsource.org/projects/dcollections | null | 0 | 1316953773 | False | 0 | c2mfq6i | t3_kqoz2 | null | t1_c2mfq6i | t1_c2mfd1g | null | 1427644442 | 4 | t5_2fwo | null | null | null |
True | aapl | null | That quote does in fact refer to the front-end, but actually they use JavaScript with Closure library and toolset, not GWT. The back-end is C++ and Java. Both [confirmed by ex-Googlers](http://www.quora.com/What-programming-languages-is-Gmail-implemented-in). | null | 0 | 1316953900 | False | 0 | c2mfqdx | t3_kq27q | null | t1_c2mfqdx | t1_c2mberl | null | 1427644452 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | I hear ya, I'm a C systems programmer myself, however I still believe you're attributing the blame in the wrong place. Your new intern wouldn't have the knowledge that you did about the variance in your deployment area.
None of your requirements stated C either right ? Nor did they state that it needed to be C90, could have done it in fortran, or algol68 ! | null | 0 | 1316953939 | False | 0 | c2mfqg6 | t3_kos4z | null | t1_c2mfqg6 | t1_c2mfmf7 | null | 1427644447 | 2 | t5_2fwo | null | null | null |
True | lolomfgkthxbai | null | I haven't advocated anything. You seem intent on misunderstanding me, but here goes:
Goal:
Move WWW traffic to secure protocols.
Option 1:
Continue the status quo and hope that everyone starts using HTTPS.
Option 2:
Introduce a new protocol that does everything HTTP and HTTPS did and more.
What I'm saying is that option 2 seems like a better way of reaching the goal. Personally I want everything secure, I don't care which protocol does it. | null | 0 | 1316954066 | False | 0 | c2mfqne | t3_kp1b5 | null | t1_c2mfqne | t1_c2m7wty | null | 1427644448 | 1 | t5_2fwo | null | null | null |
True | sjw79 | null | You could always write the RTS in C and the compiler in FACT. | null | 0 | 1316954252 | False | 0 | c2mfqyh | t3_kpqzv | null | t1_c2mfqyh | t1_c2mdnfv | null | 1427644452 | 1 | t5_2fwo | null | null | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.