skysight-inc/HackerNews huggingface dataset:
Java is pretty popular for HFT applications. I think most programs are less latency sensitive than that. But of course, Java is not for you if you have hard real time constraints.
At the risk of sounding condescending, is this essentially google.com/maps?f=restaurants restricted to 500m radius around my current location?
Nice FUD you got there. For last 5 years I had Kubuntu and OpenSUSE on my parents PCs, for the 5 years I had no psyhical access to the machines. For the 5 years I did all upgrades and distr-upgrades remotely. Never failed.
I put my hard-disk with Windows 10 installed for Gigabyte H61M motherboard(i3 3rd gen) to Asrock H91M S1 Plus(Pentium 4th gen) and it booted properly. It was slow for about half an hour(probably installing drivers in background) and then it worked fine afterwards.
I don't see it as a negative, really, just realistic. It is a fact that everyone makes mistakes, and with the inherent complexity and features that are demanded of modern software, it is harder and harder to maintain a comprehensive understanding of a codebase so that you can detect these mistakes before they cause damage. This means that even if you are a perfect developer, you need to expend a lot of energy to maintain that perfection if you're using tools that don't help you.

To me, modern tools like Rust are supposed to relieve part of the burden. In the common case, if I can be reasonably certain that I can't make certain classes of errors, my brainpower is freed to focus on other things and I can work with significatly less stress.

Rust is interesting because it allows you worry less without actually compromising much in capability. In the cases where I would need to be able to bypass the tooling, it is explicitly possible.
Why should a manufacturer be allowed to sell a TV that breaks after 2 months ? And get away with it ?
The only evidence I see here is that FICO is apparently a poor/insufficient predictor of default rate, which causes additional information (race => socioeconomic background => default rate) to increase accuracy of the prediction.
I agree with the several points you pointed out. In particular the weight problem. Since batteries don't decrease in weight while maintaining power output like Gasoline. Still if you operate a battery I don't know between 40% to 80% and you're able to keep the power output of the battery generally consistent then I guess a fixed weight isn't such a problem.

Of course I am not an EE and I'm only speaking with my limited experience of operating toys.

The pacemaker thing is interesting. My counter point would be to detect when it would turn on. But yeah, with the time to transfer energy and the extra complexity in the road, yes this has been nullified haha.

Thanks for the details.
It's nice to know that Tesla can do that, but sorry, I just don't see anything "magical" in this video -- speed wasn't that high (~110 km/h), the gap was quite wide and the two cars on the right lane also managed to pull over and stop in time too. I have personally avoided much closer encounters driving both car and a motorcycle. In such situations, you should pray that there's no truck behind you.
A good resource to learn Coq is "Software Foundation":
https://www.cis.upenn.edu/~bcpierce/sf/current/index.html

It teaches the foundation of software with simply typed lambda calculus, but also teaches how to use coq and use it for software verification. I found it more approachable than Coq'Art, which is also very good but I'd suggest starting with SF first then read Coq'Art.
It's too late for your project, but in case anyone else has similar issues, some things can help:

* coding standards (e.g: boost X is forbidden). Should be checked by the CI with clang-format + e.g. a Python script.

* code review

* static analysis (e.g: clang-tidy)

* performance-focused integration tests
Do you mean Michael Artin's Algebra? Just took his Algebra I (18.701) at MIT last semester. An incredibly challenging class, but he's a really excellent lecturer and a very likeable guy. Still really sharp.
I think the real reason might be lack of decent tooling, and developer culture.

