skysight-inc/HackerNews huggingface dataset:
So then what is a better "when in doubt" guideline?
It's common thinking (often a misconception) that C programmers only grudgingly use C because it does some vital thing that all these other "managed" and "safe" languages cannot not: if only those other languages added that feature, all C programmers, having no more reason to stay, would finally be able to abandon C! This is a good list of positive reasons to prefer C even if other languages are also suitable.
A lot of people don't want their kids reading Harry Potter
Hi, Endocrinologist and obesity specialist here.

Let me confidently assure you that inflammation in the hypothalamus is a dominant feature of obesity, and obesity is currently one of the top diagnosed medical problems in America. This stuff isn't hypothetical, but well accepted within the clinical research field for metabolic disorders.

Please don't recommend laymen avoid reading articles like this. That's rather senseless. While this stuff hasn't become standard in medical school curricula yet, it definitely will be some day, particularly when we are more confident in interventions that prevent hypothalamic gliosis.

EDIT: also, don't discount hypothalamic inflammation based on what you know about encephalitis. Some parts of the hypothalamus (the arcuate nucleus, in particular) are highly susceptible to inflammation because they are surrounded by a characteristically porous part of the blood brain barrier (behind the hypophyseal portal system). This allows bulky blood-born protein hormones (like leptin and insulin) to make it into the sensory neurons.

Indeed this part of the brain doesn't become red and painful, but something more relevant happens. Microglia surround the neurons responsible for appetite suppression and kill them off, which permanently changes the body fat setpoint that the brain strongly defends. There is definitely a profound and sometimes irreversible loss of function here, and that's the current focus in research. Hopefully some day we will find ways to drive repair of these circuits.
Over the past ~5-10 years, multitouch touchpads have been much more painful in Windows than in any other modern OS. Why? These awful Synaptics drivers. There have been free drivers in Linux that have worked painlessly for years, yet in Windows, nothing has changed.

I see this as a poignant example that closed-source drivers are just a bad idea.
Chakra is only the JS runtime of the Edge browser IIRC. So they'd have to open-source all of Edge in order to port VS Code to it instead (if they wanted to keep everything open source).
To be specific, our "byzantine" faults are limited to very specific types of behavior: running multiple copies of the same validator on different nodes, and modifying on-disk state of the validator. We make no changes to the validator source, don't inject arbitrary messages, don't attempt to invalidate already signed blocks, etc etc.
That's a very good point.

My understanding, though, is that RH etc. do that mainly for stability reasons. Their customers don't want latest-and-greatest, they want small evolutions of the stuff they know works, with only bug-fixes and must-have new features.

Of course, that comes with downsides too: build your infra on RHEL 6.x, and then once 6.x becomes end-of-life, upgrading to the new latest release is a huge undertaking.

I think RHEL is doing the right thing because it's what their customers want; I would argue that in many cases their customers are doing the wrong thing and should make more-frequent, smaller upgrades rather than one giant upgrade twice a decade. But that's certainly open for debate and reflects only my experience managing infra ;)

With something like Android, I'd expect the pendulum to swing a bit the other way: you don't want bleeding-edge or unstable, but you probably do want something quite a bit more up-to-date than something that RH pushes out. To use your example, I'd say releasing a phone in 2017 based on 2.6.32 (released nearly 8 years ago!), even with 696 patch releases, would be unacceptable.

But yeah, where do you draw the line at acceptability? I personally think you shouldn't be going with a kernel release whose series was released more than a year or so before you start development (assuming getting to a release is going to take 6-12 months from that point), and ideally you just take whatever is the latest stable when you start development, if that's possible. Sure, opinions differ, but that's kinda the point... this is my opinion :)
> why did C/C++ win there, too?

Maybe C because of its legacy an ubiquity, and C++ because it was one of the few languages with 1) serious compatibility with C, 2) good featureset, and 3) became an ISO standard
It means we simply give two different nodes the same signing key and get them to sign conflicting proposals and votes. A more complicated Byzantine fault would take into consideration the structure of the underlying protocol to try to thwart consensus safety in a more intelligent way.
Can you give me examples where I'm breaking the guidelines? I've been extra careful to leave comments that contribute to the discussion and share a unique point of view.
Breath of the Wild wasn't, at least IMO. That and Witcher 3 pulled off open world quite well.
You might be interested in the long-lived Unix Rosetta Stone:

