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 | [deleted] | null | [deleted] | null | 0 | 1316886064 | False | 0 | c2ma4gh | t3_kq001 | null | t1_c2ma4gh | t3_kq001 | null | 1427641804 | 4 | t5_2fwo | null | null | null |
True | tau-lepton | null | It can also aid in designing your classes and methods. Often, but not always, if something is hard to write units tests against there is a design problem. | null | 0 | 1316886095 | False | 0 | c2ma4kl | t3_kq001 | null | t1_c2ma4kl | t1_c2ma2w5 | null | 1427641813 | 63 | t5_2fwo | null | null | null |
True | garymrush | null | Writing test code, especially in TDD is not just about getting your code to work - it's about productivity. The cost of failing code goes up dramatically the further it gets from the programmer. A bug you just wrote, identified in a test and fix costs a few minutes. A bug in integration can take hours. A bug in deployment can take days. | null | 0 | 1316886159 | False | 0 | c2ma4tu | t3_kq001 | null | t1_c2ma4tu | t1_c2m9xhn | null | 1427641811 | 6 | t5_2fwo | null | null | null |
True | StrangeWill | null | >TDD is extremely valuable for elaborate or sensitive business logic.
This most of all, finally got tests set up on our continuous integration server and have been enforcing testing various outcomes on our business logic layer, it's great! I've found already a handful of somewhat rare situations that caused minor issues, and they've been easily fixed, and extending the testing on large parts of the library with different factors is much easier than having someone QA it (we don't actually have dedicated QA, so a lot can slip through), and much easier to program than our Selenium grid (which I complain about it breaking with every minor UI change, I'll look into fixing that sometime later though...). | null | 0 | 1316886163 | False | 0 | c2ma4uc | t3_kq001 | null | t1_c2ma4uc | t1_c2m9mji | null | 1427641811 | 4 | t5_2fwo | null | null | null |
True | tau-lepton | null | I also like having tests on existing code, especially someone else's, so I know if I've broken something doing a refactor. There are often holes in the written specs, often the hole being the complete absence of such. | null | 0 | 1316886234 | False | 0 | c2ma54i | t3_kq001 | null | t1_c2ma54i | t1_c2ma2jp | null | 1427641815 | 5 | t5_2fwo | null | null | null |
True | alekseykorzun | null | Delivering a mission critical trading software while working with dozen de-centralized engineering teams? Yes, you will have to employ architects to define the tests prior to building.
Delivering anything less critical? Have a good team that can communicate and read the specs? Do they know what they are doing? Skip the TDD and save your self time and headaches.
I don't care if you are a super engineer, you will have to re-factor some aspects of the application when changes are prompted from engineering level, systems level or business level during building/initial public launch.
While you are in launch stage do a x/x split and assign engineers to fixing any fires that will pop-up or changes and latter will start writing tests for the application.
By the time you have to do a second release of software you will have the tests you wanted (and this is where they are most useful, to make sure this new release will not break any of your existing logic).
| null | 0 | 1316886245 | False | 0 | c2ma56c | t3_kq001 | null | t1_c2ma56c | t3_kq001 | null | 1427641816 | 1 | t5_2fwo | null | null | null |
True | IrishWilly | null | Regardless of your stance on TDD, neither the article or Loubsers comment gave much of an argument for either. They both sound like the bullshit 'my style is better than yours; you must not be a *real* coder' crap that seems to plague programming blogs. | null | 0 | 1316886271 | False | 0 | c2ma59s | t3_kq001 | null | t1_c2ma59s | t1_c2m9zus | null | 1427641817 | 37 | t5_2fwo | null | null | null |
True | alk509 | null | TIL that paying grunts to stress test your app automagically fixes bugs! | null | 0 | 1316886319 | False | 0 | c2ma5gq | t3_kq001 | null | t1_c2ma5gq | t1_c2m9xhn | null | 1427641819 | 4 | t5_2fwo | null | null | null |
True | NowTheyTellMe | null | You can map the lines of suasion by watching the linguistic mimicry in groups. It can provide insight into where the thought centers of the organization lie, and who must be influenced to achieve specific action. | null | 0 | 1316886330 | False | 0 | c2ma5il | t3_kogj4 | null | t1_c2ma5il | t1_c2m1sry | null | 1427641819 | 2 | t5_2fwo | null | null | null |
True | tau-lepton | null | Being a mediocre programmer, I've come to use tests as a mechanism to improve. It's pretty clear I've screwed something up when my tests get large and/or complex. | null | 0 | 1316886349 | False | 0 | c2ma5kv | t3_kq001 | null | t1_c2ma5kv | t1_c2m9z2z | null | 1427641820 | 8 | t5_2fwo | null | null | null |
True | IrishWilly | null | All you have to do is build a full simulation of the real world as your test suite and your 10 line script will be bullet proof! | null | 0 | 1316886362 | False | 0 | c2ma5mn | t3_kq001 | null | t1_c2ma5mn | t1_c2m9yp6 | null | 1427641821 | 20 | t5_2fwo | null | null | null |
True | garymrush | null | I agree that a good set of tests help others, especially during refactoring. Test-DRIVEN-Development however is about you. You only write the code you need because you're only writing it to satisfy your test. You only wrote that test because you wanted a feature. You factor complexity out of your code because it makes it easier to test. These are all strategies that help you write good code efficiently. | null | 0 | 1316886446 | False | 0 | c2ma5y9 | t3_kq001 | null | t1_c2ma5y9 | t1_c2m9zc3 | null | 1427641823 | 8 | t5_2fwo | null | null | null |
True | d4m45t4 | null | Spot on. I used to hate on TDD just like the author until I finally understood it. | null | 0 | 1316886449 | False | 0 | c2ma5yt | t3_kq001 | null | t1_c2ma5yt | t1_c2ma42r | null | 1427641823 | 8 | t5_2fwo | null | null | null |
True | StrawberryFrog | null | > No one knows what the fuck TDD is ... flavor of the month
I recommend the book "Test Driven Development" by Kent Beck, 2002. It may not be the last word in TTD, but I think it ticks the boxes of showing that 1) Some people do actually know what TTD is quite well, and 2) it is not a short-lived fad. | null | 0 | 1316886475 | True | 0 | c2ma62d | t3_kq001 | null | t1_c2ma62d | t1_c2ma1vb | null | 1427641825 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316886515 | True | 0 | c2ma684 | t3_kq27q | null | t1_c2ma684 | t1_c2m9jlp | null | 1427641830 | 0 | t5_2fwo | null | null | null |
True | tau-lepton | null | I follow that for the most part, I run non time consuming test suite about five times per hour, and the time consuming tests on each commit, every two hours or so. | null | 0 | 1316886560 | False | 0 | c2ma6e2 | t3_kq001 | null | t1_c2ma6e2 | t1_c2ma3fc | null | 1427641829 | 0 | t5_2fwo | null | null | null |
True | garymrush | null | Having done TDD for a number of years, I know what it means to me. It may or may not be the flavor of the month, but it is a real strategy for writing software. I suppose I may have already waded through the proverbial lake of shit :) | null | 0 | 1316886592 | False | 0 | c2ma6hy | t3_kq001 | null | t1_c2ma6hy | t1_c2ma1vb | null | 1427641830 | 5 | t5_2fwo | null | null | null |
True | tau-lepton | null | And you can still get wet sitting under a roof. | null | 0 | 1316886643 | False | 0 | c2ma6p2 | t3_kq001 | null | t1_c2ma6p2 | t1_c2m9sun | null | 1427641841 | 5 | t5_2fwo | null | null | null |
True | dakboy | null | Because they have no concept of memory management? | null | 0 | 1316886687 | False | 0 | c2ma6v3 | t3_kq27q | null | t1_c2ma6v3 | t1_c2ma0km | null | 1427641835 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | Angry nerd used RANT.
It's not very effective. | null | 0 | 1316886768 | False | 0 | c2ma75s | t3_kq001 | null | t1_c2ma75s | t3_kq001 | null | 1427641839 | 0 | t5_2fwo | null | null | null |
True | hacksoncode | null | You know, the biggest thing I've always wondered about "test driven development" is "what process do you use to develop your tests?". | null | 0 | 1316886800 | False | 0 | c2ma7a5 | t3_kq001 | null | t1_c2ma7a5 | t3_kq001 | null | 1427641839 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316886871 | False | 0 | c2ma7jn | t3_kpk5f | null | t1_c2ma7jn | t1_c2m54qn | null | 1428193036 | 1 | t5_2fwo | null | null | null |
True | ZorbaTHut | null | > If your tests are complex, that's a smell that your code is too complex.
What if it's a sign that your project is complex? | null | 0 | 1316887033 | False | 0 | c2ma881 | t3_kq001 | null | t1_c2ma881 | t1_c2m9xlh | null | 1427641855 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316887070 | False | 0 | c2ma8db | t3_kq001 | null | t1_c2ma8db | t1_c2ma4kl | null | 1427641857 | 14 | t5_2fwo | null | null | null |
True | Trevoke | null | I got a new point of view on TDD when I saw it described as **Test-Driven Design**.
Indeed, you don't need to write tests first all the time - but you should always write tests and code at the same time. | null | 0 | 1316887073 | False | 0 | c2ma8dq | t3_kq001 | null | t1_c2ma8dq | t3_kq001 | null | 1427641860 | 1 | t5_2fwo | null | null | null |
True | ex_ample | null | If you *can* write your tests before your code then chances are you're not working on anything particularly interesting. Like, how would you write 'tests' for a 3D engine before you actually start coding it? Or a video codec?
If you're writing 'business logic' where all you have to do is take data from one source, transform it, and move it another source then yeah, obviously it would be possible to write the tests first.
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.
It would be just as easy to write a separate version of the software, and compare the results as a test. Sometimes I actually do this: I'll write one version that just stores data in memory, and then write the complex version that uses files or a database, and compare the results. | null | 0 | 1316887193 | False | 0 | c2ma8ta | t3_kq001 | null | t1_c2ma8ta | t3_kq001 | null | 1427641864 | 9 | t5_2fwo | null | null | null |
True | sebzim4500 | null | I was blown away by the vibrant community over there. | null | 0 | 1316887326 | False | 0 | c2ma9bc | t3_kmevq | null | t1_c2ma9bc | t1_c2m1nc7 | null | 1427641871 | 2 | t5_2fwo | null | null | null |
True | starspangledpickle | null | You hit the nail on the head, but a lot of developers take TDD to mean *Unit*test-Driven Development, which it may not necessarily involve.
Testing a complex UI is next to impossible to do efficiently and in a scalable manner with unit tests; for that you need automated ui testing. | null | 0 | 1316887344 | False | 0 | c2ma9e0 | t3_kq001 | null | t1_c2ma9e0 | t1_c2m9mji | null | 1427641872 | 6 | t5_2fwo | null | null | null |
True | garymrush | null | Yes, writing a failing test before modifying code is important to TDD, but you don't need to run a "small test suite every time a single line of code" changes. Just test, code and refactor - in that order. If the author had more experience with TDD rather than just reading about it, I doubt we'd be having this nice chat. | null | 0 | 1316887485 | False | 0 | c2ma9x7 | t3_kq001 | null | t1_c2ma9x7 | t1_c2ma3fc | null | 1427641876 | 2 | t5_2fwo | null | null | null |
True | gbacon | null | So when does refactoring take place? | null | 0 | 1316887574 | False | 0 | c2maaa6 | t3_kq001 | null | t1_c2maaa6 | t1_c2ma3fc | null | 1427641881 | 2 | t5_2fwo | null | null | null |
True | chowychow | null | C has real/high performance collection classes. Library format. Precompile | null | 0 | 1316887583 | False | 0 | c2maabi | t3_kq27q | null | t1_c2maabi | t1_c2ma3ge | null | 1427641880 | 3 | t5_2fwo | null | null | null |
True | bobindashadows | null | To find more on what you've stumbled onto here, you'll want to look into *first-class environments*. Here's a good primer link: [Abstract Heresies](http://funcall.blogspot.com/2009/09/first-class-environments.html) | null | 0 | 1316887603 | False | 0 | c2maaem | t3_kpqzv | null | t1_c2maaem | t1_c2m75qr | null | 1427641880 | 6 | t5_2fwo | null | null | null |
True | markatto | null | I wouldn't call it a "horrid monstrosity." It's still better than traditional syslog. Rsyslog is the way to go these though, it supports tls for remote logging. | null | 0 | 1316887632 | False | 0 | c2maais | t3_kpecl | null | t1_c2maais | t1_c2m98t9 | null | 1427641880 | 4 | t5_2fwo | null | null | null |
True | kamatsu | null | Don't ask me, ask Bob Martin. | null | 0 | 1316887656 | False | 0 | c2maam3 | t3_kq001 | null | t1_c2maam3 | t1_c2maaa6 | null | 1427641882 | 3 | t5_2fwo | null | null | null |
True | andytuba | null | A few complex tests sound okay, but the theory is that you should still have lots of smaller bits of code which can be tested with small tests. | null | 0 | 1316887663 | False | 0 | c2maanj | t3_kq001 | null | t1_c2maanj | t1_c2ma881 | null | 1427641883 | 2 | t5_2fwo | null | null | null |
True | pingveno | null | None, True, and False are converted to constants in Python 3. Adding them as keywords is how the conversion is implemented. No one should assign to any of them anyway. Python 3 is just enforcing that good practice. For the speed demons, the conversion eliminates an unnecessary global lookup. The bytecode compiler can generate highly efficient code for:
while True:
...
Before, people used 1 instead of True because True required a global lookup. Now, it directly loads the C values Py_None/Py_True/Py_False without a lookup. Use the dis module to see what I mean. | null | 0 | 1316887795 | False | 0 | c2mab58 | t3_kos4z | null | t1_c2mab58 | t1_c2m98g0 | null | 1427641889 | 3 | t5_2fwo | null | null | null |
True | mentalbrew | null | The only issue I have with this response is that too many simple CRUD applications become a code hairball that just gets bigger and bigger over time. Perhaps you could add testing as you start to implement behavior further from basic CRUD. | null | 0 | 1316887803 | False | 0 | c2mab6p | t3_kq001 | null | t1_c2mab6p | t1_c2m9mji | null | 1427641889 | 5 | t5_2fwo | null | null | null |
True | panfist | null | >I see great value in having unit tests, but less value in insisting that the tests get written before the code they test.
Well, it's just one way of insuring that the tests actually get written, ever. If you or your team is disciplined, I don't think it matters when the tests are written. | null | 0 | 1316887821 | False | 0 | c2mab9f | t3_kq001 | null | t1_c2mab9f | t1_c2m9yvv | null | 1427641890 | 5 | t5_2fwo | null | null | null |
True | andytuba | null | Are we reading the same article? | null | 0 | 1316887836 | False | 0 | c2mabbm | t3_kq001 | null | t1_c2mabbm | t1_c2m8q2w | null | 1427641891 | 1 | t5_2fwo | null | null | null |
True | ItsNotMeReally | null | As a manager in IT, let me tell you precious little developers something. You can argue all fucking day long about whose dick is bigger than whose. You can make fun of one another. You can hate one another. You can read some article in a magazine about how you've found the latest greatest thing: agile, extreme programming, TDD, DDD, and the list of stupid fucking ideas goes on. I don't even care if you write your code and masturbate on your monitor because you used lambda expressions in C# while the VB.Net guys had to write a bunch of extra code.
I don't fucking care about any of that. But your work still better be done on time, under budget and better fucking work and make us a profit. If not, you are fired, and I don't care what kind of cocksucking methodology you are using.
And that's real. | null | 0 | 1316887894 | True | 0 | c2mabjt | t3_kq001 | null | t1_c2mabjt | t3_kq001 | null | 1427641897 | -19 | t5_2fwo | null | null | null |
True | NewbieProgrammerMan | null | It's ok, PimpDawg's BDD is a private member that's only used within the context of the MakingShitloadsOfMoneyOnPHBIgnorance class.
*Edit: typo* | null | 0 | 1316887987 | False | 0 | c2mabxb | t3_kq001 | null | t1_c2mabxb | t1_c2m9xva | null | 1427641899 | 2 | t5_2fwo | null | null | null |
True | i_ate_god | null | there is no point in 100% coverage. You're going to write tests for getters and setters? c'mon... | null | 0 | 1316888037 | False | 0 | c2mac44 | t3_kq001 | null | t1_c2mac44 | t1_c2ma8db | null | 1427641902 | 19 | t5_2fwo | null | null | null |
True | LainIwakura | null | Yes, Zombie Mozart rose up and implemented his virtual machine about 10 years ago. Unfortunately he was dissatisfied so recently he rose up again to redesign it. | null | 0 | 1316888080 | False | 0 | c2macaj | t3_kpwjl | null | t1_c2macaj | t1_c2m9jfu | null | 1427641903 | 12 | t5_2fwo | null | null | null |
True | toddffw | null | Downvote. This guy is an amateur. | null | 0 | 1316888102 | False | 0 | c2macdp | t3_kq001 | null | t1_c2macdp | t3_kq001 | null | 1427641905 | -7 | t5_2fwo | null | null | null |
True | i_ate_god | null | the author doesn't hate TDD. He hates the promotion of it as a one-size-fits-all solution, which any methodology is not. | null | 0 | 1316888112 | False | 0 | c2macfv | t3_kq001 | null | t1_c2macfv | t1_c2ma5yt | null | 1428193031 | 25 | t5_2fwo | null | null | null |
True | cdsmith | null | > I don't think you necessarily have to write 100% of your tests up front to be practicing test-driven development, but some purists may disagree.
That's a meaningless semantic distinction. Test-driven development implies writing your tests first, so to the extent that you aren't writing your tests before you write code designed to make those use cases work, of course you aren't doing 100% TDD.
That said, no one does 100% TDD anyway. It's a stupid goal, and would be a complete waste of your time to obsess over whether you're *really* doing TDD or not in every corner of your project. You should do TDD when it helps you, and not when it doesn't. That implies continuing to use good judgement. It means that all sorts of factors, like what problem you're solving, what other tools you're using, whether your language has static types, whether you have a solid formalism or just a collection of use cases... every one of these things enters into your value judgement of whether to follow the TDD process closely, or just junk it and do what you know is right.
I can't imagine many people would disagree with that... but people often surprise me. | null | 0 | 1316888143 | False | 0 | c2macki | t3_kq001 | null | t1_c2macki | t1_c2ma2jp | null | 1427641908 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | Huh, I'm an designer and lead engineer on a large project and Dawid Loubser sounds like the exact kind of asshole contractor I walk out the door after suffering with his bullshit for a couple weeks. OMG YOU'RE DOING IT WRONG I AM CERTIFIED IN XXX AND HAVE WORKED AT MANY LARGE COMPANIES AND THIS IS THE WORST XXX I'VE EVER SEEN AND.... and we have a long history of delivering very high quality software on time without busting our ass to fit some bullshit methodology, so thank you for your time but your services are no longer required. | null | 0 | 1316888201 | False | 0 | c2macsi | t3_kq001 | null | t1_c2macsi | t1_c2m9u47 | null | 1427641911 | 22 | t5_2fwo | null | null | null |
True | cdsmith | null | That's definitely not TDD, then. If you're just trying to get unit tests written, then that's called unit testing. If you see unit testing as an objective approach to software design, and the tests themselves as benevolent side effects of that design process, that's TDD. Of course, in the real world, you'll always be doing something of a hybrid. | null | 0 | 1316888263 | False | 0 | c2mad11 | t3_kq001 | null | t1_c2mad11 | t1_c2ma2w5 | null | 1427641914 | 13 | t5_2fwo | null | null | null |
True | gronkkk | null | Not anymore. Earlier, there was a paragraph about how the author didn't want to hire anyone who ran his own mail server (and who would be obsessing over the advantages of qmail or postfix in an interview) instead of choosing google's service. | null | 0 | 1316888379 | False | 0 | c2madh3 | t3_kq001 | null | t1_c2madh3 | t1_c2mabbm | null | 1427641929 | 4 | t5_2fwo | null | null | null |
True | matthieum | null | Using tabs only is chaotic (everyone has their own preferences for the tab expansion length). Using a mix of tabs and whitespaces is error-prone (in whitespace aware languages), as it might not work so well with reindentation.
The real bummer, of course, is that tabs are "invisible": they look like regular whitespaces but are not. I've got enough to look for already, I don't have time to look for "invisible" bugs. | null | 0 | 1316888460 | False | 0 | c2madrr | t3_kooiy | null | t1_c2madrr | t1_c2m363z | null | 1427641927 | 3 | t5_2fwo | null | null | null |
True | i_ate_god | null | > In unit testing one should always test bits of functionality called 'methods'. If you find them to big to test, split them up in several smaller ones.
If you're writing tests for all your methods, you're wasting time. There are plenty of methods that will get tested implicitly.
100% code coverage is usually, but not always, a pointless goal. | null | 0 | 1316888483 | False | 0 | c2maduv | t3_kq001 | null | t1_c2maduv | t1_c2m9snj | null | 1427641929 | 18 | t5_2fwo | null | null | null |
True | StrangeWill | null | >Why the fuck is anyone writing an application that consumes 32GB of memory in Javascript?
Because learning other languages is hard, derp. | null | 0 | 1316888523 | False | 0 | c2mae06 | t3_kq27q | null | t1_c2mae06 | t1_c2ma0km | null | 1427641930 | 12 | t5_2fwo | null | null | null |
True | matthieum | null | Certainly. Never said otherwise. I was just explaining the joke as your comment looked like you had not got it. | null | 0 | 1316888539 | False | 0 | c2mae31 | t3_kooiy | null | t1_c2mae31 | t1_c2m2ia9 | null | 1427641931 | 2 | t5_2fwo | null | null | null |
True | summerteeth | null | I thought I read that Gmail's backend was written in Javascript. Sounded strange to me but it's hard to argue with the results.
EDIT: argh downvotes, should have known better than to post this without a citation
>At the USENIX annual conference last month, Gmail engineer Adam de Boor surprised the audience by noting that the company's Gmail service was written entirely in JavaScript, and that all of its code, around 443,000 lines worth, was written by hand.
[http://www.infoworld.com/d/developer-world/google-executive-frustrated-java-c-complexity-375
](http://www.infoworld.com/d/developer-world/google-executive-frustrated-java-c-complexity-375) | null | 0 | 1316888542 | True | 0 | c2mae3l | t3_kq27q | null | t1_c2mae3l | t1_c2m9jlp | null | 1427641931 | -6 | t5_2fwo | null | null | null |
True | StrangeWill | null | I have no problem saying that PHP is terrible.
Popular, easy, flexible, _I still use it_, but terrible. | null | 0 | 1316888615 | False | 0 | c2maedg | t3_kq27q | null | t1_c2maedg | t1_c2m9mhe | null | 1427641933 | 16 | t5_2fwo | null | null | null |
True | andytuba | null | Ah. Shame that Blogger doesn't implement a "*" edited indicator. | null | 0 | 1316888632 | False | 0 | c2maefl | t3_kq001 | null | t1_c2maefl | t1_c2madh3 | null | 1427641934 | 5 | t5_2fwo | null | null | null |
True | cdsmith | null | Oh, good point... I assumed that when he talked about writing tests first, he meant for the specific bit of code you're about to write. If he really is arguing against writing *all* tests first, then of course that's dumb. But I don't see any indication of that in the article. | null | 0 | 1316888636 | False | 0 | c2maeg6 | t3_kq001 | null | t1_c2maeg6 | t1_c2m9xlh | null | 1427641934 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316888695 | True | 0 | c2maeod | t3_kp1b5 | null | t1_c2maeod | t1_c2m8sme | null | 1427641936 | 1 | t5_2fwo | null | null | null |
True | ash_gti | null | Perl and Perl6 have this capability.
In perl you can use PadWalker to look at lexically scoped variables and subroutine pads.
In perl6 there is a much richer set of tools for this, including a number of tools to analyze lexical and package scopes and traverse them in a very straight forward way. The psuedo package OUTER, for instance, will just move 1 lexpad up. In perl 5 you need to do PadWalker::my_peek (1); to move up 1 lexpad, but its not all that difficult all things considered. | null | 0 | 1316888736 | False | 0 | c2maetr | t3_kpqzv | null | t1_c2maetr | t1_c2m7oxh | null | 1427641937 | 2 | t5_2fwo | null | null | null |
True | matthieum | null | It's not a work around. C++ is the language I use the most, and it is not whitespace aware :)
It is just that copy-pasting is "dumb", I think. I prefer to recopy manually because it works around the limitation of my *brain*, which needs some time to process things. By rewriting, in my own style, with my own naming convention, I am taking the time to assimilate the information. | null | 0 | 1316888747 | False | 0 | c2maevm | t3_kooiy | null | t1_c2maevm | t1_c2m2ho6 | null | 1427641938 | 5 | t5_2fwo | null | null | null |
True | karlhungus | null | AFAIK TDD doesn't imply integration tests at all. | null | 0 | 1316888849 | False | 0 | c2maf9w | t3_kq001 | null | t1_c2maf9w | t1_c2m8qvx | null | 1427641943 | 3 | t5_2fwo | null | null | null |
True | akmark | null | I feel that database software is the kind of thing that needs rocket-science level consistency or else it completely fails. If you can't trust your database 100% then you can and will find something else. TDD is the guarantee you can hang your hat on in that case. I mean it's like the standard library of any language, if it doesn't work how it says in the spec you can't help but feel personally WRONGED for it. | null | 0 | 1316888931 | False | 0 | c2maflm | t3_kq001 | null | t1_c2maflm | t1_c2ma0kq | null | 1428193029 | 6 | t5_2fwo | null | null | null |
True | 0xABADC0DA | null | > I broadly agree that many of 0xABADC0DA's downvotes are unwarranted ...
> It's naive when programmers think it's enough to win on technical merits alone.
Pretty much describes this thread.
> However, HTTP pipelining has been a part of the standard for over a decade and nobody uses it.
Even the downvoters here couldn't bury my post saying pipelining is used and works so I really doubt nobody uses it. Also it is [enabled by default](http://en.wikipedia.org/wiki/HTTP_pipelining#Implementation_in_web_browsers) in Opera.
> This makes me think there are fundamental issues involved.
*What* fundamental issues? A problem with this thread is that people haven't been able to express why pipelining can't and shouldn't be fixed (programmers saying something is 'impossible' and 'cannot be done', Turing would be rolling over in his grave if he had one).
> In a thread above, 0xABADC0DA has gotten himself into a situation where he's arguing over details of the USB standardization process, as if this will prove that design-by-committee can produce clean, fast results. I hardly think the problems of design-by-committee need to be strongly argued
Yes I posted too many replies on side-issues and minor points. Mostly in this case I just wanted to understand your point of view better, you see I feel that committees actually produce better results on average. But with a committee there's almost always somebody you can easily blame, the committee itself, the competitors that participated in it, etc.
Look I understand the downvotes. Spdy is from Google, so saying that Spdy is a poor solution to the problem / unnecessary offends many Google fans. The blog post about implementing it is by Mozilla, so it offends Firefox fans when I say they are aping Google (like with version numbers, UI, etc). And I also supported the work of committees. That certainly covers a majority of readers here that would downvote posts just because they don't like the point being made.
I had hoped that somebody could have actually responded with technical merits of Spdy though. | null | 0 | 1316888937 | False | 0 | c2mafmb | t3_kp1b5 | null | t1_c2mafmb | t1_c2m8sme | null | 1428193029 | 2 | t5_2fwo | null | null | null |
True | matthieum | null | Or you're going to remove the last catch clause because you never got the test to fire it anyway; so it'll never happen, right ? | null | 0 | 1316888965 | False | 0 | c2mafrd | t3_kq001 | null | t1_c2mafrd | t1_c2mac44 | null | 1427641952 | 0 | t5_2fwo | null | null | null |
True | Zephyrix | null | MSVC actually has an option to enable this for your own applications under C/C++ -> Code Generation | null | 0 | 1316888975 | False | 0 | c2mafsv | t3_kmshh | null | t1_c2mafsv | t3_kmshh | null | 1427641952 | 2 | t5_2fwo | null | null | null |
True | ash_gti | null | CL would of never occurred had people not been evolving existing lisps implementations. Its not bad for a language/paradigm/eco-system to evolve. | null | 0 | 1316889115 | False | 0 | c2magce | t3_kp1pf | null | t1_c2magce | t1_c2m7dsv | null | 1427641967 | 5 | t5_2fwo | null | null | null |
True | argv_minus_one | null | I'm talking about the site. It looks like a bad dot-com. | null | 0 | 1316889121 | False | 0 | c2magd9 | t3_kpecl | null | t1_c2magd9 | t1_c2maais | null | 1427641967 | 3 | t5_2fwo | null | null | null |
True | matthieum | null | I don't see the relationship between writing test before/after code (which is the debate), and you mention of UI testing (which is hellish, I agree). | null | 0 | 1316889139 | False | 0 | c2magfh | t3_kq001 | null | t1_c2magfh | t1_c2ma9e0 | null | 1427641958 | 2 | t5_2fwo | null | null | null |
True | xiongchiamiov | null | Well, sure. :)
But seriously, I've never understood how people consider it a feature to be able to check in code with terrible-ass formatting. That's the sort of thing I block with a pre-commit hook - it makes your code look ugly and pisses off anyone who uses different tab-expansion rules than you. | null | 0 | 1316889278 | False | 0 | c2magya | t3_kooiy | null | t1_c2magya | t1_c2m4qqw | null | 1427641966 | 2 | t5_2fwo | null | null | null |
True | jzwinck | null | Great for Debian-based systems, but not Red Hat ones. | null | 0 | 1316889303 | False | 0 | c2mah1r | t3_kpecl | null | t1_c2mah1r | t1_c2m6cfv | null | 1427641967 | 0 | t5_2fwo | null | null | null |
True | dngrmouse | null | kendall square, of course. (groan) | null | 0 | 1316889403 | False | 0 | c2maheo | t3_kow8f | null | t1_c2maheo | t1_c2lzdi5 | null | 1427641972 | 1 | t5_2fwo | null | null | null |
True | matthieum | null | I ticked on "if the tests passed, you aren't allowed to edit the code" too.
I suppose the idea was not to oppose refactoring, but to oppose adding new functionalities / patching bugs without adding the appropriate tests before. | null | 0 | 1316889486 | False | 0 | c2mahq7 | t3_kq001 | null | t1_c2mahq7 | t1_c2maaa6 | null | 1427641978 | 3 | t5_2fwo | null | null | null |
True | xiongchiamiov | null | If I have getters and setters, they're doing something important - not all of us have to write in Java. | null | 0 | 1316889503 | False | 0 | c2mahso | t3_kq001 | null | t1_c2mahso | t1_c2mac44 | null | 1427641979 | 22 | t5_2fwo | null | null | null |
True | ZorbaTHut | null | It's a nice *idea*, but for some projects, the source of bugs tend to be the complex interactions between small bits of code. Unit testing is great for verifying that your code works as intended, but it doesn't help for verifying that your intentions don't have bugs.
I'm in the game industry, and I gotta say that I've never come up with a sensible way to unit-test most of the stuff I work on. To say nothing about how often those unit tests would have to be changed. | null | 0 | 1316889537 | False | 0 | c2mahxb | t3_kq001 | null | t1_c2mahxb | t1_c2maanj | null | 1427641979 | 13 | t5_2fwo | null | null | null |
True | comment-dwim | null | Are we talking about [first-class environments](http://rosettacode.org/wiki/First_class_environments) or just closures whose bindings have [indefinite extent](http://www.ida.liu.se/imported/cltl/clm/node43.html)? | null | 0 | 1316889553 | False | 0 | c2mahz8 | t3_kpqzv | null | t1_c2mahz8 | t1_c2m7oxh | null | 1427641980 | 3 | t5_2fwo | null | null | null |
True | stillalone | null | There's an ssize_t. A lot of Unix commands return negative numbers for errors or a positive size. | null | 0 | 1316889568 | False | 0 | c2mai19 | t3_kq27q | null | t1_c2mai19 | t1_c2m9gcv | null | 1427641981 | 8 | t5_2fwo | null | null | null |
True | xiongchiamiov | null | Eh, TDD is very specifically about having tests written first. The point is not to have tests that insure you haven't broken anything, but rather to have tests that tell you when to stop writing code. If you write the code first, then you may be writing too much. | null | 0 | 1316889669 | False | 0 | c2maie0 | t3_kq001 | null | t1_c2maie0 | t1_c2mab9f | null | 1427641984 | 1 | t5_2fwo | null | null | null |
True | MillardFillmore | null | Ive had numpy arrays of several GB in the past. Why didn't I recode everything in C++? Because I didn't want to spend two days recoding something that took an hour in Python.
There are legitimate reasons when you just want to try something big out. | null | 0 | 1316889718 | False | 0 | c2maikv | t3_kq27q | null | t1_c2maikv | t1_c2ma0km | null | 1427641987 | 41 | t5_2fwo | null | null | null |
True | [deleted] | null | We were once assigned the exercise of devising our own binary image format to encode a small picture file filled with basic shapes. The basic idea was to invent BMP all over. Instead, I devised a crappy binary vector format for the lulz. Teacher allowed it. :) | null | 0 | 1316889751 | False | 0 | c2maip8 | t3_gvnfk | null | t1_c2maip8 | t1_c1qmnr1 | null | 1427641987 | 1 | t5_2fwo | null | null | null |
True | starspangledpickle | null | Nor did I make that relationship, but I suppose the comment is a bit off tangent. Nevertheless, it is still a frequent mistake made by people who use TDD. | null | 0 | 1316889781 | False | 0 | c2mait5 | t3_kq001 | null | t1_c2mait5 | t1_c2magfh | null | 1427641990 | 1 | t5_2fwo | null | null | null |
True | xiongchiamiov | null | Kent Beck once said "I'm not a great programmer, I'm a pretty good programmer with great habits.". This is pretty much what I strive for. | null | 0 | 1316889850 | False | 0 | c2maj2i | t3_kq001 | null | t1_c2maj2i | t1_c2ma5kv | null | 1427641993 | 12 | t5_2fwo | null | null | null |
True | [deleted] | null | Wow. How on earth did you go through with it? As a naturally lazy person, I would've instantly looked everywhere for something involving less effort. | null | 0 | 1316889853 | False | 0 | c2maj31 | t3_gvnfk | null | t1_c2maj31 | t1_c1qnt14 | null | 1427641993 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I totally agree to that, unit tests for trivial methods like setters and getters are a waste of time. | null | 0 | 1316889874 | False | 0 | c2maj64 | t3_kq001 | null | t1_c2maj64 | t1_c2maduv | null | 1427641993 | 1 | t5_2fwo | null | null | null |
True | kanistr | null | Isn't this an apples to oranges comparison? You bring the benefits of V8 vs the CPython interpreter. The same things can be said about any other more performant language environment, including python's pypy. So, it appears that the ONLY benefit of using javascript the language instead of something else (the point brought by crusoe) is that you can share server side and client side code. But honestly is this such a big deal as people tend to make it out?
| null | 0 | 1316889888 | True | 0 | c2maj85 | t3_kq27q | null | t1_c2maj85 | t1_c2m9lex | null | 1427642002 | 1 | t5_2fwo | null | null | null |
True | Koreija | null | > Yes, college programmers often believe this.
No I know it, because none of the candidates without degree were ever able to reason about their code or to just formulate simple properties and invariants. Even on a lower level most of them never heard of many error classes.
> College trained developers generate significantly larger code to
> accomplish the same goal, and it is significantly more full of error.
Because more knowledge leads to more errors and UNix, KISS, suckless, dietlibc... were censored by universities.
> I've never once gotten UML from a self trained programmer.
Of course, they never learned to write specifications. They start without thinking and in better cases add some test cases with low coverage.
> Oh look, he's a style zealot, what a surprise.
No, I prefer task specific paradigms and languages. Same problem - I never met a "self-taught" programmer who was able to switch type systems, languages, paradigms. Ok - sometimes languages, but they were all the same (C#, Java, Python...). And yes, last decade showed that there are no advantages in OOP over other paradigms.
> If you have a degree, you aren't interested in jobs.
You have a greater choice, especially with interesting jobs.
> bunch of religious garbage
Yeah, the typical "I'm better without a degree because I didn't know all da shit". The mechanic is better than someone with a degree in automotive engineering, the programmer is better than a CS...
> and always produces superior results
See, you even ignored the direction of my implication. Bad fault in my job. | null | 0 | 1316890065 | False | 0 | c2majww | t3_khkyd | null | t1_c2majww | t1_c2m8sx7 | null | 1427642004 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316890192 | False | 0 | c2make1 | t3_kq001 | null | t1_c2make1 | t1_c2mac44 | null | 1427642010 | 2 | t5_2fwo | null | null | null |
True | diroussel | null | It's probably a Spanish vs French thing, judging by the authors name. | null | 0 | 1316890196 | False | 0 | c2maker | t3_knoub | null | t1_c2maker | t1_c2lqz8a | null | 1427642010 | 1 | t5_2fwo | null | null | null |
True | andytuba | null | Ah, yep. a $20/hr QA team still proves useful.
I hear you on updating tests. When I first learned about TDD, I recoiled at the thought of how much time I'd need to spend doing test maintenance in addition to code. I suppose it's the price of good development, but -- as has been mentioned in other threads -- hard to do on a money/time budget. | null | 0 | 1316890257 | False | 0 | c2makmi | t3_kq001 | null | t1_c2makmi | t1_c2mahxb | null | 1427642024 | 3 | t5_2fwo | null | null | null |
True | RedSpikeyThing | null | I seem to remember him saying that your first test should fail because the function your testing doesn't yet exist. I would wager his argument would be write a test for the new function/class/whatever you're pulling out and watch it fail because it doesn't exist yet.
It's a retarded idea. | null | 0 | 1316890351 | False | 0 | c2makzc | t3_kq001 | null | t1_c2makzc | t1_c2maaa6 | null | 1428193023 | 2 | t5_2fwo | null | null | null |
True | MatrixFrog | null | Monkey patching is possible in Python too. | null | 0 | 1316890366 | False | 0 | c2mal1j | t3_kq27q | null | t1_c2mal1j | t1_c2m9k9d | null | 1427642028 | -1 | t5_2fwo | null | null | null |
True | GetOffTheBus | null | Yes, it all depends where in the onion you are. If you're at the middle, then you'll want a lot of tiny checks to maintain consistency for the rest of the layers. If you're on the outer edges of the onion, then it's better to have testing that tries to simulate actual use of the onion, like use testing or smoke testing. | null | 0 | 1316890399 | False | 0 | c2mal5o | t3_kq001 | null | t1_c2mal5o | t1_c2ma0kq | null | 1427642031 | 3 | t5_2fwo | null | null | null |
True | RedSpikeyThing | null | Unit tests should not be complex. Something larger like integration tests are necessarily complex. | null | 0 | 1316890412 | False | 0 | c2mal7f | t3_kq001 | null | t1_c2mal7f | t1_c2ma881 | null | 1427642032 | 2 | t5_2fwo | null | null | null |
True | neoquietus | null | Often, yes. This is not because I doubt the ability of the compiler to do it correctly; it is because the getter/setter may be updated in the future to have more complicated behavior and/or side-effects, such as caching. | null | 0 | 1316890524 | False | 0 | c2malmi | t3_kq001 | null | t1_c2malmi | t1_c2mac44 | null | 1427642037 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | What the fuck am I reading? | null | 0 | 1316890577 | False | 0 | c2malt7 | t3_gvnfk | null | t1_c2malt7 | t1_c1qm5z9 | null | 1427642040 | 1 | t5_2fwo | null | null | null |
True | flussence | null | You seem to be missing the point, which is that you're wrong in implying MariaDB is somehow deficient because you have to actually be able to think to install it in your distro of choice. Google Chromium was late getting into most distro repositories too, does that make it a bad browser? | null | 0 | 1316890662 | False | 0 | c2mam4a | t3_kpecl | null | t1_c2mam4a | t1_c2m9vy4 | null | 1427642045 | -1 | t5_2fwo | null | null | null |
True | HammerOfThor | null | Bah, my personal pet peeve is treating TDD (or any methodology) as some sort of religious experience so that if you criticize it must be because you "don't get it". 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. This attitude stifles discussions and constructive criticism from bubbling up.
| null | 0 | 1316890704 | False | 0 | c2mam9u | t3_kq001 | null | t1_c2mam9u | t1_c2m9zus | null | 1427642047 | 29 | t5_2fwo | null | null | null |
True | zero_iq | null | C does not have collection classes. The only 'collection' provided by C is the array. C does not have a concept of 'class'.
C does not have a library format. If you're thinking of .lib, .o, .so, then that's not C the language, that's the development environment/OS.
C does not provide management of precompiled artifacts. Build systems/compilers may do, but C, as a language, doesn't.
C, the language, provides none of those things.
I'm not at all knocking C, I'm just trying to highlight how none of those things limits what can be done with the language itself, and what is provided by development and runtime environment, which is independent of the language specification. | null | 0 | 1316890712 | True | 0 | c2maman | t3_kq27q | null | t1_c2maman | t1_c2maabi | null | 1427642047 | 12 | t5_2fwo | null | null | null |
True | i_ate_god | null | and thankfully so :P
but I just use getters and setters as an example. Code is full of triviality that do not need explicit tests. | null | 0 | 1316890758 | False | 0 | c2mamhh | t3_kq001 | null | t1_c2mamhh | t1_c2mahso | null | 1427642049 | 9 | t5_2fwo | null | null | null |
True | ZorbaTHut | null | > I suppose it's the price of good development, but -- as has been mentioned in other threads -- hard to do on a money/time budget.
Yeah, I think that's one of the core conflicts I have with TDD. It's all well and nice to say "this is what code should ideally be like given infinite time and budget", but reality doesn't work that way. I want to know how I can produce the best end product in the least amount of time and money.
If you've got an idea that makes my end product 5% better and costs 1% more, I'm all ears. If you've got an idea that makes my end product 10% better and costs 100% more, GTFO. Test driven design sometimes seems like it's leaning more towards the latter. | null | 0 | 1316890789 | False | 0 | c2mamm1 | t3_kq001 | null | t1_c2mamm1 | t1_c2makmi | null | 1427642052 | 4 | t5_2fwo | null | null | null |
True | dodehoekspiegel | null | C is also simple, which Haskell isn't in the slightest. | null | 0 | 1316890818 | False | 0 | c2mampj | t3_kpqzv | null | t1_c2mampj | t1_c2ma3gr | null | 1427642052 | 3 | 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.