skysight-inc/HackerNews huggingface dataset:
What about their business model (where you can't win and stupid fees everywhere) or mistreatment of customers (delays, cancels etc.).
The point is that there is a limit to testing. And some people go way overboard with it. You'll never get 100% coverage. It's simply not possible.

Now, that doesn't mean you should not test. It means you should understand the limits of unit testing and test what is important as best as you can. Most every software engineering class at universities will cover this in-depth.
Additional two on "software design and evolution" that were hugely influential for me in my career:

* Responsive design, by Kent Beck
https://www.infoq.com/presentations/responsive-design

* The Grand Unified Theory, by Jim Weirich
https://vimeo.com/10837903
The article explains right in the second paragraph why detecting methane is so intriguing.

If you dropped a molecule of methane into the atmosphere of Mars, it would survive about 300 years—that’s how long, on average, it would take for solar ultraviolet radiation and other Martian gases to destroy the molecule. By rights, the Martian atmosphere should have been scrubbed of its methane eons ago.
It sounds like this is column level partitioning.Each column or columns (based on partitioning expression) is stored as different subtable (or something similar) on disk.If only few columns are frequently accessed, they can be put on cache/faster disk or other neat optimizations for join processing.
'Code that works' doesn't necessarily mean 'code that only works today'. I'm pretty sure maintainability is implied in his statement.
The 2016 Hater’s Guide to the Williams-Sonoma Catalog
Could You Live by Yourself?
I can't remember the talk but one of the guys who really pushed agility in programming has even said that 100% test coverage should not be a goal. The talk he gave was more about testing the things that need testing and was a bit flabbergasted at the people who ran with the 100% coverage concept as part of it.
Removing implicit side-effects and global state from code and having strong, static types can go very far in allowing this, without much overhead.

Unfortunately, there isn't a really great language that enforces working like this, while being simple enough to push onto a big team :/ (if there is, please let me know)
That's one reason to write tests.

Another is that some code reviewer asks for more tests. A third reason to spend time on tests is that they're required to maintain the same standard as the shipped code, even though they're only run in the presence of the developers, and their breaking only affects the developers, not any customers.

People forget the ultimate reason for our work oh so often.
Seems pretty simple, honestly. I've written enough unit tests to throw in my 2 bits.

Put a sane, normal value test. This will pass unless shit's broken.

Then test edge cases. Test min, max.

Then test some impossible values. If they correctly fail, you pass.
It was already old in 2010, nothing has retroactively changed in the text.
Most often those (5%) don't respond to replies like "Could you please share more details on the issue or error/logs message". Its sometimes frustrating to deal with this group of users.
I was expecting a bunch of puns about nitrous oxide but all I got was a shitty article about methane. I must spend too much time on Reddit.
> Writing that test for the single expression setter won't cost you a lot.

Yeah, usually it won't cost anything to the guy who writes the test, but he is actually paid. What it costs to the business/customer/etc and whether the value added is worth of the cost is totally different matter.

I think there is clear incentive for writing unnecessary tests for certain developers - it is non-risky general work, where it is is difficult to fuck up anyway. If you are able to sell test-writing hours, what's the downside?
What is it about k-means that means it doesn't work on other distributions?

I find it easy to come up with other (contrived) distributions where K-means produces the results that a human would produce. E.g. disjoint (and distant) circles, each containing uniform random distribution of points.

Can you explain what you meant in more detail?
Apple's MacBook Pro with Touch Bar has some serious battery life problems
The linked patch notes specifically mention the difference between this and table inheritance based partitioning.

Because table partitioning is less general than table inheritance, it
is hoped that it will be easier to reason about properties of
partitions, and therefore that this will serve as a better foundation
for a variety of possible optimizations, including query planner
optimizations.
What surprises me the most about the Slack's job page is that most — if not all — the positions are on-site. It surprises me because most of the companies that I know are remote-friendly use Slack as their main communication method, so I would expect Slack itself to have some remote positions just for the Dogfooding [1]. I have applied 3 times for a regular SDE position there and two times I was rejected because I was not (permanently) living in the US, the 3rd time I got no response while staying in NYC.

[1] https://en.wikipedia.org/wiki/Eating_your_own_dog_food
Ask HN: Ideas to do homegrown Alzheimer research
So there have been some interesting new results about removing plaque and bringing back Alzheimer in mice.

One is explained in this new radiolab episode: http://www.radiolab.org/story/bringing-gamma-back/. Flickering LEDs at the right frequency (too fast to notice) for one hour a day reduced either plaque or its precursor by 50% and was even shown to bring back memories.

Another result was a about using a specific protein native to humans - boosting that protein's level also reduced plaque. I'm on mobile now, it's a bit hard to find the paper, but I'll post it here in a few hours.

Anyways, both these methods are (a) completely harmless and (b) IMO doable at home without too much expense. I'm a bit unsure how to import or acquire medical research supply (that protein) in small amounts in Japan where it matters to me. I'm also aware that the chance of success is small, but I figure - the risk here is really low, like a few hundred dollars spent for nothing tops, and the reward could be huge.

Background: Mother in law has Alzheimer, about halfway into the disease.

Anyways: Do you know LED lamps that can be set to a specific frequency and are compatible with normal fixtures? Any info about how to get medical protein in Japan?
Mixing up business and tech.

On the business side, you don't get paid for code at all. You get paid to make something people want. The fact that you're using programming to do that is inconsequential.

On the tech side, you're not delivering anything unless somebody, somewhere can test it, even if only one time.

So yes, you are getting paid for tests. In fact, that's the only thing you are getting paid for. The nub of the question is what the tests look like and how many you should have.
Given the current solar boom, we'll probably end up using the same energy source that plants use. Perhaps even a chemical process similar to photosynthesis.
Meet the Octobot
This was debunked years ago. Making plastics from CO2 is possible, but an energy hungry process which does not suck up any relevant amount of carbondioxide from our atmosphere. It isn't going to be the climatesaver they claim it to be. This is not a manufacturing issue, but depends on basic thermodynamics.
Economics and knowledge (1937)
AI Winter Isn’t Coming
Canon MG2450 Printer Driver Download
I don't think GP meant one editor line, but one "line of code".
I like this work and the presentation by Tianlu Yuan (2013) about how our knowledge about the subject progressed -- the first photos were made by Voyager (1981-82):

http://www-hep.colorado.edu/~tianlu/public/saturnHex_paper.p...

http://www-hep.colorado.edu/~tianlu/public/saturnHex_present...

"In the 1980s images of Saturn taken by Voyager led to Godfrey's surprising discovery
of a hexagonal structure on the planet's north pole [9]. Now, over three decades later,
Saturn's north polar hexagon remains, superficially unchanged and not entirely understood.
Voyager's iconic images proved a challenge to explain theoretically, but with additional data
from ground based observations and the HST in the early 90s, and images from the Cassini
mission more recently, our knowledge of many physical parameters forming the hexagon has
increased. Along with observation, laboratory experiments and numerical simulations have
helped foster greater understanding of the possible causes of the jet's six-sided shape."

The more recent pictures (2016) are also interesting, as the color has changed(!):

http://www.forbes.com/sites/startswithabang/2016/10/31/satur...

And for completeness, the comics from 2010:

http://www.smbc-comics.com/comic/2010-07-06
From the end user POV it's a shitty thing to do, but most likely this stems from the developer making a deal with Intel. It takes a lot of resources and effort to deliver VR games with the quality and length that PC gamers have to come to expect, and the VR market is still tiny; at the end of the day you can't really blame VR developers for taking deals left and right, because it's the only way to subsidize development.

If every time something like this happens there's an internet outrage, what's gonna happen is that no one will subsidize shit (because why would you pay a developer if exclusivity or exclusive features are not on the table?), VR content development will stall as there won't be incentive for developers to spend months/years of work only to barely break even (if they get lucky), VR adoption will not go on, etc.

Something's gotta give, VR gamers need to cut developers some slack if VR is to flourish in the future, you can't have your cake and eat it too.
It's actually not terribly difficult. There are good references, and I remember it took me about 4 days to write the very first version of simavr[0].

What's harder to emulate are all the peripherals, and all their quirks.

In simavr the 'core' code is pretty much unchanged (apart from the odd cosmetics) in the last 7 years, while most of the work was to emulate the peripheral blocks.

[0]: https://github.com/buserror/simavr
> But we don't write tests to check if our code works.

I write tests to check if my code works. And tests that document how the code is supposed to work currently are usually enough to prevent code from breaking in the future.

Anything related to privacy or security should be fully tested. But for the typical startup, I'd posit that beyond that test coverage should be more closely related to the number of users and level of usage rather than to the amount of code.
for the list comprehension, why not

```
do_whatever(Keys, SomeParameter) ->
[case external_lookup(Key) of
{ok, V} -> do_side_effecty_thing(V, SomeParameter);
{error, R} -> report_some_failure(R) end || Key <- Keys],
ok.
```

or

```
[begin some_func(Key), other_func(Key) end || Key <- Keys].
```

if only the value of other_func() needs to be in the result list.
Difficult to even imagine a project that could fail business-wise because some developer wrote too many easy unit tests. Do you know of such cases?
Google open sources Embedding Projector for visualizing high dimensional data
AgileVentures.org
Audi’s New AI Rig for Driverless Cars Is … a Toy Car
I agree that English is the lingua franca of software industry. Also it is kind of stupid fo Shown HN that's not written, or pre-Google-Translate-linked, in English. But at the same time, it shouldn't take a person a minutes to figure out that's an Android project.
> someone else doing a RISC-V SoC that, ... , has documentation "protected" by an NDA and inaccessible to most users.

This is, as far as I understand, at least in software, the main difference between Free- and Open Source-software.

I wonder if there is some movement like the Free Software movement but Free Hardware instead.
After you read the paper, will you share us your thoughts on it, please?!!
“The internet is amazing. How do we get all these hungry artist soul’s paid?”
Ditto... still not my favorite but now I use es6 and friends preferentially to a few other options that would have won out before.
The Algorithms of TeX in Clojure
It's hard not to find Saturn intriguing, the rings, the colors, the moons. It's the first time I saw something through a telescope that was awe inspiring. It almost seemed cartoonish with it's vibrancy and sharp edges. It's enough to make anyone want to take up astronomy.
More and more, the 'exclusive' feature I want in any product is for it to do what it says on the goddamn tin. Alas that's a feature few care to provide.
meh. I've been doing functional programming for 30 years. Just because some Ruby people have trouble understanding it doesn't mean we should water everything down for "inclusivity."
Of course you get 100% coverage if that's your goal. SQLite for example is a big project with 100% coverage:

https://www.sqlite.org/testing.html

If you want rock solid software you need to spend the time to properly test it.
Git UIs should expose the tree hash as well to mitigate that issue.
If you take words literally, you will find it difficult simply to converse with humans.
ETL Is Dead, Long-Live Streams – Neha Narkhede (QCon, 2016)
Supposing the case in which all partitions are on the same disk and that you manage to index your data well enough according to your usage that postgres does not need to do full table scans, are there any additional performance benefits on partitioning?
This is what struck me when reading the article. The winner of the hackathon is the guy who goes out to the parking lot and plants a tree. :)

