skysight-inc/HackerNews huggingface dataset:
It’s about NIST and the Standard Reference Materials (SRMs)

You might have heard about the “Standard Peanut Butter” or the “Standard Cigarettes” (or how crazy expensive they are) and both of these get a mention. But they’ve covered some other interesting stuff behind the scenes of both why the SRMs are important and why some of them are surprising expensive.

It also reminds me how just how nerdy my nerdiest purchase is. I purchased a license to REFPROP the NIST Standard Reference Data in order to get a more comprehensive propellant library for the Rocket Engine design and simulation program I purchased. I’ve used it a few times since for various calculations and it’s been neat to have at times, but the coolest part has been how amazing every interaction I had with the NIST employees was… they are just all a bunch of awesome people doing awesome nerdy stuff.
And once you've learnt those things and got some experience writing real world software in Rust, you may well find yourself more productive in Rust than, say Ruby on Rails.

Context matters a lot, and you shouldn't be making tech choices based on the way the wind is blowing ("tech radars", what's hot in the blogosphere, etc.). If hiring teams to work on your mostly-CRUD app easily is a high priority, then Rust probably isn't a good choice. If you have a team that already knows Rust, and you need to add some web app / service, then Rust is a perfectly fine choice, on the grounds that support for web stuff is "good enough" now, and the best tool for the job is often the one you already know well and are already supporting.

If I'm building stuff for _myself_ and it's getting too fiddly for a bash script, then I'll always default to Rust just because _personally_ I'm way more productive in it than anything else.

Context, context, context.
God I get tired of the if err criticism with Go. I truthfully don't even notice it when I write Go, I don't understand why folks get so bent out of shape over it.
A programming language can not guarantee a program written in it works correctly, even if you are writing in something like Coq or Idris. People who care much more about velocity than about correctness and security--as they are incentivized to do by the shared competitive game they are all playing--can and do routinely code these errors in any number of programming languages.
The productiveness, safety, and beauty (seriously!) of the surprisingly numerous Rust kernel and embedded projects suggests otherwise. That use case took off very quickly in Rust world.
Yes - McDonalds Monopoly is one well-known example.
Rust still won't save you from logic errors, so I guess I don't see your point.
The legal war over Disco Elysium reaches Disco Elysium levels of complexity
This is a very interesting article. “Gift diplomacy” as a signal of societal complexity is quite interesting.
Bay Area indeed! Thank you very much for the recommendation! I’ll check them out.
Transcribed from @mhdksafa:

"I noticed that our lovely janitor gets treated like an outcast, so I made sure to drink my coffee with him daily in front of the gate. Today I was in a hurry to get to my office, so he came to my office with a cup of coffee and awkwardly goes "Thank you for being my friend."
Can you expand on this claim a little? Why does eye contact make a huge difference in a VR office suite software?
I use Rust at a startup, and it's been great.

But I've used Rust mostly for performance-critical CLI tools, or highly specialized servers. Typically, these have a narrowly defined job that must be done reliably and efficiently. Rust shines at this. These tools run reliably with almost no changes, often for years at a time.

But I have learned that it's often less useful putting policy and frequently-changed business logic in Rust. That kind of code is often accessible to more developers in a strongly-typed scripting language.
Rust vs. Ada
Just out of curiosity, why is your perf-critical layer running so slowly? Are you any closer to cracking it?
I wish ReasonML took off more. It's an OCaml dialect which reminds me of Rust with a garbage collector, which is unsurprising given the Rust compiler's history being initially written in OCaml and where a lot of its ideas stem from, such as exhaustive pattern matching, the Result type, functional programming being as performant as imperative programming ("zero cost abstractions") and so on. ReasonML was developed at Facebook by the creator of React and it was supposed to be used as an alternative language than JS for writing React.

However, it didn't have much support after TypeScript took the JS world by storm. If it had, we might have seen the same great Rust-like benefits on the frontend as well, and perhaps the backend too instead of NodeJS.
Now is your chance to catch a few leetcode specialists who failed to deliver significant value at their previous job.
Elon Musk Hires Hacker George Hotz to Fix Twitter Search (In 12 Weeks)
You just described any modern language paired with Sqlite.
The UK is still the most finance-friendly country in Europe by far. There were attempts to setup in France etc but regulation is much more onerous and so those plans fell apart quite quickly.
In terms of productivity getting into the first release nothing beats Ruby
https://users.rust-lang.org/t/if-ada-is-already-very-safe-wh...
I don't disagree?... The idea that moving fast is more important than correct and safe code--because a startup can't afford to waste time on these matters as their competitors who "don't give a shit" will eat their lunch--goes well beyond Rust and mere memory safety.
Plastics tsunami: Can a landmark treaty stop waste from choking the oceans?
Your profile link doesn't work. Regarding `if err`, it's one thing to add it everywhere, it's another to forget and then have something break. If Go also checked for exhaustive error handling, I wouldn't mind it either.
I played both Sevtech Ages and GTNH and the difficulty was definitely part of the fun - you feel real accomplished having moved past a laborious process.
Not that I can find in any hurry, and it's also worth my mentioning that occurrences are decreasing, and I'm not sure if that's because there are fewer people legitimately taking the ad-defensive stance, or whether there's a 'chilling effect' caused by (in my opinion) the increasing volume (in both definitions of the word) of arguments against ads.

