skysight-inc/HackerNews huggingface dataset:
> Interesting to note that this thread seems to be full of a lot of people choosing to be pedantic over the word "recall" rather than taking a critical look at the Cybertruck and it's issues.

Being pedantic over a single word out of 100 is HN's bread and butter. How many times have you read a comment here that boiled down to "The author's entire article is invalid because in paragraph 3, word 65 he used the wrong word!"

Bonus points when the poster is himself also wrong about the meaning of the word, as is the case in this thread where people don't know what a "recall" is in the automotive world.
Yeah, and also a loss of $8.5B in 2019, loss $6.7B in 2020 and loss of $9.14B in 2022. Hell of a business they got there.
etcd?
But it isn’t a new meaning. Rather, those arguing that recall should now exclude OTA want to change a long established definition.
Open market operations are the mechanism by which the interest rate is controlled.

Basically, the central bank sets an interest rate target and then performs open market operations until the interest rate matches the target.

That obviously affects the quantity, but the point is that the target is the interest rate. The quantity just ends up being whatever happens to be necessary to hit the interest rate.
Usually I'm the stranger in someone else's car when I'm taking a taxi but idk
One very subjective, very irrational factor for my borderline hate for Go is that for years the Go zealots gaslighted everyone about every single part of Go.

Anything that Go did, no matter if it was the most basic implementation or if other languages already did it (better), was essential, the best and only way to solve that issue.

Anything Go did not do was superfluous and downright a conspiracy by Big Complexity to keep us unenlightened Non-Goers addicted to the Syntax Sugar: Things like sane null handling, sane error handling, less boilerplate, generics, or not creating special cases for everything (generics and tuples) instead of developing one cohesive solution.

Even now, in this thread, the strawmanning continues: Error handling is brought up, and instead of admitting the unmistakable truth that Gos error handling could be much better (s. Rust), people bring up things like JavaScript. As if anyone criticizing Go that JavaScript was the pinnacle of error handling.
Lots of stories about having google account connected to adwords locked out for various reasons, not all valid.
Biggest reason is simply quantity, Japan churns out hundreds of animated stories from new authors every year, the west do barely anything in comparison.

When you create that much content some of them do become hits, and it also encourages more authors to create more content, while western studios only invests in franchises they can control themselves to create another marvel, while Japan just churns out content while the authors retain the rights.

Edit: Many western authors writes about other worlds etc, they just don't get anything animated since it is so hard to get anyone to invest in your story.
Reminds me a bit of the latest video of Chris Niebauer https://www.youtube.com/watch?v=p_Dq5512MIE where he talks about the mind wandering upgrade through smart phones and social media. with the help if these tools the brain can offload the task of simulating/imagening things into the real world.
One practical benefit of Rust’s approach that hasn’t been emphasised enough yet is the consequences of Option<T> and Result<T, E> being just values, same as anything else.

It means you can use things like result.map_err(|e| …) to transform an error from one type to another. (Though if there’s a suitable From conversion, and you’re going to return it, you can just write ?.)

It means you can use option.ok_or(error) or option.ok_or_else(|| error) to convert a Some(T) into an Ok(T) and a None into an Err(E).

It means you can .collect() an iterator of Result<T, E> into a Vec<Result<T, E>>, or (one of the more spectacular examples) a Result<Vec<T>, E> which is either Ok(items) or Err(first_error).

It’s rather like I found expression-orientation, when I came to Rust from Python: at first I thought it a gimmick that didn’t actually change much, just let you omit the `return` keyword or so. But now, I’m always disappointed when I work in Python or JavaScript because statement-orientation is so limiting, and so much worse.¹ Similarly, from the outside you might not see the differences between exceptions and Rust-style Result-and-? handling, but I assure you, if you lean into it, it’s hard to go back.

—⁂—

