skysight-inc/HackerNews huggingface dataset:
> In my mind, adaptability is more important than immutability.

Important for what? Is there adaptability without mutability?

Programmers know that if you implement something with the premise of immutability then if mutability occurs the state of your application changes arbitrarily.

Mutability is good for the ones who can rely on an existing provider of centralized governance to make decisions that benefit them. For everyone else it's just plain corruption.

Ethereum pivoted from decentralized governance to centralized governance across borders. They are now solving different problems and I hope they see it.
Have you read Smolin's Time Reborn? I've just finished it, and while I don't agree with certain aspects of some of his ideas, I found it quite interesting and valuable.
Really I just didn't want to have to install node in the build step because it was already complex.
What wrong with fat? There's plenty of people (eg traditional eskimo diet, all the modern keto-fans) eating lots of fat and doing quite well out of it.
Pretty sure that pendulum is never swinging back in the dynamically type side.

The simple truth is that today, statically typed languages have all the advantages that once used to be the exclusivity of dynamically typed languages, while the reverse is still not true.

In 2016, there is really very little reason to pick a dynamically typed language for any serious project.

Javascript is going to be around for a while because of inertia, but it's pretty much the last mainstream dynamically typed language we'll see.
Developers get paid market price for their labor, right now employers pay them above median salary, some commenter on HN wants to point out a correlation between this particular developer's choice to spend their time to learn a new skill and their current market valuation suggesting that the latter follows from the former.
We're far from that. Much of what we actually sell are solutions focused on anomaly detection. We actually do most of our business in asia where the on prem market is much larger and people move faster.

What I'm trying to point out here is that the people who run these startups are typically Phds with little interest in building an actual business.

Many of these deep learning startups are built to be quick flips while having fun for a few years building something cool. That in and of itself is fine.

They build something differentiated and valuable, get paid a handsome chunk of money. No one really loses when that happens, it's just different when you want to go to market.

That being said, you have every right to bet against us. That's how many large companies start is with detractors.

90% of startups also fail. We have a different opinion on how it's done. Only time will tell whether we succeed or not.

That being said: Where's your deep learning startup? ;) At least we're trying something different.
A New Map of the Brain: What Does It Mean?
In response to some of the other comments I've been here for 9 years. I see zero problems with people expressing themselves. There are so many events and so many communities for doing anything you want to do.

This idea that Weetrrns have that Japanese can't express themselves because of social norms seems like complete bs to me but maybe I'm just not seeing it
Good list, but are they going alphabetically and only made it to 'k'? ;-)

Edit: Thanks, I had a feeling there was a bug... it was just strange to see files from the top-level folder appear afterward, made it less obvious.
Maybe not as detailed as your link, but still interesting:

http://www.cambus.net/why-openbsd/

Somewhat unrelated, but a very interesting read:

"Why did I choose the DragonFlyBSD Operating System?"

https://bsdmag.org/siju_george/

Let's give the 3rd major BSD OS more love :)
They're not exactly comparable. Java's type system gets in your way. Typescript only gets in the way when you ask it to. The dev experience can be quite different.
If you are lucky enough to live in an area with any kind of competition, choose them over the incumbents. You should choose them even of they provide worse speeds or less comprehensive customer service. Ideally you should choose a fully independent ISP that doesn't lease any infrastructure from the incumbents.
Why do you think that's what downvotes mean around here? pg explicitly disagrees with you, and his opinion would seem to matter.

https://news.ycombinator.com/item?id=117171
How long do you think it takes?
There is some of that, but in general I get the opposite impression. People are extremely resistant to machine learning. They don't trust it. It's actually a phenomenon studied in psychology called algorithm aversion: https://marketing.wharton.upenn.edu/mktg/assets/File/Dietvor...