http://bhami.com/rosetta.html
Following the logic of the article, Rust has made the exact same mistake every other language has made, which is to conceptualize compatibility with the C ecosystem has merely an issue FFI. Rust is hardly the first language to focus on easy FFI from day 1, but according to the article that's not nearly sufficient. And like most other modern so-called systems language, Rust hasn't gotten around to committing to a stable, exportable ABI. In fact, I think much like Go the general sentiment is that this is largely undesirable, as stable ABIs can cripple evolution of the implementation, especially those that rely on sophisticated type systems.
Is such a safe implementation of C really suitable for systems programming, rather than merely application programming? If we understand system-building as communicativity, then certainly such a system retains communicativity—so long as alien objects can be described to it in a manner sufficient for dispatching the same dynamic checks. If I memory-map a file, say, I can safely access that memory only if the structure and meaning—the bounds and the types, roughly—are described much like those of other in-memory objects. Tools and systems for providing these descriptions are
currently lacking—but are a logical extension of the runtime type information already developed in recent work. In the case of file formats, some cases like the ELF example we saw earlier (§5.5) show that the format has already been defined for us, thanks to the manifest layout of objects declared in C.

This is a key point. There are scattered systems for describing the layout of arbitrary binary data—C structs/unions, Erlang binary patterns, ASN.1 Encoding Control Notation, Kaitai Struct[1]—but nothing has really caught on across language boundaries. It's hard not to feel this data format barrier when you're using a C API from another language. We'll need to do something about this barrier if we want a true multi-language system (not just a bunch of awkward C FFIs).

[1] http://kaitai.io/
hmm... I did not. But ok.
Today, the right is stereotyped as tolerant of intolerance and the left is stereotyped as intolerant of intolerance. Both are untrue, but anonymity on the internet makes it seem like one vile person you disagree with is following you around spewing hate. When people are experiencing a rush of adrenaline from an argument, even online, many lose the ability to distinguish the words and actions of individuals from those of groups or to recognize subtlety and shades of gray. Everyone is arguing all the time these days, everyone has an opinion on everything, this huge adrenaline bubble is forming and it's going to pop one way or another...
Interesting. I haven't tried Rust yet, but it is on my "to learn what all the fuss is about" list. The main reason I'm interested is for embedded.
Ill add this

