skysight-inc/HackerNews huggingface dataset:
(Author here.) I agree with your main point but wanted to respond to your PS.

I think it's important to distinguish build tools like make from declarative versioned-dependency management tools, which multirepos require.

For example, you can build a multi-language monorepo with either make or CMake, but you can't declare that your repo builds "foo" version 1.2.3 and that it depends on "bar" version 2.3.4.

Maven does that, and it will automatically download the right version of bar for you and make it available, but Maven doesn't work well for C# dlls. You can use NuGet for dlls, but don't try it with JS modules. Use npm to manage JS modules, but don't try it with Perl packages. You can use CPAN for Perl packages, etc.
> Almost nobody is writing real novel software, they're just gluing together premade parts and managing the plumbing.

You say that like it's a bad thing.

One man's "novel implementation" is another man's "unreadable and unmaintainable pile of hacks".

I'm not saying we should all standardize on a single set of tools, but after the fourth project you've cleaned up that spends tens of GB of RAM editing XML files, you'd probably wish "uses a database" was a business requirement for every future project too (just as an example).
But this advice should be extended further. Always be willing to throw away the code and the tests. Take the learning.

Be ware, though, that you are not throwing your customers for a bad ride. As soon as you have customers, it is nigh impossible to throw away the code without neglecting them. And they are your ultimate responsibility. Not the code.
To be fair (and I'm no TDD fan personally), that mess wasn't really the fault of TDD at all. It was that Jeffries was learning how to write a Sudoku solver while he was writing his tests. If he started from Norvig's level of understanding, he surely could have written tests for an equivalently elegant solver quickly and simply.

Learning how to solve a problem by iterative coding (and throwing away the intermediate solutions) is a time-honored tradition that works very well. TDD may be an imperfect vehicle for doing that, but it doesn't really change the calculus.
I think the pseudonym "Anna senpai" is in reference to the Japanese media trope of schoolchildren falling in love with their senpai.
We're actually quite cheap. UserVoice starts at around $1,000/month, billed annually. Our plans start at $19/mo.

You can learn more here https://canny.io/uservoice
I think it's more accurate to say that we do program ourselves out of a job. We just program ourselves right into a new one in the process.
Actors don't necessarily encapsulate mutable state; they may in fact encapsulate immutable state. An actor can be treated (as in Erlang) as essentially just a(n optionally) recursive function with a mailbox, where mutation can only occur across the function boundary (i.e., when you recurse, you pass in the new value).

At this point the only benefit to allowing mutability is to allow you convenience things like for loops, and for performance reasons. From the perspective outside of the actor, the state behaves the same way whether it's mutable or immutable; you do not gain new behaviors by making it mutable (i.e., for sharing data or similar), you just make a more complex coding model (in that you're mixing mutable and immutable and have to know which is which).
Are the PDF eBooks watermarked?
>>It must be pretty hard to disrupt the "government contracts for nuclear weapons production" industry..

not to pick on you, but this is an interesting turn of phrase (I know it is sarcastic). There is an interesting gulf in SV culture nowadays between needing to "disrupt" an industry, and the industry actually just needing some renewed competition. A major problem is usually raising enough capital to really compete. And an interesting SV and banking assertion often made is that there is way too much capital chasing too few opportunities.

I guess that raising relatively small VC funds precludes putting large sums of money to work, because that means no diversification. On the other hand, if we are done with low-hanging-app-fruit for outsized returns, is the solution just to raise bigger funds? It seems there are problems that can be profitably solved with modern software, modern teams, and new ideas, but which are not solved due to too much diversification of capital.

edit: fixed autocorrect and word choice.
So if my car fails because I never change the oil, cars don't work?
One of the key benefits for me is the mindset (fostered by TDD) to make as much as possible of the code (unit) testable. This naturally leads to less coupled code, because otherwise it is not possible to test it in isolation. So the fact that you start with the aim of unit-testability leads to better designs.
Such a thing is only logical for them, yes.
Amazing Accomplishments in Product Management
I don't understand why the industry is completely focusing on electrical vehicles. It is not inherently clean energy, unless we change how we produce it.
What about the fuel cells driven cars? In my opinion it is still a valid option. You refuel hydrogen and produce water at the end.

Writing this, I recognized that it is probably short-/middle-term money, because electrical cars are quicker to develop (incl. infrastructure).
The issue is more on people dropping buzzwords rather than what they're actually doing it for.
So, this is a slightly different mantra. Working backwards from the customer is an important thing. And if you know that customers will be using your product programmatically, then yes, building the API first is important.

But note, in that world, you aren't necessarily building tests of your software. You are building specifications for your API. I can see how these might be seen as similar. And for large portions of your code, they can be.

