skysight-inc/HackerNews huggingface dataset:
You can't do TDD when "bug-fixing maintenance". It's a contradiction in terms.
> Also, typed function parameters are painful. Declaring a parameter as a `f: () -> int` instead of `f` requires that you think about what the signature needs to be. What if you don't know?

Why are you writing the code if you don't know yet what your input will be? A function transforms input into output, how can it do that correctly when you don't know what its input is?

If you don't know the input type yet, you should first be writing the things that will deliver the input, or leave the function as an unimplemented placeholder and define only the output type.

> What if you want to change it

This is one of the best reasons to use types. Directly after the change you'll be told by the compiler which other code needs changes. Compare this to un-typed languages where you'll need a lot of tests to ensure the same or risk runtime errors.
> Will all links mentioning woman driving have to be removed worldwide because some middle eastern country tells them to?

Among "some middle eastern countries" that exist, only Saudi Arabia has that law, and they do not censor images of women driving.
I don't find most of the Uncle Bob writes to be clever, and especially when he writes about TDD.

He's just too dogmatic to be credible to anyone working in the industry (and make no mistake, Uncle Bob knows absolutely nothing of the software industry in the 21st century).

His writings are only here to promote himself, his books and his consultancy. That's it.
I've seen many managers think that way.
This is the best situation for a TDD workflow, and the only situation I myself use TDD in.

If you have complex calculations or data transformations or you know well the expected input and output of what you're trying to do TDD actually speeds you up by allowing you to iterate faster on your solution.

If you're writing glue code between a number of other application components (90% of development in web backends) then TDD loses a lot of benefits.
If you read more carefully, you'd have realized that you're about 25 years late to express your point of view to me..but thank you anyways for presenting standard American dogma. Which I am quite familiar with, and I know the history, legal theory, and legal practice far better than most Americans. Possibly better than you do.

And no, the USA does not say that rights are limited to the ones enumerated in the Constitution. However the ones enumerated in the Constitution do have special legal status.
At the end of the day, it depends on what you are jumping in for. Either language will likely be fun and can get some work done.

If you are only interested in getting into the syntax. It almost literally doesn't matter. If you are interested in learning a lot of tricks that you've probably not had a lot of exposure to, CL is almost certainly the more bountiful place to start.
Or even just a clear spec from a customer who knows what they want.

The challenge in most of the software industry is that the customer does not know what they want, and oftentimes it isn't even clear who the customer is. TDD is great if you can define your problem well enough to write tests for it up-front. Most software problems with a decent economic return are not like that.
You Seldon see projects like this these days!
> However, in software it is often taught to build a wall of failing tests

People teaching that are not teaching TDD. They may be letting the tests drive the development, but TDD specifically is _all_ about the second-to-second cycle of moving between test and code. If you write all the tests up front then refactoring is expensive and you've locked in your design way too early.
Care to clarify this? I've seen plenty of Agile shops that practice TDD.
I'm surprised to hear that the print-on-demand books aren't cheap. I know you're getting flexibility with print-on-demand, which has value, but if the quality is so much worse than traditionally printed books (in my experience)... is it really worth it for a publisher the size of O'Reilly? I guess that's a question only they can answer.
If people want to buy print-on-demand books, that's fine. It's just not for me, I'd like the option of paying more for a standard of quality I find acceptable. Not enough people are willing to do the same, sadly.
Home Delivery What Will They Think of Next?
TDD takes discipline, planning, and creates stability; I think in the day and age of "rewrite it using the latest framework" it just doesn't coincide with the insatiable thirst developers to use the latest bleeding edge XYZ.
I agree - I would love to see a film, but I can't imagine how it'd work.
What's even more concerning is if you look at what Goyer & Friedman have done in the past, it's almost exclusively comic book and action movie stuff (and that track record is pretty spotty).

My expectations are low, unfortunately.
That's exactly what he said in the article, but I love your delightful added knife twist of calling him bad.
Depends if you count the test nets I suppose.
Tutorial on SEO Competitors' Analysis. Part One (with Example)
I don't believe LE has an upper limit on its number of SANs.

For systems not explicitly public, whitelists are almost always better than blacklists.
this may apply to a motorcycle you ride for fun (hobby project?) but when I program for a living my top priority is to best/fastest solve the problem at hand, not to have fun.
Nonsense!

Germany banned Hitler from public speaking in the 1920s; all this did was give Hitler more notoriety, and the NSDAP more propaganda material to work with.

Nazi Germany still did not emerge through democratic processes; they failed to gain a parliamentary majority despite years of street/voter harassment. Instead, they subverted democracy by exploiting a civil liberty loophole in the Weimar Constitution.