My memory also tells me that most of the pro-ad stances on HN have been cagey; justification within a certain set of privacy-respecting or customer-service-improvement ideals.
VspaceCode might help you and others: https://vspacecode.github.io/.

It allows you to execute arbitrary VScode commands in fewer keystrokes using Emacs like menu (never used Emacs myself, so might be off a little).
Along with default <space> key, I've also mapped ctrl+g as a global binding to trigger VspaceCode. So almost anywhere in the UI, I can always use keyboard to navigate.

EDIT: formatting
Congratulations on becoming a millionaire! That's pretty cool (for you at least, probably not their customers).
So when free markets don't align with the philosophy then we just redefine words until they do?
While I'm missing global mode my choice would be vscodevim.vim (1), mainly because it supports VScode in-browser mode such as github.dev and gitpod.io

(1) https://open-vsx.org/vscode/item?itemName=vscodevim.vim
I don't disagree, but it sounds like you somehow magically think someone who refuses to trade off velocity for safety--which was a genetic premise that doesn't have much to do with Rust in specific--won't also mess up everything else they touch, which seems far fetched.
The CEO wanted to move fast and break things with respect to security but offered a $2 million bug bounty?
It’s the empty interval. It’s the set of numbers x for which x >= 2 and x < 2, which is none, and hence the empty set. It’s the equivalent of this for loop (for integers):

for (int i = 2; i < 2; ++i) { … }

The body of the loop will be executed zero times.
I have a woodshop and I develop software for a day job. The best piece of tooling I can suggest for a wood shop is a wood stove for heating it. I have reached 100% efficiency with my materials usage and it brings me a great satisfaction to so easily maintain such an impossibly high result.
In my experience, Python is one of the least productive programming languages for projects with more than 3 people. If you have a big project, you are going to spend a lot more time reading code than writing it. Python is write-optimized.

By contrast, using Rust makes it easy to force a readable coding style on yourself and others.
> Rust was used primarily because a couple of the founders of the company were Rust experts

It's remarkable how significantly the first few months of a project impact the first few years of a company. How quickly casual & spontaneous decisions, largely based on convenience and familiarity, ossify into legacy drag.
If only there were a language feature that could tell you which case it was and ensure you handled it correctly...
_ENV is the same thing as setfenv/getfenv in Lua 5.1, except its lexical. Unless the use of function environments also make LuaJIT slower (I doubt it as that would implicate _G and a host of other behaviors, all of which LuaJIT is renowned for making work performantly), I think the best way to interpret the original sentiment regarding _ENV is that it would be a PITA to support in a backward compatible manner. There have also been several patches over the years to add _ENV support to LuaJIT, and AFAICT they've all been relatively simple (but not necessarily simple for someone who is firmly of the opinion that Lua should have been frozen at 5.1).
Bonus: Neovim isn’t phoning home to Microsoft nor does it try to bifurcate communities on using proprietary plugins.
These considerations are part of the reason I replaced gas with gas - I’ll move to heat pump when I build a house so I can be sure I have it designed for it.

As it is a tankless water heater may be the easiest way to “fix” yours - or spend a big amount for a knowledgeable energy contractor.
It's alarmist because not all software is a financial product and your original statement lacks necessary qualifiers.
NAACP denies making any such deal: https://twitter.com/DerrickNAACP/status/1595216801301921801

The NAACP are among the activists pressuring Twitter's advertisers, so if they say there was no such deal I'd trust them over Musk.
similarly people reported big changes after boston's big dig was completed
Drought Reveals Rare American Lion Fossil in Dried Up Mississippi River
Python is extremely easy to write, but hell to read. Rust code tends to be very easy to read.

On a big project, you are going to be reading a lot more code than you are going to be writing.
but adult content can’t be monetized right now afaik
This is pretty trivial to accomplish with linters. Where I work your build will fail if you have unchecked err's hanging around, along with a lot of other sorts of issues. No, it's not built into the language by default or anything, but is that dealbreaking?
https://archive.ph/eH1lM
I’ve been working on an early design of a high-performance dynamic binary translator that cannot JIT, and have reached a very similar conclusion as the author. We have an existing threaded interpreter but it’s a mess of hard-to-maintain assembly for two architectures, and we run into funny issues all the time where the two diverge. Plus, being handwritten by people who are not scheduling experts, there is probably some performance left on the table because of our poor choices and the design making it difficult to write complex-but-more-performant code. Nobody wants to write an efficient hash for TLB lookups in a software MMU using GAS macros.

