fiddlerwoaroof

And, escape analysis and "dynamic extent" hints can have similar effects by stack-allocating intermediate values. Also, you can design your transformations to compose before handing off to a result builder, which is how modern Clojure reduces this problem.

Yeah, immutable collections have to use structure-sharing to be implemented efficiently and this frequently results in common operations allocating lots of small objects rather than updating some object in-place.

If you could add some sort of hint to the object pool instance that it should always be in the new generation, then you wouldn’t have this problem. This could probably be provided generically as a class named something like NurseryCollection.

However, I thought the people that really were serious about performance would allocate the pool in memory the GC doesn’t control (back in the day using internal APIs, but I think there are new official APIs for this) such that the object pool and every object in it would just be ignored by the GC.

I haven’t tried Ada recently, but the issue I always have run into is setting up a toolchain that wouldn’t automatically force the binaries I compile to be GPLed. Is the story for writing and distributing MIT or Apache2 licensed software in Ada any better these days?

I use a single large screen (55”) but I keep my MacBook open so I can send things like my music player there where I can glance at them.

It can do anything you can do over SSH

Well, if you control DNS, couldn’t you just block the key records?

Is there a way to force SNI by blocking ECH requests?

This sounds like an integration issue: systems like LaunchDarkly typically allow you to specify a default value for when the feature flag server can’t be reached.

The other thing Gmail does is ignore `.` in the local part. So, one other trick would be to use particular dot patterns for specific accounts.

I’ve been working with Common Lisp for about ten years now and I’ve never found that this criticism matches the reality of working on lisp codebases.

Delta Lake now has Hilbert-curve based clustering which solves a lot of the downsides of hive partitioning

As far as CO2 is concerned, wouldn’t burning “yard waste” be neutral year over year? If you’re only burning this year’s growth, you can’t release any more carbon than the plants took in to grow in the first place. The wildfires might not be neutral because our forests are overgrown, but if they happened more frequently and only burned a years worth of undergrowth, they would be

No, the claim is just that it’s harder to read and verify existing code than to write new code. Depending on the level of certainty you want, verifying code is much more expensive than writing code, which is why there are so many bugs and why PR review is, imo, practically worthless.

Switching the job of programming from designing and writing code to reading and verifying code isn’t a good trade-off in terms of making programming easier. And my first speei node with AI tools has done nothing to change my mind on this point.

Verifying code is much more mental effort than writing it because you have to reconstruct the data structure and the logic of the code in order to show that the code you’re reading is correct.

> You get the LLM to draft some code for you that’s 80% complete/correct.

> You tweak the last 20% by hand.

> How much of a productivity increase is that? Well jeepers, if you’re only doing 1/5th the work, then you are… punches buttons on calculator watch… five times as productive

Except, it’s probably four times as hard to verify the 80% right code as it is to just write the code yourself in the first place.

Imo, the only solution is to avoid boilerplate generators and the parent poms projects like spring boot use for things like pom files: you can look at the boilerplate to get ideas for what might be necessary, but, if you’re starting a project, write the pom yourself. It’s a pain the first couple times, but it gets easier to know what you need.

I think it’s pretty different when it’s going to a trillion-dollar company than when it’s the main source of money for a foundation.

WebKit is funded by Apple, not Google anymore as far as I know

I love the Apple Music app too but the trick is to mainly use the songs tab and playlists and enable the column browser. Also, of the current widely-used options, Apple Music is second to none at this point: old apps like Amarok were nicer but they practically don’t exist anymore. Spotify, Tidal, Qobuz, etc. are all much more annoying than Apple Music (in part because they are Electron Apps).

I would much rather have different connectors for different underlying protocols: HDMI and USB-C are both really annoying in that the cable can silently be the limiting factor.

Lightning was a superior plug to USB-C and I, for one, am annoyed that Apple is dropping it.

USB-C is a horrible standard to consolidate on because of all the confusion about various sorts of USB-C cables (with exactly the same physical connectors) and thunderbolt cables.

Similarly, I’m glad Tesla convinced all the other American manufacturers to go with NACS for the American market because the CCS plugs are monstrosities.

Not writing the same thing over and over again is a feature of abstraction. A framework is a user-hostile way to abstract because it makes the source code opaque to developers. There's no reason why a library-based approach has to be more repetitive than frameworks.

Yes, the problem is exactly that the framework calls your code instead of being called by you code.

I've had to maintain a couple Spring Boot apps and I absolutely cannot stand them: they pull in a whole pile of random dependencies and do weird things to your build with little explanation. Then, all the functionality involves a ton of classpath scanning and annotation-based DI that makes it hard to figure out how all the things fit together.

I think the NHTSA just approved these, so hopefully they’ll start being more common

https://www.nhtsa.gov/press-releases/nhtsa-allow-adaptive-dr...

Other work on integrating APL and lisp is here: https://github.com/phantomics/april

That basically works today, my point is that there was a step change in ability over the last year or two compared to when I got my car.

Clojure has it for a large percentage of functionality: things like https://github.com/clojure-emacs/cider depend on it. However, this mostly stays in dev-time and isn't used much for releases. Which I find a bit funny because Clojure's functional, data-driven philosophy is great for enabling painless hot-code updates