skysight-inc/HackerNews huggingface dataset:
Just wait until he has to write a system with several hundred web services that have been documented to perform in a very precise manner given particular data sets, and have hundreds of customers who have integrated to that API, and absolutely required that there be no variance in the output in the API, or there (extraordinarily expensive) system integration will fail, at great costs to their business systems.

I'm not saying TDD makes sense everywhere, but being able to confirm that your 3000+ continuous integration tests all passed green before shipping a new version to all of your customer is a huge way to avoid embarrassingly predictable bugs. (Leaving, of course, the opportunity to ship the embarrassingly non-obvious bugs)

And, honestly, it's not clear that he was opposed to TDD, as he was opposed to being constrained to having to write huge test frameworks during the exploratory phase of code development, in which you may want to have a bit more freedom to write/discard while you feel out requirements/solutions.
Can't say I expected to see Nvidia fanboys

There are plenty of benchmarks to support my claim, no need to resort to name calling, just show evidence that you are right. You'll see that the majority of objective evidence disagrees with you.

Who's the fanboy then?

AMD has Nvidia beat at one point: the R390 beats the GTX970, on Windows. Luckily for AMD (and hence for us, yay competition) it's a reasonably popular point.
I don't know for MySQL but I'd guess in the case of Oracle is that they have equivalents in their own dialect of SQL.
Ha that is hilarious. I am actually trying to gain some weight and i find i weigh myself too often. I think i can could come up with the study that shows the opposite effect. After all it doesn't have to be true, just significant.
It's Dell Precision 15 with the Xeon option, but I doubt it can use ECC RAM until someone provides the reliable link.

http://www.dell.com/au/business/p/precision-m7510-workstatio...

"Memory

8GB (1x8G) 2133MHz DDR4 Memory Non ECC
16GB (1x16G) 2133MHz DDR4 Memory Non ECC
16GB (2x8GB) 2133MHz DDR4 ECC Memory ECC
16GB (2x8G) 2133MHz DDR4 Memory Non ECC
32GB (4x8GB) 2133MHz DDR4 Memory ECC
32GB (4x8GB) 2133MHz DDR4 Memory Non ECC
32GB (2x16GB) 2133MHz DDR4 Memory Non ECC
64GB (4x16G) 2133MHz DDR4 Memory Non ECC"
Markus Winand is a great SQL expert. I'm really grateful for everything that he shares with us. He writes well, explains us the differences between the different SQL engines. And his books are fantastic references.

I highly recommend his "No to offset" tutorial http://use-the-index-luke.com/no-offset
Should be common knowledge, but I still see offset being used way to often, even in core ORM frameworks :-(
Seems to me like automatic have been working on a new Client/frontend written in JS with React components, the Server/Backend will still be powered by Wordpress written in PHP+MySQL.
Show HN: A Command-Line Sentence Tokenizer Written in Golang
aaa there we go, someone else disappointed to read the article and scroll down to see the interactive map is a map the US only...
The Remote Manifesto
Good point about laptops, I didn't consider the Optimus mess. That said, when we're talking about gaming cards I'm not sure that desktop is a niche compared to laptops.
This is called the dependency ratio.
CGMN
ZGSDGH
Way stronger than I'd write, and I don't agree with it entirely, but the author has a point.

Personally, what annoys me the most about TDD I've seen in the wild are two things: designing for tests instead of actual problems, and tests affecting the structure of "real" code.

Designing for tests - the standard TDD approach, first we write tests, then we write code to pass the tests. Quite often the consideration of the problem being solved disappears. It's a fine approach when your task is to write a small black box that takes some data in and transforms it into something else. But I've never seen a case where someone made it work for complex tasks. It always ends up the same - your tests become more complicated than the tested code. It happens with any non-trivial problem, because the thinking you have to do to write tests that make sense is the same as the thinking you need to do to solve the problem in the first place. So you're basically writing the program twice, only in a convoluted way, and without considerations for global design.

Tests affecting the structure - this is IMO a strong code smell. If you're modifying your design to accomodate for tests, by e.g. adding superfluous dependencies, hooks or injection points, you've screwed up. It only makes the code more complicated and less reliable.

The only tests I've found valuable so far (in terms of effect for effort spent) are regression tests - the ones you write to catch bugs in order to make sure they won't happen again. Everything else in TDD seems to be easily replaceable by proper iterative programming.

Maybe that's why TDD is popular in the languages without a sane REPL.
I think it's mainly because a high oil price is good for the economies of oil-exporting countries, like Russia, Canada and Norway (to name a few). More exports = more economic growth. More economic growth (all things equal) should equal higher interest rates which leads to a more valuable currency.
They are intimately related. If you look at how Gödel's incompleteness theorem is stated, the existence of "effective procedures" (I.e. Computable functions) figures in intimately.

A good overview of this in a reasonably accessible format can be found here: http://www.scottaaronson.com/blog/?p=710

The same author wrote a good treatment of the implications of the undecidability of P=NP: http://www.scottaaronson.com/papers/pnp.pdf

Scott Aaronson is probably one of the best at explaining theoretical computer science, if you're interested in these topics you should follow his blog.
Startup Fuels Africa’s Mobile-Payment Boom
Good observations! At that company, sure, TDD is ridiculous.

But other companies don't do it that way, and require TDD, so the article took a narrow, biased view without considering pros and cons and different scenarios.
His experience might be a lot different from mine, but I've found TDD enormously helpful when tackling legacy systems. Maybe that's not "test-driven development" and more like "test-driven refactoring", but working on complex legacy systems where the original developers are basically all gone is scary, and TDD has helped me make some sense of it and feel a lot better about making changes.
Does anyone have a good counter-point worth reading? I understand that it's more of a anecdotal rant, but it's not the first time I've read something like this about TDD.

I've tried TDD, but I've found that it just stifles my productivity too much.
> Unit testing ... is not just about developing as it is about preventing regressions.

Absolutely this! Unit testing helps you during the dark years of maintenance phase, when you must fix a bug or add a new feature and you don't have the knowledge, nor the time, to build a full representation of the application in your head: you just touch as little code as possible to get the work done, and unit tests help to ensure that all the rest stays equal.
I don't necessarily use TDD all the time, but I think it provides significant value. A key one is to help guide developers break down complexity.

This is quite apparent especially when I conduct pair programming interviews. Developers who were exposed to TDD (or to projects with significant test code) approach the problem in a far more structured manner, and their code is much more pleasant to look at :)
TDD isn't about writing tests. It's about designing architecture.