There is a paper I was just reading here (https://meehl.dl.umn.edu/sites/g/files/pua1696/f/167grovemee...) where the author surveyed the literature for all the comparisons he could find of human experts and statistical methods. In all but a few cases the algorithmic methods did better. Most of these were crude, simple models, using only a few features. Most of them are before the age of computers and were calculated on pencil and paper. And yet they still generally outperform human intuition, which is just terrible and barely better than chance.

Yet in most the industries where algorithms were shown to do better than humans decades ago, did not switch to the algorithms.
Early optimization is the root of all good
Open Source Gameboy Emulator Written in C++
I feel exactly the opposite. I'm continually amazed that Java devs have still not acclimated themselves to Javascript after all this time. If you notice that the style you're used to coding in is causing a lot of problems and that people coding in other styles have few-to-none of these problems, maybe it's worth questioning your approach.

I maintain a medium-sized (50k lines) codebase with frequent requirement changes that uses a functional style, and the closest we've come to ever needing a type-check is null checks. Type errors are maybe 2% of total errors when developing, and because our code doesn't have too many layers of indirection, they've all been trivial to fix way before production. I'd much rather spend 30 seconds every week fixing a type error than spend hundreds of hours writing type files and code in a dialect of Javascript that doesn't provide 100% coverage.

If you embrace functional programming with mostly immutable data structures and avoid mutation, side-effects, and gross mixins/polymorphism, you reduce the size of your codebase significantly, which makes it much easier to keep documentation terse and up-to-date.

On the other hand, if your team is so undisciplined and untrustworthy that you need to throw errors on compilation because you don't trust them to update comments and docs or name variables descriptively and your entire team knows Java but not Javascript, I could see the huge amount of boilerplate involved in Typescript being well worth it.

As someone who's primarily a Javascript developer who does Clojure on the side, I feel that the Java approach is fundamentally impoverished. I've never met anyone who chose to develop in Typescript whose background wasn't enterprise Java, just like I've never met anyone using Ramda (before lodash replicated it) whose background wasn't in FP.
Whether it's TS or some other form of minification or listing, I find node on a build server is unavoidable these days. I just wish it used fewer resources during npm installs...
The HN discussion a couple of weeks ago on "Neuroscientists' Open Letter To DIY Brain Hackers"[1] (144 comments) might be of interest.

The topic has appeared on HN other times, but never getting >=10 comments.

[1]: https://news.ycombinator.com/item?id=12078895
Many casinos don't use auto-shufflers on all games, especially on higher limit games, because gamblers generally don't trust them. This applies to all casinos on the Strip that I'm aware of. Re: it being hard to figure out on 6-8 decks, the scenario presented was that his mind is a supercomputer with perfect memory and he has perfect vision. So he could very easily determine the exact order of an unlimited number of cards by watching the shuffle and knowing the starting order of the cards (that being said, you can walk into any high end casino on the strip and play up to 6 blackjack spots at $10,000 each on a hand-shuffled, double deck game - MGM, Aria, Bellagio, Mandalay Bay, Caesars Palace, The Mirage, etc).

You're thinking in terms of human constraints; that's not what this hypothetical was about.
Dart isn't even in the same progamming paradigm as Elm and Purescript, so I don't think it was meant as a slight towards the Dart team.

And really, Dart is more like Java, it's nowhere near the elegance of the ML/Haskell pedigree of Elm and Purescript
if that was ironic, I would tell that some people need money but don't need to share implementations.
We need to ask “are humans becoming more robotic?
> I have no idea how Etherium or the blockchain works.

Your ignorance is readily fixable; luckily for you you're already on the internet. Google is just a click away.

That being said, you don't need to know how they work. A blockchain is a decentralised database where no single authority can edit it, and thus you don't need to trust any one entity to host it or vouch for it.

1) It's useful in situations where you can't trust someone to look after the database because they may edit it maliciously.

2) It's not useful in situations where you can trust someone to look after it, and you'd like them to have the ability to edit it beneficially (by, eg, reversing a fraudulent transaction).

> these all sound like fake words

Your apparently shockingly sheltered upbringing is leading you astray. You should probably fix that before it causes you some serious embarrassment.
Where is the evidence that static typing results in a net benefit? There's some evidence that points in the opposite direction:

