skysight-inc/HackerNews huggingface dataset:
It's doubtful our sonar would even pick it up. And if it did, it would sound like whales humping, or some kind of seismic anomaly. Anything but a submarine.
Maybe especially in seawater?
The problem is subjective and thus more difficult to provide evidence for.

I don't think the parent doubts the runtimes or is claiming that the code for his pet language wasn't written properly and therefore the site is a sham. The issue is: what is reasonable code?

Benchmarks invariably become a game of massaging the code to produce the optimal assembly. And that's the problem. The reason that we invented higher level languages was so we could stop thinking about assembly. The point of most higher level languages is not to optimize CPU cycles, but to optimize human brain cycles. If we only cared about speed (and not at all about development time), we would just write all code in assembly.

I am not particularly interested in how fast meticulously fine tuned code in a given language runs. I have no doubt that, given enough time, an excellent programmer can finely craft a block of code to run very fast in any half decent language. And this site is evidence of that.

What I want to know, and what benchmarks never show, is which languages make writing performant code simple, idiomatic, and natural. Which languages give me good performance, without having to really work for it?

This is an amazing site, but it is a stretch to think that it compares languages. It compares programmers and their implementations. The implementations are more like their own art form, like Chess or something.
Just FYI there are a couple of small typos like benefcial and fnancial
What about making client side public key auth not a UX disaster in all major browsers?
Can someone explain to me why this link has such a low ranking on HN, already? It's pretty fresh and has lots of upvotes. I was trying to post it, because I didn't see it yet.
It is funny how we've regressed. For CRUD apps that don't do anything graphical, the current crop of web apps don't do anything better than a mainframe and a 3270 terminal did 50+ years ago. And the man-hours required to produce and maintain them is much higher.
If this protocol got implemented widely, I think there would be some value in creating an alternative app that essentially combines this with a local password database. The app could automatically generate site-specific keypairs, and you would still only need to memorize your master password.

This combination would solve the problem of your master password being disclosed (your opponent still needs to get your database), while retaining the benefit of giving sites only your public key instead of a usable password.
Removing inhibitors to creativity
Of course businesses shouldn't sacrifice all of their revenue.

Consumers are largely employees of businesses. If consumers do not have money to buy things from businesses then everyone loses. Instead of engaging on a senseless endeavor to lower wages as much as possible, strive for a FAIR wage that will allow consumers to do business with businesses.
The goal is similar, but not execution. I don't know all specs of Persona - learnt about it when it was being deprecated - but the key difference SecureLogin cannot be deprecated.

"All user data stored on the persona.org services will be destroyed, including registered email addresses and password hashes"

And hey, there's nothing on SL servers.
Thanks we will correct those asap
The Campaign for North Africa was never meant to be played straight; consider it a reference for other game designers to study.

The consim/wargame split is more nuanced than you described. A game like Combat Commander: Europe attempts to replicate the chaotic unpredictability of small unit engagements: it's extremely unrealistic, yet is enjoyable + is commended for capturing the chaos.

The crux of the distinction is, a simulation isn't a game (they're not fun). Most wargames aren't consims, and some of the best consims don't even attempt to replicate the level of low-level detail you describe.
The joke, for passers-by: Terraforming Mars was huge hit boardgame last year, and is now in the running for the Spiele des Jahres, the German game-of-the-year which is often considered one of the foremost awards in tabletop gaming. In particular, Terraforming Mars seems to be the preferred choice among most gamers, but the SdJ committee is somewhat infamous for its surprising final selections, often not matching what speculators think of as the intended weight/complexity of the category. So that post's title, "the argument (for|against) Terraforming Mars", is an extremely relevant and current discussion topic in the board game community.

(The real link is, of course, simply about the planet.)
I'm not saying people should use 1Password instead of this. I'm actually not recommending anything, just trying to get my head around the concept. Reading the Github page, the impression I was left with was that this was essentially the same thing as an auto-installed site-specific serverless password manager. Is that incorrect?
In my opinion SL does exactly that: another take on client side public key auth. It's not built in the browser on purpose for flexibility.
Safe rust clearly cannot express everything that can be expressed in C. It cannot even express everything that is safe in general. But "the safety features of Rust" includes drawing a barrier between the safe parts of your code and the unsafe parts. There is significant value in that compartmentalization. Moreover, you are assuming that things written unsafely in C should be written identically in rust, when there very well could be more idiomatic, modern ways to do the same thing without any unsafety at all.
Very good point. While all of these guidelines are spot on, I'll also usually favor maintainability/readability (as in proper combination of applying standard Good Practices and design patterns) over anything else, if context allows. Then again, I noticed since C++11 and beyond there is much less of a trade-off between maintainability/readability and runtime performance than there used to be. Might also be compilers getting better, and hardware in general somewhat faster. The latter also being why I start to care less about compile-time performance.
They didn't pick Vulkan because of the performance, they picked it because their Vulkan driver is better maintained, yet still performs as well as D3D12.
Politician: We need to regulate the internet because ... terrorism
50% of speed isn't the whole deal. Latency and memory use matter too.
Audio,Video, Games, Networking,etc require minimal latency.
Memory use is also critical: when you data structures explode into GBs of RAM, a twice larger means you can run out of RAM and start swapping to disk, lowering performance substantially. Finally 50% of speed in isolated benchmarks with minimal GC use doesn't mean 50% inside a complex application, where GC can pause the current thread or steal time continuously.
You can absolutely underpay your employees, sell goods to employees of others firms who do not, and profit. There is a clear benefit to a single company doing this.