http://www.drdobbs.com/tdd-is-about-design-not-testing/22921...
> Let me emphasize: you write the test cases for your program, and then you write your program. You are writing code to test something that doesn't even exist yet. I am not rightly able to apprehend the kind of confusion of ideas that could provoke such a method.

I don't understand this. What is so absurd about specifying facts about the program you will write? When we have tools that can prove facts, we will be doing formal specifications instead of random sampling. But still, testing is a way of statistically specifying facts about your program, for which it seems sensible to be written before the program.
If you're doing TDD (or software development) like this, you're doing it wrong. Yes, yes, I know. No True Scotsman [1]. But when many - I mean LOTS OF - people say "I get benefits form [Technique]", you can't just say: "It cannot work. I tried it, it sucked.".

I mean, you can say that. But doing so makes you look... ignorant - at best. You know, there is a possibility that you just got it wrong.

So, many great programmers say that they get benefits from TDD. They get benefits. Not the suits. Not their co-workers. They.

TDD is hard. I had to learn it and practice it. And I'm still learning and practicing it, even though I'm now also teaching it to others and helping teams implement it. But I get benefits from it. Writing tests helps me to think about problems and to actually improve my designs [2]. And writing tests helps me to know when to stop - To not gold-plate my designs.

Sorry, but this "article" is just an angry rant, with no real arguments. Please, don't give up on TDD early because of rants like this. If you have any questions about TDD or need help getting started, feel free to ask (here or in private - you'll find my email address in my profile)...

[1] http://davidtanzer.net/no_true_scotsman_in_agile

[2] But you have to refactor ruthlessly. And learn and practice refactoring, which is hard.
TDD is truly cult like in it's extreme. Usually it's managers and slightly weaker technical folk with a scrum certification that spew the absolutist TDD path.

I'm a contract java developer and I know how to 'play the game'. The hypocrisy in the amount of fizbuz clones I've written in a TDD fashion on interviews, to then see the production code has no little to no unit tests.

I once got negative feedback on an interview because I wasn't TDD enough after expressing the opinion that TDD works great for most use cases but there are limits, e.g. positioning of a front end element isn't always best done TDD. The guy interviewing was non technical and of course any dissent to TDD meant I was a bad fit.

Anyways - end rant. Like I said I just learnt to play the game.
TDD is about design, not writing tests.

http://www.drdobbs.com/tdd-is-about-design-not-testing/22921...
There's a popular paradigm shift theory that posits that we tend to adopt frameworks that explain the world, then work incrementally within those frameworks until they cease to make as much sense/have as much explanatory power as they once did.

Then someone (Newton, Darwin, Einstein) comes along and assembles a new framework based on new observations/theories that do a better job of explaining things. Eg the switch from creationism to evolution, or from newtonian physics to relativity.

Here are some more examples:

https://en.wikipedia.org/wiki/Paradigm_shift#Examples_of_par...
Buried in the rant are a couple of sound points:

>- You're trying to make a design before you learn anything about it.

>- People write something one way, but then are afraid to change it because they'll have to rewrite the testing code that goes along with it.