In all seriousness, they gather the solar energy themselves, absorb the CO2 themselves, after a small initial investment you can walk away and the result is plenty of useful materials (including bioplastics)!
I think the biggest problem with TDD is that there are two types of code, trivial and non-trivial.

I think testing trivial code is a waste of time and does nothing but improve coverage numbers.

When you think about a non-trivial problem to write tests, you don't always know what the final code will look like. Maybe you forget an edge case or some small detail in the requirements that will cause you to restructure the code and approach the problem in a different way. In which case, you now need to re-write your tests. You might as well just write tests around the final version.
Ted Grozier, flagship programme manager on the EnCO2re initiative, explains the thinking. He says: “The idea of a hackathon is you basically lock people in a room, you give them pizza and energy drinks, and they solve problems quickly.”

I always makes me sad when I see people talking about hackatons as a "tool" the can use by giving "pizza and energy" drinks. Hackatons have become a corporate tool.
I've actually been running an analytics company for a few years (http://parse.ly), and as a result of seeing what you're describing and thinking it was pretty strange -- that many companies have "not invented here" syndrome about analytics -- we actually turned our data collection and event enrichment infrastructure into a fully-managed cloud service. It's called Parse.ly Data Pipeline, and is described here: http://parse.ly/data-pipeline.

Together with cloud SQL tools like BigQuery or Redshift, it gets rid of the need to build a "full analytics stack" on your own. You can license the data collection/enrichment from us (we've already scaled it to billions of monthly events), you can use our clean starting schema (over 100 enriched fields per event), and then you can pipe the data into a fully-managed analytics warehouse, or just analyze it in raw form. Then you can actually spend all your time focusing on insights, rather than fussing about data collection clusters, pipelines, ETLs, etc.

I would love to hear what you think of the idea; it was launched just a few months ago.
I know cases where too much focus on tests might be reason for a startup failure. Eg. instead of trying to find the product-market fit, resources are spent building tests, and then funding runs out. Of course it is very difficult to argue whether test writing was the issue or something else, and people have different incentives related to that.
This was a great read! Thank you
The Google Play store, at least, allows developers to reply directly to reviews. Others can see their reply as well.
Yes. You can model state easily in functional programming languages but the technique is unfamiliar to imperative programmers since it's more explicit. This is a very good thing.
Termbox is somewhat similar to the recently announced dply.co, but I think our approach is much better for the following reasons:

* The interface is super streamlined. Open the page, confirm captcha, click launch - boom, you got a terminal. The planned SSH support will be similar to that - no web page, just do ssh root@ubuntu.termbox.io and you get logged in to a Ubuntu box.

* We use VM based containers (hypercontainer.io) and not full VMs, so startup is very fast and instances are super cheap. 2 hours of the 512MB DigitalOcean server cost $0.014, 2 hours of a 512MB Termbox instance currently cost us around $0.0001

* Because our instances are so cheap, we do not impose any limits on the amount of boxes you can create. Just leave them behind, they will be cleaned up automatically.
It's like a carpenter saying "I don't get paid for load testing table tops, I get paid for durable furniture."
I don't get Arduino phenomenon. AVR devices can be simply wired on breadboard. Also usually there is more suited device for project than throwing 328P everywhere.

And arduino uses UART bootloader, which uses up UART port and doesn't offer debugging. They have addational chip on board for usb<>uart, so why not instead use uC which can act as programmer and debugger using normal interface?

Atmel(Microchip now?) also have some nice XMEGA uCs with much more perpipherals that ATmega series, but are pretty expensive.
-- Functional programming does not work well in programs which handle a lot of states

Apache Spark is written in Scala. It can handle extremely large amounts of state across large clusters of machines. Is the argument here that Scala is not purely functional? Or what am I missing?
probably won't fail business-wise, but will cost incrementally more for each test business-wise.
On this topic, Microsoft just partnered with Qualcomm to use their chips in new devices.

https://www.qualcomm.com/news/releases/2016/12/08/qualcomm-c...
Tests might help you write better code.To the extent they do, you should use them.

That's like saying "I get paid for functioning software, not writing code."

Yes, you get paid for the output of the act, not the act itself.
You get paid to make the best technical decision for the company/project/who ever it is that's paying you. You get paid to communicate and understand when test are needed and when they are not. Startups will probably have a lot less test than bigger companies ; unless your a security startup or something that needs a solid foundation that you can trust.

Its all a trade off that needs to be communicated to whoever is paying you.
FWIW HN does not do markdown[0], let alone markdown extensions like triple-backtick code blocks.

[0] it implements a very small subset of markdown badly: emphasis (with no escape so it tends to break when you try to use multiplication signs in your comments) and indented "code" blocks
As a German, the thing I like most is that you never ever see bottle trash lying around in parks or on the street, as any stray bottle is quickly (and I mean within minutes) swept up by the homeless/less fortunate.
Maybe you forget an edge case or some small detail in the requirements that will cause you to restructure the code and approach the problem in a different way. In which case, you now need to re-write your tests. You might as well just write tests around the final version.

Maybe, but I'd wager on the whole that you probably don't. Your surface API should be the same, and you shouldn't be testing internal implementation anyway. If you write clear and consistent interfaces, then forgetting a requirement will mean adding a test – not rewriting them.
Or, you know, write property-based tests instead, so you only need to worry about the logic and not the test values.

I've always found that if you let the author of a piece of code decide on what value that code should be tested with, he'll test for the edge cases that he's thought of (and dealt with), not the ones that actually crash production.
Take a look at http://fossi-foundation.org/. Whatever terminology you're using, I think it's right to say lowRISC and FOSSi have a shared vision for free and open source designs that respect user freedom.
Appart from things other comments have already mentioned there's some issue that the article doesn't properly reflect: Where does the CO2 come from?

You can grab the CO2 from the atmosphere and thus produce (temporary) negative emissions. But then you need even more energy in the first place. So naturally you'd get the CO2 from somewhere where you already have large amounts of CO2, e.g. a coal power plant. So you have created a justification to keep the coal plant running (with a supposedly imperfect co2 extraction process). How's that going to work out in a supposedly CO2 free energy future?

Also it should be considered that the CO2 in the plastic isn't gone for good. Plastic has a limited lifetime and will eventually end up in a landfill or a waste processing plant where it'll release its stored carbon back to the atmosphere.

So if your process is "burn coal -> capture CO2 -> use CO2 to create plastics -> plastic ends up in waste processing plant" you have delayed the emissions from the coal plant and you can argue that you have used the coal in a more efficient way, but the CO2 still ends up in the atmosphere.
Don't Get Stuck: how to get unstuck and code faster
They can also not go to work. Choice is fast to do.
I don't have that kind of hubris. I value reliability, repeatability, and consistency. And so do my customers by tell of the issue reports we get. They're most upset when something goes wrong.

I write tests, many tests, when I'm working in a dynamically typed programming language. I write tests even when I'm working in a soundly typed language. The only difference is that in soundly typed languages the type system guarantees many properties for me so I don't test for those.

Personally I like to write tests first but I don't believe that gives me any productivity benefits. It's just the way I think.

> People forget the ultimate reason for our work oh so often.

Tests are important because reliable code is important. The customers are important but so is the business. It costs quite a lot of money to support error-prone, poorly designed software. Tests aren't a silver bullet but they are a tool to alleviate the problem.
> if software backdoors were available and leaked to the public

https://www.blackhat.com/us-15/briefings.html#the-memory-sin...

conveniently "discovered" by a 3 letter agency favorite principle contractor (Batelle Memorial Institute - have fun researching them) employee just after everybody switched to the next(fixed) cpu generation.
Is this a problem? If so, can anything be done about it?

The notion that formal training from a reputable institution should count for more than self-learned skills doesn't seem particularly problematic. And even the notion that credentials from highly regarded and highly selective institutions should count for more than those from less distinguished institutions also seems ok. Of course they do. How could they not?

But maybe I am missing something. If so, I'm sure the internet will promptly inform me of it.
well, not at all times.
http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-3416
While outside publishing platforms those needs are rare (and that's why I consider it an antipattern) I agree with you in terms of a publishing platform.
They go into detail here:

https://www.fsf.org/news/free-software-foundation-releases-f...
The age of outrage