skysight-inc/HackerNews huggingface dataset:
Definitely agree - when I say slightly slower I'm mostly referring to the happy-path/basic uses (reading files, using hashmaps, web servers, etc).

There are definitely aspects of Rust that are much more complex (typically with a tradeoff of more expressiveness, but not always), but at least in my experience, these are usually areas where you can't easily express the same thing in Python. I think many times people forget that you can frequently `clone` your way out of many issues if you are trying to move fast.

And of course areas where I still only use python: manipulating tabular data, making graphs, quick scripts for interacting with APIs etc.
Not OP, but here's a screenshot illustrating what I personally typically do on sites I use a lot: hide things, make things low opacity until hovered, add a dark mode if missing. https://imgur.com/a/tCFkVzK

EDIT should have installed uBlock on the left/default browser for a fair comparison. Oh well, you get the idea :)
Finding and eliminating thousands of calls to recreate a giant regular expression in a popular open source emoji plugin.
I don't think it takes being a cancer researcher to know that an experimental treatment is riskier and could actually shorten your life. I get that some people need a lot of guidance/counseling to understand what the risks might be, but there are plenty of people capable of understanding the risks. Even for routine procedures people are rarely informed of the risks. Sure, they might get an Epic printout, but most skip or skim it and fhe doctor doesn't explain everything. Look at how many women are later surprised that the pill could increase their risk for breast cancer, gliomas, etc because it's colloquially known as being low risk with the benefit of not being pregnant. If you start reading off all the risks and truly getting people to conceptualize the probabilities, it would take too long and scare too many away.

If I'm terminal, hand me a packet and let me sign up for the experiment. If not, I might be buying/renting/borrowing some lab equipment, probably to an even bigger self risk (radioactive boy scout haha).
Fortunately MNIST is a pretty distinctive Google search term. At most you would need to search for (MNIST machine learning).
This is all great stuff but my silly mind was expecting new cool features from Svelte 5, not only DX improvements.
The original post proposes they be abandoned. So I’m arguing against that.
Indeed. Didn’t want to influence answers, but there is something fishy with all this. Remember that Allen Wu is still out there selling a competing ISA, likely with stolen IP.
IMO this is an example of how cancer needs to be attacked. We need an army, not a pharmaceutical company.

We need an army of biology lab workers that can do these bespoke attacks, perhaps enabled by software-generated compounds and formulae. I really don't want to say AI, but maybe even AI.

Once we get the manual labor approach largely solved, then iterate on efficiencies.

Immunotherapies seem to be "the answer". The issue is that they are a very complicated answer, to a complicated disease (cancer is actually thousands of genetic damage diseases under one moniker).
Interesting that signals are coming back hard - Elm had and removed signals due to the learning curve and complexity. With solidjs I pretty immediately ran into the gotchas of signals. I like that reactivity is explicit rather than implicit in svelte 5 - implicit reactivity makes debugging stale views pretty unintuitive.
There already available in GCP under Vertex AI, there are a lot of APIs/models.
Have you ever given ice cream to young children?

I was a picky eater as a kid, yet I still can't fathom why so many kids prefer vanilla over other flavors.
It kind of had to get sent back to the drawing board to work well (avoid all the absurd one-at-a-time limitations of generators), but async-iteration-helpers I think will be an incidental huge help in normalizing/nudging the consumer api into "just an async iterable". Updating/writing state might be more complex, speak to the implementation, but seeing things change should have a semi-standard api.
https://github.com/tc39/proposal-async-iterator-helpers

One huge sadness I have is that when you have a callback in .then or .next, your handler doesn't get a gratis reference to what you were listening to. I'd love to have this be a better record. DOM is so good about having thick events that say what happened, and it's so helpful, sets such a rich base, but js snubbed that path & left passing data in 100% to each event producer to decide as it will. Consumers can craft closures to seal some data into their handlers but it sucks compared to having an extensible data flow system. We're kind of sort of finally fixing this crime the hard way by standardizing async context/async_hooks, which is a whole new ambient way to create context that we can enrich our async events with, since there was no first class object to extend for having omitted passing in the promise to the promise handler. https://github.com/tc39/proposal-async-context

