krebby

I'm working on an open source tool called noodles.gl that uses this library and it's been great. The devs have been good about keeping a cadence of solid changes and keeping the community updated, and overall I'm happy to have bet on this library years ago.

I love the flexibility and the fact that there's a variety of examples for basically anything I want to accomplish with it. Great work to the team.

https://noodles.gl

Such a sweet story! My friend actually went to the author's Borg party a few weeks ago and I'm second-guessing my choices that night after reading this. Funny to see it on Hacker News!

If you guys like reading about this kind of thing I recommend Cocktail Codex from the people behind Death & Co (referenced in the article). It's a great way to think about cocktails as a remixable grammar and the purpose behind all the mixing, muddling, and stirring.

Grasshopper for Rhino is a big one, or VisualCAD/CAM. Blender, Houdini, or Unreal Blueprints are others. It gives you the exploration benefits of a UI plus the procedural benefits of code. Inputs tend to be auto-bound which makes exploration much, much faster.

I'm working on one for web map data visualization: https://youtu.be/GJ0ftFB8r4I?t=871

How about a visual programming language? Plenty of 3D and CAD software uses a VPL for procedural design, which helps a ton to bring out the benefits of both

I think this is referring to the fact that React uses synthetic event listeners - it's cheaper to bind an event listener once at the root and do your own element matching than it is to continuously bind and unbind listeners.

https://react.dev/reference/react-dom/components/common#reac...

IMO it's simple enough to just write directly without library code.

For most cases, the Element Capture or Region Capture API should be sufficient: https://developer.mozilla.org/en-US/docs/Web/API/Screen_Capt...

Demos: https://mdn.github.io/dom-examples/screen-capture-api/elemen... https://mdn.github.io/dom-examples/screen-capture-api/region...