However, for the vast majority of your code, it exists to help out other parts of your code. Not to be used as a library/framework by others.
Show HN: Xcessiv – A web-based notebook for automated hyperparameter tuning
I'd like to see one on the roll-out of Japans Earthquake Early Warning System.
Show HN: Cyber Insurance API
If there are changes to an interface that make irrelevant those tests, then you change those tests (and, if you're semantically versioning like you should be, you bump the major version number). I don't really get what you're objecting to. Implicit in doing TDD effectively is adopting the (light) burden of refactoring.

Yeah, people will delete tests because they refuse to refactor them. They're bad programmers. Don't work with them?
Article misses that little ol' Haleyville, Alabama was the first city to roll-out 911.
Test Driven Development? All these acronyms and not once is it spelled out in the article or the discussion! Is it like saying HTTP or DNS to most people? I'd honestly never heard of it...but the concept seems logical from a high level.
Low-income families spend 40% of their money on luxuries
> Software, as an industry, generally profits the most when it can identify an existing need that is currently solved without computers, and then make it 10x+ more efficient by applying computers.

>In this situation, the software doesn't need to be bug-free, it doesn't need to do everything, it just needs to work better than a human can.

Well said, these statements underscores importance of FINDING the PROBLEMS/TASKS that are done by HUMANS/MANUAL that can be AUTOMATED with COMPUTERS that can yield 10X efficiency .

Here are few gems from the original article
https://blogs.msdn.microsoft.com/ericgu/2017/06/22/notdd/

The ability to write and refactor code to a state with low coupling, well-separated concerns > TDD Skills

1/ Design on the fly is a learned skill. If you don’t have the refactoring skills to drive it, it is possible that the design you reach through TDD is going to be worse than if you spent 15 minutes doing up-front design.

2/ I think that’s a good summary of why many people have said, “TDD doesn’t work”; if you don’t have a design with low-coupling, you will end up with a bunch of tests that are expensive to maintain and may not guard against regression very well.
Can you provide a reference? I'm not a big proponent of TDD but have read up on it and experimented with it some, and none of the TDD literature I've read suggests writing all the tests up front. Virtually all the mainstream TDD literature and talks advocate for the "write a test, make it pass, lather, rinse, repeat" model of development.
Elmer homepage, https://www.csc.fi/web/elmer
John Carmack Archive – Interviews [pdf]
Lane Goldberg in this case.

http://www.builtbylane.com/
You're right that the probability of any individual "unicorn" type idea succeeding is ridiculously slim. But I think you're not appreciating the larger context. Consider this:

1) I have never had more job offers in my life than the past 24 hours. Like, really good jobs. Obviously that wasn't the goal, but it's not like I'm out on the street or really in any way worse off than I was before.

2) I learned more in the past two years than I have any other time in my working life. So again, I'm not in that bad of a spot. It wasn't a waste of time at all.

3) Even though there are very few massive hit VC successes, they do happen dozens of times a year. Just because something is low-probability doesn't make it stupid. Do you think people are dumb who write novels? Or become actors? Or open food trucks? Nobody should try anything that probably won't work?

That's a really sad life outlook.
Sorry--that was a generic "you" there, not you-specifically. I'm saying that this is something everybody needs to understand because writing state-munging code is intrinsically harder to do correctly.

He's not just "splitting the code into two parts", though. He is consciously and specifically defining a core based on functional principles that avoid mutating state (which is harder to measure and reason about). That UI layer, his "imperative shell", is where state is managed, rather than embedding side effects into his business logic. (If you watch the Boundaries talk you'll see he frames larger applications as sets of functional cores surrounded by a layer of imperative routing between them.)
Interesting that you mention REPLs. I wonder if the often maligned Python docstring concept has/had more merit than it is currently given credit for.
They might be able to Salvor it, Hardin my opinion though
What are you talking about? TDD generally deals with unit testing. Which by definition is more fine-grained than end-to-end integration tests against non-mock dependencies.

All of which is unrelated to UAT. Where you show the alpha to the business, and it's only after seeing it live for the first time that they start to get on the same page about what their business goals were to begin with.
Generating music with expressive timing and dynamics
State is a desirable thing in the code that wraps your business logic, for sure! Otherwise you're not actually doing anything. That's distinct from state in your business logic, though.
... or they could have used BigQuery with a primary key on message ID.
Wow, that must've taken forever to dial on a rotary phone.
Disclosure: I've worked in both P&C and Reinsurance for several years. Also on Wall Street for a couple years. Also in Healthcare for a couple years.

Overall I think this is a nice briefing on the state of the insurance market in the modern economic landscape. It is extensively regulated with rates set and various nuances. All of this, of course, comprises part of a grand "data set" that looks quite appealing to modernization.

Unfortunately, I think there should be a strong expectation that the market (industry) will both be openly hostile to "disruption" oriented attitudes a la Uber, but laugh at any ability to raise capital to compete at any meangingful level.