Birth order. (i can't for the life of me find the source).

Birth order can be huge in predicting agreeableness. The "get along" factor.

First born. Middle. Baby. Only. Powerful dynamics
This is one of those ideas that seems obvious at first glance ... and then problematic with more thought. Have you ever gotten 100% of the peanut butter out of a jar? I haven't. Is that fraud? There's a distinction to be made between jars of peanut butter and ink cartridges, but it wouldn't be easy to draw that line. (For an even better example, see Merchant of Venice, Act 4, Scene 1 ...)
Autonomous Cars Are Not Imminent
How to Run a Van Westendorp Pricing Analysis
Low level backward compatibility with portability idioms is great for enduring software assets. Anyone not sweating speed and space between equivalent possible implementations is a different kind of useful software developer with different operative quality criteria and execution risks. Rust will hopefully enjoy a long and boring stable future.
There is such a thing as ventless clothes dryers, from major brands such as Whirlpool, LG, etc. [1] We had an older one in an apartment we rented; it had a water reservoir that collected the moisture which you had to empty into the sink regularly.

[1] https://duckduckgo.com/?q=ventless+clothes+dryer
Thanks for this. Beautiful font.
> All I can say is that the reaction to Cargo from Rust programmers is overwhelmingly, almost universally positive

You can prove anything when you introduce a sampling bias that large.

> Not solving builds and package management is not a realistic option for a language in 2017.

Package management was solved decades ago, my OS manages the packages and a lean and mean system is the result. The rust solution results in massive binary sizes for simple command line tools. This is fine if there goal is to replace java, but not if they want to replace c.
I switched to Fira Code a couple months ago, as well, and now when I don't have it I feel sad. The ligatures make my Perl and JS code so pretty. It's just more satisfying when I have to stare at the same project for hours.
> They may not be "sane" in your view because they're different from the way you implement them in C++

I saw two kinds of Rust graphs.

One is safe, easy to understand, but slow (e.g. reference counting).

Another one (unsafe Rust) is very hard to implement, thousands lines of code. Also, modern C++ is much safer than unsafe rust.

> C++ has no protection against the most pernicious memory management errors, particularly use-after-free

CRT debug heap / MALLOC_CHECK_ / libefence, depending on the platform/compiler
> in the age of i5's and i7's on every desktop with 8+gb of ram

Is that really so? Large corporations probably don't want to overspend money for excess hardware power. Intel Celeron or Atom + 1-2Gb of RAM should be enough for office work.
FAT/exFAT have good support across the three OS's, but they are very far from being "modern" filesystems. One of the most fundamental cons for me is the lack of journaling on these filesystems; it's very easy to corrupt a drive formatted as exFAT, especially if it's a portable device (which is probably one of the most important uses of a cross-platform filesystem)
Apple's business model seems mostly based on that premise.

Ideally, drivers are open-source, but Apple has found that centralization is still a noticeably workable compromise.

Unfortunately for Apple, that quickly falls apart when they don't support modern features like Vulkan...
ah there's more than one of me. now we are font sectarians. come, brother!
Nice, I missed that one first time around too
Excellent, I think the author would do well to re-frame the question as you have. If nothing else to put it more clearly into the space of provable compilation.

When I transferred into the "Oak" group that later became the "Java" organization, the team I was on was looking at whether or not you could write an OS in Java sort of in spite of its safety rules. This sort of concept has been revisited by Rust with its safe/unsafe modal operation.

What both of those efforts have in common is that determining safety may be impossible at the construct level but provable if you were to exhaustively search all possible outcomes.

What the paper and your comment add to the discussion is the intriguing idea that you could create a 'safe' backend (say the equivalent of the JVM) as a target for a C compiler. And code that could not be compiled would be flagged for later analysis. Much like VHDL can express hardware that cannot by synthesized you might end up with a C compiler that could compile code that could not be executed. I could be fun to spend a bit of time poking around that rabbit hole.
My favourite has to be Hasklig, with ligatures support enabled in WebStorm.
Well, just saying it has fast FFI doesn't tell me much. Being able to wrap something like sin() was in Python 1.0, but most applications need more help than that. There have been 5+ popular systems since then trying to make the experience better... it still is barely solved.

That said, I admit I'm more on the pessimistic side. Having touched Go before it's open source release in 2009, I didn't think they thought enough about integration either. I think it was worse than Rust, because you couldn't call Go from C or C++, unless the main program was in Go.

Also their build system isn't used inside Google. And they do nontrivial stuff with signals and threads.

But Go seems to be being adopted. However there is an important distinction: Everybody is rewriting new versions of Google-style servers in the open source world. But all the stuff at Google is still in C++.

So I think nobody ever rewrites old software. They write new versions of similar things, and then hopefully those new things get adopted. But the old thing will probably be around for a long time too.

And to be fair C didn't replace Fortran or Cobol either -- scientific applications still use Fortran and old banks (apparently?) still use Cobol on mainframes.

Maybe that's the most you can expect. But in that case there still does need to be a "plan" for making existing C code like the Linux kernel and OpenSSL safer. I think my issue is that some people apparently think that plan involves Rust when it doesn't. Maybe the core team has never pushed that idea but some other people seem to be under that illusion.

-----

This is a different argument, but a language only needs to "solve" package management if it always assumes it has main(). I was looking for something more humble that you could stick in a file in an existing C or C++ project, e.g. for writing as safe parser.

Also the 5+ different Python + C/C++ solutions now need a Python + Rust analogue. For a language at the Rust layer, there's this O(m*n) problem or strong network effect to deal with.

Actually that was thing I was thinking while reading this PDF -- a lot of it can be boiled down to "C and C++ have network effects". Particularly C++.

Asking Rust to break the network effect is like asking Apple to break the Windows monopoly with Mac OS X. That didn't happen -- they built the new thing iOS, and beat Windows with that. So then the question is if Rust is more like OS X or iOS.
My mother's from France. Growing up her family's business was agriculture. They didn't have smartphones, TVs. This meant they'd spend a lot of their time talking with others, especially people older than you - and that's how you learn critical thinking. I recently saw a video interview - https://www.youtube.com/watch?v=8hUOUNZrbBg - with Bill Clinton and George W. Bush. Clinton commented he doesn't know how people do it these days with all the distractions for consuming and not engagement - and that he learned his thinking skills heavily through family dinner every night.
License-compatible does not remotely mean Windows-compatible.
So if you point it at a satellite, or the ISS, and run a generator? Would that be a good backup power source for solar currently used?
It's not just the mental ease, it's also the physical typing ease (and in some cases, the possibility).

For example, he points out that to connect C to existing parts of the system (which is the OS and OS level tools), all you have to do is call the functions. If you want to call a C library from a Java program, it's a lot more work. Furthermore, C has the capability of understanding Java structures (although it's awkward), but Java has no way of understanding C structures from within the language. There is no way to model a driver I/O port in Java, but in C there is.