http://games.greggman.com/game/dynamic-typing-static-typing/

When a language imposes static types, it also imposes a development cost, possibly negating all the value it brings.

Typescript is a little in the middle in that static typing is optional, but then you also don't reap the supposed benefits wherever you don't use it. Any "tool-based" refactoring is now less reliable than a simple text search.

As for catching type errors, those are usually caught very early. If they aren't, that points to a lack of test coverage.

As for the "documenting" aspect: The article claims that by static typing, the documentation need not be consulted, which is rather irresponsible. If you use a function, you had better read the documentation. I know that's a bit much to ask from actual developers, but it's true.
Curious to hear why this is being downvoted.
And here I thought it was the Nike Chalkbot: http://m.youtube.com/watch?v=HmW-eGCrSxs

Still cool though!
The elusive HIV vaccine: how scientists’ frustration is turning to hope
You may be interested in: https://en.wikipedia.org/wiki/Dialectic#Hegelian_dialectic
Sports superstars make a lot of money but there's more to be made in the business world.
Maybe it's because I'm lazy and sloppy, but I'd rather the language catch type mistakes than having to write tests for that. Plus, domain modelling with types is nice in ML dialects.
Yeah, my comment didn't make sense. Terrible example. Was running out the door.

I meant to say that in the U.S. things are marked in ounces. So, it's like calculating (10 oz / 16 oz.) * price. Whereas, elsewhere it's usually 100 grams.
Yes, I am Scott. And thank you. :)
I recently installed it on a Lenovo X1 Carbon 2nd Gen. The only headache was the Intel wifi chipset needing proprietary firmware (easily obtainable after install, but I wasted a bunch of time trying to get it working on install only to learn I really didn't need it despite thinking I did). Other than that hiccup, literally no other OS issues at all and no custom tweaking needed to get a solid setup in place.
Did you read the whole article? This technique doesn't appear in the manual at all and I've read it quite a few times. If it was so fundamental why is it so awkward to construct?
There are still a lot of Javascript developers around :-)
> it also imposes a development cost,

Very very small cost.
I'm also happy to help where I can.
Not this thing again :-/
You can do that using MiTM Proxy as well, as explained here: https://dadario.com.br/mitming-ssl-tls-connections/
Ahh, I believe there were some sarcasm tags there that didn't render in your browser.
Look, I'm from Chile, literally the country with the worst earthquake in history. That thing isn't gonna roll down, things in a earthquake don't jumble around like in a bingo ball blower and btw that's probably the most stable building in LA, houses in the US are made of plasterboard glued with snot to shitty pine-wood, they aren't designed to be stretched and compressed.

At the end, the neighbours are just being annoying

EDIT: i need coffee
Why isn't an obvious choice? What other system has enabled by default the following security mitigations:

* Enforced W^X in the kernel on i386/amd64/sparc64.

* Enforced W^X userland as of 6.0 (..exceptions must have a special ELF PT_* flag and be on a filesystem mounted wxallowed).

* arc4random(3), which backs rand(3), random(3), and drand48(3), with an audited base/ports tree. Software must opt-in to deterministic broken POSIX behavior.

* Stack protector (..which OpenBSD pushed into wide adoption).

* bcrypt password hashes only, with an automatically selected rounds value based on system performance.

* PIE by default for base and ports.

* Static-PIE for self-relocating static binaries.

* SROP (sigreturn(2) oriented programming) mitigation by default.

* C shared library re-ordering at boot time, i.e: libc.so is re-linked at boot time so objects are randomly ordered.

* System-wide sandboxing (pledge(2)) of a large percentage of the userland, incl. privileged part of the X server, most networking facing daemons included (..with increasingly reduced pledges, thanks to the next part..).

* Privilege dropping and separation for most of the base system as a matter of policy, new stuff doesn't get enabled without it.

Plenty of other innovations in programming interfaces, widely adopted outside of OpenBSD.. which leads me to disbelieve your claims of non-uniformity in opinion of any reputable 'security pro'.