I applaud your interest in perhaps improving a legally sanctioned form of graft (I prefer Mutual Organizations myself). Conversely, my experience leads me to laugh a little because I've seen the numbers and the complexity behind the scenes. I've got no interest in the industry beyond the paycheck it provided, but it is quite fascinating in numerous respects. Just the naming conventions alone once you get to Bermuda is a trip. Good luck.
I'd argue most languages are agnostic about (im)mutability. It's libraries that aren't.
You're ignoring section 2, which says the sonic boom can be as loud as other things the public tolerates (like jackhammers).
Question: do you consider giving up on the soft-DRM (watermarking of PDFs) too?

Lack of DRM (both soft and hard) was for me the biggest feature when buying from O'Reilly. It's what made it quite unique and why I bought most of my tech-related eBooks there.
I had a somewhat unpleasant surprise when I bought books directly from your website and found them to be watermarked. Didn't see that written anywhere on the site before I purchased...
On HN, it's better to address the argument directly. If he's mistaken, it doesn't matter who he is.
In a similar vein, I've found it super-helpful when refactoring. It gives you extra confidence that your refactoring isn't gradually breaking important stuff.
What to do about the Hudson though?
Thank you! This is very thoughtful. I'm definitely taking some time and thankfully not under too much financial stress. But honestly I actually feel really fine. This happened a couple weeks ago and I have had some time to process it. Writing the post was super cathartic.
Non-proof-of-work consensus always ends up depending either on trusted third parties or majority vote. Anyone can create a valid-looking non-PoW chain in a short time, and there's no way to separate valid chains from each other. In Bitcoin, when you want to bootstrap, you connect to n nodes and if just a single node is honest you will get the right chain. For non-PoW, if there's disagreement, you have to trust either a majority on what the right chain is, or add trusted nodes that overrule a majority vote. For proof-of-work there will always be a chain with most work done, provided >50% of miners are honest (hard dependency).

I have written a bit longer on the subject here: https://runeksvendsen.github.io/blog/posts/2017-06-14-bitcoi...
The tests get in the way. Because my design does not have low coupling, I end up with tests that also do not have low coupling.

Not to be smug, but I feel like this is a rookie mistake I learned 10 years ago immediately after starting TDD.

The slogan I use in my head is that testing calcifies interfaces. Once you have a test against an interface, it's hard to change it. If you find yourself changing tests and code AT THE SAME TIME, e.g. while refactoring, then your tests become less useful, and are just slowing you down.

Instead, you want to test against stable interfaces -- ones you did NOT create. That could be HTTP/WSGI/Rack for web services, or stdin/stdout/argv for command line tools.

Unit test frameworks and in particular mocking frameworks can lead you into this trap. I've never used a mocking library -- they are the worst.

There are pretty straightforward solutions to this problem. If I want to be fancy then I will say I write "bespoke test frameworks", but all this means is: write some simple Python or shell scripts to test your code from a coarse-grained level. Your tests can often be in a different langauge than your code.

The last two posts on my blog are about this:

"How I Use Tests": http://www.oilshell.org/blog/2017/06/22.html

"How I Plan to Use Tests: Transforming OSH": http://www.oilshell.org/blog/2017/06/24.html -- I want to change the LANGUAGE my code is written in, but preserve the tests, and use them as a guide.

And definitely these kinds of tests work better for data manipulation rather than heavily stateful code. But the point is that testing teaches you good design, and good design is to separate your data manipulation from your program state as much as possible. State is hard, and logic is easy (if you have isolated it and tested it.)

Summary: I use TDD, it absolutely works. But I use more coarse-grained tests against STABLE INTERFACES I didn't create.
> Am I not allowed to point out the simple fact that DQ has no scientific educational value

You have, and the person who put DQ in the list disagreed. Why does it matter whether you personally like the game? You said your thing, the other person disagreed. Unless you're emotionally invested in DQ in particular, for unrelated reasons, I'd say the case is closed.
Salto-1P Is the Most Amazing Jumping Robot We've Ever Seen
There was an article last week-ish about reading OpenBSD source daily.

https://news.ycombinator.com/item?id=14521386
This is how it was done in the old days. Companies want to cut costs (employ less Substation Technicians), so they upgraded their equipment and systems to allow for remote operation. You used to have to call a SubTech locally at each substation if you wanted breakers, disconnects, or switches operated. Now, system operators will be able to do most of that remotely and only have to call a SubTech during emergencies when manual operation is required. Without networking you also have a lot less RELIABILITY (something grid operators and the DOE care greatly about). You can't have protective tripping and relaying without networking and comms, especially on the transmission lines that connect major metro areas that are hundreds of miles away from each other.