Most attempts to add static types to ruby code don't come with complementary tools to give us some of the advantages that would immediately gain developer support. In your editor, for example, code completion based on type annotations would be a huge plus, but I don't know of any tools that give me that in ruby (if they exist, I'm unaware). In most cases, your code will still run regardless, unless you use the separate tool to type-check, and are disciplined about its feedback. It's unlikely that all your team will _always_ run the type checker, and although you can have it configured to run the type checker on every save just like you'd do with tests, it's an inconvenience.

In terms of culture, I'm mainly thinking of Rails here, but I can think of more than a few ruby projects/libraries as well. Ruby is, simply put, a dynamic language. Even if you use typed.rb, you won't get much information about the libraries you'll be using. Code completion is mostly based off comments/documentation and only in some editors, and in many cases might not even be there. I also feel that many ruby developers simply don't like types, and that's the end of the story. I'm convinced that most don't see the advantages. For instance, in teams where we've added Rubocop to simply lint our codebases, I've noticed developers complain about warnings and errors that the linter reports, whenever the developer thinks they know better. I imagine the same happening with type annotations in ruby codebases. It would become a task that you run before committing or before a merge request (like tests, in some teams). When they're confronted with a bunch of errors, they'll go into flight mode: "but i've tested this manually and it works, why is this linter complaining, and why is my type checker complaining as well?". Needless to say, the type checker might have just flagged a _potential_ bug for a use case you might not have manually tested yet.

edit: I think tooling can help shift the developer culture aspect. Better tooling provides a better developer experience and in the end that's all we want. Flow and TypeScript are perfect examples (which I adore).
The Java VM is written in C though.
I could definitely live with such a solution, but even six months might be too quick. So, as long as the plan is to lengthen the LTS window, I think that could work.

The company that employs me just upgraded to a C++11-capable version of GCC three months ago. Even C++'s three year cadence seems like it might be too fast! Thing is, the company wants to vet our entire platform, which itself only changes yearly. They want to know they can get bug fixes, and vetting/upgrading the compiler is a lot of work regardless, so they tend to do one and stick with it for a while. OpenBSD does the same thing for security reasons. If Rust wants to replace C and/or C++, these are things that will need consideration eventually. I don't see my company allowing Rust any time soon, unfortunately.

As a compiler-writer, I'm more concerned that Rust is a quickly-moving target at the moment. I think that as Rust becomes more mature, it will naturally begin to stabilize feature-wise, in which case something akin to the Haskell model would work well, with innovation happening in the flagship compiler and "snapshots" of the language being taken as standards periodically. That's just a matter of time, though.
You don't say a word if your parents use an Asian language interface? That's the parent's point, not Linux upgrades in general.
> if my motivation were "I need a fast language and don't want to deal with safety issues", I'd use Java. It's plenty fast

Context is pretty important to the original comment:

> python/ruby/whatever shops are using Rust because they need a fast language, but don't want to deal with safety issues.

they're not looking for a fast language in isolation, they're looking for a fast language in the broader context of their existing technological stacks. Java doesn't help that much when you're looking into ways to speed up your Ruby application, at least not easily.

Furthermore, Java has the issues that it's only fast when memory is plentiful and it has a long startup/running time, it's "eventually fast" if you will.
We don't pay more because of our consumer protection laws.
I have been down this route and you also have to disable the use of free email accounts.

If the service value is not too high then even making people who want to abuse the service go through the process of registering a free email account works. Put a little bit of friction into the process and the script kiddies move onto an easier target.
The "findings" you are describing are characteristic of security-conscious users suffering from paranoid schizophrenia.

This is not an isolated incident. The "badBIOS" incident reported by Dragos Ruiu a few years ago ([1]) had many of the same characteristics as what you are reporting:

• Vague symptoms, affecting all computers (and, often, even non-computer devices) owned by the individual

• Inability to isolate the agent involved

• Belief that widely publicized exploits or discoveries are involved, often in the absence of any evidence (e.g, DirtyCOW here, ultrasonic networking in Dragos' case)

Please seek psychiatric help.

[1]: http://www.infoworld.com/article/2609622/security/4-reasons-...
Top 8 Free and Open Source Project Management Software
Any solution that doesn't involve producing fewer people in the first place is just window dressing.
That's not the same. The Skoda video only shows detection of the car in front of you and responding to that. In this case the Tesla also bounces the radar under that vehicle and responds to the motion of the car in front of the car in front of you.

If you watch the video again carefully, the Tesla alerts before the car in front brakes, because the car in front of that is braking.
DZone Guide to Software Development Lifecycle Published
Java's bad safety reputation comes mostly from the Java plugin, where many inventive ways to bypass its sandbox have been discovered. When used as a normal programming language, without depending on it for sandboxing (that is, when all code running in the JVM is trusted), its safety is quite good.

(Java also has a not so great reputation about speed. That one also comes from the Java plugin, which often took minutes to start up, while keeping the Netscape browser UI locked up.)
If this list was "Young founders" or "xyz state founders" no one would bat an eye.

Please let men and women be differently abled. Equality is the opposite of specialization. Specialization is power in a complex world. Video on that idea: https://www.youtube.com/watch?v=jNz5WXwKHsU

Sexual dimorphism has outcompeted equality. Equality lost.
The average person in the developed world owns a device whose capacity to freeze stuff is dependent on it being just below zero celsius and a device whose capacity to keep it cool whilst not accidentally freezing it is dependent on it being just above zero celsius.

That's a little less arbitrary than fractions of the circumference of the earth, or the coldest temperature in Danzig in winter 1708/9. (Weather ranges and human temperature preferences are also a lot more subjective)
The Eleventh HOPE (2016)
I'm curious, this would probably be better than using an image preload/loading icon as far as delay or even blank spots/placeholders.

I think I've seen this before but I've used an overlay loading gif which was shown over the image while the image loaded then when it loaded the loading gif would be hidden.
Show HN: 8cc.cr – compile-time C compiler implemented as Crystal macros
> The metre was originally defined in 1793 as one ten-millionth of the distance from the equator to the North Pole.

https://en.wikipedia.org/wiki/Metre
> A year later, Xi reached an agreement with Obama that his country would stop commercial cyber­spying. (Feng Li/Getty Images)

But the NSA continued commercial cyberspying against Petrobras. These people are not to be trusted.
Used almost all of the PHP MVC frameworks across multiple projects:

Laravel (2015/16), Yii1/2 (2015-now), CakePHP (2015), Zend (2009), CodeIgniter (2009-Now), Symfony 1 (2008/9)
People don't sit on a plane randomly. Fat families sit together. And randomness is not an equal distribution.

Also, cargo is lighter than the human payload. Most people aren't lugging around their body weight in luggage.
I've actually found a really good solution to tailgaters: put very slight pressure on your brake pedal, enough to get the brake lights on, but not enough to actually cause any substantial deceleration. This will cause the tailgater to also slow down, but more than you because they have no way of telling how hard you are braking. The result is increased distance between you and them.

Do that a few times and even the most persistent tailgater gets it and either changes lanes or stops riding your ass.
I watched a similar video recently, but a car ahead avoided an accident and the car where video was taken from was rammed in the back because of a sudden stop. Which make me think maybe Tesla's response wasn't the best possible.
When the car behind me is driving too close, I leave even more space than usual to the car in front to give myself time to brake slowly if anything happens.
Same thing is true about the USA. I read about this recently, something like the 14 billionaires that Trump put in his cabinet have as much wealth as 50% of Americans.
Suppose the airline had a scale which worked in the following way. It will measure their weight, but add randomly generated noise of a few pounds either way. Suppose this scale is perfectly adequate for the airline's purpose - i.e. it provides a sufficiently accurate measurement to provide safety - but it no longer provides a "true" measurement.

Based on your reasoning, since this scale is no longer a perfect measurement of the true causal factor, it shouldn't be used.

In reality, passenger weight can vary between weigh-in and getting on the plane. The passenger might eat food or use the bathroom before boarding. Weight on-plane, rather than at boarding time, is the true cause of decreased safety. Weight at boarding is merely a statistical approximation to this (and admittedly a very good one).

Reality is uncertain, so it seems we are back to the same place.

Tangentially: Why stop at that level of granularity when you can easily keep slicing...As an aside, wtf is the point of FICO if not to be a measure of precisely these outcomes?

The reason for this is that using more factors is often legally problematic. Such factors are often correlated with race and regulators therefore treat using them as "redlining." For example, (income = low) AND (location == oakland) might also be predictive, but that's strongly correlated with race, and regulators will rape you if you try and use it for predictive purposes.

Also, from what I've seen, your suggesting that slicing further will eliminate the predictiveness of race doesn't seem to be true. At the very least, we often need to slice much further than our available data sets allow. For example, FICO includes a lot of data but still doesn't make race non-predictive. Similarly, in education, race is still predictive after accounting for parental income - rich blacks do worse than poor Asians: https://en.wikipedia.org/wiki/Achievement_gap_in_the_United_...

The idea that we can avoid these ethical questions by slicing data in the exact right way is probably not true. We should instead figure out our ethics so that we can do things right even if the data doesn't turn out the way we imagine.
What I heard was an alert go off after the first (red) car slightly veered off to the right, allowing sensors to detect the second (black) SUV's abrupt stop.
Guy I know said/says to me "your hipster Linux" haha

It's like my computer's are garbage so I use Linux to compensate for the lack of hardware but now I like using Linux as a web developer.
That's fine. You seem to have figured out your ethics.

But for those folks here who don't view this situation similarly, I think the airline example is also a tricky case. I certainly have no good answer.
Arcan Display Server Working on X.Org / Wayland Compatibility
John Baez has some interesting things to say about different structures that appear in water:

https://johncarlosbaez.wordpress.com/2013/11/29/water/

And these things have a very strong temperature dependence. I wonder if it has anything to do with the current discussion.
I'm always happy when sites don't mess with <img> like this, since it completely breaks down for non-JS browsers. :/ There are ways to do this without breaking, but it's not always done. Apparently.
I see your BART, and raise you Santa Clara VTA Rail.

http://www.mercurynews.com/2012/12/26/25-years-later-vta-lig...

> Almost every highway and road and most parking spaces have a revenue recovery ratio of 0%

Theoretically, that's what the fuel tax is for. At the federal level, the highway trust fund raised $35 billion in fuel tax and spend $39 billion on highways (and $8b on transit - the deficit here being covered by the general fund). If we wanted to be generous we'd say that's an 89% recovery ratio, which probably is totally unfair and ignores some important capex somewhere (recent "stimulus" spending, for example) but is substantially more than zero.

(State and municipal numbers are quite variable, I'm sure.)
I use the HackerNew Chrome extension to improve the site UI/UX: https://chrome.google.com/webstore/detail/hackernew/lgoghlnd...

The source can be found here: https://github.com/tommoor/HackerNew

It always confuses me now when I open the site on another persons machine.
"speed wasn't that high (~110 km/h)" -- That is as fast as you can go on major roadways here in Brazil> I would say it is pretty fast...

" In such situations, you should pray that there's no truck behind you." -- So true. Wouldn't the autopilot account for that before braking that fast? It would cause a much bigger problem if not...
Stepanov and Musser were working on generic programming in the 80s[0][1], which predates Haskell. I suspect parametric polymorphism was common in the FP world by that time, but I don't know whether it was used as an organising principle to the extent that Stepanov promotes.

[0] https://en.wikipedia.org/wiki/Alexander_Stepanov

[1] https://en.wikipedia.org/wiki/David_Musser
> A 32-bit assembler (like gas) will turn `mov %esp,%ebp` into `89 e5` while `mov %sp,%bp` becomes `66 89 e5` -- the former being correct when actually in 16-bit.

He is using nasm with "bits 16" directive, so 66 prefix will be emitted for "mov ebp,esp". gas with 32-bit target is totally unrelated to this discussion.

> http://wiki.osdev.org/Unreal_Mode

So what? MBR runs in 16-bit real mode.
Dupe link. More comments at https://news.ycombinator.com/item?id=13268768
Forked requests testing: Regression proofing deployment without regression tests
do the cars have some serious computer hardware or is it really good code/cloud assisted computation? Maybe ANN's active while driving?
Did you not hear the warning tones trigger before the accident occurred?
Pilot here.

Every airplane has a maximum weight it can fly. Different than cars, every airplanes also have an envelope where the center of gravity has to fall enter. If the center of gravity is behind the design envelope, airplane has a tendency to flip backward, stall on take off then crash, it has happened before. It could also means if the airplane enters a spin, the recover may not be possible. If the center of gravity is too forward, it will slow the cruising speed due to increased drag, much easier to stall during cruise and burning more fuel.

So for every single flight, pilot or dispatch has to calculate those 2 numbers, for every passenger and baggage, and decide how many fuel to take on each flight.

Of course, asking each passengers weight would be awkward at best, so airlines and FAA used an average body weight number to avoid this, it worked until 2003. An accident happened which killed 21 people on board a small transportation aircraft. It is found that the average body weight number FAA and airline used were outdated http://www.ntsb.gov/Investigations/AccidentReports/Pages/AAR... FAA has since advised airlines that what FAA presumed average weight of its population has increased, and advised airlines to do the same.

Of course, this will only work on average cases, and will fail if the sample group is out of average. Resampling has to be done to remain operating in the envelope, and if standard deviation is still out of normal, each individual weight has to be taken.
Why are most electronics so boring? The exciting washing machine
More often than not, brand-spanking-new software is written against 30-year-old APIs.

Lots of software we use day-to-day is old. For example, a couple years ago I fixed a 20-year-old bug in netcat, which itself hadn't been updated since the mid 90s. After I fixed the bug, I didn't need to fish out an old compiler or any compatibility libraries; I just compiled it with the latest GCC and glibc, and carried on with my day.

Don't get me wrong, I like Rust a lot and I'm excited that there's finally a real contender for the systems programming throne after all these years. I'm just less enthused about the prospect of refactoring my codebase once every few months to stay current. This is something that I think will level out with time, though. C itself was almost 20 years old before it was standardized, after all. I don't think it will take Rust that long, and I look forward to the day my copy of the Rust standard arrives on my doorstep.
No, you're just counting every rider 400 times in an exercise where you are deliberately dense.
Link?

The Tesla would be aware of the cars behind it as well, so this sounds unlikely
Right lane cars can see breaking SUV, you can't from this POV. This could be the moment you reach out for the candy, check the thing on the right seat, or even check the rear view mirror longer than usual and 1/2 seconds will all it takes at 110 km/h.
Give that man a medal
I am not blaming lack of input sanitization, the bug is clearly still there. What I am saying is that input sanitization would prevent this attack because it will only allow valid characters to get to your mailer, which will exclude spaces, tabs, double and single quotes. Thus I fail to see an exploit vector which would bypass proper input sanitization. Do you see it?

In general I agree that PHP mail() function should take a part of blame here for not exposing a sane interface. Spammers have abused many bugs where programmers failed to sanitize "To:" or "From:" addresses and attackers could pass \r and \n characters (which allowed adding BCC fields, effectively sending e-mails to arbitrary addresses).

> Also the vuln does not apply to CLI sendmail...

Sure it does:
>> ...will result in the followig list of arguments passed to sendmail program:

EDIT: you probably meant to say that the vulnerability is only triggered when CLI sendmail is called via mail(), which is true. Configuring PHPMail to use sendmail via CLI directly apparently doesn't expose this vulnerability.