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 | Jigsus | null | I hope so man... I hope so... | null | 0 | 1316890847 | False | 0 | c2mamtg | t3_ko2wv | null | t1_c2mamtg | t1_c2lz4ul | null | 1427642054 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Good point. What I heard when learning Python though, was to write code that was largely self-explanatory, and to comment what was going on when things got dense and confusing. | null | 0 | 1316890870 | False | 0 | c2mamwd | t3_gvnfk | null | t1_c2mamwd | t1_c1qmjdv | null | 1427642055 | 2 | t5_2fwo | null | null | null |
True | jbristow | null | Figuring out the granularity of tests was really tough for me.
Basically, what I found was that every time I ask the program to do something more complicated than assignment, put in a test. This led to me favoring monads without really knowing what they were.
After hacking around with LISP, F#, and Haskell, it became easier to see where the testable points in my Java code were and refactor to open up seams around them.
Yes, I still have problems unit testing things that are outside of my direct control (I'm looking at YOU legacy pl/sql and legacy custom Spring batch modifications), but it's getting easier. | null | 0 | 1316890995 | False | 0 | c2mandu | t3_kq001 | null | t1_c2mandu | t1_c2mahxb | null | 1427642057 | 1 | t5_2fwo | null | null | null |
True | HammerOfThor | null | Wow, what a tremendous asshole.
I find it amusing that a new methodology can come into vogue and all of a sudden everyone who is not using it is just a hack, and not a software engineer. Apparently the entire history of computer software before the last decade or so was done by hacks and fools. | null | 0 | 1316891079 | False | 0 | c2manpi | t3_kq001 | null | t1_c2manpi | t1_c2ma44y | null | 1427642059 | 64 | t5_2fwo | null | null | null |
True | _pupil_ | null | > *It is wholly possible for an intelligent person to have earnestly tried TDD and to have come to the conclusion that it doesn't make their code better.*
It is wholly possible. The author fails to enter that category through one simple point: informed criticism. There's a difference between an informed point of view and one borne out of ignorance. In the case of this article the difference is quite obvious.
| null | 0 | 1316891140 | False | 0 | c2many8 | t3_kq001 | null | t1_c2many8 | t1_c2mam9u | null | 1427642061 | 0 | t5_2fwo | null | null | null |
True | RedSpikeyThing | null | How is a 3D engine any different than "'business logic' where all you have to do is take data from one source, transform it, and move it another source"?
>But the problem there is, what if there are bugs in your tests? I this situation the tests aren't going to be much more complex then the code itself -- and just as prone to error.
If the tests aren't any more complex than the code itself *then you have written good code*. When I review code I expect tests to be *simple*. I can write most tests without conditional logic or looping.
If the error rate in test code is equal to the error rate in production code then writing tests significantly reduces the probability of an error in production code because an error most exist in both the test code *and* production code in order for it to go undiscovered. | null | 0 | 1316891239 | False | 0 | c2maobq | t3_kq001 | null | t1_c2maobq | t1_c2ma8ta | null | 1427642064 | 5 | t5_2fwo | null | null | null |
True | i8beef | null | While your cheeky response is amusing, just want to point out that the problem domains that we are dealing with are considerably smaller than "the real world", unless you are writing a life simulator or something...
Only really need to write tests for expected and enforced inputs. | null | 0 | 1316891310 | False | 0 | c2maol7 | t3_kq001 | null | t1_c2maol7 | t1_c2ma5mn | null | 1427642067 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316891464 | True | 0 | c2map5b | t3_kq001 | null | t1_c2map5b | t1_c2ma2w5 | null | 1427642074 | 1 | t5_2fwo | null | null | null |
True | herpyderpster | null | C doesn't have classes let alone collection classes and it doesn't have a standard library format. That's up to the compiler/linker system. | null | 0 | 1316891497 | False | 0 | c2mapa1 | t3_kq27q | null | t1_c2mapa1 | t1_c2maabi | null | 1427642076 | 13 | t5_2fwo | null | null | null |
True | UncleMidriff | null | I wholeheartedly agree. I was at some all-day code conference thingy where they had a bunch of different sessions on a variety of programming topics. I decided to go the one about TDD.
I kid you not, the insufferable douche bag giving the talk compared TDD to Bhuddism, Zen, etc. He had the demeanor of some ancient guru teaching his students in the mysterious ways of a forgotten art. Holy geez, it pissed me off so much. Now every time I hear or read about TDD, that assbag is the first thing that pops into my head, and I reflexively want nothing to do with it.
I understand TDD has some interesting and useful points to make, but the tone in which I see it written about makes me want to shove pointy things through my temples. | null | 0 | 1316891522 | True | 0 | c2mapdg | t3_kq001 | null | t1_c2mapdg | t1_c2mam9u | null | 1427642076 | 18 | t5_2fwo | null | null | null |
True | StoneCypher | null | > > Oh look, he's a style zealot, what a surprise.
> No, I prefer task specific paradigms and languages.
Six of one, half a dozen of the other.
> Yeah, the typical "I'm better without a degree because I didn't know all da shit".
Now you're making incorrect guesses to refute data-backed observations, and downvoting for disagreement.
Tsk, tsk.
Inbound: "google it for me or you're wrong." | null | 0 | 1316891598 | False | 0 | c2mapof | t3_khkyd | null | t1_c2mapof | t1_c2majww | null | 1427642079 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316891624 | False | 0 | c2maprv | t3_kq001 | null | t1_c2maprv | t1_c2ma42r | null | 1427642081 | 1 | t5_2fwo | null | null | null |
True | flussence | null | But then they'll have to change all the code again when antimatter memory is invented! | null | 0 | 1316891627 | False | 0 | c2maps7 | t3_kq27q | null | t1_c2maps7 | t1_c2m9l8f | null | 1427642081 | 1 | t5_2fwo | null | null | null |
True | HammerOfThor | null | Yeah, granted his tone is not very measured, but I don't believe I've ever read a criticism of TDD that didn't have a response along the lines of "well you obviously just haven't had the epiphany yet". It is frustrating because to a zealot any criticism of their beliefs means you are uninformed. | null | 0 | 1316891754 | False | 0 | c2maq99 | t3_kq001 | null | t1_c2maq99 | t1_c2many8 | null | 1427642086 | 12 | t5_2fwo | null | null | null |
True | tdk2fe | null | I work with a very small startup, and testing is an absolute fucking nightmare. Nobody in our organization knows anything about it, and our testing policy is pretty much writing a fix, testing what you think it fixes (manually), and then pushing it into production at night.
I wish I knew more about it, as I know its valuable, but right now the boss isn't interested in investing in that type of knowledge capital. Can anybody here recommend some good resources on where to get started? Majority of the work is in javascript, PHP, perl, and SQL. | null | 0 | 1316891935 | False | 0 | c2maqym | t3_kq001 | null | t1_c2maqym | t3_kq001 | null | 1427642111 | 7 | t5_2fwo | null | null | null |
True | robertwilliams | null | Writing tests for trivial code, is trivial - so why would you object to it? | null | 0 | 1316892020 | False | 0 | c2maray | t3_kq001 | null | t1_c2maray | t1_c2mac44 | null | 1427642112 | 1 | t5_2fwo | null | null | null |
True | boot20 | null | This author sounds like a cowboy. I would really recommend he start with [Toward Zero Defect Progamming](http://www.amazon.com/Toward-Defect-Programming-Allan-Stavely/dp/0201385953/ref=sr_1_1?ie=UTF8&qid=1316891746&sr=8-1) and then [Test Driven Development by Example](http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=sr_1_1?s=books&ie=UTF8&qid=1316891821&sr=1-1).
I mean let's be honest. There needs to be some control and testing. Sure Agile Development and TDD are buzz words to management, but the honest to god truth is that they are useful when done correctly.
It's like ITIL, if you try to conform your organization to the ITIL definitions you are doomed to fail. However, if you take it as a framework, and build from it, you can streamline projects and get things done without having to go back and do them over and over again. | null | 0 | 1316892020 | False | 0 | c2marb0 | t3_kq001 | null | t1_c2marb0 | t3_kq001 | null | 1427642112 | -1 | t5_2fwo | null | null | null |
True | bobindashadows | null | If your CPU optimization is never over 2% then all that optimization time was completely wasted. Considering evented code has been easy on Ruby since before Node existed (EventMachine), I'm not sure what your point was at all. | null | 0 | 1316892145 | False | 0 | c2marsy | t3_kq27q | null | t1_c2marsy | t1_c2ma684 | null | 1427642117 | 4 | t5_2fwo | null | null | null |
True | robertwilliams | null | I have yet to encounter a case where TDD is a *bad* idea. It might not always be the optimal approach, granted, but it always adds value. | null | 0 | 1316892146 | False | 0 | c2marsz | t3_kq001 | null | t1_c2marsz | t1_c2macfv | null | 1427642117 | 4 | t5_2fwo | null | null | null |
True | kefex | null | More data, less bloviating. | null | 0 | 1316892262 | False | 0 | c2mas8d | t3_kq001 | null | t1_c2mas8d | t3_kq001 | null | 1427642121 | 5 | t5_2fwo | null | null | null |
True | robertwilliams | null | > Letting the tests dictate how your code looks is actually a good thing, because it's hard to write code which is testable and tightly coupled. The more modular the code is, the easier it is to test.
Thank you for pointing this out. Unit tests are good for more than verifying functionality, and TDD is not merely a mechanism to make sure the tests get written. If you view your tests as clients that use your code, it helps you write code that is more cohesive and loosely coupled, and therefore easier to use. | null | 0 | 1316892342 | False | 0 | c2masjm | t3_kq001 | null | t1_c2masjm | t1_c2m9snj | null | 1427642122 | -2 | t5_2fwo | null | null | null |
True | garymrush | null | I don't doubt that there are complex problems, even when decomposed perfectly, and sometimes these can lead to complex tests. That being said, in my experience these are the exception. Usually when you find yourself trying to create a complex test to get at some private behavior of your class it's because you've got another class hidden inside. Refactor that little bitch out, test it, and then simply verify that your original class uses it correctly. | null | 0 | 1316892484 | False | 0 | c2mat3j | t3_kq001 | null | t1_c2mat3j | t1_c2ma881 | null | 1427642126 | 2 | t5_2fwo | null | null | null |
True | SuperGrade | null | I've worked in areas with passionate developers. I've worked somewhere where I can assure you there are none, and I would advise anyone remotely interested in the craft away from working there.
A workplace congeals around people whe are generally similar in some regard. In some workplaces, the person he describes will not be welcome, and he won't enjoy working there.
| null | 0 | 1316892489 | False | 0 | c2mat4c | t3_korcu | null | t1_c2mat4c | t1_c2m9op0 | null | 1427642126 | 3 | t5_2fwo | null | null | null |
True | robertwilliams | null | Yes it is recursive. But the code tests the tests ultimately. | null | 0 | 1316892696 | False | 0 | c2matyt | t3_kq001 | null | t1_c2matyt | t1_c2ma7a5 | null | 1427642135 | 3 | t5_2fwo | null | null | null |
True | robertwilliams | null | TDD also helps with your design. Your tests help you think about how to design cohesive objects that are loosely coupled. Test-later does not help you with the design.
| null | 0 | 1316892839 | False | 0 | c2mauin | t3_kq001 | null | t1_c2mauin | t1_c2mab9f | null | 1427642141 | 6 | t5_2fwo | null | null | null |
True | neoquietus | null | >how would you write 'tests' for a 3D engine before you actually start coding it?
An example:
I presume in your 3d engine you have a way to transform things from world-space into screen-space. Given a particular triangle in world-space, there is a proper mapping of it into screen-space. To write a test for this, you would simply pre-calculate (possibly by hand) how a particular 3d triangle would map onto screen space, and then the test would simply place that particular 3d triangle into the engine and fail if the resulting screen space co-ordinates did not match up.
This is not foolproof, of course (this test only proves that the one particular 3d triangle gets mapped correctly), but it does help catch errors. All the other components of a 3d engine can be tested in a similar manner. The basic form is: starting state/input, desired output, actual output. Feed the engine the input/starting state, and store the results. If actual output != desired output, the program fails the test.
As for the actual function names, that is decided at design time, or defined in an interface. You write the test first, and it will fail to compile because the interface/function it uses doesn't actually exist yet. At that point you then write a stub/empty class; your tests should now compile (and fail). Now you can actually implement the functionality, until all your tests pass. | null | 0 | 1316892851 | False | 0 | c2mauk8 | t3_kq001 | null | t1_c2mauk8 | t1_c2ma8ta | null | 1427642142 | 9 | t5_2fwo | null | null | null |
True | duckfighter | null | Look at his last sentence: "You don't even know what he's working on."
If he needs at least 32gb, well that is what he needs. As you can see, the bug was even fixed. | null | 0 | 1316892993 | False | 0 | c2mav50 | t3_kq27q | null | t1_c2mav50 | t1_c2m9t72 | null | 1427642149 | 17 | t5_2fwo | null | null | null |
True | Peaker | null | Sounds like a very very special case... Why not do the same for various other constants?
Also, there are possible ways to make constant/interned-string lookups in the globals dict a very quick O(1) (basically pre-look-them-up when creating the function object), with modest changes to the PyDict implementation.
| null | 0 | 1316893227 | False | 0 | c2maw1d | t3_kos4z | null | t1_c2maw1d | t1_c2mab58 | null | 1427642161 | 1 | t5_2fwo | null | null | null |
True | robertwilliams | null | My own TDD epiphany: I was writing some code that interfaced with a 3rd party back-end system that was not well documented or well understood. I was working on adding a feature related to how the back-end system handled default values. I started to just hammer out the code for this special condition, when I thought "No, I'll take 10 seconds to do this the TDD way". In our case, we weren't doing proper *unit* testing; it was actually integration testing with a test instance of the back-end system. So I wrote what was supposed to be a failing test - call the method on my business layer, then retrieve the value from the back-end system and verify it was properly set to a default value (which I assumed it *wouldn't* be, since I hadn't written that code yet).
I ran the test and it passed. *Huh?* Turns out the back-end system, unknown to just about everyone, already had this logic implemented in it.
If I hadn't been doing TDD, I would have written probably a couple dozen lines of useless, and possibly wrong, code.
| null | 0 | 1316893241 | False | 0 | c2maw3b | t3_kq001 | null | t1_c2maw3b | t1_c2mam9u | null | 1427642162 | 5 | t5_2fwo | null | null | null |
True | ex_ample | null | First of all coordinate mapping is one of the simplest aspects of 3D rendering these days. And if you did write that test what about corner cases and edge cases you don't know about. Hard-coding a SINGLE triangle and testing only that triangle isn't going to be much help. With stuff like doom and quake a big part of what the engine does is BSPs and quadtrees so that you can cut down on the number of things that need to be calculated per-scene. | null | 0 | 1316893330 | False | 0 | c2mawgq | t3_kq001 | null | t1_c2mawgq | t1_c2mauk8 | null | 1427642168 | 7 | t5_2fwo | null | null | null |
True | pistacchio | null | amen.
as a developer, i think one of the most useful skills one can learn is to separate what is "enterprisey" and what is not. there one only true and proved way to get the job done: do the fucking coding till it works.
everything added to this may help in some situations, may harm in others and in most is irrelevant. BUT there is a field where "test driven development", "agile", "enterprise java beans", "scalable technology" surely has an important place: the field of making money. you can't milk a large corporation by saying "hey, just use sqllite, for your needs it's more than enough, it's robust, wide spread, open source and fast", but "for $2000 a hour i can set up a course in test-drive-development strategies for your development team that will keep them synergically focused on the challenges that your business may face, so that they can work together towards a goal sheltered by an iron-safe environment they themselves have helped building" would work. | null | 0 | 1316893341 | True | 0 | c2mawid | t3_kq001 | null | t1_c2mawid | t3_kq001 | null | 1427642168 | 9 | t5_2fwo | null | null | null |
True | EugeneKay | null | > The issue with MariaDB adoption
No, I'm not: I think MariaDB is a great thing. I've tested it with self-compiles, and it worked just fine. But I, and many others, are not going to go through that trouble to use it in production, opting instead to wait for a distribution-provided easy-install package, same as every other piece of software I use in my production boxen.
Sysadmin elitism such as "have to be actually be able to think" is really not my cup of tea. That's how you end up with obscure kernels that you've probably never Hurd of. | null | 0 | 1316893351 | False | 0 | c2mawk4 | t3_kpecl | null | t1_c2mawk4 | t1_c2mam4a | null | 1427642168 | 5 | t5_2fwo | null | null | null |
True | ex_ample | null | > How is a 3D engine any different than "'business logic' where all you have to do is take data from one source, transform it, and move it another source"
Usually 'business logic' is much, much more simple. With a 3D model you're not 'transforming' data but rather calculating it from a few inputs. Transforming from a small initial state specification to whatever -- with business logic you end up with about the same amount of data or less (i.e. a summary) | null | 0 | 1316893370 | False | 0 | c2mawmf | t3_kq001 | null | t1_c2mawmf | t1_c2maobq | null | 1427642169 | 5 | t5_2fwo | null | null | null |
True | andytuba | null | Anyone know why it's called "Mozart?" | null | 0 | 1316893498 | False | 0 | c2max57 | t3_kpwjl | null | t1_c2max57 | t1_c2m9rl4 | null | 1427642176 | 2 | t5_2fwo | null | null | null |
True | lalaland4711 | null | Still? What's wrong with you? ALWAYS use curly brace.
Why would you not? It has caused big bugs. Learn from the past and just do it. No excuses. | null | 0 | 1316893639 | False | 0 | c2maxpn | t3_kooiy | null | t1_c2maxpn | t3_kooiy | null | 1427642183 | 5 | t5_2fwo | null | null | null |
True | sztomi | null | What do you mean? I have fullscreen flash on linux just fine. | null | 0 | 1316893706 | False | 0 | c2maxzf | t3_ko2wv | null | t1_c2maxzf | t1_c2m8xhm | null | 1427642187 | 2 | t5_2fwo | null | null | null |
True | Xorlev | null | He said later he was trying to maintain 140,000 connections, not entirely unreasonable. Not that I'm super impressed by node.js, I think there's much better ways to do it. | null | 0 | 1316893706 | False | 0 | c2maxzg | t3_kq27q | null | t1_c2maxzg | t1_c2m9t72 | null | 1427642187 | 24 | t5_2fwo | null | null | null |
True | znk | null | I dont often write my tests first. But every time I do everything seems to end up easier. Plus I kinda hate writing tests after I'm done coding. But I never learn and keep coding then testing. | null | 0 | 1316893781 | False | 0 | c2maya5 | t3_kq001 | null | t1_c2maya5 | t1_c2m9yvv | null | 1427642190 | 2 | t5_2fwo | null | null | null |
True | lalaland4711 | null | > putting the brace on a separate line really helps the readability of the code.
At least acknowledge that this is a matter of what you're used to, or taste. It's not objectively better for readability.
To me having a separate line adds nothing, because I'm used to it not being on its own line. | null | 0 | 1316893794 | False | 0 | c2maybj | t3_kooiy | null | t1_c2maybj | t1_c2m1prn | null | 1427642191 | 7 | t5_2fwo | null | null | null |
True | lalaland4711 | null | exceptions vs panic / rescue! | null | 0 | 1316893847 | False | 0 | c2mayiz | t3_kooiy | null | t1_c2mayiz | t1_c2m87u0 | null | 1427642194 | 5 | t5_2fwo | null | null | null |
True | s1024 | null | For development of the core of the system I would vote for Invariant Driven Development. If I can figure out some invariants that should always be true before and after data manipulation, then I would implement it and call before and after each data manipulation. Also I would prepare a special utility that will check logical consistency of the data: also would provide the way to intentionally bypass the check in cases of false positives.
Also I think that TDD is somewhat good for code coverage test when you need simply to check that all the interface windows/reports is working and is in good health especially the seldom used one.
One time automatic test helps me to load the system and find obscure bug in the JIT engine. The error happens only after several thousands run of the report and sure it will be impossible to do it manually. | null | 0 | 1316893882 | False | 0 | c2mayo5 | t3_kq001 | null | t1_c2mayo5 | t3_kq001 | null | 1427642196 | 4 | t5_2fwo | null | null | null |
True | UghImRegistered | null | > some things programmers say can be massive red flags.
So true, and consequently I didn't pay attention to anything past his first few sentences. | null | 0 | 1316893978 | False | 0 | c2maz1k | t3_kq001 | null | t1_c2maz1k | t3_kq001 | null | 1427642201 | 2 | t5_2fwo | null | null | null |
True | fallacybuffet | null | Especially when they sometimes fail: "WTFf?!?! Oh." | null | 0 | 1316893980 | False | 0 | c2maz1x | t3_kq001 | null | t1_c2maz1x | t1_c2maray | null | 1427642201 | 2 | t5_2fwo | null | null | null |
True | otakucode | null | Developing working systems is complex intellectual work. When a task is complex and intellectual, most people seek to remove the complexity and remove the need for intellectual effort. When you flip a switch and your light comes on, they want to believe that the light coming on is because the switch was flipped, and that no understanding beyond that is necessary. They don't want to be bogged down by realizing that the switch permits the completion of a circuit which allows the flow of electrical current which comes over transmission lines from a power station where water turns turbines, moving alternating magnetic fields over wires, motivating the electricity to flow. Any time you cut off your knowledge and try to throw away all the extra information that goes into a system in order to reduce it to a simplistic vision, you are losing things. You are losing the capability to understand how all the components work together, where to look if something breaks, etc.
But, people have been pampered. They have been told from the time they were children that these simplified understandings and elimination of a need for intellectual rigor and effort is how the world works, and that our simplified visions are the truth. And for most of human life, this is true. You hit the gas in your car and it goes. You don't have to know that it is causing combustion, unlocking the chemical potential energy inherent in long-chain hydrocarbons formed through the combination of sugars and solar energy. If it doesn't go, you take it to a mechanic and they fix it, no need to understand it yourself. They're taught that the people who do know the more complicated aspects of the systems are deceptive, and likely to trick the 'normal' people who don't spend their time thinking about anything. They're taught that people who spend their time learning science and reason and the like are uncaring, cold, calculating people who barely qualify as human, and they do so only insofar as they follow their intuition and go against what reason says they should do.
Asking people in general to abandon this pursuit, of pretending that complex things are simple, is unlikely to be effective. Deep down, they see understanding and acknowledging the complexities that escape their intuition as a character flaw. It would make them bad people to be so exact. | null | 0 | 1316894028 | False | 0 | c2maz7n | t3_kq001 | null | t1_c2maz7n | t3_kq001 | null | 1427642204 | 6 | t5_2fwo | null | null | null |
True | learnyouahaskell | null | I remember reading on Programmers or StackOverflow about pranks such as `#define if while`, `#define 0 1`, and so on. | null | 0 | 1316894130 | False | 0 | c2mazmg | t3_klhlv | null | t1_c2mazmg | t1_c2ldru7 | null | 1427642210 | 1 | t5_2fwo | null | null | null |
True | learnyouahaskell | null | I don't know Latin, but this is correct in English. A datum, a medium. | null | 0 | 1316894182 | False | 0 | c2mazu7 | t3_klhlv | null | t1_c2mazu7 | t1_c2lb1ru | null | 1427642212 | 1 | t5_2fwo | null | null | null |
True | learnyouahaskell | null | This is actual proper English, as well. | null | 0 | 1316894207 | False | 0 | c2mazx4 | t3_klhlv | null | t1_c2mazx4 | t1_c2l85qd | null | 1427642213 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I started programming a correction for you, intending it to be a check function.
"Hm, we'd have to deal with passing variables and shit. Fuck this, I'll make it a class!"
*programmes class*
"Now, for the main execution bit..."
*types in code, gets weird error*
"Shit, the editor's mixing tabs and spaces...
*painstakingly fixes tabs and spaces*
"Oh wait, nothing happens when you win. Let me just..."
*breaks everything*
"Oh, fuck this shit." | null | 0 | 1316894233 | False | 0 | c2mb00a | t3_gvnfk | null | t1_c2mb00a | t1_c1qncft | null | 1427642215 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | Change the language (in version 2, 3, ...) without giving up existing code. A new version doesn't break backward compatibility with old versions (you 'merely' have to define rules how e.g. v2 code can call v1 code). In sum: make backward compatibility a problem for a handful of specialized people (Standard committees and compiler writers) not for thousands of programmers. | null | 0 | 1316894425 | False | 0 | c2mb0s1 | t3_kos4z | null | t1_c2mb0s1 | t1_c2m9p66 | null | 1427642229 | 8 | t5_2fwo | null | null | null |
True | mm9k | null | Can't remember where I read this, but someone once said (paraphrasing from memory), "The only industry more driven by fads than the software industry is the women's fashion industry." | null | 0 | 1316894448 | False | 0 | c2mb0ur | t3_kq001 | null | t1_c2mb0ur | t1_c2manpi | null | 1427642229 | 28 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316894541 | False | 0 | c2mb16q | t3_kq27q | null | t1_c2mb16q | t1_c2marsy | null | 1427642231 | 1 | t5_2fwo | null | null | null |
True | jtxx000 | null | > Every test suite failure should be a complete, mysterious surprise,
> never a possibility you were prepared for. Any other attitude
> indicates that you're using the test suite as a crutch, which you need
> only because your understanding is weak.
-- Jim's rule for test suites; found in the Guile codebase | null | 0 | 1316894580 | False | 0 | c2mb1cj | t3_kq001 | null | t1_c2mb1cj | t3_kq001 | null | 1427642233 | 2 | t5_2fwo | null | null | null |
True | AaronOpfer | null | Having CPU consumption low has added benefits of lower latency for page generation. | null | 0 | 1316894672 | False | 0 | c2mb1p7 | t3_kq27q | null | t1_c2mb1p7 | t1_c2marsy | null | 1427642238 | 1 | t5_2fwo | null | null | null |
True | quotemstr | null | You mean over himself. The blogger presented a cogent argument against TDD; Loubser just lobbed personal insults and accused, without explanation, the blogger of not *really* understanding TDD. Loubser's reaction is of the kind you normally see from the incoherent screams of intelligent design advocates. | null | 0 | 1316894738 | False | 0 | c2mb1xp | t3_kq001 | null | t1_c2mb1xp | t1_c2m9u47 | null | 1427642244 | 8 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316894804 | False | 0 | c2mb256 | t3_kq001 | null | t1_c2mb256 | t1_c2mauin | null | 1427642245 | 7 | t5_2fwo | null | null | null |
True | mitsuhiko | null | There are good reasons for not using unsigned types and for what V8 was originally developed having a 1GB limit was a reasonable decision. | null | 0 | 1316894824 | False | 0 | c2mb27q | t3_kq27q | null | t1_c2mb27q | t1_c2m9qn4 | null | 1427642246 | 5 | t5_2fwo | null | null | null |
True | bobindashadows | null | > when you just want to try something big out.
That's not what was going on in that thread. 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* so they can continue using the tool that's not prepared for their use case. | null | 0 | 1316894839 | False | 0 | c2mb2a1 | t3_kq27q | null | t1_c2mb2a1 | t1_c2maikv | null | 1427642247 | 20 | t5_2fwo | null | null | null |
True | seabre | null | Sure it's possible, but in the Python world, it's very very frowned upon. Ruby (the Rails community in particular I think), though, it's the complete opposite. | null | 0 | 1316894858 | False | 0 | c2mb2cb | t3_kq27q | null | t1_c2mb2cb | t1_c2mal1j | null | 1427642247 | 6 | t5_2fwo | null | null | null |
True | gregK | null | >An obvious target would be the
libraries of one of the major functional programming languages, such as Haskell
I'm sure he won't have trouble finding plenty of metaphors... | null | 0 | 1316894913 | False | 0 | c2mb2ii | t3_kp71h | null | t1_c2mb2ii | t3_kp71h | null | 1427642250 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | I typed those three lines and got nethack. Perhaps you omitted one or two steps? | null | 0 | 1316894924 | False | 0 | c2mb2k0 | t3_kpecl | null | t1_c2mb2k0 | t1_c2m8sym | null | 1427642250 | 2 | t5_2fwo | null | null | null |
True | f2u | null | Why? You could add an optional style checking mode that flags whitespace violations, and look at whitespace to improve error messages. GNAT does both. | null | 0 | 1316895077 | False | 0 | c2mb347 | t3_kooiy | null | t1_c2mb347 | t1_c2m22z3 | null | 1427642265 | -1 | t5_2fwo | null | null | null |
True | AStrangeStranger | null | The advantage of tests written before you start coding - you know where you are going and when you have got there (basically it is a spec and verification) - subject of course to GIGO. I find it works really well for integration tests or where you can treat things as black boxes. It also works really well when resolving bugs - you set up the test to replicate bug, then fix it.
Where I find it problematic is testing internals of a system as I find it better to keep in flow, rather than stop and write tests as I recognise missing testing of conditions /error handling | null | 0 | 1316895090 | False | 0 | c2mb369 | t3_kq001 | null | t1_c2mb369 | t1_c2m9yvv | null | 1427642256 | 1 | t5_2fwo | null | null | null |
True | lebski88 | null | It has to add enough value to justify both its development and its ongoing maintenance though. | null | 0 | 1316895098 | False | 0 | c2mb37f | t3_kq001 | null | t1_c2mb37f | t1_c2marsz | null | 1427642256 | 7 | t5_2fwo | null | null | null |
True | f2u | null | Indeed. To me, that is the far more pressing concern with a syntax that can lead to the dangling else ambiguity. | null | 0 | 1316895127 | False | 0 | c2mb3bb | t3_kooiy | null | t1_c2mb3bb | t1_c2lzxae | null | 1427642259 | 2 | t5_2fwo | null | null | null |
True | bobindashadows | null | Exactly. Just ask companies that actually live or die by scaling. I bet they all overprovision 50x just to keep their utilization under 2%.
Edit: Downvotes while he gets upvotes? Seriously? We're supposed to accept "I can't do *page generation* in a responsive way unless I drastically overprovision"? | null | 0 | 1316895194 | True | 0 | c2mb3kh | t3_kq27q | null | t1_c2mb3kh | t1_c2mb1p7 | null | 1427642261 | 9 | t5_2fwo | null | null | null |
True | DrMonkeyLove | null | >... you must first write a failing test for it that will be passed when it is completed - if the tests passed, you aren't allowed to edit the code.
So he's completely against rewriting hopelessly complex code that "works". I've seen some godawful code that passes all the test but had to be rewritten in order to ever add anything new. I guess the new stuff would be the test that fails I suppose. I'm just not a fan of one size fits all software engineering. It always ends up being too restrictive or not applicative in every case. | null | 0 | 1316895313 | False | 0 | c2mb407 | t3_kq001 | null | t1_c2mb407 | t1_c2ma3fc | null | 1427642268 | 3 | t5_2fwo | null | null | null |
True | FCof | null | I am not very familiar with Mozart. But according to its web page, it has been used in a number of research projects, there are many publications on the system, so... I think in a way it has been powering the future, and if they want to redesign parts of it is because there are still more Mozart ideas for the future! | null | 0 | 1316895313 | False | 0 | c2mb40g | t3_kpwjl | null | t1_c2mb40g | t1_c2m9k0b | null | 1427642268 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316895418 | False | 0 | c2mb4fe | t3_kq27q | null | t1_c2mb4fe | t1_c2m9na3 | null | 1427642274 | 1 | t5_2fwo | null | null | null |
True | Liorithiel | null | Sure, http://www.google.pl/chrome/eula.html?platform=linux | null | 0 | 1316895453 | False | 0 | c2mb4kr | t3_kq27q | null | t1_c2mb4kr | t1_c2m9na3 | null | 1427642276 | 3 | t5_2fwo | null | null | null |
True | mushishi | null | What specifically was interesting about this to have a need for letting us know about it? You could have at least provided a link to your demo. | null | 0 | 1316895635 | False | 0 | c2mb5ah | t3_kqa5d | null | t1_c2mb5ah | t3_kqa5d | null | 1427642286 | 2 | t5_2fwo | null | null | null |
True | neoquietus | null | Ah, I am glad you brought up corner and edge cases!
Basically what you would do is simply create more tests, each one covering a specific corner or edge case. There'd be a test to cover the clipping of a triangle when it is entirely off screen, one for when it is partially off screen, one for when two of its vertices are off-screen in a corner (a corner corner case, as it were), etc. Also, every time you find an error that was not caught by a test (IE: all your tests passed but there was still an error of some sort) you write a test that specifically finds that error. It prevents them from creeping back into your code.
>Hard-coding a SINGLE triangle and testing only that triangle isn't going to be much help.
Hard-coding a single value for testing is surprisingly useful, despite what it would look like at first glance. For example, suppose I am testing a function I have written that implements the COSINE operator. Given a value of 55 degrees, I expect the function to return 0.573 +/- 0.001. What are the odds that, assuming I didn't write the function specifically with the intent of falsely passing the test, that an error exists in the function, but that it still produces the correct output for 55 degrees? If I have initialized a variable incorrectly, the result will be way off. If any of my multiplications are in the wrong order, the result will be way off. If I use multiplication in a place where I should have used addition, the result will be way off. If I have an array access off-by-one error, the result will be way off.
Still, testing several hard-coded values can be useful. For single value inputs I like to test at least the following values: positive infinity, 1, 0, -1, negative infinity, and a number randomly selected from that range by my calculator's RAND function. | null | 0 | 1316895671 | False | 0 | c2mb5ey | t3_kq001 | null | t1_c2mb5ey | t1_c2mawgq | null | 1427642288 | -1 | t5_2fwo | null | null | null |
True | somecallmemike | null | I agree, I am looking forward to the newsql startups such as drizzle, mariadb, galera/mysql, scaledb, etc. We need better options, and Oracle is definitely not going to be the company to deliver (IMO). | null | 0 | 1316895959 | False | 0 | c2mb6io | t3_kpecl | null | t1_c2mb6io | t1_c2m76y9 | null | 1427642304 | 2 | t5_2fwo | null | null | null |
True | H-Resin | null | You misunderstood, I don't work in the US Patent Office, I work as a paralegal for a patent attorney. Most documents we see are translations from German into English, and for some reason we get apple-nokia lawsuits somewhat frequently. | null | 0 | 1316895974 | False | 0 | c2mb6kt | t3_kosg9 | null | t1_c2mb6kt | t1_c2m1p0i | null | 1427642305 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316895975 | True | 0 | c2mb6kx | t3_kqa5d | null | t1_c2mb6kx | t1_c2mb5ah | null | 1427642305 | 1 | t5_2fwo | null | null | null |
True | Dan_Farina | null | I was not aware of this limitation, but the amount of bile about this (comments along the line of "large memory usage in Javascript? Are you going full derp?") on Proggit is ridiculous. Javascript is a language with some of the most heavily optimized and widely deployed implementations in existence, *and* has good embedding and sandboxing characteristics. In this combination of attributes it is nearly unique.
Yes, the lack of regular integers is nearly insane, and the implicit type coercion rules definitely feel like a stab in the face, but it is what it is.
I, for one, am exploring use of plv8 on database-side execution to untrusted clients:
https://gist.github.com/1150804
It will probably be the fastest 'trusted' (i.e. safe to give to non-superusers) PostgreSQL PL integration, and I think will have huge implications in database use cases and in the database-as-a-service space, where giving someone full, unsandboxed python (or whatever) is not always an option.
Also, for laughs/horror:
http://bellard.org/jslinux/
| null | 0 | 1316895993 | True | 0 | c2mb6nh | t3_kq27q | null | t1_c2mb6nh | t3_kq27q | null | 1427642306 | 25 | t5_2fwo | null | null | null |
True | HaMMeReD | null | When I'm programming games and such, I change my API's and functionality of my app as how I see fit, and not up to some requirements document. Sure I have a overall architecture and plan, but I couldn't write tests without constantly breaking them and having to update and maintain them.
| null | 0 | 1316896179 | False | 0 | c2mb7ew | t3_kq001 | null | t1_c2mb7ew | t1_c2maobq | null | 1428193012 | 6 | t5_2fwo | null | null | null |
True | NoHandle | null | TDD is a good idea if you work on code other people will have to use. Basically anything substantial should be tested because it will lower maintenance costs substantially and reduce bugs on every release, especially the first one. | null | 0 | 1316896242 | False | 0 | c2mb7ol | t3_kq001 | null | t1_c2mb7ol | t1_c2marsz | null | 1427642317 | 1 | t5_2fwo | null | null | null |
True | _pupil_ | null | Total agreement :)
I watched a lecture on youtube the other day about genetics, and the lecturer said something that's really stuck with me: "There's no such thing as a bad gene, there's just a bad gene-environment fit".
At the end of the day I think most software engineering practices fall into the same boat. Less a matter of absolute good/bad, and more a reflection of the value that you'll get out of them for a given situation/problem.
| null | 0 | 1316896253 | False | 0 | c2mb7q6 | t3_kq001 | null | t1_c2mb7q6 | t1_c2maq99 | null | 1427642318 | -1 | t5_2fwo | null | null | null |
True | theoldboy | null | Exactly.
TDD is just the latest example of a new methodology that is very useful in the right place, but is seized upon by certain people and evangalized as The One True Way Of Coding which must now be used for **everything**, and if you don't then you suck. | null | 0 | 1316896600 | False | 0 | c2mb92r | t3_kq001 | null | t1_c2mb92r | t1_c2manpi | null | 1427642333 | 13 | t5_2fwo | null | null | null |
True | [deleted] | null | This is the same way many authors argue that we think about math.
Think about the common phrases when doing math.
1. The function goes to... (Going to is a physical notion).
2. The Set contains... (Containment is a physical idea)
3. This node(vertex) is between these nodes in this graph ( Between is a physical notion)
4. That number is bigger than that other number ( Bigness is a physical idea)
Very few working mathematicians think about math in foundational sense. That is in terms of Axiomatic Set Theory and the application of Ordering on those sets.
Your brain evolved to solve the problems it saw around. The very neural structures have a physical assumptions built in. We use and abuse them to do mathematics.
http://www.amazon.com/Where-Mathematics-Comes-Embodied-Brings/dp/0465037704
| null | 0 | 1316896612 | False | 0 | c2mb94d | t3_kp71h | null | t1_c2mb94d | t3_kp71h | null | 1427642336 | 8 | t5_2fwo | null | null | null |
True | theoldboy | null | [_DD: What do you practice?](http://blankdd.com/) | null | 0 | 1316896746 | False | 0 | c2mb9nc | t3_kq001 | null | t1_c2mb9nc | t3_kq001 | null | 1427642342 | 1 | t5_2fwo | null | null | null |
True | neoquietus | null | As a programmer in IT, let me tell you precious managers something. If I say that there are two methodologies we could use when we make thing X, where one way is quick and cheap but not extensible, and the other is slower and more expensive and more extensible, and you choose the cheaper way, don't come crying to me six months down the road when adding on to X is more expensive.
Methodologies matter. | null | 0 | 1316896814 | False | 0 | c2mb9vn | t3_kq001 | null | t1_c2mb9vn | t1_c2mabjt | null | 1427642344 | 8 | t5_2fwo | null | null | null |
True | [deleted] | null | No, we have multi-paradigm programming languages. It takes a while longer to learn such a language, but it is still a single language which can be learnt by and understood by several developers. | null | 0 | 1316896939 | False | 0 | c2mbae1 | t3_kos4z | null | t1_c2mbae1 | t1_c2m6t4x | null | 1427642354 | 5 | t5_2fwo | null | null | null |
True | eaturbrainz | null | And this is when you want algebraic data-types. | null | 0 | 1316896968 | False | 0 | c2mbahu | t3_kocub | null | t1_c2mbahu | t3_kocub | null | 1427642352 | 2 | t5_2fwo | null | null | null |
True | reten | null | Tdd is a way of reinforcing good habits.. Before you implement you should think about:
* Requirements
* Interfaces
* test cases
* dependencies
* Data / modeling
* then implementation.. | null | 0 | 1316897089 | False | 0 | c2mbaxg | t3_kq001 | null | t1_c2mbaxg | t1_c2m9yvv | null | 1427642358 | 4 | t5_2fwo | null | null | null |
True | xiongchiamiov | null | Oh god, thank you. One of my professors [has done a bit in TDD](http://www.google.com/search?q=david%20janzen%20tdd) and he addresses these sorts of complaints in his classes - the problem is that people received a one-sentence summary of TDD from someone who doesn't quite understand it, and they think it's just "write all your tests, then write your code", which is bollocks. You're spot on. | null | 0 | 1316897158 | False | 0 | c2mbb7g | t3_kq001 | null | t1_c2mbb7g | t1_c2m9xlh | null | 1427642361 | 1 | t5_2fwo | null | null | null |
True | reten | null | This!! Happened twice to me in the last two weeks.
/ shit, I have a lot of dependencies.. Time to redesign a bit /
| null | 0 | 1316897195 | False | 0 | c2mbbcm | t3_kq001 | null | t1_c2mbbcm | t1_c2m9u3g | null | 1427642363 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316897232 | False | 0 | c2mbbhe | t3_kqat8 | null | t1_c2mbbhe | t3_kqat8 | null | 1427642371 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Use a DSL, something like done in Clojure or Common Lisp -- like e.g.
(html
(body
(h1 "header")
(p "some text")))
..closing and balancing tags doesn't have to be painfull, and this will generate an error if one forget to close a tag. | null | 0 | 1316897327 | False | 0 | c2mbbut | t3_kos4z | null | t1_c2mbbut | t1_c2m0ams | null | 1427642370 | 5 | t5_2fwo | null | null | null |
True | paganel | null | > become a software ENGINEER
My father is a civil engineer, he has been in the construction business for about 30 years. Just recently his team built 2 hyper-markets, the sort of place where if the roof collapses because of winter snow (let's say) then 50 people die and the subject makes it on the opening of the TV news.
I just want to say that I never saw him "testing things first and then building them", he (and the other people in his profession) just plan the hell out of everything before construction starts. I don't think that makes him less of an "engineer", as I don't think programmers that don't follow the TDD mantra are some kids "hacking together toy software".
Also, if it matters, what I DID see my father doing during his entire professional career is that he tried to stay on top of the latest and (presumably) best technological developments in his field. I don't see that happening very often to our peers in the software industry (no, just following the latest fad because your boss told you so does not count as being knowledgeable about anything).
| null | 0 | 1316897359 | False | 0 | c2mbbzi | t3_kq001 | null | t1_c2mbbzi | t1_c2ma44y | null | 1427642373 | -6 | t5_2fwo | null | null | null |
True | sabowski | null | http://downloads.askmonty.org/mariadb/5.2.7/
Bottom of the list contains RPMs for centos and redhat | null | 0 | 1316897427 | False | 0 | c2mbc8t | t3_kpecl | null | t1_c2mbc8t | t1_c2mah1r | null | 1427642376 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | Why is Peaker being downvoted? He's right. | null | 0 | 1316897443 | False | 0 | c2mbcb4 | t3_kos4z | null | t1_c2mbcb4 | t1_c2m98th | null | 1427642377 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | tldr: Good techniques are useful but being anal and obsessive about them is not. | null | 0 | 1316897455 | False | 0 | c2mbccw | t3_kq001 | null | t1_c2mbccw | t3_kq001 | null | 1427642378 | 35 | t5_2fwo | null | null | null |
True | ttfkam | null | Late to the party; Netbeans had this months ago. | null | 0 | 1316897535 | False | 0 | c2mbcp2 | t3_kq0ms | null | t1_c2mbcp2 | t3_kq0ms | null | 1428193009 | -6 | t5_2fwo | null | null | null |
True | [deleted] | null | Hi, Norway here; we use Clojure. Have fun with Java and C# .. cya! | null | 0 | 1316897602 | False | 0 | c2mbcy5 | t3_kos4z | null | t1_c2mbcy5 | t1_c2lzpws | null | 1427642390 | 2 | t5_2fwo | null | null | null |
True | otheraccount | null | Starting with failing tests and watching them pass when the code is finished helps ensure that the tests actually work. If you write tests against working code, the tests you write may all pass but not really be testing anything properly. | null | 0 | 1316897741 | False | 0 | c2mbdhr | t3_kq001 | null | t1_c2mbdhr | t1_c2ma2w5 | null | 1427642404 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | Actually, you're the guy who couldn't learn Haskell. | null | 0 | 1316897777 | False | 0 | c2mbdnh | t3_kos4z | null | t1_c2mbdnh | t1_c2m10bf | null | 1427642396 | 5 | t5_2fwo | null | null | null |
True | robertwilliams | null | I remember writing some code once and decided I needed a new field w/ getter and setter in another class. I let the Eclipse auto-correct feature take care of it... but I forgot to ever go add the field itself and implement the getter and setter. That was a fun bug to track down. | null | 0 | 1316897809 | False | 0 | c2mbdro | t3_kq001 | null | t1_c2mbdro | t1_c2maz1x | null | 1427642401 | 1 | t5_2fwo | null | null | null |
True | eoliveri | null | Another reason to embrace TDD is that it can help to tighten up user requirements and to reduce creature feep.
| null | 0 | 1316897819 | False | 0 | c2mbdt5 | t3_kq001 | null | t1_c2mbdt5 | t3_kq001 | null | 1427642401 | 1 | t5_2fwo | null | null | null |
True | toaster13 | null | I 100% agree that there shouldn't be a random limit (I like that they simply don't know the limit of the 64bit V8) and that was a bug. That's fine. I still think the use case is also exposing a bug in the developer's approach to his application, not just in V8.
I work as a infrastructure architect and if one of my dev's came over and told me they need 32G of ram (minimum!) for their whiz-bang javascript based super high throughput application I'd be conducting a very thorough review of exactly what they were up to and why. Needing 32G of memory is not self justifying. That big of a memory footprint usually indicates heavy data crunching or passing and javascript is not an appropriate or efficient language for either of those things. | null | 0 | 1316897866 | False | 0 | c2mbdzm | t3_kq27q | null | t1_c2mbdzm | t1_c2mav50 | null | 1427642405 | 15 | 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.