If anything, the rise of Nazi Germany demonstrates why such loopholes in protections for civil liberties are so fundamentally dangerous. For a more modern example, look at how "hate speech" laws in Russia are in fact used to silence political dissent.
How to Visualize Your Recurrent Neural Network with Attention in Keras
> both Netflix and Amazon allow you to download content for offline viewing these days

In both cases sadly still with DRM; beyond the ideological stuff I'd love to be able to download a file and play it with the player I like, or to be able to reencode it. On some aspects pirate services are still better (though only if you care about that kind of things).
You are still writing the tests first, with no real learning from them other than "they are now passing."

It is thought this is like engineering. You design an experiment and then pass it. However, that is not how experiments work. You design an experiment, and then you collect results from it. These may be enough to indicate that you are doing something right/wrong. They are intended, though, to be directional learnings. Not decisions in and of themselves.

So, I probably described something in more of a strawman fashion than I had meant. I don't think that really changes my thoughts here, though.
Is the difference between inability and ability but not doing so great?
I am writing from Pearson and have seen a lot of queries about where can folks find DRM-Free PDFs of technical books now. I want to share that informit.com, a Pearson eCommerce site, sells DRM-Free PDFs from our imprints Addison-Wesley, Prentice Hall, Sams, Cisco Press, Microsoft Press, New Riders, Que, and Peachpit.

informit.com/store/eBooks
> If code is highly coupled, tests become highly coupled and a nightmare.

TDD is supposed to prevent that. What's supposed to happen is, if the test is hard to write, it's telling you something. You're supposed to pay attention to that pain. It's supposed to show you that your code is highly coupled, and make you fix that.

If you just go ahead and write the test, difficult as it is, instead of finding a way to refactor to clean up the coupling, then yes, TDD produces a nightmare of a test. That's because you're not doing it right, though.

(Yes, I recognize that this is a lot like a No True Scotsman. But in fact any methodology, practiced badly, will produce sub-optimal results...)
I have a theory on why people maybe overvalue embedded DLSs: many problems become trivial when the terms of a language are a natural fit for the problem domain, where 'terms' are just any abstractions (new types, instantiations of old types).