Also worth pointing out, maybe arguable as a hazard tale, observables was proposed a long long time ago. There's still a ton of adoption. But it also feels extremely similar yet notably apart & worse ergonomics than async iteration. It's imo a good thing it didn't get formalized. https://github.com/tc39/proposal-observable

Alas one reactivity I really wish we had had is object.observe (note: different API than observables), or something like it. Undoing good specification work & saying, 'yeah, if users want it, they can implement it themselves with proxies' has lead to no one doing it. And you can't just observe anything; whomever is the producer has to up front make the decision ahead of time for all consumers, which turned a great capability into something first boutique then quickly forgotten. Alas! https://esdiscuss.org/topic/an-update-on-object-observe

I ack your ask, and there's no shortage of options that are pretty damned good. But I feel like we are still in a discovery not deployment phase, still delay competing because we have a lot of terrain and idea space to consider. Before we pick, standardize & ship one.
> Overall YJIT is 61.1% faster than interpreted CRuby!
> On Railsbench specifically, YJIT is 68.7% faster than CRuby!

https://speed.yjit.org/

For 3.2 there also was an improvement of the interpreter:

> We now speed up railsbench by about 38% over the interpreter, but this is on top of the Ruby 3.2 interpreter, which is already faster than the interpreter from Ruby 3.1. According to the numbers gathered by Takashi, the cumulative improvement makes YJIT 57% faster than the Ruby 3.1.3 interpreter.

https://shopify.engineering/ruby-yjit-is-production-ready
See also: https://xkcd.com/1172/
Orion: iPad as an external HDMI display for video game consoles
`key` informs React of the identity of an element. That helps it during the reconciliation phase -- if it knows only one `key` in a list of DOM elements has changed, then it will run the DOM updates only on that one. Similarly if the order has changed, it only needs to move its index in the parent DOM element.

