skysight-inc/HackerNews huggingface dataset:
As an aside: I'm curious as to why you'd implement a Result type in C++ as a tagged union where you have to manually branch on the tag, and not as an abstract class with two children.
There is a few things that has been repeated since napster.

Exposure has shown to be very profitable. Having no viewers is much worse than not getting 100% payment from everyone. Viewers is what allows revenue in the first place, and if 10% of pirates pay through direct purchase or for streaming, then that is much more than 0%.

Entertainment budgets don't generally go down for people who pirate media. Each time I have seen a study there has been a positive correlation between pirating and spending. It show that if people care enough to pirate movies, TV and music, they also care enough about movies and TV to watch and buy such content later in their life. I would guess that a person who has a strong habit to watch a lot of tv/movies as a poor student, also carries over that habit when they get a good job and get a good budget to spend on streaming and cable.
This is just incredible. It turns out that the booking references (usually 6 digits) used for all flights around the world can be used to access much more private information for travellers. These codes can be read from for example boarding cards, of which there are plenty posted on sites like Instagram. With a code and surname, the email address, mail address, phone number, frequent flyer number and other information can be accessed using weakly secured websites. It doesn't even need to be the airline the booking was made from, because they all accept and share the same booking codes.

The researchers showed that it was possible to find booking codes with open ended tickets, leaving the possibility of someone getting a free flight by changing the booking.

The airline booking systems are in need of a major overhaul, but the airlines clearly don't care enough right now. Hopefully this is a catalyst for change.
What about the OnePlus? I'm happy with my iPhone 6S, but I would switch to that if the next iPhone isn't to my taste. A couple of my friends have it, and they seem to love the fast charge ability.
Tall people will spend more on food/pay for leg room upgrades. etc. My point being you could argue about this for ever. At the end of the day the decision is would you pay an extra couple of $ per flight so that everyone can afford to fly or would you rather save a few $ but a number of tall people can't afford the ticket now? And even for the ones who can do you feel like the result is just/fair? There's no right or wrong (unfortunately).
There is a bug in the update process that can cause the phone to slow and drain battery like crazy. Doing a reset might clear it up. Its a pain but I did the same thing a couple of times through the various updates and now its behaving as it should for about 6 months.
As an intermittent Word user, I've never learned the ribbon.

I could see how you could conclude that your complaining was for complaint's sake, but mine?
Ah, you're counting sanitizers here. I mean the core language itself. gcc, without those flags, will happily compile and run that C code without any complaints at all. (I have 4.8 locally, it does not understand the "undefined" one, but the address one seems to infinite loop? which is very strange.)

That doesn't mean that I think static analysis tooling is bad, or invalid or something!