http://www.openbsd.org/innovations.html
> It doesn't seem too long ago when Java Developers rushed to Ruby because it wasn't statically typed.

Java has a particularly bad type system.
It has never been determined if static checking is the killer app of static checking, or feedback say in the form of code completion is. Anyways, the story is not as simple as ideologues on either side of the debate would have us believe.
Tell HN: Hacker News's favicon is missing?
I browse hacker news using Mozilla Firefox on Ubuntu. I don't know it just happened to me or to everyone that HN's favicon is missing. When I see the HTML source code, there is a favicon.
I notice in your comments that you express concern about the development cost imposed by static typing, but then you later on state that you expect type errors to be caught by tests.

Here's the thing: test coverage is crucial on any large project, and we (hopefully) all agree that they're worth it, but tests can be very hard to write and impose a huge development cost. Static typing helps reduce that cost by reducing the number of tests you need to write. Generally, the more powerful the type system, the more the number of tests you need to write is reduced.

It's been my experience that the development cost of static typing is infinitesimal compared to the savings of having to write and maintain fewer tests. YMMV.
It's unlikely. Unless you carefully control your eating more exercise leads to weight gain, not loss.

Exercise is great for general health, but it's useless for weight loss unless you are also on a carefully controlled diet. (i.e. if you exercise you will want to eat more. Unless you force yourself not to, you eat up gaining weight.)
I'm pretty sure that neither Go nor Elixir have anything to compete against Hotspot/Azul in the GC department.
>Javascript is going to be around for a while because of inertia, but it's pretty much the last mainstream dynamically typed language we'll see.

Python's still pretty popular too
It's with data as with unprotected sex: when you take data from someone, you're exchanging data not just with them, but with everyone with access to their systems and anyone they exchange data with.

I'll start calling airgapped systems abstinence-only networking.
> it's pretty much the last mainstream dynamically typed language we'll see

I partially agree. I think as type inferencing gets smarter, we're going to end up with languages that are statically typed by the compiler or interpreter, but that there will be few-to-no type annotations in the code. So yes, I think the future is static typing, but I think it's going to end up a compiler feature and not part of the language at all.
My problem with using mitm proxy is that it isn't as easy to hack on.

I'm an nginx person, so learning a new python code base to hack on features I want is way harder than having something simple I can add on to, as needed.
I think that's pretty much untrue.