So, maybe people are assuming that this benefit derives from having a full language which is a natural fit for a problem domain? (My contention being that the terms are what's really significant and the rest can be nice, but diminishing returns + tradeoffs.)

edit: fixed phrasing. I'll also add: I think certain sub-problems in an application can be specialized enough to need something really different (e.g. SQL, Prolog), but it seems like a relatively uncommon thing.
Ignoring the massive infrastructural costs and practicalities, but given the efficiency losses of the wireless-charging freeway idea, what would be the benefit of putting solar panels above the freeway and chargers underneath, over just having solar panels on the car instead?
Yes, I guess that's what I'm getting at. And the SAS and SEALs are very aware of each other's existence, I'm sure, as well as that of the Russian Spetsnaz and similar forces.
> 4.7kΩ ± 5%

And now ask somebody to type those unicode chars on the top of his/her head...

Plus how do you look what it does in google ? In a a documentation ?

How do you generate documentation for those ?

Cause you have no method name, no class name, nothing.

And then what's the exact implementation behind it ? Does it do something funny ? So I have to mix the dozen of funny details of all the code from the guys who though the 20 times they do this super-important-operation they need to recreate a whole new syntax ?
> It's not irresponsible to use a perfectly fine OS.

The first problem with this statement is the idea that there's such a thing as a "perfectly fine OS". We don't even need to consider containers, the longer an OS has been in the wild, the longer its potential vulnerabilities have been found and exploited.

Windows XP is a perfectly fine OS; using it nowadays is irresponsible.

> What is irresponsible is for Docker to purposefully avoid to mention that it has endless issues on these widely used OS.

That responsibility doesn't and should never fall on the developers of an application. The extent of one's responsibility as a developer is to define the recommendations for its use. Anything beyond that is entirely on the user.

One would go insane if one had to wonder every single operating system someone decided to use one's application in.

> It is not a 2.6 kernel by the way, redhat is backporting tons of stuff from the 3 and 4 branches.

"Backporting stuff" doesn't make it not the 2.6 Kernel, it very much is.
Though I think that's what most of HN believes, strangely.

Weird how different we perceive things: For me I always thought HN adored twitter and only I and a few others cried out loud against what I perceived as the naked emperor.

I try to be open to see where I'm wrong though and I might be about to change my rating to same rating as Mac OS: "probably great but doesn't work for me."
> the test demonstrates the correct change of that interface.

No, they don't. Tests never prove correctness. They prove that assumptions are met. Whether or not those assumptions are correct is unprovable.

The problem is, there are changes to interface that could make the entire approach of the existing tests completely meaningless. If all you're doing is changing the name of a method, that can be practically automated away in most cases. But if you're changing fundamental behavior, like "we no longer add up a bunch of numbers and show them to the user here, now we print out a bunch of labels", then your leftover, failing tests are completely useless.

I've seen far too many cases in-the-wild where people either just deleted those tests, or faked-it-till-they-maked-it to force the tests to pass, without any thought putting into whether or not the tests prove anything important.
>I've never heard TDD being that you write all of your tests up front, before you've written any code.

That's interesting, because as a non-TDD practitioner who occasionally gets it evangelized to me, that's certainly how I was told to go about it by multiple people.

Possibly TDD has a marketing problem?
Curious. How so?

Get a bug report.

Write a unit test that reproduces the bug.

Fix the bug.

The unit test now passes.

Check it in. Now its part of your growing regression suite.

How is this not "test driven"?
Some code is perfectly suited to TDD. Other code not so much.

I was just working on something with a bunch of tangly functions that measure and remap data and prepare it for sonification as sound events.

I keep jest running and the workflow is much quicker and more satisfying than any other way of hacking.
You might be surprised to learn that all power plants have some sort of primitive "networking" capability, albeit something that looks more like a direct point-to-point phone line between plants and the grid operator (see DNP3.) As you can imagine these are relatively expensive to install, but part of the bring-up of a new power plant.

All of these plants also have some sort of SCADA system internally and turbine fields need the same (the turbines need to be connected to each other, and the operator needs to be able to control the turbines in some way: e.g. turning them off when there is an excess of power, reading power output, faults, etc.) So one way or another, communication needs to occur whether it's over an IP network or a dedicated PTP line.

If someone gets physical access it's mostly game-over unless you've got builtin hardware-level encryption between all of the internal components of the facility. If there wasn't an ethernet port in the server cabinet the hacker could just connect an RS-485 line and start sending MODBUS commands or whatever protocol the SCADA system is using.

But the article does a good job pointing out that the assumption that "the facility/network is secure" does not hold as well in distributed generation as it did for traditional power generation.

Edit: see also https://en.wikipedia.org/wiki/DNP3
One annoying thing I've seen less technical stakeholders ask about with letsencrypt is "why the padlock isn't green" in Safari/Edge. Unlike Chrome and I think Firefox, those browsers only display a green padlock for SSL certs with EV, which of course letsencrypt doesn't (and arguably can't really) do.

The "grey padlock" for an otherwise perfectly valid certificate seems to confuse a very small subset of users, especially when there's a ton of badly written articles out there advising users only to trust "green padlocks", given the behavior in almost all other browsers. Thankfully showing google.com not using an EV certificate is usually easiest way to shut these conversations down.
How do we change the dynamics of the VC industry?
I was quite comfortable with refactoring for a very long time before I started doing tests, and I think that colors my approach to the problem space. I write code until it misbehaves the first time, and then I start writing tests, comfortable in the knowledge that in another half hour this code will be unit testable and look better than what everyone else is turning in, and that I'll spend 20 minutes at the end cleaning it up even more.

But I am not everybody, and trying to set team policy on my comfort levels is quite likely a bit dangerous.

I've paired with a few smart people this month and was horrified by how they refactor. Most trust their hands more than the tools. They do a LOT of transcription instead of copy and paste, and don't use the IDE's refactoring tools at all. That's not just inviting human error to the table, that's giving it the seat of honor.

For most processes there are ways to do it that are worse than nothing at all, and unfortunately many of us seem drawn to them almost instinctively. I try not to think about it because it just makes me angry that the distance between what we collectively know and what we individually do is so wide.
Ahh, the bolt weevils. Classic.
Fixing docs one README at a time
Araxis Merge 2017 Crack Mac and Serial Key Free Download
(Author here.) When I wrote that, I was echoing what I believed to be a widespread view. For example: https://martinfowler.com/bliki/CannotMeasureProductivity.htm...

"Productivity, of course, is something you determine by looking at the input of an activity and its output. So to measure software productivity you have to measure the output of software development - the reason we can't measure productivity is because we can't measure output."

In an earlier post, I argue that in light of the fact that we can't measure productivity, we should measure job satisfaction instead. https://redfin.engineering/measure-job-satisfaction-instead-...
Violence is the last refuge of the incompetent

...but it might beef up a screenplay. Still, much of Star Trek manages to get by on threats alone.
In the years leading up to World War I, the Royal Navy was convinced that rate of fire was everything.

Every ship drilled to maximize their rate of fire. Commanders of vessels who could not keep up with their peers were sacked.

When the Battle of Jutland came around, the Royal Navy greatly outnumbered the Kreigsmarine, and caught it unaware. The engagements were incredibly in the United Kingdom's favour.

Numerically, the battle was a disaster for the Royal Navy. Its losses were double that of their opponent. One of the reasons for it was that a number of RN ships exploded after taking a single hit - while German ones took shell after shell, and stayed afloat.

In their zeal to optimize their firing rate, the Royal Navy did away with the simple precaution of installing airlocks between their ammunition storerooms, and their gun rooms. You see - opening and closing an airlock every time you needed to get to and from the ammunition room wasted too much time.

Hitting a German gun room would destroy the gun. Hitting a British gun room would destroy the entire ship. But boy, did those gun crews shoot fast.

Unless your competitive process rigorously accounts for every form of cut corners, you're going to get what you measure... With some shortsighted optimizations thrown in.
The Strange and Amusing List of Collective Nouns for Africa’s Animals
Firefox reading mode seems to work just fine on this page
I think you're being a bit overdramatic, or there's a difference between your configuration and mine (FireFox Desktop). I find it quite readable, pleasantly so even.
Having read a lot of Python code that uses scientific libraries that override operators and key indexing I'll have to disagree.

The result is easier to read if you're familiar with it but exponentially more complicated if you're not and still learning. It creates marginally shorter code but I feel like the sacrifice of the explicitness / verbosity of a normal method / function call isn't worth it.
I do believe there exists some combination of format, production, and screenwriting that could bring Foundation to video. The largest problem is getting the right people to do it.

My ideal setup:

Format: Miniseries with 1-1.5 hour episodes

Network: HBO or Netflix. Mostly because I think only those would take a chance without mucking around the story.

Directors/Producers/Screenwriters: This is the foggiest in my opinion. The Nolans might do well. It would have to be directed by someone visionary but faithful, like Peter Jackson was for LOTR (a great example of a "un-filmable" story turning out well).
Maybe if that bonus was tied to the amount of critical bugs that came back within the next year or so
It's a very common way to evangelize TDD. Ruby Koans is a tutorial entirely based on that principle.
Seems like the contractors over that facility should be removed? What does it take to lose a government contract?
Slotin's story is such a great example of complacency. "Using a screwdriver was not a normal part of the experimental protocol. ... the screwdriver slipped and the upper beryllium hemisphere fell, causing a prompt critical reaction and a burst of hard radiation."
Programmers who manage to learn a language primarily by using it usually do so because of one of two reasons:

1 - the language was simple enough that there really wasn't that much to learn

2 - that programming language was similar enough to the languages they already knew that there really wasn't all that much to learn

When you're trying to learn something that's radically different from what you already know, and relatively complex, then it's a lot harder to just pick it up by playing with it and using it. That's when you usually need a good book, teacher, and/or course.

I've heard so many programmers brag about how they can learn any language in a weekend, or about how "all languages are the same". Usually they know only one language paradigm: Algol-like imperative languages, and sometimes don't even realize that there are other paradigms out there that are mindbendingly different, and which might actually be challenging to learn if all they've done their life is programmed in languages like C or Java.
How would you call it? I'm interested in how you'd specify `I` and `O`.

`I` is obviously a string, but it seems like `O` needs to be at least three different types:

> (reduce (fn (x y)
(list x y))
(list "a"))
"a"
> (reduce (fn (x y)
(list x y))
(list "a" "b"))
("a" "b")
> (reduce (fn (x y)
(list x y))
(list "a" "b" "c"))
("a" ("b" "c"))
I don't do the TDD like a waterfall. I don't do upfront all the tests, there is a discussion between the code (what express the business need) and the tests that "wraps" it inside a safe zone (what ensures that the behavior is the one intended). As such, as the idea grow, both the code and the test grow at the same time. Look at [0] to have an idea of how the tests extend the safe zone along the code.

Also, I much prefer a lot of nice unit tests over a lot selenium tests (which takes a lot of time to run).

[0]https://github.com/charlesthk/python-resize-image/commits/ma...
An example of the drawbacks of decentralization - meanwhile in Sweden, 98% of phones were already covered by the "90 000" emergency number by 1965.
A lightweight PostgreSQL-based Ruby object store using JSONB, in ~ 100 LOC:

https://gist.github.com/ciconia/57ad430cf437f0548d596a6f0026...
I think many, many more people make fun of the startup mentality. Which is harsh, but justified.

It's nice that you chased your dreams. The problem is, this is how almost all startups end up, with the last guy wondering what to do next. If you get struck by lightning, you get acquired. If you get struck twice, you get VC money.

That you "accepted" the risk just means you took a very bad bet. If you learned from that, great. No shame in that. But it's not something people are going to be impressed by, especially this late in the game.
Use it frequently. Memory patterns form by applying knowledge. Help some open source projects using the topics you learned. Nothing magic.
Ask HN: Online tutor services for development
Hello everyone,

I'm wondering if anyone has had any luck as a beginner utilizing tutors online to help with writing code. A quick google search has yielded codementor.io but I wanted to know if anyone here had any suggestions. Obviously I could attempt this through trial and error but it'd really help if I could get some proper direction.