It is not clear the benefit is greater than increasing wages, but that's another thing.

But if everyone does this, to the point that there are not enough potential consumers for the majority of products, then there is no benefit to lowering wages. You can't sell anything to anyone.

In the end, no one wins the race to the bottom.
I strongly disagree with the prioritization of compile time and run time performance over maintainability. I can't count the number of times this has bitten me because of some premature optimization someone chose to write. Most of the time the "optimized" code is faster, but it was never a bottleneck to begin with, and is significantly harder to read/modify. Also, if compile time is so important to you, try using Meson as your build system.
I never take a loan to buy a car or motorcycle, but I have written off a few vehicles (all my fault, and none involving other people. One amusing-in-distant-hindsight-only case was when I spilled paint all over the interior of a car, written off by the insurance company as beyond economic repair).

In each case I only got the value of that vehicle as per the lowest price the insurance adjustor could find, taking the mileage and age into account. That was never enough to buy something of equal value to me, and I assume totally inadequate to pay off the outstanding loan amount.
Earth stays far, far more hospitable than Mars even after absolutely colossal asteroid impacts.
Browse every book hyperlink ever posted on Marginal Revolution
I mean it is pretty odd that you would do a call for papers and pick out those you liked the most without knowing race or gender but then replace some just because it turns out they had the wrong gender/skin color/whatever.

It's actually totally understandable.

Let me explain.

The conference organizers clearly have diversity as a goal.

In their naivete, they thought to themselves "we want equality for everyone! I know... let's just make this a pure meritocracy! Then there won't be bias and everyone will be happy!", and so they used a blind review process.

Of course, it didn't dawn on them at the time that if you took a blind random sampling of programmers, had them write presentations, and then approved them, you'd end up with a lack of diversity because the industry itself has an almost comically absurd lack of diversity.