(I forgot about CompCert, but I've never run across any of the other ones in the wild.)
I find it easier to reason about.
I typically explain that Rust's safety has side effects that are beneficial outside the obviousness of merely being safe. Namely, Rust's safety allows for migrating runtime checks into compile-time checks when constructing state machines around the ownership mechanism. Additionally, Rust's safety allows for additional compiler optimizations, because that safety can make more guarantees about the safeness of certain internal compiler flags. These have a speed benefit in addition to the already existing convenience benefits of not having to fight with broken code. I'd much rather fight a borrow checker than to fight through gdb's and lldb's to figure out why everything's totally broken.

Then I go on to explain that there's a lot of great features in Rust that make it more convenient than C/C++ in a wide range of general purpose programming tasks. The pattern matching, sum types (Option/Result), error handling strategy, and my favorite, the Iterator trait.

For the performance-minded C/C++ software developers, I explain that the safety that Rust provides via lifetimes and ownership allows me to comfortably perform extreme performance optimizations that would otherwise be incredibly nasty and error prone in C/C++ codebases. I can feel safe knowing that if it compiles, it's almost always going to work how I expect.

Then there's the whole test-driven development mentality to Rust software development that Rust provides with `cargo test` and `cargo bench`, and data-oriented programming approach that Rust takes versus the inferior object-oriented approach via protocol-oriented programming (traits) to feature ad-hoc polymorphism and generics. It's a bit more complicated to explain that though.

Then there's the whole community/tooling/documentation pitch. I think this is one of the more important aspects of Rust as it demonstrates that Rust has a future and is more than just a niche. It has momentum which cannot be destroyed. It's a language invented during the age of the Internet and takes full advantage of that.

Rust does not employ guerrilla warfare tactics like other languages have done in the past. You can think of C/C++/Java/etc. as long-running empires. Guerrilla warfare-style tactics simply don't work against them. Emerging languages have always targeted C/C++/Java/etc. through guerrilla warfare tactics -- a loose community that mostly does their own thing. Rust is ambitiously establishing an empire of it's own through it's community -- a plethora of official projects and services: rustup, cargo, crates.io, docs.rs, users forum, internals forum, reddit thread, official documentation, docs team, an official book, GitHub hosting, etc. It's a recipe for success.
David Autor: Why are there still so many jobs? [video]
I wonder if "took courses" could be a stand in for "prepared heavily". It seems like people with all the other attributes might think they didn't need to study. People without them might think they did and took courses to "catch up". In my experience, preparation is the key driver of performance in these types of interviews.

It seems reasonable that a person who took a MOOC might have prepared in other ways as well while people who didn't probably didn't prepare much at all (since watching a few Algo lectures seems the most accessible refresher.)
I'm curious what would happen if they looked at, as separate categories, people who mastered out of a doctoral program, people who did the 5-year BS/MS, and people who obtained a doctoral degree as well as a master's.
There are magnitudes more alcoholic doctors and other professionals out there. By your logic we should be bringing back the prohibition.
We ban accounts for being uncivil like this (and below), so please don't do this again. Instead, please (re)-read the following, and post civilly and substantively, or not at all.

https://news.ycombinator.com/newsguidelines.html

https://news.ycombinator.com/newswelcome.html
It is intentionally not handling external dependencies. That's not what it's for. Many libraries and wrappers will compile the library if missing on the system (eg: rust-curl as a practical example will compile curl and statically link it if needed).
> The safety argument simply doesn't register most of the time.

Just like Steve said:

> Rust is safer than C or C++. (“I never have problems with safety in the C++ code I write” is a common reply.)

The CVE provides a pretty convincing argument that people can't write safe code in C/C++. And improving safety over C/C++ specifically is Rust's raison d'etre (you know, being developed by Mozilla which has a pretty large C/C++ codebase where safety is an important aspect). The bashing isn't based on people merely disliking C/C++. It's based on the fact that we observed 30 years of C/C++ being used in the industry and yet we still discover security holes caused by the same underlying flaws in the language.

Yes, Rust may have other features to offer, too. But safety is a big one and is thus mentioned so often.
New Teslas have Nvidia PX2 which is very fast. Can easily run deep neural networks realtime

https://blogs.nvidia.com/blog/2016/10/20/tesla-motors-self-d...

Not sure what HW their previous cars had
SRE is about engineering systems to be reliable, which is certainly not a goal taken seriously by default. In a traditional environment the system itself is not reliable and not trying (very hard) to be; rather, the combination of system + pager-carrying operators is reliable.

Many more people are paging operators to do DB replica promotions by hand, than are inplementing distributed consensus algorithms and self-healing distributed databases.
I guess they had to make such a huge change eventually. I'm sure they weighed the benefits of improved UX for new users against the learning required for existing users. In any case, they had (and still have) a near-complete monopoly on office productivity software, so they wouldn't lose much either way. Worst case scenario is going back to the older UI if the backlash was too much.
Rust's allocation strategy beats the JVM hands down in every benchmark. 20+ years of engineering cannot cover the flaws of VM and GC languages. Writing efficient stack-allocated software will always trump GC/VM solutions.
wow how many people stopped to help and ran to the cars after realizing what happened.
Some of this is incorrect like the PHP bit about "expression interpolation". Here is an example:

<?php
$hello_world = 10;
$two = "two";
echo "hello_world = $hello_world\n";
echo "two[1] = {$two[1]}\n";
I chose to use mine as a camera, just like one wrote about at http://linuxbsdos.com/2016/11/05/the-samsung-android-tablet-...
Please don't post uncivil or unsubstantive comments, even when provoked. It just makes the thread worse.
Ooh, a chance to talk about Rust in the context of fish.

I did the initial introduction of pthreads to fish 1.x, when it was thread-oblivious, and it was very difficult because there was a lot of global data (it's a shell, after all). Races and deadlocks were initially very common, and Rust could have helped with at least the first problem. It would have been very valuable.

More generally, the Rust pattern of having a lock own the data it protects is really nice. This can be more-or-less implemented in C++11 via lambdas, which should solve the wrong-lock problem. (I didn't use that technique at the time because I was targeting C++98.)

It's fun to think of a shell in the context of Rust. One place where Rust's guarantees cannot provide much help is signal handling. Signal handlers require global data to do anything, and signals are incompatible with most of Rust's ownership machinery for globals, primarily locks.

Code that runs post-fork is similar: it must not allocate memory, and there's no protection against that in Rust (or in C++).

A second place is the system interface. fish often has to dip below the surface-level APIs. It can't use getenv() or strerror(), and instead has to access `environ` and `sys_errlist` directly. Many of Rust's safe interfaces would not be usable, and we would have to write replacements using unsafe code.

fish also uses shared memory (mmap, shm_open) in a few places. Rust is supposed to protect against data races, but I don't see how it can do so in the context of shared memory.

Last and probably most importantly, shells make use of a lot of the horrible termios stuff, which tends to vary across systems and make heavy use of the C preprocessor. This will be gross anywhere, but especially gross in anything that's not C or C++. I first attempted to write a shell in Go, and this is why I gave up.

Overall IMO Rust could provide a lot of value for a shell, but probably will require a fair amount of unsafe code at the edges and fiddling to support legacy interfaces.
To me, any language is two things:

(0) How easy it is to write a program that just does what I want.

(1) How easy it is to avoid writing a program that seems to do what I want, but doesn't.

Rust already scores highly in (0), but it truly excels in (1). Beating Haskell and ML at their own ”it compiles, it works” game is no small feat.

As for whether GC or no GC, most of the time I don't really care either way. Garbage collection is incredibly helpful, but so is Rust's particular brand of resource management. As long as there is neither memory corruption nor resource leaks, I'm happy. :-)
On top of that, I would assume that the bar is much higher for candidates with years of experience, either because the more experienced candidates self-select for more senior jobs or because it sets up some expectations from the the interviewer ("he's been a tech lead for 12 years and didn't know about quick sort!").
"I’m excited to see that what mattered way more than pedigree was the actions people took to better themselves."

so a degree from a top school is not earned (nor are admissions i guess), but rather conferred at birth? i beg to differ.

the commentary on the "disutility" masters degrees is even worse.
It's forbidden to put recyclable materials in the public recycling bins on sundays in Switzerland. Mostly because glass shatters loudly. So while cities massively encourage recycling, some laws prevent it on certain days.
> It always pains me to see people criticising capitalism for easy points, when despite its flaws it has brought us an age of unprecedented equality and prosperity.

That's an achievement of a hockey-stick rise in exploitation of fossil fuels and energy use per capita, not some esoterically defined system called capitalism.

Just about the only core tenet of capitalism are strong protections of property rights. All of the negatives typically associated with capitalism are due to failures in regulation (over or under) and the irrationality of human beings and their policies.
Imagine if Notes could have been merged with Smalltalk environment and Hypercard environments. Have the Notes/workflow idea with the live Smalltalk environment, and the linking of hypercards (hyperNotes).
Rust is very expressive. The main benefits of functional programming languages is contained with Rust's Iterator trait and the ad-hoc polymorphism that traits allow.
Completely serious, we're alumni of The Climate Corporation.

Satellite data is cheap or in many cases free, and the cost of sending a trained loan officer out to the field is far too high to justify.

Shoot me an email at earl@apolloagriculture.com and I'd be happy to chat more.
Rusts guarantees aren't just about multithreading: http://manishearth.github.io/blog/2015/05/17/the-problem-wit...
GC can surpass the performance of manual memory management in certain situations, assuming that the manually managed code is forced to allocate for some reason. GCs almost universally use far more memory than manual schemes, though (I'm having a hard time imagining a counterexample).
That's almost the canonical example. Say for a particle system you use a fixed-block allocator that's the size of your particles. Now your allocations are quick since you don't have to do fitting and you don't fragment memory since they're all clumped together.

Other common trick in video games is to have a single-frame arena allocator for objects that are transient frame to frame. You just move a pointer forward and reset the pointer at the end of the frame.
The price of Bitcoin is creeping back toward its 3-year high of $1,000
You mean a select few programmers do. And even if you've struck gold and all of your programmers are from the 90's so that they know what it means to manage memory manually, the landscape - the code - always changes and so will the trade off. The deal is that you want to deliver software quickly and make sure it performs adequately, but no one needs perfectly, in regular business.
Top school is also serving as a proxy for wealth and privilege. Good grades are also a proxy for wealth. Kids who have rich parents get private tutoring.
The best I can do is load up a second stage. Searching for the COM file is where I get lost. I've also been trying to do it in C for months and I haven't been able to finish for various reasons.
Me too. I initially had some lag problems with it but turned off "Power button instantly locks" and it went away, and it's been smooth sailing since (about a year).
The main problem for rust that comes to mind is the already huge codebase written in c. Personally I tend to use opencv and openssl a lot. I know there are rust wrappers around openssl and opencv it would be nice to see pure implementations. I think an application like tls would benefit from rust a lot.

There are other things like advanced static analyzers such as frama c which exist only for c. Similar tooling would be helpful for rust.

Then there's of course embedded where rust could really shine. However llvm doesn't have backends to many of the 8bit architectures. Furthermore industry standards such as misra c dont seem to have rust equivalents, although rust may be better suited for safety critical code.

Finally, explaining the need of a borrow checker to a beginner is very difficult unless they already have experienced enough pain with segfaults. It took me ten minutes with a pen and paper to explain pointers to my 12yo brother. How can I explain the need for all of rusts safety checks unless he has experience with segfaults. Any suggestions here would be welcome.
> I don't see how it can do so in the context of shared memory.

Basically, it does not let you access shared memory without _some_ kind of synchronization primitive in safe code. That might be an atomic variable, or maybe a mutex, whatever.
The main problem for rust that comes to mind is the already huge codebase written in c. Personally I tend to use opencv and openssl a lot. I know there are rust wrappers around openssl and opencv it would be nice to see pure implementations. I think an application like tls would benefit from rust a lot.

There are other things like advanced static analyzers such as frama c which exist only for c. Similar tooling would be helpful for rust.

Then there's of course embedded where rust could really shine. However llvm doesn't have backed to many of the 8bit architectures. Furthermore industry standards such as misra c dontbseen to have rust equivalent s, although rust may be better suited for safety critical code.

Finally, explaining the need of a borrow checker to a beginner is very difficult unless they already have experienced enough pain with segfaults. It took me ten minutes with a pen and paper to explain pointers to my 12yo brother, how I can explain the need for all of rusts safety checks would be hard unless he has experience with segfaults. Any suggestions here would be welcome.
Ebikes are particularly interesting: there have been a rash of ebike Kickstarters (see e.g. https://www.kickstarter.com/projects/hongquan/karmic-kyoto) and startups recently, and if the bikes get cheap enough they could really change a lot of people's attitudes towards biking and bike infrastructure. They might also make bike shares more attractive; Seattle is very hilly and its bike share may go electric: http://www.seattletimes.com/seattle-news/politics/leading-bi...

My girlfriend bought an electric bike four years ago, but that was a little too early, and when we moved to a place with stairs the electric bike had to go. But the person who bought it on Craigslist loves it and rides it to drop her kid off at daycare, then to work.

If you haven't ridden a pedal-assist electric bike, you should stop by your local bike shop and try one out. They're quite remarkable, but in a way that is difficult to appreciate over text. I personally don't need one and ride a Novarra Gotham (https://www.rei.com/product/888337/novara-gotham-bike-2016), but I see the appeal and think that these will eventually take off, maybe sooner than is widely expected.

There are various problems or trade-offs, which I'm sure people will point out in this thread, but the cost-benefit is there or getting there.
> 3. Iterators. Never seen a language do them so well with so little overhead. The focus on zero-cost abstractions really shines here.

Try some D, maybe? :)
All of that will come after rust gets an ISO standard (like C and C++). Joking aside, C++ will be around forever and to a lesser degree, C will be too. They have 45 years of experience and revision. 50 years from now they'll probably still run the world just as they do today. C++11 and beyond is just as safe as any language. Rust came to be about 10 years too late.
> Anyway, in both 1990 and 1992 there were much better looking video games (richer backgrounds, etc.).

Maybe in the arcade, certainly not at home in 1990 and 1991, SMW was one of the best looking games of the time.

Look at the games in 1990:

https://en.wikipedia.org/wiki/1990_in_video_gaming

Some of the best looking games of that year:

SMB3 just came out to the US, SMW was light years beyond it.

Bonk's Adventure was good looking for the time but doesn't hold a candle to SMW.

On the PC we had the original Commander Keen, which while a great PC game of the era, doesn't even begin to approach the quality of SMW.

Secret of Monkey Island was a beautiful game, but it is an adventure game. The screen is mostly static. SMW is far more impressive, being side scrolling and having parallax scrolling of multiple background layers (and occasionally foreground layers as you see in the forest.)

Nothing in 1990 compares to SMW.

If we jump forward to 1992 (by which point SMW is 2 years old):

https://en.wikipedia.org/wiki/1992_in_video_gaming

Then we see Wolf 3D come out for the PC, which was really impressive and of course changed everything. But it wasn't like it made SMW look dated (besides being FPS vs. side scroller, Wolf didn't have very many types of enemies, had static ceiling and floor, etc.)

For side scrollers we have Ecco the Dolphin, which is a cool game but I don't think as visually complex as SMW.

Mega Man 4 looks great but is not doing anything graphically that SMW hasn't already done. It has a different art style that you may personally prefer.

On the Genesis we have Sonic the Hedgehog 2, which looks good but again doesn't have as much going on as SMW.

I'm struggling to find these games that were much better looking. Can you give me some examples?
I would normally agree with both of you, but Angular 2 really is sociopathy. It's a wicked nightmare that could only be born of J2EE-type misanthropy. I don't choose that editorial posture lightly. Have you attempted to use Angular 2?

I'd rather impale myself on Spring and Hibernate2. 10,000 lines of malignant Maven and Ant XML tumour seem like a cakewalk by comparison.
I like the ribbon pretty well, although it was clearly designed in the days of 4:3 displays. Would be nice to have an option to put it on the side instead.

The one thing I really dislike in Office 2013/2016 is the animated cursor. In Word it's just a distraction, but in Excel it is ludicrous: when I click on a cell, I'm looking at that cell, I'm not thinking about the cell the cursor used to be on at all, but for some reason Excel wants to draw my attention back to the previous cell just so I can watch the cursor box move. This is not something to benefit the user, it's a designer screaming "Look at me!"

Fortunately, there is a way to turn off these Office animations and a lot of other animations too. Open the Ease of Access Center in the Windows control panel and select "Make the computer easier to see". There's an option there to "Turn off all unnecessary animations".

This stops the animated cursor and some other animations in Office, and it also turns off the goofy Start menu animation. To my eyes it is a nice improvement.