¹ I still kinda like Python, but it really painted itself into a corner, and I’ve become convinced that it chose the wrong corner in various important ways, ways that made total sense at the time, but our understanding of programming and software engineering has improved and no new general-purpose language should make such choices any more. It’s local-maximum sort of stuff.
IMHO it's just that it's a beam VM language, which is a fatter runtime/ecosystem than is really needed to achieve the goal stated above can bring it's own bag of problems (but also it's own superpowers).

Also to be productive you have to utilize the rest of the erlang ecosystem, so at least some superficial knowledge in elixir & erlang is helpful for for some use-cases.

Syntactically I actually don't think it's that for off, but I dunno what GP was thinking, maybe that it leans more into functional patterns & sugar for those whereas rust/go can also be used in a procedural style. (Though at least personally I am using way more functional patterns in rust than I expected)
> so if one goes down ... just spun up on another

On Fly, one can absolutely set this up. Multiple ways: https://fly.io/docs/apps/app-availability / https://archive.md/SJ32K
I was diagnosed with hypothyroidism a decade ago and it seems to coincide with premature graying in my 30s
This doesn't count because the idioms are very different from Go and Rust. And I suspect there's a high learning curve for features like Functors.

If you check the Wikipedia page for OCaml to find out where it gets used, you'll see why it's ocaML. That is, you'll notice that it's mostly a MetaLanguage, or a language for writing other languages. The same observation applies to other languages in the ML family.
It is kindof an interesting point you bring up here. However, it's also true that languages (and software in general) are what people make of it, not necessarily what their creators intended. I do believe that the stuff that happens to do what you want when shoved into a C++ compiler _is_, for all intents and purposes, C++. And I kinda' think/feel that that is also what the committee is saying - "we want C++ to keep doing that, rather than evolve into a safer thing that is no longer C++"
I took the question to be on the logistics of executing this kind of operation with digital ledgers, not on when/whether those operations make sense.

Confiscating foreign assets would do little[0] to reduce inflation. But it's the same for local assets. Obviously just chopping off a zero from every note and bank balance doesn't actually reduce inflation, unless accompanied by some other structural changes.

[0] I say "little" rather than nothing, since it could have the effect of repatriating the money -> increasing the exchange rate -> making imports cheaper. But I can't imagine the effect being strong.
not sure, probably either an eks cluster with a job scheduler pod that creates jobs via the batch api. The scheduler pod might be replaced by a lambda.
Another possibility is something cooked up with a lambda creating ec2 instances via cdk and the whole thing is kept track by a dynamodb table.

the first one is probably cleaner (though I don't like it, it means that I need the instance to be a kubernetes node, and that comes with a bunch of baggage).
Memories of QEMM shudder
Needs to be more than one accumulator.
Plenty of OSS developers/companies have survived and make a living out of their work. You just have to provide enough value on top of your project with your closed-source services that people are inclined to pay for them, instead of hacking up their own solutions. Or consultation.

No one forces you to make your project OSS. It's a trade-off you should consider carefully before you do. But because people keep doing it, it's clear there are massive benefits to it.

And many open source projects are just modules extracted from the company code base to gather developer mindset and to reduce costs by harnessing outside developers. It's, as such, a fine model as it is. Rug-pulling and exertion of power through stupid lawyer BS is what kills those projects if anything. If people are not paying for your OSS addons, perhaps they aren't that good after all.
except we are actually using them :)
If Tesla is a software company rather than a car company, then did you also consider Wework one rather than office rentals? Honestly interested why their, as of now, main product shouldn’t define the type of company they are.
Its not just car manufacturers, ever since SW stopped shipping in CDs the pressure to just ship and fix it with a patch has permeated everywhere. If there was no further opportunity to fix later I wonder would the Boeing issues have been as prevalent.
Well I think they refer to the genetic make-up of the circadian timing system, as mentioned in https://en.wikipedia.org/wiki/Night_owl .
Is it fracked?
Cities cut red tape to turn unused office buildings into housing
> Meanwhile, automotive companies aren't scared of moving parts. A car has loads of spinning parts already; they have mastered the art of making spinning things that can keep spinning for thousands of hours.

Almost an understatement.

