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 | immerc | null | In that case, for you, the fact that Python doesn't lend itself to copying and pasting may not be a drawback. For other people, it is.
I don't copy and paste directly into an editor then check something in. For me, the best way to understand code that's posted somewhere is to copy and paste it, then start modifying it -- throw in print statements, rename variables, re-order things. Once I've done that, I'll understand it.
Different people handle programming differently, but if possible, your language shouldn't get in the way of your preferred workflow.
| null | 0 | 1316904010 | False | 0 | c2mbzz6 | t3_kooiy | null | t1_c2mbzz6 | t1_c2maevm | null | 1427642685 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | Agreed - It's about balance.
In some systems, where there is plenty of time and a frozen spec, I can design the low level functionality and know it won't fundamentally change. In that case I've found TDD useful (although, in truth, I tend to develop tests and code in parallel).
On the other hand, when the code is in a state of flux TDD doesn't work. How can I write unit tests for method A if in a day or two method A will be discarded and replaced by methods B and C?
Often these changes of direction happen after I've started coding. You may say that I'm a crappy developer because I should nail the design down before starting coding. Unfortunately, I live in the real world where clients want something yesterday, other vendors are working on their parts of the system and haven't nailed down the interfaces yet, and I can't afford to sit and wait for them. Better to refactor 25% of the code later than to not start at all and have to do 100% of it in a rush. In that situation TDD is nonsense - tests get written after the code has coalesced.
| null | 0 | 1316904078 | False | 0 | c2mc08p | t3_kq001 | null | t1_c2mc08p | t1_c2m9yvv | null | 1427642688 | 2 | t5_2fwo | null | null | null |
True | StrangeWill | null | I'm shifting towards implementing TDD for specific new features (stuff like shared libraries that will be used on a lot of projects, central BLLs for our reporting, etc.), and if we were doing TDD I wouldn't be going back and fixing stuff implementing the tests afterwards.
The whole complaint here about TDD that the article seems to center around is relying on your developers for testing, in my circumstance it saves us time and bugs that even if we had QA they wouldn't catch. | null | 0 | 1316904191 | True | 0 | c2mc0jn | t3_kq001 | null | t1_c2mc0jn | t1_c2mbyen | null | 1427642693 | 2 | t5_2fwo | null | null | null |
True | cryo | null | Writing a test is a very limited form of design, one that has a hard time ensuring that your algorithm runs in O(n) time, say, and other things like that. | null | 0 | 1316904300 | False | 0 | c2mc10e | t3_kq001 | null | t1_c2mc10e | t1_c2mbgb9 | null | 1427642707 | 2 | t5_2fwo | null | null | null |
True | PriscaDoulos | null | Go tell that to the guys at Oracle. | null | 0 | 1316904556 | False | 0 | c2mc1zb | t3_kq27q | null | t1_c2mc1zb | t1_c2ma0km | null | 1427642714 | 1 | t5_2fwo | null | null | null |
True | tekknolagi | null | I believe he did it for speed, as well | null | 0 | 1316904601 | False | 0 | c2mc25a | t3_kpqzv | null | t1_c2mc25a | t1_c2ma3gr | null | 1427642715 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | I knew some people at Bloomberg that were using Mono to run .NET code on WinNT4. They make some strange technology choices over there. | null | 0 | 1316904648 | False | 0 | c2mc29u | t3_kq27q | null | t1_c2mc29u | t1_c2m9xl6 | null | 1427642718 | 10 | t5_2fwo | null | null | null |
True | cryo | null | You're confusing tests with test driven development. | null | 0 | 1316904675 | False | 0 | c2mc2fd | t3_kq001 | null | t1_c2mc2fd | t1_c2m9zc3 | null | 1427642718 | 4 | t5_2fwo | null | null | null |
True | sporkexec | null | Fortunately, PHP doesn't support monkeypatching unless you use [runkit](http://www.php.net/manual/en/ref.runkit.php), which is an awful hack. I'm sure this is more a consequence of its brittle design rather than an actual decision, though. | null | 0 | 1316904797 | False | 0 | c2mc2uw | t3_kq27q | null | t1_c2mc2uw | t1_c2m9mhe | null | 1427642727 | 1 | t5_2fwo | null | null | null |
True | cryo | null | Testing != TDD | null | 0 | 1316904835 | False | 0 | c2mc2zn | t3_kq001 | null | t1_c2mc2zn | t1_c2ma4gh | null | 1427642725 | 5 | t5_2fwo | null | null | null |
True | rafekett | null | Most people don't know ML/Haskell but most do know C, and tool support is better for C. | null | 0 | 1316905102 | False | 0 | c2mc3yu | t3_kpqzv | null | t1_c2mc3yu | t1_c2ma3gr | null | 1427642746 | 4 | t5_2fwo | null | null | null |
True | VikingCoder | null | Having code that is *testable* is the point, I think.
TDD is a way to force that.
The only other value of TDD in my mind is that you end up with tests, which can establish a contract. If a developer breaks a test you wrote, they've broken a contract that you think you depend on. You two should hash it out, and figure out what to do. | null | 0 | 1316905122 | False | 0 | c2mc41i | t3_kq001 | null | t1_c2mc41i | t1_c2m9yvv | null | 1427642747 | 1 | t5_2fwo | null | null | null |
True | jmdugan | null | possibly, yes. it seems from the two replies to my comment, there is some extra meaning to this phrase "test driven development" I've missed | null | 0 | 1316905147 | False | 0 | c2mc44n | t3_kq001 | null | t1_c2mc44n | t1_c2mc2fd | null | 1427642742 | 1 | t5_2fwo | null | null | null |
True | argv_minus_one | null | >If it's truly trivial code, the tests are trivial and take very little time to write or maintain.
Just because it's a waste of a small amount of time doesn't mean it isn't a waste of time. | null | 0 | 1316905195 | False | 0 | c2mc4an | t3_kq001 | null | t1_c2mc4an | t1_c2mbiky | null | 1427642746 | 2 | t5_2fwo | null | null | null |
True | jyper | null | python never supported backticks for execing.Backticks
return string representation. | null | 0 | 1316905225 | False | 0 | c2mc4ei | t3_kpqzv | null | t1_c2mc4ei | t1_c2mbhkf | null | 1427642749 | 3 | t5_2fwo | null | null | null |
True | mikef22 | null | And boasting that he gets to "hire and fire" developers. So we'd all better listen to him confusing TDD for testing. | null | 0 | 1316905386 | False | 0 | c2mc4sv | t3_kq001 | null | t1_c2mc4sv | t1_c2mc2fd | null | 1427642751 | -1 | t5_2fwo | null | null | null |
True | MatrixFrog | null | So it's more of a problem with the way the language is used, than a flaw in the design of the language itself? At least to some extent... | null | 0 | 1316905415 | False | 0 | c2mc4wl | t3_kq27q | null | t1_c2mc4wl | t1_c2mb2cb | null | 1427642753 | 3 | t5_2fwo | null | null | null |
True | ruberik | null | Suppose that someone said, "Your screwdrivers can only hammer in 100 nails before breaking, and I need to hammer in 3,200 of them," you'd be justified in assuming that person was using the wrong tool whether the screwdriver was flawed or not. | null | 0 | 1316905444 | False | 0 | c2mc4zy | t3_kq27q | null | t1_c2mc4zy | t1_c2mbqav | null | 1427642754 | 11 | t5_2fwo | null | null | null |
True | cryo | null | Testing != TDD | null | 0 | 1316905579 | False | 0 | c2mc5h3 | t3_kq001 | null | t1_c2mc5h3 | t1_c2ma0kq | null | 1427642760 | 8 | t5_2fwo | null | null | null |
True | BraveSirRobin | null | Agreed, but I'm not sure what you mean by boilerplate duplication; by "boilerplate" I mean things like setters and getters whose location is more relevant than the trivial code\* they contain. You can't really abstract this kind of "duplication".
\* Here in the UK this is often called "Noddy Code", from [this](http://en.wikipedia.org/wiki/Noddy_%28character%29). | null | 0 | 1316905624 | False | 0 | c2mc5mp | t3_kq001 | null | t1_c2mc5mp | t1_c2mbiky | null | 1427642759 | 3 | t5_2fwo | null | null | null |
True | cryo | null | Mission critical software existed before TDD | null | 0 | 1316905775 | False | 0 | c2mc64z | t3_kq001 | null | t1_c2mc64z | t1_c2ma56c | null | 1427642769 | 5 | t5_2fwo | null | null | null |
True | BraveSirRobin | null | But how do you get the instance of that inner class out of your original one to do test asserts on? Any class that retains "state" might need to expose the state object for testing. Wrapping this data up in another object (while useful for other reasons) doesn't help this problem. | null | 0 | 1316905809 | False | 0 | c2mc68v | t3_kq001 | null | t1_c2mc68v | t1_c2mbvit | null | 1427642780 | 4 | t5_2fwo | null | null | null |
True | nanothief | null | His advice isn't bullshit, and is pretty easy to do with the right tools. With something like autotest, all relevant tests are run when any code is changed. This gives great feedback if you accidentally break a unit test while working on another problem.
Also, his advice to write a unit test before changing any code only applies when you need to add or change some functionality that isn't covered by existing tests. For example, if you receive a bug report that the program crashes when a negative value is given for a users net worth, to fix the bug you should write a new unit test that ensures that situation is handled correctly.
If you are changing code for performance or refactoring reasons, you don't need to write any new tests. The existing tests will give you very good confidence on getting the changes right without introducing new bugs. | null | 0 | 1316905980 | False | 0 | c2mc6ui | t3_kq001 | null | t1_c2mc6ui | t1_c2ma3fc | null | 1427642778 | 0 | t5_2fwo | null | null | null |
True | _pupil_ | null | Very true - you could always test after-the-fact, and if you managed to achieve the same level of coverage and test quality your code should, in theory, be as stable and more resistent to errors as with TDD. I just don't think that's going to happen 9 times out of 10 ;)
To start with you would lose out on at least some of the benefits to design, code quality, and ease of refactoring... also, most experimentation is made simpler when you have test scaffolding in place... and you wouldn't actively avoid 'rabbit holing' yourself on solutions that aren't 100% lined up with the eventual use of the code. IMO these are are significant factors that play in to avoiding costly support during development and over the entire lifetime of the product.
If you're committed to code quality and test coverage - and if you're not I hope you never work on anything critical to peoples lives - then I think you have to look around: how many projects testing after-the-fact are managing to do that, and do that well?
There's never time tomorrow, you're always going to be busy. Discounting future time leads to painful results... IMO if you're going to test at all, it's only going to happen if it comes first. That also means you get to reap the most reward from your work. | null | 0 | 1316906039 | False | 0 | c2mc72a | t3_kq001 | null | t1_c2mc72a | t1_c2mbz4k | null | 1427642780 | 2 | t5_2fwo | null | null | null |
True | Iggyhopper | null | Someone actually said, "Your screwdrivers can only do a certain thing 100 times before breaking, and I need to do it 3,200 times."
You don't assume things. | null | 0 | 1316906042 | False | 0 | c2mc72q | t3_kq27q | null | t1_c2mc72q | t1_c2mc4zy | null | 1427642780 | 5 | t5_2fwo | null | null | null |
True | Fabien4 | null | I recently got a dedicated server for an application. I basically got OVH's cheapest "serious" server, and got... 24 GB RAM. Now I have to find *some* use for all that RAM...
| null | 0 | 1316906078 | False | 0 | c2mc77t | t3_kq27q | null | t1_c2mc77t | t1_c2ma0km | null | 1427642781 | 1 | t5_2fwo | null | null | null |
True | TheMeansofProduction | null | [Larry Ellison](http://news.cnet.com/8301-13953_3-10052188-80.html) | null | 0 | 1316906161 | False | 0 | c2mc7i2 | t3_kq001 | null | t1_c2mc7i2 | t1_c2mb0ur | null | 1427642784 | 5 | t5_2fwo | null | null | null |
True | gthank | null | Ah. I can see how that might be a pain for some things. Most of my C was classroom, and trivial enough I didn't need to do math on the size of things very often. Thanks for the info. | null | 0 | 1316906367 | False | 0 | c2mc86p | t3_kq27q | null | t1_c2mc86p | t1_c2mbvcb | null | 1427642792 | 2 | t5_2fwo | null | null | null |
True | _pupil_ | null | If you can, get your hands on a nice refactoring tool - it makes worlds of difference.
At any rate: something that pops up a lot in some codebases is that tests tend to do a lot. A single test will cover multiple aspects of functionality and multiple interfaces. This can make refactoring a pain.
Personally I use my tests to show me when I'm trying to do too much. If I see a test getting above a few lines, barring special circumstances, chances are I'm putting too much into the object I'm working with. Bulky tests are a clear sign to refactor, and the result is that you end up with a much more 1:1 relationship with your code and your tests and much more focused objects. In that case, when your tests are simple and minimalistic, any refactoring will become *much* simpler as you're just physically moving less code.
Combine that with some basic refactoring support (rename and extract method), and code just flies out.
| null | 0 | 1316906832 | False | 0 | c2mc9u0 | t3_kq001 | null | t1_c2mc9u0 | t1_c2mbv0l | null | 1427642825 | 3 | t5_2fwo | null | null | null |
True | BraveSirRobin | null | > it's not to test the implementation, the internal state of the object after certain operations.
The problem imho is that the design spec often dictates what this should be and therefore it needs tested. This is where code coverage tests are an opposite to "good" testing. Properly testing the spec is far more important than making Emma happy. ;-) | null | 0 | 1316906862 | False | 0 | c2mc9zb | t3_kq001 | null | t1_c2mc9zb | t1_c2mbuv1 | null | 1427642818 | 3 | t5_2fwo | null | null | null |
True | _pupil_ | null | And by "me six months from now" you mean "me when I come home from the bar and am inspired to code". | null | 0 | 1316906949 | False | 0 | c2mca5n | t3_kq001 | null | t1_c2mca5n | t1_c2mbhcm | null | 1427642822 | 1 | t5_2fwo | null | null | null |
True | BraveSirRobin | null | That's pretty much what I do, but I can't help but think that more planning might make the skeletal part unnecessary. | null | 0 | 1316906981 | False | 0 | c2mcaap | t3_kq001 | null | t1_c2mcaap | t1_c2mbtm7 | null | 1427642824 | 1 | t5_2fwo | null | null | null |
True | _pupil_ | null | Yeah, for some kinds of prototypes, especially if you're playing with a new language, it doesn't always make sense.
For experimentation though I find TDD invaluable. It give me such a quick feedback cycle for testing out new code. Especially when working with an entirely new technology (I gotta do *what* with DCOM?), it can give you the confidence to know that your code works even if you're no expert.
Oftentimes I test for the output I want and just hack in a single function until it (suddenly) works. Then I refactor like a madman :) | null | 0 | 1316907373 | False | 0 | c2mcbf9 | t3_kq001 | null | t1_c2mcbf9 | t1_c2mbhck | null | 1427642841 | 1 | t5_2fwo | null | null | null |
True | mm9k | null | Thanks | null | 0 | 1316907408 | False | 0 | c2mcbjc | t3_kq001 | null | t1_c2mcbjc | t1_c2mc7i2 | null | 1427642842 | 1 | t5_2fwo | null | null | null |
True | shizzy0 | null | It's true that hard-coding a single test case will not catch edge cases like that. However, it does give you a net of modest guarantees that your code works on those simple cases--no need to run it manually to find that out. Without those tests, you always have to go to exercising the code manually. If you do find edge cases, great! Add those to your test cases. | null | 0 | 1316907728 | False | 0 | c2mccoz | t3_kq001 | null | t1_c2mccoz | t1_c2mawgq | null | 1427642852 | 3 | t5_2fwo | null | null | null |
True | joemoon | null | "The computer industry is the only industry that is more fashion-driven than women's fashion."
[Larry Ellison](http://en.wikipedia.org/wiki/Larry_Ellison) | null | 0 | 1316907835 | False | 0 | c2mcd2a | t3_kq001 | null | t1_c2mcd2a | t1_c2mb0ur | null | 1427642856 | 18 | t5_2fwo | null | null | null |
True | expertunderachiever | null | No, different distros [which we test in] don't all support the same version of the tools. They all have C90 compilers though... Imagine that. We write portable code with tools that any self-respecting distro should have. | null | 0 | 1316907890 | False | 0 | c2mcd9w | t3_kos4z | null | t1_c2mcd9w | t1_c2m8vg7 | null | 1427642859 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316907987 | False | 0 | c2mcdlq | t3_kq27q | null | t1_c2mcdlq | t1_c2ma684 | null | 1427642863 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316908060 | False | 0 | c2mcdvp | t3_kq27q | null | t1_c2mcdvp | t1_c2mae3l | null | 1427642868 | 2 | t5_2fwo | null | null | null |
True | TikiTDO | null | If your tests aren't getting written, that's a critical management failure. Forcing your developers to write tests when they would not otherwise suggests to me that you are hiding a much more fundamental problem in how you organize your developers. Sure, you could go down the Agile Development checklist all you want, but you still need to understand your product and your programmers before you can even hope for a clean release. | null | 0 | 1316908249 | False | 0 | c2mcek2 | t3_kq001 | null | t1_c2mcek2 | t1_c2ma2w5 | null | 1427642879 | 1 | t5_2fwo | null | null | null |
True | gadgster | null | Targeting only webkit browsers on mobile platforms is a sensible choice at the moment. But, a few years ago, a similar argument was made for only targeting IE6 on the desktop. A lot of sites did this and most people know the pain this caused going forward.
Whilst this comparison isn't really fair, I think that using a library that attempts to abstract your site from mobile browser differences and provide graceful fallback for clients missing capabilities is worthwhile.
| null | 0 | 1316908297 | True | 0 | c2mceq3 | t3_kpgmn | null | t1_c2mceq3 | t1_c2m7vkp | null | 1427642881 | 2 | t5_2fwo | null | null | null |
True | seabre | null | >So it's more of a problem with the way the language is used
Exactly. | null | 0 | 1316908326 | False | 0 | c2mcets | t3_kq27q | null | t1_c2mcets | t1_c2mc4wl | null | 1427642887 | 1 | t5_2fwo | null | null | null |
True | keithb | null | Don't ask objects for data, instruct them to do something with the data they have. TDD can have a profound effect on design and this is one manifestation of this. TDD code tends towards the functional, because mutating state is hard to test, and tends towards the "tell, don't ask" style. | null | 0 | 1316908425 | False | 0 | c2mcf6e | t3_kq001 | null | t1_c2mcf6e | t1_c2mc68v | null | 1427642890 | 15 | t5_2fwo | null | null | null |
True | pingveno | null | > Why not do the same for various other constants?
None, True, and False are the only constants that weren't already built into the language. Look at the contents of dir(\_\_builtins\_\_). Now it's only classes and functions.
I haven't heard about the optimizations you speak of, but I doubt that they can beat the implementation of LOAD_CONST. From what I can tell, it takes 2-4 x86 instructions for the constant lookup itself.
x = consts->ob_item[oparg];
consts is a tuple and oparg is the argument to the LOAD_CONST opcode. | null | 0 | 1316908454 | False | 0 | c2mcfae | t3_kos4z | null | t1_c2mcfae | t1_c2maw1d | null | 1427642893 | 3 | t5_2fwo | null | null | null |
True | meddlepal | null | Time to get a new girlfriend if she cares that much about the appearance of a plate. | null | 0 | 1316908483 | False | 0 | c2mcfe7 | t3_kogj4 | null | t1_c2mcfe7 | t1_c2m4n0d | null | 1427642893 | -1 | t5_2fwo | null | null | null |
True | keithb | null | Don't write tests for getters and setters. (Mainly, don't write getters and setters). But do ensure that the getters and setters you do write are covered by tests. These don't have to be tests for the getters and setters. | null | 0 | 1316908564 | False | 0 | c2mcfod | t3_kq001 | null | t1_c2mcfod | t1_c2mac44 | null | 1428192995 | 8 | t5_2fwo | null | null | null |
True | [deleted] | null | I do for getters and setters on Mbeans - to verify their basic functionality, which is to delegate everything to the managed object. | null | 0 | 1316908612 | False | 0 | c2mcfuf | t3_kq001 | null | t1_c2mcfuf | t1_c2mac44 | null | 1427642899 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316908629 | False | 0 | c2mcfwh | t3_kq27q | null | t1_c2mcfwh | t1_c2mbe5e | null | 1427642900 | 1 | t5_2fwo | null | null | null |
True | Stormflux | null | I don't know about that. I tend to have getters and setters for everything, just because. Even if they don't have any implementation, as in:
public class Foo
{
string SomeString { get; set; }
int SomeInteger { get; set; }
// rest of the class omitted
}
I mean, I guess technically it isn't needed, but it's so easy, you might as well. And I've gotten used to seeing it that way, so it throws me off for a second if it's not there. | null | 0 | 1316908786 | False | 0 | c2mcgfz | t3_kq001 | null | t1_c2mcgfz | t1_c2mahso | null | 1427642906 | 0 | t5_2fwo | null | null | null |
True | teabagged | null | So... This article presupposes a magical fantasy land where developers make all the business decisions. Obviously nothing should be dogmatic including TDD, but there is plenty of value in it. | null | 0 | 1316908799 | False | 0 | c2mcghq | t3_kq001 | null | t1_c2mcghq | t3_kq001 | null | 1427642906 | 1 | t5_2fwo | null | null | null |
True | keithb | null | TDD has been around for a lot longer than 10 years. It's about as old as those other techniques you mention. | null | 0 | 1316908844 | False | 0 | c2mcgn9 | t3_kq001 | null | t1_c2mcgn9 | t1_c2mbx7n | null | 1427642908 | -1 | t5_2fwo | null | null | null |
True | musman | null | This might not be exactly programming, but I think web developers who use SASS/SCSS might like using Bootstrap.
Here's the homepage for [Sassy Boots](http://usmanity.com/sassy-boots/) | null | 0 | 1316908865 | False | 0 | c2mcgpp | t3_kqfos | null | t1_c2mcgpp | t3_kqfos | null | 1427642909 | 1 | t5_2fwo | null | null | null |
True | oSand | null | No, no. It was Oscar Wilde. | null | 0 | 1316909023 | False | 0 | c2mch9o | t3_kq001 | null | t1_c2mch9o | t1_c2mc7i2 | null | 1427642913 | 3 | t5_2fwo | null | null | null |
True | BraveSirRobin | null | State is a nightmare for testing but it's sometimes unavoidable e.g. when you are modelling something real world that has state. A lot of code that interfaces with the outside world requires it, e.g Telco switches where states are "in-call", "available" etc etc. In another comment I mention doing a lot of GUI automated testing, in terms of "state" it's the worst of all as things like Tree UIs and popup dialogs make managing it a necessity to track state and code workarounds to restore it when an error occurs. That's PITA and then some!
The only way around that in lower-level code is to pass the state into each method call, so that it exists outside of the class. The return object would be the updated state. Is that what you are suggesting? | null | 0 | 1316909137 | False | 0 | c2mchog | t3_kq001 | null | t1_c2mchog | t1_c2mcf6e | null | 1427642917 | 3 | t5_2fwo | null | null | null |
True | pinguz | null | > I have yet to see unit-tests that account for every possible state of the system they test
Probably because that's obviously impossible and not the goal of unit testing in the first place. You write unit tests that test certain inputs and border cases, and later extend them to test more specific scenarios if and when needed. You'll never be able to test every possible input, and you never need to. | null | 0 | 1316909214 | False | 0 | c2mchyd | t3_kq001 | null | t1_c2mchyd | t1_c2mbwl2 | null | 1427642921 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316909290 | False | 0 | c2mci86 | t3_kq27q | null | t1_c2mci86 | t1_c2mcdlq | null | 1427642924 | 0 | t5_2fwo | null | null | null |
True | argv_minus_one | null | JavaScript engines are optimized for *browser scripting,* not massive server-side number-crunching. This issue is an example of that. | null | 0 | 1316909433 | False | 0 | c2mcir9 | t3_kq27q | null | t1_c2mcir9 | t1_c2mb6nh | null | 1428192994 | 11 | t5_2fwo | null | null | null |
True | berlinbrown | null | It isn't a party. It is just whenever the particular IDE will bring support. | null | 0 | 1316909458 | True | 0 | c2mciua | t3_kq0ms | null | t1_c2mciua | t1_c2mbcp2 | null | 1427642932 | 6 | t5_2fwo | null | null | null |
True | jeffdavis | null | From a purely technical standpoint, you're right.
But a software fork is not a technical problem (and not even necessarily a problem). If it is a problem, it's a social problem -- nobody is quite sure where to go. MariaDB? Drizzle? SkySQL? Stay with Oracle?
And the choice *is* important. Where do you get your updates? Can you trust the releases to be relatively stable/robust, or do they just throw the code out there, and let you figure out if it's stable or not? Is there a vibrant community that has enough resources to meet needs as they come up, or is it struggling to find the time to answer your bug report? Which projects can attract real engineering talent? Real customers?
That's one of the advantages of postgresql. No real forks, it gets good releases out reliably, the dot-zero releases are relatively stable, it's got a robust community, it's attracting good engineering talent from a variety of sources, and there are real customers that push it enough to help make it better.
MySQL had some of those things before it was bought, but now it's in a fairly awkward position. | null | 0 | 1316909481 | True | 0 | c2mciww | t3_kpecl | null | t1_c2mciww | t1_c2m8qv9 | null | 1427642933 | 7 | t5_2fwo | null | null | null |
True | twistedrapier | null | Good managers already know this. They go out of their way to help facilitate stuff like this because it gets the product out the door with less headaches. Only space fillers like ItsNotMeReally don't get that. | null | 0 | 1316909530 | False | 0 | c2mcj44 | t3_kq001 | null | t1_c2mcj44 | t1_c2mb9vn | null | 1427642937 | 3 | t5_2fwo | null | null | null |
True | TikiTDO | null | Where do you see anything dismissing unit testing? The entire article is about the holy mantra of writing your tests before your business logic. Sure, there are people that do this and love it, but it is certainly not the only way, nor the single best way to code. I personally find that injecting tests into my code too early breaks my flow, and leaves me foundering in the details when I could (and would) easily resolve those issues at a conceptual level. Every single time I have tried it, I found myself wasting a huge amount of time going back and forth between my tests and business logic trying to fix intermediate bugs that would have gotten ironed out well before the final version.
Since then I switched to my current method where I simply understand my code well enough to apply a very generalized debugging and testing framework to ensure it is moving in the right direction, then write my actual tests once I have ironed out most of the problems, and have a decent baseline. This way I do not have to interrupt my thought process in mid-stride just because I had earlier thought it was a good place to have a test right there, but I still get a full range of tests to ensure my final product is maintainable. Granted, I have the ability to keep very low level details of a ridiculously huge system in my head, but that just goes to show that you should always be aware of your own (And others') limitations and abilities before trying to sell one method as being the one best way. | null | 0 | 1316909658 | False | 0 | c2mcjkf | t3_kq001 | null | t1_c2mcjkf | t1_c2m9zus | null | 1427642942 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | It is hard to understand FFT without first understanding the Fourier Transform in general. Have you taken PDEs? | null | 0 | 1316909688 | False | 0 | c2mcjo6 | t3_kogj4 | null | t1_c2mcjo6 | t1_c2lw9ta | null | 1427642943 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | If you want to continute this discussion on /r/law,
http://www.reddit.com/r/law/comments/kqd4b/alright_rlaw_what_do_you_think_useful_tool_for/
tl;dr it's completely ineffective. | null | 0 | 1316909817 | False | 0 | c2mck4c | t3_k6mf5 | null | t1_c2mck4c | t3_k6mf5 | null | 1427642949 | 1 | t5_2fwo | null | null | null |
True | keithb | null | Not necessarily. That's the monadic solution that, say, Haskell uses to manage state. You can get there with TDD but it's not required. The object maintains state between method calls, it doesn't have to be maintained outside the object.
Take your telco example. It may well be that a call object has states such as you mention, but there is almost never any unavoidable reason to expose which of those states it is in at the interface of the object. The object knows its state, tell it what you want it to do in each state and feed it events that might change the state. | null | 0 | 1316909963 | False | 0 | c2mckmx | t3_kq001 | null | t1_c2mckmx | t1_c2mchog | null | 1427642957 | 6 | t5_2fwo | null | null | null |
True | BraveSirRobin | null | Java's memory management is top notch. It has numerous GC implementations to deal with excessively large heaps. Only the top 1% of C++ programmers could come up with something more performant. | null | 0 | 1316910063 | False | 0 | c2mckye | t3_kq27q | null | t1_c2mckye | t1_c2ma0km | null | 1427642960 | 7 | t5_2fwo | null | null | null |
True | jeffdavis | null | Because EnterpriseDB ships the same code as postgresql, but just with some tools on top and nice packaging (e.g. for windows and mac), and offer support and training. Their enhancements to core postgresql are contributed back the community under the postgresql license (bsd-like).
And enterprisedb only owns the copyright for their own contributions, not the entire source.
In other words, it's *not at all the same*. | null | 0 | 1316910151 | False | 0 | c2mcl8b | t3_kpecl | null | t1_c2mcl8b | t1_c2m88xb | null | 1427642963 | 2 | t5_2fwo | null | null | null |
True | WyattEpp | null | Very funny, but screw the holy war. This is accessibility. emacs may think it's cute to replace eight spaces with a tab and say it's using both, but that's not what I'm arguing for. If my position, as you say, is the core of the holy war, then what's the big problem? I could belabour this point further, but I'll leave it be for now; I have work. | null | 0 | 1316910299 | False | 0 | c2mclq7 | t3_kooiy | null | t1_c2mclq7 | t1_c2m7ieq | null | 1427642973 | 2 | t5_2fwo | null | null | null |
True | twoodfin | null | That's like saying people were doing "object-oriented programming" in the '50's with function pointers. TDD, as an articulated development philosophy (i.e., "tests first"), is nowhere near 40 or 50 years old. | null | 0 | 1316910400 | False | 0 | c2mcm2k | t3_kq001 | null | t1_c2mcm2k | t1_c2mcgn9 | null | 1427642974 | 7 | t5_2fwo | null | null | null |
True | x-skeww | null | >Why the fuck is anyone writing an application that consumes 32GB of memory in Javascript?
People are writing applications in JS which *may* consume more than 1GB. Since that's V8's limit, some people are suggesting that this limit should be increased to some sane far-away value like 32GB.
IE9 for example allows you to put up to 4GB of data into data URIs. Of course this doesn't mean that anyone is doing that. The old 32kb limit was simply way too low. | null | 0 | 1316910828 | False | 0 | c2mcnhi | t3_kq27q | null | t1_c2mcnhi | t1_c2ma0km | null | 1427642993 | 3 | t5_2fwo | null | null | null |
True | inmatarian | null | Are you going to try to make your programming language self-hosting? | null | 0 | 1316910914 | False | 0 | c2mcnrp | t3_kpqzv | null | t1_c2mcnrp | t3_kpqzv | null | 1427642997 | 1 | t5_2fwo | null | null | null |
True | jeffdavis | null | > The end result is the same.
I think that's where you are way off. Even if you win the logic argument here by drawing some kind of equivalence between enterprisedb and oracle, I think you are way off when it comes to reality.
Almost all development of postgresql itself, including almost all development done by enterprisedb, is contributed back to the community.
And enterprisedb doesn't control the release schedule for community postgres.
And most development takes place outside of enterprisedb (though they are a significant contributor, of course).
Those are huge real world differences. By your logic, I could take FreeBSD off the shelf, add a new feature called "ls+" which is just like "ls" except it formats the results in some superior way, and start selling that version for a premium. And then you could say that the FreeBSD community is beholden to me in the same way as MySQL is beholden to Oracle. | null | 0 | 1316910925 | False | 0 | c2mcnt0 | t3_kpecl | null | t1_c2mcnt0 | t1_c2m8sxr | null | 1427642997 | 2 | t5_2fwo | null | null | null |
True | x-skeww | null | >Ruby (the Rails community in particular I think), though, it's the complete opposite.
They don't like that anymore and some sort of scoped monkey patching is already on its way. | null | 0 | 1316911025 | False | 0 | c2mco5k | t3_kq27q | null | t1_c2mco5k | t1_c2mb2cb | null | 1427643001 | 1 | t5_2fwo | null | null | null |
True | throwaway-o | null | numpy is pretty efficient. If you had a numpy array several GB in size, I'd be totally fine with that. | null | 0 | 1316911530 | False | 0 | c2mcpuf | t3_kq27q | null | t1_c2mcpuf | t1_c2maikv | null | 1427643027 | 10 | t5_2fwo | null | null | null |
True | sketerpot | null | It helps that SPDY is 100% compatible with HTTP; it is only used if, during the SSL handshake, both client and server reveal that they support SPDY. If this is not the case, then they just use HTTP.
No "embrace and extend" bullshit, no irritating incompatibility, no monopolistic bludgeoning. This is how things are *supposed* to move forward. | null | 0 | 1316911541 | False | 0 | c2mcpvl | t3_kp1b5 | null | t1_c2mcpvl | t1_c2m8vc0 | null | 1427643027 | 9 | t5_2fwo | null | null | null |
True | tilio | null | i'm not sure you had enough buzzwords in there. this pitch surely wouldn't get $2k/hr. you need at least 5 or 6 more buzzwords to get up there. distributed, scaleable, robust, stateful, results-driven... i find those are pretty timeless, and they're always winners. | null | 0 | 1316911596 | False | 0 | c2mcq23 | t3_kq001 | null | t1_c2mcq23 | t1_c2mawid | null | 1427643029 | 4 | t5_2fwo | null | null | null |
True | diadem | null | Because fuck case studies and metrics from real world scenarios with statistically significant results. This guy is arrogant and relies on opinions so he must be right!
>But the demand that you should always write your tests first? Give me a break.
The idea is within reason, obviously. Not dogmatic. | null | 0 | 1316911609 | True | 0 | c2mcq33 | t3_kq001 | null | t1_c2mcq33 | t3_kq001 | null | 1427643029 | 1 | t5_2fwo | null | null | null |
True | throwaway-o | null | Welcome to GLib / Vala. Not C (GLib technically is, Vala isn't but compiles down to C), just as good. | null | 0 | 1316911629 | False | 0 | c2mcq69 | t3_kq27q | null | t1_c2mcq69 | t1_c2maman | null | 1427643030 | -1 | t5_2fwo | null | null | null |
True | diadem | null | More like chef Ramsey.
>Apparently the entire history of computer software before the last decade or so was done by hacks and fools.
We are a very rapidly changing field. The needs of the industry is changing and we constantly are being given tools that weren't available to us a long time ago.
For heaven's sake we are a *technology* field. Our gurus of the past would have thrived with more modern technology. | null | 0 | 1316912014 | False | 0 | c2mcrfn | t3_kq001 | null | t1_c2mcrfn | t1_c2manpi | null | 1427643049 | 1 | t5_2fwo | null | null | null |
True | tilio | null | only unqualified inexperienced tools think that unqualified inexperienced tools have just as valid opinions as experts. i'm not saying loubser is an expert, but the OP's article reeks of inexperience.
wait about 5 or 6 years until you're out of school, and hopefully you'll begin to know what i'm talking about. | null | 0 | 1316912120 | False | 0 | c2mcrsa | t3_kq001 | null | t1_c2mcrsa | t1_c2ma59s | null | 1427643052 | -4 | t5_2fwo | null | null | null |
True | diadem | null | Your contractor is a strawman.
Look at case studies for companies in similar situations to you. It sounds like he's an idiot and him being right or wrong in what he says will be given to nothing but chance. It's important to constantly look inward to see how we can improve ourselves. Don't let a scumbag contractor prevent you from doing this because he put you on the defensive.
You'll either find a better way or have data showing you that you've been doing it right all along. In either case you win.
Note: If you are so nose to the grindstone that you don't have time for this I highly suggest that you include it in your schedule in the future. | null | 0 | 1316912299 | False | 0 | c2mcsen | t3_kq001 | null | t1_c2mcsen | t1_c2macsi | null | 1427643057 | 3 | t5_2fwo | null | null | null |
True | minerlj | null | Are we talking about A B split testing here for page conversion ratios? | null | 0 | 1316912363 | False | 0 | c2mcsm8 | t3_kq001 | null | t1_c2mcsm8 | t3_kq001 | null | 1427643060 | 1 | t5_2fwo | null | null | null |
True | tau-lepton | null | Agree with garymush, it can seem unintuitive, but private methods shouldn't be tested if the design is clean. That being said sometimes I'll test an algorithm that will be private if I haven't worked out where I want it in the design yet. | null | 0 | 1316912494 | True | 0 | c2mct2l | t3_kq001 | null | t1_c2mct2l | t1_c2mbg9l | null | 1427643066 | 4 | t5_2fwo | null | null | null |
True | tau-lepton | null | I too hate the bean pattern, | null | 0 | 1316912669 | False | 0 | c2mctnx | t3_kq001 | null | t1_c2mctnx | t1_c2mahso | null | 1427643074 | 6 | t5_2fwo | null | null | null |
True | jmdavis | null | I don't know what emacs does. I use vim (which is yet another holy war). My point was that you seemed to be arguing for using tabs as indentation and spaces for everything else as if that were outside the holy war. The entire "war" is over whether tabs should be used _at all_. Those who are pro-spaces, don't want tabs to be used at all, whereas those who are pro-tabs think that tabs should be used for indentation-only.
Anyone that's mixing the two is being foolish, and I think that that it is generally agreed upon. If emacs is doing something where it's automatically inserting tabs for spaces, then that's obviously a problem for emacs users, and it certainly sounds like it's a something that they shouldn't have done. But I don't know the ins and outs of emacs and what it does and doesn't do. | null | 0 | 1316912672 | False | 0 | c2mctog | t3_kooiy | null | t1_c2mctog | t1_c2mclq7 | null | 1427643074 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | The CRUD operations would be used to implementing some of the business logic. They don't need separate tests since they'll get covered by the business logic tests. | null | 0 | 1316912795 | False | 0 | c2mcu4g | t3_kq001 | null | t1_c2mcu4g | t1_c2m9mji | null | 1427643078 | 1 | t5_2fwo | null | null | null |
True | checksinthemail | null | As did I. Sure better than that stupid ass brogramming youtube that was supposed to make me laugh.
| null | 0 | 1316912931 | False | 0 | c2mcul7 | t3_kqd8o | null | t1_c2mcul7 | t1_c2mbwom | null | 1427643084 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | * Work out a test strategy
* Prioritize risky code first
* Specify how much time you have for test development
* Start implementing tests going down the list from high priority toward low priority
* When you run out of time, stop wherever you're at with the tests and move on to the next task. You don't always need 100% test coverage. | null | 0 | 1316912975 | False | 0 | c2mcuq9 | t3_kq001 | null | t1_c2mcuq9 | t3_kq001 | null | 1427643087 | 1 | t5_2fwo | null | null | null |
True | johnyma22 | null | I'm from the Etherpad foundation.
We placed java with javascript (nodeJS) from Etherpad because nodeJS requires roughly ~5% of the original java stack (rhino) resources.
It makes perfect sense to have javascript server side apps when they have such small overheads. That's what NodeJS brings to the table.
| null | 0 | 1316913136 | False | 0 | c2mcva8 | t3_kq27q | null | t1_c2mcva8 | t1_c2m9f3j | null | 1427643093 | 6 | t5_2fwo | null | null | null |
True | amigoinvisible | null | Not to be confused with
http://en.wikipedia.org/wiki/FACT_computer_language
| null | 0 | 1316913147 | False | 0 | c2mcvbp | t3_kpqzv | null | t1_c2mcvbp | t3_kpqzv | null | 1427643094 | 3 | t5_2fwo | null | null | null |
True | garymrush | null | What I'm suggesting is refactoring out that inner class and testing it independently. Since the original class would only be dependent on the new classes interface, it can be supplied a mock instance as a property or alternate constructor. As an example, suppose my Universe class is getting a little too complex, so I decide to factor out Galaxy. I supply my Universe with a GalaxyFactory, and now I only have to make sure it uses it properly. | null | 0 | 1316913223 | False | 0 | c2mcvkm | t3_kq001 | null | t1_c2mcvkm | t1_c2mc68v | null | 1427643098 | 3 | t5_2fwo | null | null | null |
True | wildthought | null | Every methodology can be taken to an extreme. RUP, Waterfall, and I think TDD is especially prone to it.
It reminds me of the relational database modeling vs. OOP debates during RUP's heyday. What do you do first, data model or class model. I would argue it doesn't matter as long as you get the same result. Their are rules that ORM's have figured out how to reverse and forward engineer between each other. If those rules exist, then why can't we model either way first.
Similarly whether we write tests first or code first should be the purview of the person writing the program. Do I really want to write a test first for every stored procedure I write. Of course, I do not. I am sick of seeing articles on how to do TDD in the database layer. I am equally sick of having to create my own mocks to mimic a layer I can get to in milliseconds.
I think it has its place, but it does promote coding bloat. Now, RUP promotes documentation bloat. I truly believe, that quality software engineers (aka master craftsmen) can choose what methodologies to draw from as needed. To say, I have the way and its the only way is telling me that you are afraid to think outside your own box. | null | 0 | 1316913371 | False | 0 | c2mcw33 | t3_kq001 | null | t1_c2mcw33 | t3_kq001 | null | 1427643105 | 2 | t5_2fwo | null | null | null |
True | Nuli | null | If it's a requirement that an algorithm finish within a particular time frame that can be tested for. Simply knowing the complexity, which is also testable, is probably insufficient. | null | 0 | 1316913573 | False | 0 | c2mcwrr | t3_kq001 | null | t1_c2mcwrr | t1_c2mc10e | null | 1427643114 | 1 | t5_2fwo | null | null | null |
True | borshlite | null | Is it just me, or is TDD simply standardizing, and documenting the way that development is done normally? When this process was first introduced/forced on me by people who misunderstand it, I was thinking that well, yeah I'm given case scenarios, and my code needs to be able hand x and y situations. I agree with the author of this article that some people feel TDD's dogma will solve all of a programmer's problems, but in reality it should have already been only a part of the process, and documenting/standardizing will help by people reviewing your scenarios, but it isn't going to solve some of the problems that present themselves over and over again like advertised. | null | 0 | 1316913634 | False | 0 | c2mcwyt | t3_kq001 | null | t1_c2mcwyt | t3_kq001 | null | 1427643117 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316913638 | False | 0 | c2mcwzn | t3_kq001 | null | t1_c2mcwzn | t1_c2marsz | null | 1427643118 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | > The whole concept of Test-Driven Development is hocus, and embracing it as your philosophy, criminal.
Doesn't sound like he likes it too much, either. | null | 0 | 1316913671 | False | 0 | c2mcx3e | t3_kq001 | null | t1_c2mcx3e | t1_c2macfv | null | 1427643119 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | The scala toolset is pretty unfriendly overall, wish it would get a little easier. | null | 0 | 1316913687 | False | 0 | c2mcx60 | t3_kmygn | null | t1_c2mcx60 | t1_c2lovit | null | 1427643120 | 1 | t5_2fwo | null | null | null |
True | godofpumpkins | null | There really isn't much of speed penalty with GHC Haskell these days, if you know what you're doing. | null | 0 | 1316913777 | False | 0 | c2mcxhs | t3_kpqzv | null | t1_c2mcxhs | t1_c2mc25a | null | 1427643124 | 2 | t5_2fwo | null | null | null |
True | mrjbq7 | null | Oh, those are really *really* **really** big numbers. | null | 0 | 1316913808 | False | 0 | c2mcxma | t3_koio1 | null | t1_c2mcxma | t1_c2m8f09 | null | 1428192987 | 1 | t5_2fwo | null | null | null |
True | mariox19 | null | And let's not even talk about when the code is later modified to shoehorn some kind of added functionality into it. | null | 0 | 1316913835 | False | 0 | c2mcxq0 | t3_kq001 | null | t1_c2mcxq0 | t1_c2ma0du | null | 1427643127 | 2 | t5_2fwo | null | null | null |
True | checksinthemail | null | I had a boss who looked just like that.
Except he was bigger in LOC and Test coverage % - he couldn't give a rat's ass about the bugs as long as it didn't affect his next bonus.
| null | 0 | 1316913880 | False | 0 | c2mcxvu | t3_kop0t | null | t1_c2mcxvu | t3_kop0t | null | 1427643132 | 1 | t5_2fwo | null | null | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.