torginus

I guess the others have made these points, but since unikernels run in VMs with virtual hardware, I guess a virtual ethernet card can have an interface that's easy to program for, making the driver trivial. You're not talking to real hardware in any case.

Similarly, a filesystem's just a data structure that happens to be on disc. You can mmap your harddrive and let the host hypervisor handle swap, preemption etc.

It's similar to a process contract, but with slightly different boundaries

Personally speaking, I started my programming journey a long time ago, building stuff for DOS - one of the first-ish things I did was build a Windows-like GUI interface, which was quite functional given the circumstances, basically writing pixel colors to the framebuffer in C.

The whole thing was quite functional, and a few thousand lines total, and built a bit naively - the framework and the app were under 10k lines combined total.

Later I tried rebuilding it for Win32, and it ended up being more code (sans bespoke UI framework), and I'm not sure it was better, though I'm certain, the whole mass of code doing the thing was an order of magnitude more.

If I were to attempt building it in Electron, I could add 2-3 orders of magnitude to that easy, all for the same basic functionality.

All I'm saying is abstraction isn't really what it's cracked up to be.

The problem with OS level sandboxes, and the reason why WebAssembly's being explored in this space (and Electron is so popular), is that relying on OS/hardware features means your TAM shrinks to a fraction of total, and it's historically well known you set yourself up to lose.

History is littered with tons of super cool OS features that didn't manage to gather enough market share and ended up as cool futures, and fodder for 'we invented the future 20 years ago' style articles.

Yeah, I have similar thoughts. If SpaceX's IPO has been a dumpster fire, and share price dropped to the third of its initial value, it would still have been massively overvalued, and made Musk much richer than if they went with a more realistic market cap, and let the market carry them upwards.

Isn't the 'we need gradients' a foregone conclusion?

Gradients can be calculated numerically, meaning that any method that samples the cost function and makes optimization decisions based on that can actually compute gradients if it needs to.

I have them and don't really like them (I assume you mean the Thread ones). Battery life is mediocre, worse than coin cell operated Sonoff Zigbee one I have, accuracy is good, but you can't set update rate or threshold or any generally advanced feature.

Sometimes they either stop updating or drop off the network permanently.

I wouldn't really trust them for anything even remotely important.

Shame since they're pretty cheap, perhaps they'll fix the firmware and then they'll be excellent.

In this case they literally are - if you broadcast in the 5G spectrum, you better have your devices certified, otherwise the local broadcasting authority (which would be the FCC in the US) will ruin your day.

My guess would be that big German companies like to sell and insure their industrial equipment wholesale. For example, if you buy stuff from Siemens, everything in the factory must be as per how the applications engineer described it - which is to mean you have to buy everything from them and set it up exactly as they want - otherwise there goes your insurance/warranty.

This isn't exactly cheap, it's worth it for the big players, but needless to say, I'm not exactly enamored with the practice.

I think LLMs are going to be (are) excellent at skirting IP law - 'make me something that does the exact same thing, but is sufficiently different that it can be considered novel'

I don't understand how standards are allowed to be patent encumbered - I get it they aren't really, but more often than not (like with the Oracle vs Google Java lawsuit) there's just one possible and obvious way to implement patents thats both efficient and correct.

For example in telco, error correcting codes are often designed in a way, that there's an algorithm that can turn the logic into a netlist.

yeah this makes no sense to me. Why would Rust limit the LLVM backend's ability to generate code for a particular platform?

Yeah and cars are expensive, in real estate as well. A car needs like 20m2 minimum for a parking spot and the bit of road to get to it, if you build something like a garage. That m2 isn't really cheaper than living space, and that's half the size of a small apartment.

So most places either build less dense, or accept that wherever you go, there might not be parking spaces nearby. Which if you have public transport, often means its easier to park in some low cost P+R and take the subway.

I'm fairly convinced its within the means of almost every human (say like 5 of the 8 billion people) to drive a car. That includes people in African countries with like $1000 GDP per capita. Sure it will be genuniely awful, 30+ years old, held together by duct tape, society might want to stop you from owning something so horrible, or make it not worth it, but the economic bar for something that drives is so low, that people will scrap working or easy to fix cars.

SF also stands for 'Speculative Fiction' - which takes an unusualy premise or assumption, and prods and pokes int and tries to get some interesting thinking and an enjoyable, suprising story out of it.

Blindsight is literally:

We went to the macguffin in a spaceship, and a bunch of unrelated stuff happened along the way, then when opening up the macguffin like a fortune cookie, "big idea" was written on a slip of paper inside, and we had our minds blown. The end.

Yes finally. While I fully accept the possibility Im just too thick to get it, I never understood the hype. I found it a slog to get through, despite it not being too thick.