The core point I’ve identified is that existing compilers are pretty good at converting high level descriptions of operations into architecture-specific code (at least, better than we are given the amount of instructions we have to implement) but absolutely awful at doing register selection or dealing with open control flow that is important for an interpreter. Writing everything in assembly lets you do these two but you miss out on all the nice processor stuff that LLVM has encoded into Tablegen.

Anyways, the current plan is that we’re going to generate LLVM IR for each case and run it through a custom calling convention to take that load off the compiler, similar to what the author did here. There’s a lot more than I’m handwaving over that’s still going to be work, like whether we can automate the process of translating the semantics for each instruction into code, how we plan to pin registers, and how we plan to perform further optimizations on top of what the compiler spits out, but I think this is going to be the new way that people write interpreters. Nobody needs another bespoke macro assembler for every interpreter :)
I have been a fan of George Hotz for a long time. Supposedly he left Comma.ai to do another startup.

If he completes this assignment, working for just room and board, I'm betting there's a book and possibly a movie out of it. In fact I'm sure that it will be a best seller if done correctly I'd volunteer to be his co-writer.
Web3 came and went to no fanfare in places like Estonia, who have cutting edge digital identity and trust systems built on boring, existing crypto primitives and smart cards, while in the US we’re stuck with checks and paper signatures. Everyone raves about distributed identity while Login.gov is now integrated with almost 220+ federal agency systems, is the primary identity provider for Social Security (and soon, IRS after the ID.me debacle), and is a bit of PKI and CAC/smart card infra away from being a huge leap forward.

Hot take: real innovation is finding the right person’s metaphorical arm to twist to get enough leverage to get the tech implemented. The tech is the easy part. Bureaucracy hacking is underrated.

https://e-estonia.com/solutions/e-identity/id-card/
Yahoo still had other things like news and stocks once nobody was around for a game of Literati. What does Twitter have when there's no one left to argue aimlessly?
Sweet, well the large feature we just spent 9 months building at a company that has yet to turn a profit is not anything that anyone wants to use so we’re throwing your beautiful porcelain dollhouse down the basement stairs and building something else.
Maybe you're just not grateful enough? /s
Google Photos search is magical.
I don't really agree with that framing. Most of the languages people use to write web apps are safe! The actual tradeoff rust is making is that performance is more important than developer productivity. It's not willing to sacrifice safety for productivity, but fundamentally the reason to use rust is that it's fast.

If you don't need performance, you might be better off using any number of safe, GC languages. (That said, I actually find the ergonomics of Rust nicer than most other languages. A rust-like language with a GC would be very nice for web backends imo.)
> Sure, you can move faster without Rust for now; but you'll pay the price later on.

The flip side argument for an early stage company is that if they can’t move fast they may not survive. Not having tech debt is great, but it’s better to have tech debt and be alive than no tech debt and out of business.

To be clear, I’m not personally taking a hardline position on either side here. I think these kinds of choices are always a balancing act. Moving too fast can kill your business just as effectively as moving too slow: it’s just as hard to ship changes to a permanently on fire ball of spaghetti as it is a pristinely typed piece of clockwork, and sometimes harder.
What does that shift in paradigm give you over Visual Mode in Vim?
There's no way around the fact that instrumental kindness, gratitude and appreciation aren't really kindness, gratitude and appreciation.
Thanks for making evening less boring ;) I also have my somewhat related strategy, it is called Zero Rust.
Wait what? Python, if anything, has a reputation for being readable! Perhaps this is more of a criticism of dynamically typed languages in general? As the team grows, adding mypy types can help a lot.
It has a data driven approach that does not sum up into an ontology, still it flies.
And suddenly everyone is extremely concerned about the state of Twitter's finances.

Hating on Twitter has become just another political in-group signal. Yawn.
According to this article you can opt out of the shit pile entirely. Maybe these guys are right and we should present them with a society that isn't so well-served by the crawling through shit metaphor.
It is dealbreaking. These days I gravitate more and more towards strongly statically typed languages over weakly dynamically typed ones, which I definitely used to use when younger. Fact is, linters are simply not the same as something built-in from the ground up. Trust me, I have written many thousands of lines of Python and Ruby, and even with linters, they don't hold a candle to even something like TypeScript in terms of type ergonomics and refactorability, not to mention even stronger languages like Haskell or OCaml.