If you need cross-browser compatibility (and can't just use a canvas) then yeah html2canvas is the way to go

What were your needs that the API didn't meet?

How does this compare to something like the the Media Capture API? Looks like this uses `canvas.toDataURL()` which can be slow to serialize compared to `toBlob` or `canvas.captureStream(0).getVideoTracks()`

I've been using CropTarget.fromElement with a CaptureController: https://gist.github.com/akre54/e93ab2ce27999aecb109e38085f2e...

Getting better!

https://simonwillison.net/2024/Oct/25/pelicans-on-a-bicycle/

Trunk

Some really nice example visualizations from Matt Yarri and Julia Lynn at the MTA: https://www.linkedin.com/posts/matt-yarri_some-of-the-data-w...

https://new.mta.info/article/introducing-subway-origin-desti...

They write these emails knowing that they'll be public record at some point. The audience is as much internal as it is for the history books. The details get hashed out offline, while the record gets preserved as an email

For anything more advanced than a simple easing function or some basic keyframes on one or two channels you'll quickly run into the limitations of this approach.

I've been using Theatre.js the last few years and really loving it. It's a library divided into two parts; one is a studio UI with a timeline for editing keyframes and bezier curves, and the other is a runtime for taking those keyframes and interpolating values in relation to a timeline. Try it for anything that requires coordinated animations.

https://www.theatrejs.com/

Another good option is Neptyne. Integrates with Google Sheets (provided you're comfortable storing your data there)

This would be fun to use with Chernoff Faces https://en.m.wikipedia.org/wiki/Chernoff_face

The reference video (https://youtu.be/Zqw4-1LcfWg) says they use a NeRF / structure from motion and then create a mesh with marching cubes from the generated radiance field. This is how most soa text-to-object generators work now as well

I think we're broadly in agreement but I'm responding to the bit about "What will happen to the 5% profit margin business? Do you think customers will keep rewarding them?".

If you only ever reward investments with high rates of return it leads to atrophy in boring yet essential sectors of the market. Supermarkets, like you mentioned, have a very low profit margin (usually 1-3%). Can you imagine what would happen if no one was willing to invest in a supermarket?

The issue is that this leads into Dutch Disease. When a single tulip bulb can buy you a house, why bother becoming a carpenter? Society needs carpenters way more than it needs tulip growers.

That 10% growth rate may or may not be factoring in some externalities that the 5% growth has to

The Corridor Crew just did a good legal analysis on this a couple weeks ago: https://www.youtube.com/watch?v=u2dIvUAd5QE&t=533s

Basically the Disney brand has gotten so huge and diversified that a public domain Mickey isn't an existential threat to their business anymore. Terrifying in its own right, but at least we might see an end to the endless copyright extension. Interesting times ahead!

Yes, they're essentially optimizing for separate things: https://mattdesl.svbtle.com/drawing-lines-is-hard

SVG naturally spends a lot of time and resources tessellating paths into triangle strips, which requires mitering and sorting and other not easily parallelizable (read: slow for GPU) algorithms.

This looks great! I love how intuitive the editor is.

For those who need a bit more advanced timeline, check out Theatre.js. Nice to see more motion on the web platform!

Yeah unfortunately differentiable SVG rendering is still something that is very difficult to accomplish with diffusion models. I looked into this last year and found VectorFusion [0][1], which appears to be using a similar technique to this app - generate the raster image and then apply a vectorization tracer. This leads to the blobbiness you see, given the way the diffusion model generates the image and the tracer applies to the output.

There have been a few attempts (i.e. this recent one [2][3]) to attempt to fine-tune the parameters of the SVG with image segmentation, before comparing rendered outputs with a CLIP model. This is promising but the search space for vector images is just so huge that so far you really need to start with an existing image as a basis rather than starting from scratch. Interesting area of research!

0. https://ajayj.com/vectorfusion/ 1. https://arxiv.org/abs/2211.11319 2. https://intchous.github.io/SVGCustomization/ 3. https://arxiv.org/abs/2309.12302

Encoding alpha, please! https://github.com/w3c/webcodecs/issues/672

Thanks for the great work on WebCodecs!

And a great Hipster Hitler T-shirt http://hipsterhitler.com/comics/19_eastern_front.jpg

What's "lower level" in this context? And why shouldn't we assume that assembly language or even circuit design will also be affected by describing in natural language?

We've heard variations on this argument for decades and I see no difference why LLMs, despite their immense capabilities, will be massively different. They still take guidance and produce garbage output which requires knowledge and expertise to turn into a cohesive product. Will they replace some script writing, or some business logic translation? Of course. But so did SQL, no-code, and plain-English testing frameworks. LLMs are an incredibly powerful tool but they're not a silver bullet.

Great post. I really like the idea of explicitly enumerating all state possibilities for a correctness guarantee. This seems spot on for how I want to think about distributed systems.

Am I right in assuming this solution is somewhere in between distributed tracing and Workflow definition, like event based programming, but the possible states are always strongly typed / defined?

I've also been thinking a lot about node-based programming, in a creative context. One piece I keep coming back to is that node trees are really helpful when the logic is straightforward, but can be a bit visually overwhelming for first timers when the logic is nontrivial or it generates complex artifacts as an output. Does State Backed support grouping nodes, a la Blender or Houdini? Or how do you think about information hiding for this type of thing? Looks like right now the nodes represent functions, so you don't have to think about what sendWelcomeEmail does, eg. How do you think about representing the state within that logic then?

You can often find a camera attached to a motion controlled robot arm on the red carpet these days, going back a few years now: https://petapixel.com/2019/02/28/this-robot-shoots-stunning-...

The entertainment new channel E! Is well established in this space. I have to wonder at what point a low cost arm is cheaper than an array of cameras.

If no one steps up to challenge Waymo in this space in a reasonable timeframe, Waymo wins. If they do, Uber wins.

Uber's play is as a platform. They win if there are several SDC providers (with working autonomy). As an analogy, they're Android; they want to own the network and have multiple operators plug into the Uber app, while the hardware makers don't want to do the work to spin up an expensive 2-way marketplace. Waymo is playing at the iPhone game. They want to be the biggest market operator, and can get away with not owning the top of the funnel for the time being. If other operators fall far behind in progress, Waymo will spin up the investment to vertically integrate and try to siphon Uber customers off that way.

I think you're underplaying the difficulty of what Uber has built. Uber is an operations-heavy business. Determining pricing strategies, handling incidents, and working with local governments is at the core of its service. Google has traditionally shied away from businesses that require big operational investments in real-world assets the way that, say, Amazon or Airbnb have. These take time to build properly, and is a big piece of the puzzle that I can't see Waymo wanting to take on. It makes sense for them to want to partner, especially now that Uber has spun out Aurora.