A typical car wheel hub with a 20-27 inch tire diameter has experienced around 75-100M full rotations by the time it reaches 100K miles.

Meanwhile, the engine probably has revolved ~5-10 times more during the same time.
Why ServiceTitan was on the clock to go public
Investing in a market opportunity rather than a company or person.
I do not think that is the strongest argument.

The strongest argument comes from Viacom v Youtube. If Viacom itself is unable to identify which videos are infringement or not how is a Youtube supposed to be able to?

Or to put into different terms. If a copyright holder historically has asked an ISP (Google eventually become one) to un-takedown content as it wasn't actually infringing; why should the ISP be liable for not-proven-in-court activity by customers?
It all comes down to math:

https://stephaniekelton.substack.com/p/how-to-cut-2-trillion...
All credible lifecycle ghg emissions analyses have found that EVs have substantial reductions vs ICE. It is true that they have more emissions from manufacture but this is overcome, on average, in a few years. This is true even on carbon intense electric grids. And their emissions drop as the grid gets cleaner.

https://www.ucsusa.org/resources/driving-cleaner

The Cybertruck is a likely exception. It's manufacturing emissions are likely enormous and it's likely to be driven less than average since it's impractical.
There is some DX similarity between checked exceptions and Result types.

Because the compiler will fail if you don't explicitly mention each possible exception.

But checked exceptions are coming out of style: They're unchecked in C#, and frameworks like Spring Boot in Java catch all checked exceptions and rethrow them as Spring Boot flavored unchecked ones.

For unchecked exceptions and Result types:

The DX is very different in one critical way:

With Results you constantly have to differentiate between error and ok states, before you proceed. With unchecked exceptions you generally assume you're always in an ok state. It's equivalent to wrapping your whole function body in 'try { ... } catch (Exception e)'. And you can get that with Result types in Rust by using '?' and not worry about doing something half-way.

Ultimately: Are you a happy-path programmer?
Imho, most features of Rust that people would like to see in Go would still fit into the "concept" of Go. Just like they added generics, they could add just three things: A generic container for errors (Result), one for saner Nil handling (Optional) and a small sprinkling of syntax sugar to make these comfortable to work with (something like an elvis operator equivalent).

Go has the one big advantage that is almost solely responsible for it's success: It was created and directly used by a giant company that could afford to create amazing tooling around it and develop great opensource libraries for it. Already being in use and having libraries feel like the biggest determinants of a languages success.
Yup, common misconception for folks that haven't used it in a decade.

Our team uses C#. We dev on Apple silicon Macs. Some use Rider, others just use VS Code. We build on Linux via GitHub Actions. Ship to prod running AWS t4g Arm64 instances.

C# to me is like TypeScript++. The language, syntax, and core constructs are close enough that anyone with a good handle on JS and TS can pick it up easily and be productive.
Besides that being a propagandized lie and an iteration that fell off because it didn't stick, you could at least make an effort and provide a source.

But I did forget about this Russian propaganda point, thank you for pointing it out.

Also, I should add the:

- USA is building bioweapons labs in Ukraine;

- There are CIA bases in Ukraine;
I concur. So much focus on grandiose ideas when there are so many low-hanging fruit around.
A more interesting question is, do you as a startup company have any information worth sharing? Ideas are dime a dozen and like you just said, the differentiator is the capabilities of those people. And that is not something that can be shared, and no other startup can benefit of it.
Thanks, that worked great. Crazy photos.
Well, I've also programmed for over thirty years and I wouldn't use a language without exceptions and even wrote a whole essay defending that position:

https://blog.plan99.net/what-s-wrong-with-exceptions-nothing...

> Even junior engineers have a trivial time debugging most go errors

Not my experience at all. I had to do this once. An HTTP request to a production server was yielding a 400 Bad Request with no useful information for what was bad about it. No problem, I'll check the logs and look at the source code. Useless: the server was written in Go and the logs had no information about where the error was originating. It was just getting propagated up via return codes and not logged properly. It ended up being faster to blackbox reverse engineer the server. In a language with exceptions there'd have been a stack trace that pinpointed exactly where the error originated, the story of how it was handled, and the story of how the program got there.

