nateroling

I really love the ideas here.

I also wonder if this kind of workplace is a myth. Maybe every business really is a disaster if you look close enough. Or maybe it does happen, once in a while, where a company really hits their stride, but it’s essentially random when they do.

Or, maybe I’ve just been working in disasters too long and I’m cynical, hard to say.

No, I think I he’s saying that we have that, and we should use it more.

AlphaGo uses discovery when it evaluates potential moves and iterates.

Claude Code uses discovery when it generates a script and the evaluates whether it works or not.

He’s saying we need to allow ai systems to do the evaluation and iteration themselves for science and engineering the same way we do for code.

Basically, harness engineering for engineering.

I tend to agree. After seeing http://chatjimmy.ai, I think multi-agent systems are mostly just solving for LLMs being slow currently.

I’ve bounced off of LazyGit multiple times because I never figured out how to make it play nice with a light theme terminal.

I haven’t used dark mode anything for years. I set my monitor so it’s roughly as bright, or slightly brighter than, a piece of white paper.

No more flash-bangs when some website doesn’t support dark mode.

Instantly crushed that there doesn’t appear to be a phone app for this.

This is on the cluster level, while the article is talking about the database level, I believe.

I mean that when a computer can visually understand a document and reformat and reinterpret it in any imaginable way, who cares how it’s stored? When a png or a pdf or a markdown doc can all be be read and reinterpreted into an infographic or a database or an audiobook or an interactive infographic the original format won’t matter.

Seeing the Gemini 3 capabilities, I can imagine a near future where file formats are effectively irrelevant.

This made me do a double-take. Surely you would never do this, right? It seems to be directly counter to the idea of being able to audit changes:

“Event replay: if we want to adjust a past event, for example because it was incorrect, we can just do that and rebuild the app state.”

Can you write a prompt to optimize prompts?

Seems like an LLM should be able to judge a prompt, and collaboratively work with the user to improve it if necessary.

This, but for many things.

Paint is ready at the hardware store Table is ready at the restaurant Construction is done on a bridge

All kinds of things that we need a one-time notification for.

Looking at the trees in the background of the first photo, it’s clear he’s using a longer focal length on the non-iPhone.

He has some good points, maybe, but in general it’s a pretty naive comparison.

I don’t think control center actually uses the liquid glass elements. They don’t respond to accessibility options like reduce transparency, for one thing.

Fine-grained reactivity (ie Knockout) was a thing well before React. If anything, React was a response to the deficiencies of fine-grained reactivity.

I’ve done the same with SQLAlchemy in Python and SQLKata in C#.

Sadly the whole idea of composable query builders seems to have fallen out of fashion.

I had the same thought, but it sounds like this operates at a much lower level than that kind of thing:

> Then, a physics-based neural network was used to process the images captured by the meta-optics camera. Because the neural network was trained on metasurface physics, it can remove aberrations produced by the camera.

More than any other Nikon flagship. Title had me thinking they outsold Canon and Sony.

Software calendars are so poor compared to this. There’s no concept of importance, of impact, of life. Just times and titles, every one equivalent. Digital calendars have hardly evolved since the palm pilot.

Imagine if apps just… worked like this, somehow. Start off with a realtime visualization and point and click commands, and as you learn them you can evolve into a straight CLI…

Explaining that semi-obscure reference: Barry Lyndon is a Kubrick film that famously has shots lit by only candlelight. This was accomplished by using extremely ”fast” lenses created by NASA for (I believe) the Apollo missions.

Absolutely is is. But the tool itself is a medium for that communication. What is Figma for, if not communicating design decisions?

The problem with these kind of pixel-perfect, inspectable design tools, is that there's no distinction between important details and unimportant details.

For example, if our app uses a letter-spacing of 1.2 for all the body text, and your Figma design uses a letter-spacing of 1.25, is that important? Or is that a mistake?

In something like Figma, being consistent is difficult for designers. But in code, being consistent is the default — exceptions are hard for developers!

There's a fundamental mismatch that just ends up being painful all around.

"The map is not the territory." Trying to get a design doc to 100% accuracy is often a waste of time. Design tools need a way to specify which details are important, and which are not.

Would this be a usable alternative to Plex’s Watch Together? Could I host a live stream of a movie and have friends watch it in sync?

Not op, but experience mostly.

Shooting jpeg and using the out of camera images is a different workflow from shooting raw and fiddling with them in post.

I have a custom theme that's pretty minimal, because I find lots of colors distracting.

Colors are vaguely based it on pen on paper:

       white: background
   dark blue: foreground
  light gray: brackets and commas and stuff
         red: literals (strings, numbers, true/false)
       black: comments

This means comments and literals stand out, which are usually the things I don't want to miss when I'm reading through code.

Maybe I’m thick, but I don’t see what makes this (or solid, or svelte) different from Knockout or RxJS. Does this somehow avoid the tangled dependency chains and complex push-based reactivity issues that I deal with in RxJS/Angular?

To me the brilliance of React is the VDOM, which allows you to treat your components like a render loop in a game.

What’s the piece that I’m missing that separates Signals from RxJS observables?