But it doesn't help in the rendering phase - aka when the virtual DOM is constructed when `render` is called on the root component, and all our JSX code is executed across the component hierarchy. Virtual DOM reconciliation cost is only a part of the performance penalty, re-running the "view as a function of state" computation is another major chunk.
The reason the browser doesn't differentiate between them is because the end result is the same - the cett doesn't match the browsers trusted store. The battle has beenosr on self signed certs at this point (unless you're an enterprise, at which point bundle them with your image).

The difference between a misconfiguration and a compromise is intention, both should be treated as equally suspicious.
Understanding the problem usually comes later, first step is to be able to reproduce the problem!
Something missing from OTel IMO is a standard way of linking all three together. It seems like an exercise left to the reader, but I feel like there should be standard metadata for showing a relationship between traces, metrics, and logs. Right now each of these functions is on an island (same with the tooling and storage of the data, but that's another rant).
Ask HN: What's up with the weirdness of Rust's design?
I'm investing time learning a new language or two to use as my main workhorses, to get away from the mess that is JS/TS, after having worked with them for about a decade now.

I already have a lot of experience with C# back in the day, and after having done quite a bit of research, I settled on Rust (for it's versatility, speed, strong type & memory usage checking, and excellent tooling) and OCaml (for its functional programming strength, expressive typing, use for DSLs, and stability). I'd like to use Rust as my general purpose language, and Ocaml to write Rust code generators and DSLs.

However, the more I learn Rust, the more I am baffled by choices made regarding syntax and type/memory use checking. The syntax seems excessively redundant and low level, with implementation details leaking all over the place. One example is at [1]. Another example is at [2], where there is this quote:

> ...why should a reference to the first element care about changes at the end of the vector? This error is due to the way vectors work: because vectors put the values next to each other in memory, adding a new element onto the end of the vector might require allocating new memory and copying the old elements to the new space, if there isn’t enough room to put all the elements next to each other where the vector is currently stored. In that case, the reference to the first element would be pointing to deallocated memory. The borrowing rules prevent programs from ending up in that situation.

The explanation makes sense, but the larger question is: why should low level implementation details affect syntax at this level? Why can't references be updated automatically when a vector is moved?

I also don't get this whole complexity about string handling (e.g., string slices vs regular strings). I've read the docs several times and I still don't really get why this design is necessary.

The whole language just seems unnecessarily complicated, quite a contrast to the cleanness and elegance of Ocaml. Can't we have a simpler syntax and design layered on top, probably with a GC as an option?

[1] https://stackoverflow.com/questions/68725942/is-a-mut-on-a-moved-function-parameter-leaking-implementation-details-to-the-f

[2] https://doc.rust-lang.org/stable/book/ch08-01-vectors.html
A company of your choice wants to expand its operation to a foreign country of your choice. The company has two investment proposals namely Project X and Project Y.
Project X Project Y
Initial Investment 200,000 300,000
Net Cash flow
Year 1 50,000 200,000
Year 2 100,000 100,000
Year 3 100,000 50,000
Year 4 30,000 30,000
Year 5 20,000 20,000

The discount rate of return @ 10%.
Year 1 Year 2 Year 3 Year 4 Year 5
0.909 0.826 0.751 0.683 0.621
Analyse the financial statement using ratio analysis.
2. Appraise the investment using the techniques such as NPV/Payback / Discounted Payback /Accounting Rate of Return / Net Present Value/ Internal Rate of Return
3. Identify the sources of Fund
4. Conduct various environment analysis using PESTEL, Five Forces Framework, Core Competences, Value Chain.
5. Portfolio analysis using various techniques of strategic management
6.Analyse the significance of stakeholder
analysis.
It's awful. I was impressed by the video and the technology, but the presentation style is irritating.

I felt especially sorry for the people working at the Rwanda site just trying to do their jobs efficiently, while he mucks about being fake-excited about everything. There's almost an air of "smile and nod and hope he goes away soon" about it
> Where else do people talk like this?

On TV, but it got out of fashion recently.

There's a Monty Python sketch about an island full of foreign news reporters that's quite illustrating.
You can find problems like “oops, the Android they use in India on phone model X has chrome that blocks the screen every week so they can’t get passed the login flow”

It’s about better sampling of the actual distribution. User testing has huge selection bias.
Yeah, we're in the quality discussion avenue
Your workstation will never be secure. Ever. It's not possible. Give up and work to implement zero trust. Ephemeral environments like CI/CD are not inherently secure because they're ephemeral either.
You can't redirect sites like that with DNS. All of those domains resolve to the IP of a load balancer (probably the same one minus some anycast routing), which then decides whether to show the requested service based on the HTTP Host header, not the DNS record. You can quickly verify this by looking up mail.google.com via DNS and putting that IP into your browser bar, which will redirect to google.com instead of opening Gmail.

A CNAME record would just mean they use the same load balancer.

$ curl -H "Host: mail.google.com" 142.251.16.17
...gmail-specific html

$ curl -H "Host: maps.google.com" 142.251.16.17
...gmaps-specific html

$ curl -H "Host: www.google.com" 142.251.16.17
...google search-specific html
it is reactive by default, just if you use $: and the dependent value never updated, it would give undefined, personally i never got this kind of issue XD so I'll stick with old syntax until I really2 need $state/$effect/$derived
Hey,

This is the exact pattern we target :)

Drop Electric onto an existing Postgres data model and use the Shape-based sync to manage dynamic partial replication of subsets of data between central Postgres and local SQLites:
https://electric-sql.com/docs/usage/data-access/shapes

James
Sounds like it’s not very widespread at all. How many magazine editors are there in the US?

Maybe don’t call others “stupid” when your entire post is creating fictional villains.
I had a truck do this kind of behavior once.

Finally figured it out after months when I moved a wire and it started, then move the wire close to another wire and it would no longer start. These were wires that would typically be close, so my guess is one of the wires was now generating enough noise that it was bleeding over into some other system and causing it to fail. As the car bounced around the proximity of the wires changed and lead to the random behavior.
In answer to the same question I built UniteAI https://github.com/freckletonj/uniteai

It's local first, and ties many different AIs into one text editor, any arbitrary text editor in fact.

It does speech recognition, which isn't useful for writing code, but is useful for generating natural language LLM prompts and comments.

It does CodeLlama (and any HuggingFace-based language model)

It does ChatGPT

It does Retrieval Augmented Gen, which is where you have a query that searches through eg PDFs, Youtube transcripts, code bases, HTML, local or online files, Arxiv papers, etc. It then surfaces passages relevant to your query, that you can then further use in conjunction with an LLM.

I don't know how mainstream LLM-powered software looks, but for devs, I love this format of tying in the best models as they're released into one central repo where they can all play off each others' strengths.
In web 2.0 everything is done by javascript.
Related: as a troubleshooter, don’t get locked into a theory too quickly. You can easily overlook other information that doesn’t fit.
I think the idea is that the cost of the goods themselves is pointless and we're effectively rationing in a world where there's no need for it. I would much rather pay directly for the logistics in exchange for "take however much you want" and see if we can drive the waste to 0.

If you're just gonna throw em out I'll take a whole sack of potatoes and put them to use.
To be fair, it's almost certainly delivered by a motorcycle.

But that's still hundreds of kilograms.
> But...they have.
How many stories have there been about how GPT-3 and GPT-4 have gotten worse over the period they've been out?

They are experimenting with trade offs. In this case, things like appropriateness, less overconfidence, etc.

That isn’t indicative of any slowdown.

> Sure, people are working on more improvements, but they're not here yet, and while that doesn't mean they will never come, it does mean that, compared to what appeared to be a rapid rush of "AI" progress, things have slowed down.

I don’t follow.

People and teams keep publishing and releasing new techniques but big projects don’t release major updates as quickly.

How are your arguments more relevant to GPT4 than they would have been for GPT3? Earlier models?
Kick: Self-Driving Bookkeeping
What if they are on cellular and that hasn't been upgraded to IPv6?

Years ago I handled fraud cases for an e-commerce site with local police, at some point they started asking for IP and port numbers for the offenders, rather than just the IP. Turns out that one of the cellular phone providers had basically run out of IPv4 addresses for their 4G network and did some NAT solution. If you didn't have the port number the client had connected from then they could only tell you which cell tower had been used, not who the customer was.
Lying about it opens you up to potential litigation and being exposed through discovery. It makes less sense to outwardly lie to paying customers rather than simply lie by omission.
The point is that there is a swath of failure modes that only become apparent when you actually have instrumentation point at them first. QA can’t fish these out.
Interoperability: Swift’s Super Power
He was referring to the use of tear gas in order to disperse crowds (rather than using violence)...that section of the memorandum tends not to be quoted (and Britain only used gases in warfare after Germany began using it indiscriminately in WW1).

It is quite bizarre to imply that pre-colonial India was a haven for human rights but that Britain, the country with the most advanced legal system and which had recognised the notion of human rights nearly 900 years earlier, did not.
An escape character would still be in-band, but in this context any string containing the escape character wouldn't be a valid plate (In New York any non-alphanumeric character except @ and space would work.)
Someone got me excited about tracing and I started tweaking our stats API to optionally add tracing. Retrofitted it into a mature app, then immediately discovered that all of the data was being dropped because AWS only likes very tiny traces. Depth or fanout or both break it rather quickly.

And OpenTelemetry has a very questionable implementation. For a nested trace, events fire when the trace closes, meaning that a parent ID is reported before it is seen in the stream. That can’t be good for processing. Would be better to have a leading edge event (also helps with errors throwing and the parent never being reported).

Kind of a bummer. Needs work.
You may be thinking of the ECMAScript Observable proposal: https://github.com/tc39/proposal-observable
Frenkel on String Theory
Exposing these details allows "zero cost abstractions", which are important for a systems programming language.

https://doc.rust-lang.org/beta/embedded-book/static-guarante...

There are of course ways to get garbage collection, ignore these details, etc. in Rust with use of appropriate abstractions. But Rust may not be the best option for every application.
> I believe it was spitting out perfectly formed zeroes where another digit was in the original. Yikes.

JBIG2 lossy compression. Covered in another hn story: https://news.ycombinator.com/item?id=29223815

From the story and the comments:

> This is not an OCR problem (as we switched off OCR on purpose), it is a lot worse – patches of the pixel data are randomly replaced in a very subtle and dangerous way: The scanned images look correct at first glance, even though numbers may actually be incorrect.

It's lossy compression turned to 11 that looks convincingly non-lossy.
> Far more then a m68k processor running at 20 mhz had any right to feel.

The Amiga 1000 and Amiga 500 ran on a 7.09 (PAL) or 7.16 (NTSC) 68000 starting out with 256 KB (not MB) ram for the 1000, 512 KB for the 500. With this they ran a pre-emptive multitasking single-user OS which was partly ROM-based, partly loaded from floppy. These were responsive systems as long as they did not need to pull data from floppy drives.
AI, unironically.
Maybe you'd like noprocrast mode? Limits use time.

It's in your user config, click your username.
That's literally and precisely what it means.

Perhaps there is some new watered down usage (like what happened to "literally" or "bricked") but that is precisely why people use the term "air-gapped" - to denote networks with PHYSICAL separation from other means of access.

(Of course, if you connect an AP, it's no longer air-gapped."
> Anyway, there's also the looming "threat" (lol) of HTTPS and encrypted DNS proliferation and improvement making the core use case for commercial VPNs obsolete

For a lot of people the core use case is accessing Netflix in a different country!
Bespoke, patient-specific, genomic treatments: they'll ask how deep are your pockets. I am reminded of Lance Armstrong beating cancer.
Exactly - deviate from the established protocol and you open up legal risks, possibly get fired from your practice (since most are big companies now and not individuals or partners), etc.
Same reason grayscale cars are very common: even if a family likes bright colors, they may not like the same bright colors, and may not trust they’ll be able to sell it to someone else later.
Definitely an urban legend at this point. A reddit thread[0] mentions it being collected in 1990 from computer stories going around in the 80s[1]

[0] https://old.reddit.com/r/talesfromtechsupport/comments/5yrs1...

[1] https://www.goodreads.com/book/show/3227607-the-devouring-fu...
Because you have voters in your country which are against that. They may be the minority while voting but they set the agenda.
UMAP is as ubiquitous as T-SNE these days, though to be fair those on HN that focus on JVM, LLVM, NPM, or TLS may not know about UMAP/T-SNE.
To be clear, the GNU+Linux copypasta is not a real quote. Though RMS doesn't fully disagree with the content

https://www.gnu.org/gnu/incorrect-quotation.html
Vanilla accounts for about a quarter of all ice cream sales in the US. Chocolate is a close second but I think vanilla wins as it is also the most common to serve with other desserts. Apple pie a la mode is always with vanilla ice cream for example...
Show HN: Platform to practice job interviews using AI
Fortunately Gokrazy's site (https://gokrazy.org/) explains exactly what it is and what it's for up front: "With gokrazy, you can deploy your Go programs as appliances to a Raspberry Pi or PC (→ supported platforms)."

It's a minimal Linux distribution that contains just the Linux kernel and the bare minimum of userspace (basically just init) needed to run Go programs on Linux. Like Alpine Linux, but just for Go.
Author here: completely agree. I think it is not much of an achievement by itself, but it is interesting to see that it works!

I will add a comment/edit to the post once I am home to clarify the relative ease of solving MNIST
I work on Svelte 5 and I was also a React engineer on the core team previously FWIW.
Personally I have to hide Stack Exchange’s trending questions on my work machine. Those things are catnip to me.

askubuntu.com###hot-network-questions
serverfault.com###hot-network-questions
stackexchange.com###hot-network-questions
stackoverflow.com###hot-network-questions
superuser.com###hot-network-questions

Also many sites disregard prefers-reduced-motion, so I’m often hiding visual distractions like endless carousels and cute decorative animations.
uBlock Origin works on Orion for Mac (running forked WebKit), but does not work on Orion for iOS (because of Apple's limitations on iOS).
Historical: Room 641A at AT&T in the US.