Both of these suggest tests of the wrong granularity; that people are, as he says, writing silly little fencepost error checks for every single function.
> "Trying to improve software quality by increasing the amount of testing is like try[ing] to lose weight by weighing yourself more often."

Giving the benefit of the doubt that this quote is in fact an accurate metaphor – to begin with this quote is to begin with the assumption that TDD's single motivation is improving software quality. TDD is a fantastic practice for ensuring conformity to a specification; which one might describe as software's correctness. A more objective metric than "quality".
Have you read the SQL99 or even 2003 spec? No database supports everything. It's a matter which features one cherrypicks. If you want to use lots of XML and ORMs inside your database or use Java as stored procedures than SQL 2003 spec is great. The enterprise grade database software Oracle, DB2, MSSQL and Postgres are all somewhat comparable.

MySQL with e.g. its InnoDB storage engine is very fast and web scale. Whould a materialized view or other advanced features be useful in MySQL? Sure. But it's a tradeoff. And many devs are willing to go with MySQL for websites.

And SQLite is different than the rest too. And then there are a bunch of NoSQL databases for various usecases.
As Elon Musk wrote [1]:

It is, however, important to clear up the difference between "space" and "orbit", as described well by https://what-if.xkcd.com/58/

Getting to space needs ~Mach 3, but GTO orbit requires ~Mach 30. The energy needed is the square, i.e. 9 units for space and 900 for orbit.

1 - https://twitter.com/elonmusk/status/669129655597731841
I think I see part of his point, though. By its nature, a unit test is (often, albeit not necessarily) tightly coupled with the thing it is testing--which means that anyone who changes the implementation must change the test, which increases the complexity of code changes.

I know that in my own work, the single most important thing for me is to be able to massively refactor, restructure and redesign my and others' code, as I'm working with it (this is probably why I like dynamic languages and macros so much, and probably why I benefit from static typing so much); anything which gets in the way of deleting, reorganising, clarifying, duplicating, altering, reducing and shifting code is going to slow me down and make the resulting code worse.

Perhaps, though, there is a middle ground: while the internals of a library must be free to mutate, the external interface ought not to change nearly as much. Perhaps all unit tests should be written to test the external interface, not the internal details. That might also help avoid the tests-which-test-that-the-code-does-what-it-does disease.

I do really appreciate tests, and they do help detect and prevent certain types of regressions.
Sorry for your luck. Just wondering, do ads show up on these sites? With the internet.org or this I'm curious if they have ads that link. It seems they could only go to user pages.
I still remember the day I realized that this 5-years-cursus titled engineer was a glorified cashier position.
It feels like there's a little bit of comparison mismatch here - I would equate Jasmine to Mocha, as they're both test frameworks, whereas Karma is a test runner.
Mocha comes with a test runner OOTB, but you can also run Mocha tests with Karma.

One of the things I like about Karma is the ability to run the test suite in a number of browsers. We run our suite in Firefox, Chrome and PhantomJS as part of the CI setup.

I wonder if it wouldn't have been possible to set up a complementary test runner which allowed your Jasmine tests to be run with jsdom? That would give you the speed increase, but without needing to port, and would have allowed you to still leverage Karma when needed.

However, a good read and the Karma bootup time is certainly a pain point I've felt!
It's not really a rant, it is a very strongly communicated opinion. And I agree with a lot of it.

I don't mind writing a few test cases during or after I am done with my work. This is mostly to protect someone (including me) to change my perfect design after I have found it, though ;-)
> I am against writing unit tests in general

> How often have you seen a program crash? If it was developed by a large software company, chances are it was written using TDD. Clearly, TDD is not a magic bullet. So, TDD does not "prove your code works".

> Developing software is like a painting commission

Several reasons I gave up a third of the way in. I rarely write tests first, but I can appreciate that it works for plenty of people - my brain just doesn't work that way.

It's hard to take anything in this article seriously because of the nerdrage and the dismissal of anything he disagrees with as "stupid".
And, as the article points out nicely, this basically prevents people from refactoring their code. In any nontrivial codebase, when you have a lot of tests, then what would have been 15 minutes of work rearranging class structure turns into a whole day of rearranging test cases to fit the architecture again.
I'm not sure if this is the cited source, but the following Google paper is one of my bookmarks:

http://static.googleusercontent.com/media/research.google.co...
This is my view as well.

More generally, it's about not 'coding too far into the future', even (especially) with tests.

But I like to code a little ways into the future.

'README driven development' is also interesting.
The (old, "radeon") open source AMD drivers are good enough for a bunch of Steam games, including popular ones like CS:GO or Dota2. Unfortunately they don't scale with higher end cards having the same performance as old ones.
>So this is the first reason TDD fails: You're trying to make a design before you learn anything about it.