So unless the average skill level of individuals in minority groups is extemely disproportionately higher than the average population (which rather contradicts the idea that race or gender don't impact skill), they would be poorly represented because they're poorly represented in our community in general.

So after approving their blindly reviewed set of presentations, they realized, shoot, they have an alarming lack of diversity in their presentations (read the above two paragraphs again if you don't understand why).

And so now they have to go back to the drawing board. All because they didn't understand population statistics.
That is an extreme simplification. Modern crud apps run from essentially any network in the world on hardware of every conceivable form factor and vendor. The protocol is open and so obvious it is routinely taught to middle school children.

All of those things are significantly different than a mainframe/term setup
One way of looking at the priorities is through the lens of "how difficult will it be to address these topics after the product ships?", with all of the inertia that entails.

For example, most runtime performance is fundamentally architectural. Once you ship an architecture it is nearly impossible to change it in practice. You rarely get a second chance to do this correctly.

Correctness can be particularly insidious if the code behaves well enough to use. There are many examples of incorrectness that became a "feature" after it shipped because users started exploiting the side-effects of incorrectness in their own applications, making it very difficult or impossible to properly address the underlying broken-ness. A lot of code spaghetti is the product of a janky feature implementation that has some incorrect behavior that needs to be supported indefinitely to keep users happy. (This is what I always fear most when developing software.)

Compile times are a partly a side-effect of architecture but in practice you can often make large improvements without materially altering the design of the software. With minimal thoughtfulness in the software design, you can push this off until it really becomes painful without losing the ability to change it.

And so on. Readability and writability are among the easiest things to change after the fact.
Good ol' two wrongs make a right.
C (and C++, who inherited most problems with memory insecurity from C) are still used for a very wide variety of programs. There are plenty of alternatives to C other than Rust. Which of them is appropriate depends on the task at hand. In no particular order, all the following languages can replace C with greater memory safety:

Rust, Go, Oberon, Common Lisp, Scheme, D, Java
It’s true you must give Fastmail a phone number to set up 2FA, but you can erase the phone number once 2FA is in place.
You need some sort of "terminal server" to maintain the session and station state, and I think screen's server does that thing quite well - I don't see a good reason to integrate the "terminal server" with the OS. You could split "UI session management" and "process management" somewhat (e.g. have Docker manage the process swarm and pass stdio to screen), but that's even more splitting.

The uglier part is that screen needs to communicate the UI state to a terminal emulator. Theoretically, you could have screen expose an API and have a client-side GUI client directly display a UI, and that is even probably a good idea (I'll like a Qt tmux client that can talk to a remote tmux with JSON over SSH), but nobody bothered to implement it yet, and a "VT100 over serial" client can be used without running new software at the "user endpoint".
> The following two sections, Subspaces and Linear Combinations are theoretical.

My personal take: learning and making proofs is important because you get to understand the point of the more abstract topics (such as vector subspaces, orthogonal complements, direct sums, etc.)

And then you have new tools for thinking.
Part of the problem is that the old analog systems were never expected to match the tests in the real world either -- that's the origin of the YMMV phrase. But I suppose the tests were sufficient to keep them within some bound.
SVD seems like a tough way to get rank; can't you just reduce and count pivots?
I think that expressing these important points as priorities is missing a better way of looking at them.

I see them as tensions, the engineer's job and wisdom is in balancing these tensions

Except correctness. Code should be correct.
For more on Rosette I recommend watching Emina's keynotes at the (sixth RacketCon) [0] and Clojure/west 2017 [1].

[0]: http://con.racket-lang.org/2016/#speakers

[1]: https://www.youtube.com/watch?v=KpDyuMIb_E0&index=25&list=PL...
I disagree. TN3270 runs on essentially any network in the world, and has existed for quite some time. I am scoping this down to CRUD apps that are text and labels.
The Most Essential Elements of Any Non-Fiction Work
We identify as a group - a tribe. In recent millenia, it's worked out well for individuals to identify with even larger groups. Today, it's rational to identify globally, for the benefits of trade, collaborative technological development and peace. There may well be some evolutionary pressure towards this. (Yes, there's reward for defection, but collaboration works even better).

Granted, "global" isn't the same as "species" - but in practice, and forever there is communication between members, they are identical (have the same referent).
There's already way too many unfun abstracts, please don't encourage designers to not spackling on a loose theme.
Except in very special cases, I would suggest Maintainability be #2.
Don't knock snark. It's perfectly valid way to challenge and traces its history to early computer science. It's why you fear goto. It's why I exploit it.
The Top 7 Languages to Get Ahead of the Curve
There are many UK car dealers that will sell you a 7 day insurance certificate to 'drive away today'. This is quite convenient usually as it allows them to tax the car as well for you, so it becomes road legal.
Register allocation in general is np-complete[1][2]. Having polynomial-time coloring algorithm for SSA doesn't make the allocation optimal -- you still need to "lower" the SSA to proper machine code.

[1] http://www.cs.cmu.edu/afs/cs/academic/class/15745-s07/www/pa...
[2] http://pharm.ece.wisc.edu/wddd/2006/papers/wddd_05.pdf
Show HN: Lockbox – User-friendly CLI/lib over cryptography.io encryption cipher
Agreed on the hygiene... However, we're humans, and even the best of us will make a mistake at some point. The impact of that mistake in that scheme seems potentially catastrophic in a way that's different from traditional password managers. I don't see an easy way to fix it given your design goals (which I really like!)
Since programms are non-deterministic, knowing the initial parameters should be enough, theoretically, but I am not sure if the internal translation of microcode is still deterministic. Considering the initial conditions for the kernel and every other part of the system would have to be reset in hardware and rebooted for every run until the bug is triggered, I'm not sure how feasible this approach would be.

Edit: My comment doesn't even get to your question. I mean, bug reproduction is quite hard before recording.
It's mostly correct, but it really is not a password manager.
Manager is a helper for some people, protocol is a requirement for all. So I want to draw a line between protocol and a manager.

It's like https://getclef.com/ or SQRL or Mozilla Persona, but not exactly a manager.

By being a protocol it can be _legitimately_ deterministic (you know why deterministic managers aren't great, Tony Arcieri wrote a good post)

By being deterministic it can be absolutely free and scalable

By being scalable and free I hope it has a chance for being popular (no vendor lock-in).

No real innovation, definitely, but in little details it's a good balance of existing things.
Facilitating contributions from the Scala community, what can be improved:

[0] https://github.com/scala/scala/pull/5515

[1] https://failex.blogspot.nl/2017/04/why-i-didnt-sign-scala-cl...
The Utter Complete Total Fraud of Wind Power
Redis vs. Mongo DB – The battle of the NoSQL databases continues
The original English saying was with "better" instead of "perfect". That said, both have the same meaning: you can keep improving it forever, there will always be a "better" way of doing it.

What I think it means is that you have to know your objectives, as everything is a trade-off. Time you spend refactoring is time you don't spend testing or documenting it, for instance. Or it might be better to have two features at 90% "perfection" than one at 99%. Or spend that time with better marketing/landing page/etc.
I'd like to see that too.
Laravel 5 Boilerplate Project
If you don't care about "making it pretty", you can make a cookie-cutter 3270-style UI pretty easily.
Which scheduler automatically inserts instructions to add more ALUs to its CPU? ;)
Round 14 of Web Framework Benchmarks (May '17)
This comment of both incoherent and unrelated.
I never really tried to type my password and hit Send, so I never worried about this case. Hygiene has to be reshaped to understand how important master pw is compared to all pw we used to type, like 123456.
> language provides no guarantees that it has to "play nice" with foreign threads

I hope it continues to play nice, as I have a project depending on this behavior (bindings for a CPU emulator which spawns a thread for the CPU main loop, and calls back into my Go code on some events).

Thanks for the info. I guess the biggest problem is making sure `go` in a locked goroutine doesn't release threads to the scheduler from the locked goroutine? That's a weird thing to reason about. I initially guessed you'd need a separate feeder thread, but you want `go` from a locked thread to keep the uid and namespace of the locked thread.

So I guess there are two potential solutions:

- goroutines spawned from locked threads are pure coroutines and will not be scheduled on another thread

- goroutines spawned from locked threads can only execute on the locked thread, or on threads spawned from the locked thread that don't predate the goroutine. Child threads can also only be used for matching child goroutines, and will be more aggressively collected. This would converge closer to an oldschool threading model than green threads, but should hopefully prevent bugs like UID/namespace hopping.

This is the kind of thing you could possibly do with a small patch to the Go runtime. Go makes it so easy to build the compiler/runtime, perhaps forking Go for this is reasonable until there's an official solution.

There's also the issue of what to do with the primary thread that has been marked unsafe when it returns. Instead of LockOSThread, you probably want "give this OS thread and its children magic sandbox scheduling behavior, which includes collecting the thread when it returns, because we're going to call stuff like setuid".
C++, though, only works if you follow a bunch of coding guidelines (that I can tell you for free the last C++ team I worked on didn't) and don't interface with any library APIs that don't follow those guidelines.

Don't get me wrong, C++ is coming on by leaps and bounds, but if you want to get to safe and performant without GC, it's not the place you should be starting. (Equally, I'm not saying Rust solves all the world's problems. Just that it's a better place to start.)
Et Tu Brute: Are You a Yes-Man?
non-closable 'open in app' pop-up window.
Except such stories are meaningless because they are random in nature. Unlike in the Icarus story, air gets colder with altitude so does that suddenly reverse the meaning of the story?

Now, we can use a real world example like car accidents as traveling 35+ MPH is unsafe. But, now the counter arguments are obvious because in the real world there are trade offs and meaningful stories are more open to interpretation.
I disagree. Most program won’t be able to port to Ethereum. Other than random number generator, any user inputs, I/O, network api will all cause non-deterministic. Any program needs timing would not work, because timing isn’t reliable. Calling Ethereum turing complete is misleading marketing in my opinion. The smart contract is very restricted. It is useful to some extent, but stop calling it turing complete world computer please ....
"Unique" is very right: https://en.m.wikipedia.org/wiki/Volkswagen_Act
If they use the "air gap" to separate the dry side from the wet side (stator from rotor) one may be able to mess it up by dropping a cloud of iron containing abrasive particles. They'd be drawn into the gap and grind away. Depending how it's constructed of course.
My initial concern was an aggressive server timeout on nginx/haproxy. I think the defaults should be long enough, but it's entirely possible to have something lower than 20 seconds. (and the app developer might not even be aware of this)

I have no reason to think it's unacceptable, was just curious. Interesting project!
Interestingly, lesser cylinders is spreading up the range of BMW (and other marques) and no longer an indicator of a cheap model. The 2017 330i is equipped with a 2.0-liter turbocharged four-cylinder...
Screen has supported vertical split panes for a long time now.
A species includes its individuals. If the species dies, all of the individuals are also dead.
The comparison to the Red October is unfounded, this totally has a propeller.
I've seen research (at Columbia?) on FPGA accelerated queries.
Can this model be translated into computer vision code? I always wonder if it means there are new more efficient models still to be found to copy from nature, or if the model ends up not being the most efficient and just the result of evolution.
They convert as they join, but a lot of them did not grow up as Muslim. Being Muslim (as per ISIS definition of what muslim means) is part of the ISIS rhetoric, and people convert to be part of ISIS.

OP says that only people part of "a subset of people" can be part of ISIS and propagate terror. implying that only people who grew up as muslim can become terrorists.