Anecdotally this is the same argument many C++ devs make in regards to Rust safety guarantees. The difference is just...different.
I would claim the author has an extremely narrow view of where safety matters. Hell: he's even using a pretty safe language (Go) as his alternative! I think the most charitable interpretation I have for the article is that he doesn't actually want to say "I refuse to sacrifice safety for velocity" but "I refuse to sacrifice performance for velocity", which just isn't the same thing.
The idea that a clever memory leak is the root cause of most stolen data instead of a phishing attack is ridiculous
Starship is an excellent prompt, and requires very little effort to set up.

I appreciate the details about the current environment it puts in the prompt. e.g. the current git branch, which AWS profile / region is active, etc.
https://github.com/kisielk/errcheck

Every Go project I've worked on has used this linter. I think it should be builtin, but it's very easy to incorporate.
It's super annoying, I switched from Go to Rust for my personal projects because of it. It's like a seat belt beep that won't stop.
PGO on a conventional executable with accumulated profiling data is likely to be more performant. JITs also have a problem because they must transmute RW data pages into RO code pages to satisfy NX. PGO enables longer-term analysis that effectively supersedes JIT. JITs are nice in theory, but don't tend to save profiling data to drive optimizations in performance-critical sections that matter.

Might try LuaToCee and then apply PGO iteratively.
Factories have done unmeasurable damage to our ecosystem, that is unequivocable. But we had to rename it climate change because people couldn't get over the phrase global warming whenever it was cold so I don't see "Reduce Pollution!" as a winning slogan. People who care, care about the underlying concept no matter what it's called. People who don't care don't believe it's a problem in the first place and won't do anything to reduce pollution.
https://www.youtube.com/watch?v=tNLn2xYzvao worth a watch
Because you’d either need a special “always zero” register (some chips have this), or a menomic for some or all of the instructions that assume zero as an operable (some chips have this), or wipe a register (this is the problem here - uses a register) or use memory.

Adding an implicit zero may make sense for some instructions but probably not all.
> No one believes that Henry Ford has personally reviewed and approved every social media post that has an ad for Ford trucks next to it.

Because he died in 1947?
"Is this based on personal experience, "

It is based on the fact that be publicly fired very competent people on Twitter for contradicting or criticizing him.

https://timesofindia.indiatimes.com/gadgets-news/this-is-wha...

https://www.businessinsider.com/tesla-elon-musk-ruthlessly-f...

He also publicly mocked all the people he fired

https://www.ndtv.com/world-news/elon-musks-dig-at-sacked-emp...
Haskell and Pandoc has too much dependency bloat. Just installing Pandoc on Arch requires like 200MB in dependencies, and over hundred haskell specific dependencies.
Have you tried ReasonML?
https://blog.reverberate.org/2021/04/21/musttail-efficient-i...
Say what you will about the tech industry but most startups have better processes than this for a crisis situation. There’s a lot the conventional world could learn about the development of incident response ops in the tech world IMO.
This doesn't match my experience. It took some time to get up to speed, but at this point it's much faster for me to write something in Rust than in other languages that I'm proficient in that are ostensibly faster to develop in (e.g., JavaScript).

Part of this depends on one's bar for quality. In Node.js I could write `JSON.parse(input).foo.bar` really quickly. In Rust, I'd probably write two struct definitions with `#[serde(Deserialize)]` first, then a similar line. It'd take 45 seconds longer, but when I'm done, the Rust program validates the input and prints decent error messages.
No, the people he hired made that while he sexually harassed women and lied about how good his self driving software was.
> I propose that perhaps we do know enough, and the problem is that at social / economic level, we fail to prioritize what needs to be done.

We could quibble about the first part (for one, species are disappearing faster than we can study them, so there is really no way to be sure we know fuck all about how things work), but the second part is clear. We aren't prioritizing anything but economic growth. We can't even conscience using less energy, like e.g. the amount of energy (per capita) our parents or grandparents used. Like leaf blowers. FFS, unless you are a lawn care service, most people could get by with raking.
A lightswitch so good they made it illegal
Trying too hard to write good code can be a deadly mistake for an early-stage startup regardless of the language you use.

If you're really a startup, looking for a product-market fit, then you don't know exactly what you're building yet. There's a high change you're going to throw away a lot of code.

e.g. you spend effort caring about scalability, flexibility, proper architecture, full test coverage — only to hand it to users who will say they won't buy it, it's not actually the feature they wanted. You can learn such lessons with crappy copy-pasted code, and then worry about code quality once you've figured out what to actually build.
You don't have to go out of your way to see it. He posted it publicly and it was widely posted on reddit because it was such a odd thing to post.
I was thinking text/plain would be best way to get the point across.
All of us is not as smart as one of us.

The thundering herds of groupthink and Tragedy of the Commons ensue.