Diagnosing errors given stack traces is very easy. I've regularly diagnosed subtle bugs given just logs+stack trace and nothing else. I've also had to do the same for platforms that only have error codes that aren't Go (like Windows). It's much, much harder.
Show HN: Xink, a TypeScript filesystem API router
And it's a Vite plugin, but isn't everything these days?

(pronounced "zinc")

xink's unique feature is that it's a directory-based router. Think Next's App router or SvelteKit routing. And since this is for APIs, each route file should export functions named after HTTP methods in order to define your route handlers (e.g. GET).

I like using this in SvelteKit, and since I couldn't really find an API-only router that uses a similar strategy, I decided to put something together.

xink is in the alpha stage (maybe beta??) and I'm looking for contributors to help make it better. I currently only code as a hobby, so I'm sure there are some areas that need improvement, fixing, or some major thing(s) I've overlooked.
Fred Brooks discussed this in the unfortunately named pun "The Mythical Man-Month". Most of the gray beards have read it, ask to borrow it, it will make their day. The punchline was on the IBM 360 they stopped fixing bugs when the fix cause the same or more bugs than the unfixed bug, which soon became all bugs.

Well aware of Brooks, when the loop var semantics were changed Go did an analysis showing that many more bugs were fixed than created by the change.
A Revolution in How Robots Learn
Payflow.dev: A payment platform optimized for startups
Payflow: an alternative to Stripe for startups. With one-line code integrations, it doesn’t get any easier. We’ve got your back, making collecting payments so smooth you’ll forget what “pending transactions” even mean. Say goodbye to headaches and hello to effortless cash flow—because who doesn’t love getting paid?... Join the waitist
> Not as flexible as AWS

Today, Fly.io is more or less in the same market as Lightsail, not AWS. And when you compare it to Lightsail, it blows it away.
Ok, I’d like to read this article, but all the inline <code> blocks are styled to be utterly unreadable to my particular red-green colorblindness.
Go is not simple, it's easy.

The difference, for example is: Go invents an abstraction just for one use case, and just for the standard library/runtime itself, instead of taking the time to create a universal version of that abstraction. Generics for maps and lists, and tuples for error handling.
How a French Whale Made $85MM Off Election Win on Polymarket
Apple ordered to open up in-app purchases in Brazil
I started learning Go and when I got to the chapter on slices is when I dropped it.

I can't put my finger on why it was so off-putting, but it just left a bad taste.
Show HN: SQLite Plugin for Jekyll
I love Jekyll, especially the Datafiles[0] feature, which lets you use CSV/JSON/YAML files and iterate through them. Mixed with the Jekyll Data Pages generator[1], which lets you create a page for every row in your dataset, it is a very powerful combination.

However, Liquid is a terrible language for data-mangling, and simple filtering/sorting/merging can become very annoying. So I wrote a Jekyll SQLite plugin that lets you use the same data interface in Jekyll/Liquid, but backed by a SQLite file(s).

It gives you the simplicity of the Baked Data pattern[2], and the flexibility of using SQL for data-wrangling, within a static site generator.

As a demo, I took the northwind dataset, and generated a site[3] with a few sample queries[4]. It demos both site-level, and page-level queries alongside data-pages generator to generate a page for every product/category/customer.

I've been using this across a few sites in production for almost a year, looking for feedback on usage semantics and feature suggestions.

[0]: https://jekyllrb.com/docs/datafiles/

[1]: https://github.com/avillafiorita/jekyll-datapage_gen

[2]: https://simonwillison.net/2021/Jul/28/baked-data/

[3]: https://northwind.captnemo.in/

[4]: https://github.com/captn3m0/northwind
If we all dump our vehicles and buy EVs, the energy required to to scrap/recycle 1.5 billion ICE vehicles far outweighs any savings we would make and will take decades to recover.