Well yes, I use my unit tests to learn what works and what doesn't. You're allowed to rewrite or scrap tests, if they are no longer relevant. In the end I feel that having unit tests result in a better final design.

Yes, sometime unit tests are a little contrived. But they can also help you design cleaner interfaces and increase your code reuse.
Axel Springer Goes After iOS 9 Ad Blockers in New Legal Battle
Qualify for Europe’s biggest programming contest
Well, you can go from

"The cat meowed"

to

"The cat the mouse feared meowed"

If your claim is that nesting to arbitrary depths is not allowed, what is the maximum depth that is "legal"?
> I was once one of these newly educated kids. So, for a few years, I worked exclusively with the Test-First strategy. When it was over, the results were undeniable. The code--all of it--was horrible. Class projects, research code, contract programs, indie games, everything I'd written during that time--it was all slow, hard to read, and so buggy I probably should have cried. It passed the tests, but not much else.

Sounds like most everyone's first years :)
Da art of storytellin' (a prequel)
> It also assumes a bug free app with 100% code coverage is the objective, regardless of the cost it takes to write all that test code.

I disagree on this. 100% coverage is actually a bad thing, in my opinion, because there's always a lot of code you do not need to test (simple constructors, accessors/mutators, etc).

A unit test should test things that you are relying on being correct. You write a unit test as a way to protect future developers (including yourself) from totally screwing things up by accidentally changing something important.

An application with a few bugs that took half the resources to develop is nice- until the customer needs a few extra changes 18 months later, and you turn 'a few' bugs into 'a whole lot of' bugs.
Code Golf November: The Longest Collatz Conjecture
I ordered a phone from them last week. The shop said it's 2 to 5 days delivery, the confirmation said allow for 5 to 10 days, now this post tells me it will be 10 to ∞ days.

I don't think debt restructuring is a fun process, so I wish them well.
>Usually when I'm coding from scratch I write a very, very, VERY coarse-grained test that "tests something", and when I reach the point of passing it (which may involved creating and designing multiple classes) I probably have a working design and I may begin creating other, smaller unit tests for individual components. The initial test may disappear or become an integration or acceptance test.

This reads pretty much how I work too.I don't think it is unusual. Start coarse, outside in. Write the finer grained 'unit' tests where appropriate. Focus on where you need the crutch (design and confidence) not on clambering to test all the things.
Hm, makes you wonder if you built an 8 bit computer entirely out of discrete components (transistors, resistors, diodes) how large it would be, and what clock you could still attain. Power usage would probably be pretty impressive too.
Show HN: Rake like build library for Crystal language
Sounds like a well placed comment would be of more value than a test there.
Seeing that DRAM pricing is so dirt cheap, it's difficult to persuade any chip manufacturer to devote another 10-15% (my estimate based on previous memory design projects) of die area to ECC bits & decode circuitry when they won't get another dime for the capability.
In real-world situations the stress falls on different words depending on which parse of "fruit flies like a banana" you are adopting
>Ultimately present day philosophy, last I looked and certainly since Wittgenstein, is all about playing with word meaning and almost upfront about it, but pg argues in reality it always was like that.

Have you read any present day philosophy? That's at best a description of some of the worst tendencies of analytic philosophy, which peaked in the 40-50s. (Many philosophers these days identify as "analytic" in the broad sense of "not continental", but that is more to do with sociology than anything else.)
Intent to Ship: Service Workers with FetchEvent in Firefox 44
> Unit tests are momentum against change.

I get the point, but feel different. When a project becomes large enough, changes can result in breakage in the weirdest places. Proper testing can help discovering this breakage before shipping. For me, tests are a safety net for changes in the tested code.

Large projects without any tests are effectively unmaintainable, often times even for the original author, and most certainly for others.
Oh look another article with a provocative (e.g. link-bait) title. I'm sure this will be a well-balanced, nuanced piece on the costs and benefits of TDD, when it makes sense, when it does not make sense, and will leave me with a better understanding of the subject.

Oh.
Rogue Dell Root CA Client Test
Regression tests are absolutely awesome, especially if written for nontrivial components which will later be modified or expanded.

Having worked with dynamic languages quite a bit, I found that iff your language has a decent REPL, so you can code iteratively, you don't need unit tests to drive your design. You perform those tests in REPL yourself, which helps you flesh out the design, but you don't have layers of code that'll make changing the design harder.

The way I personally work with Lisp is a mix of writing code in a file, compiling particular parts of it and playing around with it in REPL until I've figured out the right design - at which point I may as well start adding some tests around tricky places. The idea is to not burden yourself with permanent tests until you have your design figured out.
> Week 3-4: Write tests.

> Week 5-10: Write code.

??? what

The feedback cycle is one test, implement code. Not implement test suite for the entire program, then implement your code base.
Homoeopathic data storage?