It's one of those 'they showed the plot in the trailer' but for books instead of movies. It barely elaborates on the central idea, which it basically withholds as the 'big reveal'. Which works about as well as the Star Wars prequels did with the revelation that Palpatine was evil all along.

The characters are deliberately written to be as unrelatable as possible, yet its full of boring character drama between these dysfunctional people. It fails as 'big idea' scifi, and fails as an actual enjoyable book.

Yes, but they are not able to act on their decisions, or ask for elaboration.

Maybe someone did order those enlargement pills, and an agentic model would be able to scan email history and determine that, when classifying an email as spam.

Cool. So this should be a bug ticket, not irrefutable proof that GCs suck :D

Please read the article. The issue was caused by swapped out metadata being read in a critical section, not typical heap traversal shenanigans.

This is not exclusive to GC, any program that reads a rarely accessed piece of memory is vulnerable to this.

The issue described in the article isn't really GC specific. The Go GC has a critical section that reads metadata.

Any program that has a rarely accessed, but vital chunk of memory is vulnerable to this sort of issue.

Modern OSes need a facility to signal to a thread that it hit a paged out chunk of memory. It's not like it's not possible to create a swap-aware GC (or any other kind of code that touches lots of memory).

I would go further - I think the whole swap lifecycle needs to be communicated. Before the OS swaps out a page, if it could invoke the GC which would clean up that piece of memory so that we dont end up writing garbage to swap.

The OS should also allow marking pages as piority to stop them from being swapped out.

I don't. High speed rail is everywhere in Europe and connects cities with a populations of a few hundred k to maybe a low million.

These mid sized cities are usually along the rail lines, like beads on a string.

Whereas these megacities are built densely and usually have radial transport networks which require insane levels of urban planning and are difficult to navigate in the best of cases.

EGLStreams actually was(is) a pretty good API, and I think most compositors would've had a much better time if they decided to implement that on top of GBM.

To summarize the difference between the two, with EGLStreams, you just request a buffer to draw into from a pool, then once you're done, you just submit it, thereby relinquishing control of it.

With GBM, you explicitly need to manage the lifetime and access of your buffers, making sure you don't leak or accidentally write it when the GPU/driver tries to, there's no clear ownership, and you have to handle surfaces for double/triple buffering.

It's a much lower level API, and much harder for drivers and app developers to get right, which was no doubt responsible for many years of buggy Wayland compositors - in fact, basically there wasn't a single correct implementation until Valve built Gamescope/their wlroots-based KWin fork and did a bunch of driver work.

As they say, there are people whose hobby is 'cars' and there are ones whose is 'driving cars'

Not just for security - generally speaking if you have high speed rail infrastructure connected to a good and fast public transport grid, there's genuinely no reason to build a huge city.

High density housing is very slow to traverse and getting from point A to B in a big city might take more time than getting on a train that takes you to another city 200km away in 30 min. In a traffic jam, you'll be lucky to do 5km in the same time.

I think the ability to retrieve and display data in <20ms, thereby leading to interactions that are instant is still an open and underexplored UX issue.

What if you could just hover a link and all the important data would just appear?

What if you started typing a command in console, and the execution results would appear speculatively as soon as you hit the key?

Some programs do this to some limited degree, but besides the humble textbox and outside videogames, instant interactivity is seldom seen.

hasn't IP law passed the statute of limitations? As in most models are probably trained on output of other models, as creating enough data otherwise is not feasible. Additionally, they are trained on github repos made since the AI boom, which were generated by models with IP issues (who knows what and how).

Thus training on 'clean' data is like trying to unscramble an egg.

I think we have seen this sort of 'process' before, with the introduction of GPU acceleration and fast animation on UIs. It played out like this:

1. Software is fast and UI is instant, things happen instantly

2. UI is instant and software is slow - UI will lag

3. UI is animated with transitions and sofware is slow - people are initially happy, but it wears off in weeks

4. Software gets optimized, now UI animations take longer than getting the underlying data

5. The logical endpoint. Software is fast. UI needs to be instant Remove all animation and let UI render instantly; This is what most users actually prefer.

The parallel with LLM websites is direct imo. We're now getting these fancy websites, but once the magic wears off, everyone will go back to the 'text and links on page' style.

While HTML4 geocities style website have a soft stop in my heart, this page absolutely feels like it was made by an LLM which makes it ironic in a way it was never intended to be I assume.

I'm not sure, water is very good at conducting shockwaves. If you had an aquarium the size of an olympic swimming pool you could kill all of them by dropping a hand grenade in it.

I wish I was arrogant. Or alternatively I wish I was surrounded by arrogant coworkers who at least took some pride in the quality and quantity of their work.

Not saying everyone is like this, but plenty enough are.

But hey, at least folks unburdened by the pressure to ship anything have plenty of time to play office politics.