pornel

Toyota wants to show nobody wants EVs by making EVs nobody wants.

ESP32 boards are small and cheap adapters between Wifi (network APIs) and I/O pins for small electronics like LEDs and relays.

If you want a web API for something in the physical world, make ESP32 do it.

Charging at home is already more convenient and quicker (in human time) than driving to a gas station, and now they're optimizing the 30 seconds it takes to plug the car in.

This dreaming about roundabouts is as American as the fantasies about using metric one day.

or perhaps The Proper English has been adopted by LLMs, so now real people have to write like middle-schoolers to avoid being accused of publishing slop.

The big news here is they've replaced LLVM with MSVC's backend.

Throwing it as-is into a simple bayesian filter works great too - nobody honest writes fun&zwsp;ding.

Stellantis is still producing 400V EVs with below-average efficiency. Their cars display estimated range based on their marketing number rather than real battery condition and driving history, so the range drops by 1.6 miles for every mile driven.

A lot of range anxiety would go away if their EV tech wasn't crap.

> I fail to see how any sort of much lower level access to the machine would be portable across price ranges and microarchitecture generations

That's the assumption that can be removed. GPUs don't have stable ISAs, and their assembly-like code gets recompiled for each microarchitecture.

In the Intel's world of prebaked machine code adoption of a wider set of SIMD instructions takes a decade+. In GPUs it's just a driver update.

Modern CPUs hide so much logic that the assembly language is an abstraction itself. CPUs have many times more registers than their assembly language, execute instructions speculatively and out of order. Multiple layers of caches are synchronized in complex ways. There's an invisible complex work scheduling algorithm that can even make one CPU core interleave work of two (hyperthreading).

GPUs can expose more of their internals thanks to shader compilation. They don't have to emulate previous-gen chip, and instead every chip can expose exactly what it supports and rely on software being recompiled for it.

Apple would have probably lost more customers if it didn't also create a hard-to-leave lock-in ecosystem.

Lots of people use old iPhones and don't care about some "up to" benchmark bumped every year, but are stuck with iMessage contacts, their stuff in iCloud, Apple Watch or apps that are not allowed by Apple to even mention they have Android versions.

BTW, Rust's lifetime annotations for borrowed references are a mostly orthogonal feature.

Liveness of objects for move/drop semantics is tracked differently, without any syntax and with implicit runtime drop flags where necessary.

C++ could probably add the same deinitialized/moved-from state tracking (with an opt-in for back compat sake) purely to avoid dtor bloat, without having to add safety of borrow checking.

Not enough for coding. 48GB is minimum for a non-lobotomized coding model like qwen, and you'd likely want 64GB to have long context and not kernel panic when Chrome opens.

You could run one of the smaller Gemma models to have a chatty Wikipedia.

There doesn't have to be any meaningful analogy here. Laws don't have to treat humans and machines equally. Laws are for people and allow things that are less than ideal, but necessary for people to function.

Humans can't leave their old brains at their previous employer, can't delete their experience learned on proprietary data. It wouldn't make sense for the law to fight this.

But the law can control what can be done with information stored outside of your brain.

Unpleasant for interactive agentic work. Still useful to leave it to do some work in the background.

The bug here is not related to virtualization, but a footgun as old as C stdlib: system() that doesn't take arguments separately, and instead relies on shell escaping by the application.

Opus is good at deciding what to do beyond literal interpretation of the prompt (like checking assumptions before coding). Smaller models need to be told not only what to do, but how to behave.

oh-my-pi's Advisor feature can fill a lot of this gap (a smaller model told to reflect on its own output catches when it's doing a rush job and skips instructions).

Because the other non-isolationist countries have the rest of the world to trade with. Their tariffs on USA don't make all of their imports more expensive, only redirect trade to other countries.

You should be able to cancel it for free.

In EU you also have 14 days to return products bought online, for any reason.

You can take a working codebase, tell a shitty LLM to rewrite it badly, then swap it around to look like LLM-to-working code rewrite.

You can't enforce those licenses against AI-generated parts, because enforcement relies on the recipient having no other way to avoid copyright infringement.

However, there's no issue with including non-copyrightable code in otherwise copyrighted projects. There's already plenty of non-copyrightable code like auto-generated boilerplate.

Note that an incremental language improvement doesn't mean a small code change. For example, C++'s iterator with two related but technically independent pointers is a PITA for alias analysis, which is a problem not only for Circle/Safe C++ but for WG21 Profiles too (https://www.circle-lang.org/draft-profiles.html). An incremental language change would be to adopt a Rust-like iterator. That would be a small language change, but a migration away from begin/end would be a massive churn for C++ codebases that sounds more ridiculous than rewriting in Rust.

Bjarne still sees C++'s safety problem as lack of adoption of Modern C++. WG21 is catering to C++ users who will not make such changes.

WG21 has firmly rejected everything resembling Rust's borrow checking (a solution that now has a decade of proven track record, and has been demonstrated to be possible in C++ via Circle/Safe C++). Addition of "pervasive annotations" is so unacceptable to WG21's view of C++ that they're still insisting on Profiles.

1. In "verifiable" domains ML is not limited by training data any more. Models can help generate the training data and/or learn the objective through reinforcement learning.

2. Yes, because the most capable model is the only one that can charge a premium. The rest is a commodity.

I expect this to be automated too, and in the end boil down to paying for more tokens to fix the program.

Code too messy to be editable by an LLM is already too horrible for humans to touch. Fixing vibecoded software as a service will boil down to reverse-engineering requirements from the messed up program, and prompting a better model to design it properly and rewrite.

Eventually models will be trained to do this themselves, so it won't be a service you ask a dev for, it will be an extra charge on your AI subscription.

They use technical means to create lock-in that prevents me from NOT using these services.

Apple actively prevents users from installing any other OS on an iPhone. Apple actively prevents uses from finding and installing apps through other means.

I'd be okay paying App Store fees when I had a choice, and decided that it's the best source of apps, worth the cost. But because I'm forced to pay for a service I didn't ask for, fuck Apple.

(and the mobile duopoly, ecosystem lock-ins, and barriers to entry mean I can't really refuse this shit, I can only choose one of two flavors of this shit).

> But the major players do seem to be happy to replace their C++ code with Rust.

Because incremental improvements don't provide enough value. A stable C++ codebase is best left untouched. It's not worth to rewrite C++ into C++++ to get a couple of features that are flawed retrofits backported from modern languages. In the end you still have C++.

> Aliexpress

There are even cheaper ways of starting a fire.

Instead of prompting "Summarize: $SESSION" you submit "$SESSION Summarize what has been done so far".

This way you have a prefix cache hit on the session and don't pay any more than for a regular prompt.

There is a solution that Mozilla uses in prod for legacy C codecs:

https://rlbox.dev/

It's not a replacement for Fil-C's role as a precise ASAN/Valgrind, but it works great if you want to call a C library without letting it freely spray caller's memory.

I don't like that it throws away the whole KV cache when compacting. It costs a cache miss of the whole conversation length, and that's a waste of time and money.

LLMs are perfectly capable of summarising the conversation without a new system prompt.