TLDR: Its a business decision.
TDD totally deals with unit testing. Are your units not reflective of business goals? Mine tend very strongly to be, perhaps because I extract IO and other state crap out into the less functional part of my program (and I don't really unit test that).
> Insurance carriers set their rates based on actuarial models designed to predict the likelihood of future events.

Sure, until the government says that you are no longer allowed to set rates based on actuarial data; maybe you aren't allowed to charge people appropriately if they have some expensive "pre-existing condition", or because of certain "protected" but statistically relevant characteristics. This throws a big fat spanner into the whole expectation value thing, because you're no longer an insurance company but a weird privatized subsidy pool that isn't allowed to make expectimax decisions anymore.

Your clients aren't allowed to expectimax anymore either; if they catch on to the fact that they're actually subsidizing someone else, they're not allowed to form their own rational insurance pool (because it would violate restrictions on "discrimination", e.g. ACA section 1557) and if they choose to opt out of the irrational "insurance"/subsidy market you hit them with a hefty fine.

I encourage everyone to look up expectation values for payin/payout of medical insurance for different customer types under current regulations (start with https://www.ncbi.nlm.nih.gov/pmc/articles/PMC1361028/ ). TL;DR If you're a reasonably healthy man below retirement age, you're getting screwed hard. Maybe society can collectively agree that this is a good idea, but we should at least be honest and stop referring to it as "insurance". Actual insurance markets without coercion are a net positive for all participants, rather than a convoluted scheme to (effectively) transfer money from one demographic to another.
This is a hype article. Wind farms and their equipment could be hacked for years. Just subscribe to the ISC-CERT RSS feed and you'll see they were hackable going back years. Nobody discovered anything new.
Hi all! IEEE wrote another article on one of my robots.

I'm here if you have any questions.
why does that matter? works for black mirror
there's plenty of non money uses for a distributed consensus based write only database. Think of property ownership, vehicle registration, stock markets.
Problem number one, that girl in the opening picture has a ring on her left hand. Perhaps try again with single girls?
It isn't an either or. You want to do both, because doing one or the other doesn't really solve the problem created. If you can't get the perpetrator for some reason, at least having a way to mitigate the damage is useful. In some cases that might be de-listing in the search engine, in others it might be making a service provider take action. The trick is to not give it undue power so it can be used as a bludgeon where it doesn't make sense, and that balancing act is actually the hard part, IMO.
Leveraging Interfaces in Go
If you signed an agreement with an inventions clause, you invent something, and do not assign the patent to your employer, your employer has two options: fire you, or not fire you. They can't take your agreement to a judge and get an order assigning the patent to them.

That's because your lawyer would be able to point out all the ways in which the agreement was not a contract.

As we recently saw with the Zillow letter to McMansion Hell, a cease and desist letter is a legal document, but that does not necessarily mean that it has any inherent merit or correctness.

In order for a judge to be able to grant relief in case of a breach, the document has to meet all the criteria for a legally binding contract. If there's no contract, neither party has to do jack squat for the other.

There are exactly zero contracts existing between me and my current employer. We have an informal, unenforceable-in-a-court-of-law agreement that says I will do X and not do Y, and then the employer will pay me Z every two weeks. Any day of the week, I could show up to hear, "Our deal's off. Go away, and never come back." I'm not ecstatic about the arrangement, because there is a sizeable power imbalance between me and my employer, but I can't do anything to change that individually. But I do work and get paid for it.

All those agreements do is let me know that I shouldn't bother doing certain things, unless they would allow me to quit my job.
Here is the docket: http://appellatecases.courtinfo.ca.gov/search/case/dockets.c...
Transcription can lead to the same conditional in two blocks of similar code instead of the two intended. It can lead to fencepost errors due to changing or inverting an inequality. And in some languages it can lead to code that looks up data that doesn't exist (misspell a property name outside the happy path).

The big problem is that you're chewing up short term memory slots that used to hold the next thing you planned to do. For me I generally use only a couple slots for a single refactor because it's all muscle memory.

Additionally, it just takes a hell of a long time, which means you go from virtually no chance of interruption to a measurable one.

When I was young I had an exceptional short term memory and could pull off some crazy big refactor without introducing errors. But now it's normal at best, and also I rely far less on those sorts of feats, in part because I put a higher value on commit history readability.
Well I mean, you're correct it would break the communication over NAT, but it breaks the communication over the local network at well. You might still receive that packet to your NIC, but unless you know beforehand it will send using that source port and thus tell the OS (by setting up a socket or etc. to collect that packet) then the packet will never be routed to your application. So I don't really feel like this could be intended because it just makes stuff not work.
Introducing HumbleNet: a cross-platform networking library that works in the bro
To be fair, the mini-series format has recently proven to be quite successful. Examples include Fargo and True Detective.

Honestly, I'm more concerned with the scale of the Foundation universe and timeline. If it's not well written and presented, viewers will easily lose track of the where and when.