On top of that they have massive chemical battery packs which are horrible to mine the resources for, are useless after 10 years, and cannot be recycled.

The report you quoted confirms all of this.

Simply putting synthetic fuel into our existing cars negates all of that and turns our existing cars tailpipe emissions into water.
No, but thanks for spamming on their behalf.
Ahh…no. The Fed sets the interest rate directly. What you are talking about is yields on treasury bonds, which are manipulated via bond buying to force money into assets by artificially dropping the yield of those bonds, thus creating a more attractive investment in the stocks, assets, etc.
Gotta love the manichaeism here, makes everything so much simpler.
The reddit thread mentions that the author was probably going to write a blog post about it at some point; I went and found it so you don't have to.

I was curious what exactly differentiates boost::unordered_flat_map from absl::flat_hash_map, and was not disappointed. It seems that the lion's share of the performance improvement comes from using more of the metadata for the reduced hash value, although there are a few other contributing factors.

The blog post further describes where absl::flat_hash_map performs better: iteration (and consequently erasure), which is ironic given those are a couple of areas where I always felt that absl::flat_hash_map was especially weak. But, it makes sense to double down on Abseil's strengths as well as its shortcomings.

https://bannalia.blogspot.com/2022/11/inside-boostunorderedf...
While that is true, there are clippy::indexing_slicing, clippy::string_slice for that:

https://github.com/rust-lang/rust-clippy/issues/8184#issuecomment-1003651774

error: indexing may panic
--> src/main.rs:100:57
|
100 | rtmp::header::BasicHeader::ID0 => u32::from(buffer[1]) + 64,
| ^^^^^^^^^
|
= help: consider using `.get(n)` or `.get_mut(n)` instead
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
> They're worthless if the rest of the world is not on board with you.

Not really. The EU is one of the biggest contributors to climate change. Our change will help. And the rest will have to follow eventually because they are also affected. And they will be in a bigger hurry and it will cost more.

> If you're the only one on board, all you're doing is making your domestic industry uncompetitive and your working class citizens poorer via high energy prices, while the largest polluting nations are destroying the planet further while also getting richer thanks to not giving a crap about the environment and eating away your share of world GDP.

Also, it's not a race we have to win. Life is not about becoming the richest.
DigitalOcean has been doing this for years, and their value proposition is unmatched IMO

For $5 you get:

Latest gen CPUs and RAM

HTTPS

DDoS protection

Cloudflare CDN

Autoscale

Competent support

I'd say the best part is the predictable monthly prices

And while most people probably don't care, they are an established public company, so there is more chance they will exist in 10 years
Nvidia Teases " Most Flexible Sound Machine", Fugatto
Sorry, I didn't see the replies... but you technically don't have to connect for every new request, just connect once and leave it open for new requests. /shrug
> which I never managed on AWS

I haven't looked at it recently, but App Runner could do a few of Fly.io esque things (but slightly more expensive): https://aws.amazon.com/apprunner/
Subligual methylcobalamin works just as well as the shots and you can buy it anywhere.

Also, get a Methylmalonic Acid Test with you B12 levels. An MMA test is more useful because it is an enz=yme which uses B12, so when the active form of B12 is low, so will MMA in most cases.
If you want a free lunch, I can understand when you’re eventually disappointed.
feel free to add details you think are missing.
How fast does Java compile?
I would take edge compute if it's free and easy. That's fly.io's value prop.

In a world where much web browsing starts with ACK SYN ACK, it is nice if the server is close to you.
I think the sticking point is what people mean when they say simple. To me, and likely to many saying Go isn't simple, simple is not a synonym for easy.

Go is easy, but it is not simple. For example, solving the problem of generics in a generic way from the start so the same problem can be addressed in the same way everywhere, would be simple, but maybe not (as) easy. Contrast that to giving the runtime/standard library a special exception with maps and lists. That's easy, but not simple. People used to literally use code generators or weird UTF-8 characters to fake generics, that's not remotely simple.
Breaking Up Google Would Be a Big Mistake