The paper is worth thinking about. If you are creating a language, take interoperability between already existing languages into consideration. JNI is ok, but think how much better it could be if it did auto-marshalling of objects!
Here's one of the newer ones I mentioned, which I haven't read but seems well regarded: http://cs.brown.edu/~sk/Publications/Books/ProgLangs/

EoPL took about as much work as a good college class, minus the sitting-in-lectures-and-tests part. Some parts aren't depended on later, like the OO chapter IIRC, so they're up to whether you're interested.
> I'd lean towards worse. I don't recall anyone attempting to publicly shame me for not being "conservative enough". I'd wager that most liberals have encountered some version of that.

Odd. Just an observation: conservatives in the US have a commonly used name for that - RINO - Republican in Name Only - and there is no equivalent name among liberals.
Why Can't Quantum Mechanics Explain Gravity?
The first line of Vancouver's fully automated Skytrain was deployed in 1986!

https://en.wikipedia.org/wiki/SkyTrain_(Vancouver)

Similar systems exist around the world: JFK Airtrain, Kuala Lumpur LRT, a few places in china (Beijing IIRC?)
The characters are supposed to grow along with the audience in the Harry Potter to my knowledge.
Raize FTW :)
To me, both fond and colour are important. I want a good, clean[1] monospaced font with a nice set of ligatures.

[1] What I mean by this is that characters (and especially symbols) are easily identifiable, which usually means they should not have much unnecessary detail. They also should not bee too thick or thin. I mostly use Fira Code currently, which is like Fira Mono but with ligatures.
Depends on the batter. There's a stat for batting average with runners in scoring positions (at least one runner on at least second base).

It has a lot of factors though like the batter's own psychology, the pitcher having to pitch from the stretch (an abbreviated motion to defend against base stealing when there are >0 runners on base), etc.

Baseball stats by the actual teams to get an edge is the most advanced in all of sports. The internal stats of the teams likely have much more sohpicticated numbers that control for a lot more variables.
I noticed the same person has made seemingly very powerful gdb-inspired debuggers for a whole bunch of languages, which is really impressive. I'm not super comfortable with gdb (it's been years since I used it with any regularity), in general, but I'd be willing to invest more time in it knowing the knowledge transfers to other languages.
> Let me confidently assure you that inflammation in the hypothalamus is a dominant feature of obesity

I certainly believe you (I'm not qualified to agree or disagree, as I'm not a specialist like you). The point of my rambling comment is to make sure the readers understand that the kind of inflammation we're talking about here is very removed from what people usually think about when they think of inflammation.

> Please don't recommend laymen avoid reading articles like this. That's rather senseless

Hm... Here I'll have to disagree. I think medical research should be consumed rather judiciously, especially by laymen or by doctors that are not specialists in the research area in question.

I'd rather have people read distilled accounts of research (textbooks, meta-analysis, etc.) than studies in knockout mice.

EDIT: Answering your edit. I'm not discounting anything. I think the study is as relevant as it gets for a study in mice, and the role of hydrocarbons of the diet is an important one. After all, is it just calories in VS calories out or is there something else?

I do understand what the study is talking about when it talks about microglia and inflammation. I'm merely trying to answer the question about "What is inflammation IRL" in a way that laymen may understand - most people don't know that microglia are derived from cells of the immune system (in a sense, they are the "inflammatory cells" of the brain), and can't draw the parallel between neutrophils and monocytes happily blasting away through the extra celular matrix under the skin in search for pathogens and microglia killing healthy neurons.

In no way I want to be skeptical of the article or discount the importance of its findings. I only want to draw the distinction between the "naïve" idea of inflammation and the kind of inflammation the article is talking about.

EDIT2: The poster asked why he didn't feel "inflammed". He would certainly feel "inflammed" if he had an encephalities, so there is definitely some confusion here. My comparison between this "low level" inflammation and encephalites was meant to highlight that. Do you think I was unclear?
I would submit that the two are in contention with one another.
FWIW, Microsoft did announce their support for HR 392 earlier when Congressman Jason Chaffetz introduced it. HR 392 removes the per-country GC caps, with the aim to remove the decades+ wait for immigrants from populous countries.

Your general point about tech leaders who shed copious tears on social media for Dreamers stand.