That program is 0.x seconds on Scala-JVM and 0.0x seconds on Scala-Native.
Subtyping combined with paramtericity is still a problem with good (I.e. doesn't suck) type inference. Unless you are will to live without either, it isn't true that static thong has all the advantages of dynamic, yet.
You're not writing tests to catch type errors. You write tests that actually use your code, where a type error will almost certainly be picked up.

Chances are however, your type error will already occur the first time you run your code.
The title of one of the article sections is literally "TypeScript is a Superset of JavaScript" ...people do still read before commenting, right?
How long have you been there?
The list is truncated in web view on Github. If you use Visual Studio they all have nuget packages which lets you search for (and add them) easily to a project.
You're half right on the wasteful and ethically questionable part: corn is very low nutrition, and is basically junk food. Growing it at all while people are still starving is pretty horrible.
Could India Be the First to Get Rid of Cash?
I read an interesting article (sorry, don't have the linK) some time ago about a man who cleans houses after someone dies in them. The story was quite sad. He talked about the high percentage of jobs that are old people who died alone out of neglect. He said at first he could barely handle the sadness of it. But eventually he came to feel that he was doing a service to the old people by properly taking care of them and their things after their passing. The unseen part of Japan seems very sad and lonely.
AutomataFiddle – Create and render automata diagrams in browser
Well, these are difficult questions, but I kind of like Vlad Zanfir's recent comments on this issue which is that it's best for everyone if the "out of the ordinary" nature of hard forks is maintained as much as possible: If there is a pre-established policy on how to handle these situations it could backfire in many ways- It may be better to just require the merit of any hard fork to be considered on a case-by-case basis.
Here's something I wrote a few years back here. What's changed in the 6 years following is that I think we're down to just two approaches, unless you feel OpenBSD is assimilating the MAC approach.

https://news.ycombinator.com/item?id=1997385
> Static typing helps reduce that cost by reducing the number of tests you need to write.

Those type annotations are the tests, they're just run by the compiler. And once you realize that, you can start to ask: are these the most valuable tests to write? If I have a fixed amount of time to write & maintain tests, would that time be better spent testing things more likely to be incorrect?
Historically this cost was a lot higher though.

It's only fairly recently that mainstream languages had type inferencing. Before it could be quite costly (and affect code legibility too)
> I'd much rather spend 30 seconds every week fixing a type error than spend hundreds of hours...

I'll take "unrealistic estimates" for $500, Alex.
I found easy to get started, it's as simple as the post. The real benefit I see is to plug arbitrary python code to hack requests and responses. It's very good, but I've noticed some crashes in my experiments too.
Real-time world air quality index
The directory is too big for GitHub's web view, unfortunately. The type definitions are moving to npm, so hopefully they'll be easier to search/view.
https://aqicn.org/contact/
What do you mean by compiler hooks here? I just mean intrinsics and magic traits. sizeof() is an intrinsic. It looks like a function, but isn't. Copy is a magic trait. It works like a trait but signals additional meaning to the compiler. So is Add. Implementing Add looks like implementing any other trait, except that it conveys extra meaning to the compiler. The GC support will involve basically the same thing. In fact, that intrinsic will probably be wrapped in a slightly higher level api, so you're not even directly calling an intrinsic.

Like I said, the GC will look like a normal library and be loaded the normal way. It doesn't hook into the compiler like a plugin (no library code is run at compile time), it just makes use of magic traits and functions which signal meaning to the compiler. Such traits and functions already exist in rust for non-gc purposes and get used all the time.

Rust also has that replace-allocator support you mentioned, BTW. If anything, allocator crates are more "special" that GC crates -- GC crates look like any other crate, but allocator crates have some special annotation.

I think I read a preprint of that paper, not sure (cant read the paper from here right now). It addresses the other half of the rust GC problem -- one half is designing a safe GC interface (which is solved by rust-gc or these hooks), the other is writing a good and useful GC algorithm.
You may understand the mechanics of C++ linking (although I doubt it because including a header has nothing to do with linkage, I'm assuming you mean ADL, overload resolution, etc), but it doesn't seem you understand the mechanics of how C++ compilers are built and optimized. Furthermore, how many cpp units do you expect to require the Vulkan API? If it's much more than a few dozen, I would argue you haven't organized your engine well. Source: former graphics engineer.
It doesn't amaze me at all. Before tooling was very poor with no autocomplete so using a typed language meant you had to type maybe 20% more (and cluttering the code) on top of having to add everything to a struct in exchange for catching runtime type errors.

Now with type inference and intelligent autocomplete, these features add back efficiency to the point of making them as fast, if not faster to develop non-enterprise sized programs.
There are official builds of nano for win32 (Cygwin). In my experience, they work quite well - especially when paired with Cmder/ConEmu.

https://www.nano-editor.org/dist/v2.5/NT/
I think there's a couple of steps here that make it not a cycle:

- Lots of languages used static typing for implementation ease/ no need for VM (probably not as much for safety issues, given the many failures of C's type system). Also, lack of GC meant that memory management is a big deal, and types and memory management are pretty linked.

- It's verbose though, and you can still easily make mistakes, so dynamic languages offer both cleaner code and the safety checks weren't that useful anyways (again, this is from C/Java land. Null pointer exceptions!).

- Newer static languages offer even better type systems that catch an order of magnitude more bugs. And type inference means that it doesn't affect legibility nearly as much.

So we're basically progressing on all axes at once. Language design isn't zero-sum, luckily.
Top 5 WORST Sonic Games of All Time