I recently picked up Essentials of Compilation by Jeremy Siek, perhaps his book and lectures will make something click for me.

In the meantime Julia has been my happy medium for a “lisp”.

There are other human benefits to reducing car traffic and use in favor of public transportation: * Reduces air pollution * Noise pollution * Allows a focus on human centric urban planning * Allows for higher density commercial and residential increasing tax revenue * Reduces pedestrian traffic injury

Well done video essays:

Parking minimums https://youtu.be/OUNXFHpUhu8?si=xAxUHCA0xmxCIZWg

Noise pollution https://youtu.be/CTV-wwszGw8?si=Eov6X3Z3I1T0l_bd

Infrastructure strain https://youtu.be/7Nw6qyyrTeI?si=KrVJ3tDaODHNGBwm

More on Infrastructure and Sprawl https://youtu.be/SfsCniN7Nsc?si=0ulEtryX4K6Ysy-N

Articles:

https://climate.mit.edu/explainers/public-transportation#:~:...

https://www.researchgate.net/publication/379358672_Vehicle_n...

https://www.britannica.com/topic/urban-sprawl/Costs-of-urban...

Climate town videos are all well researched and provide an enormous amount of follow-up content from their sources.

Generally, I care about all of the above and I perceive investments in public transportation to have a higher ROI.

Some extra historical context is helpful too: https://youtu.be/oOttvpjJvAo?si=ZGXF81qJnD_Fgw0L

The book The Color of Law by Rothstein is worth a read.

In the end there is a balance between public transportation and car dependency and right now the scales are leaning too much in favor of cars.

People don’t care as long as it tastes good. The current methods we have for farming meat do not scale and we need to work on alternatives. Meat is tasty and people want to eat it.

Innovation will continue in the lab grown meat sector and when it eventually scales it will over take traditional methods. Current factory farming is anything but natural and there is plenty of harm being done.

I do prefer the style of of your components more, where you separate out the script and styles with html tags. I don't know if one way or the other is superior for performance, I but just like the separation verse the templated strings in Lit.

With build tools being so straightforward now-a-days, I struggle to see the value in the build less approach. One use case I can think of is maybe a constrained environment where the application contains some kind of customizable user components fully in the browser like a reporting WYSIWIG of some kind.

Is there a particular reason you prefer this approach?

I find that tools like Mermaid are pretty invaluable, especially when editing very large processes. Draw.io diagrams tend to get pretty unwieldy as they scale and editing inter process stuff if you forgot something quite frustrating.

Sequence diagrams are possibly my favorite feature in Mermaid: https://jessems.com/posts/2023-07-22-the-unreasonable-effect...

Admittedly I primarily use D2 nowadays. The only features I miss in D2 from mermaid are the GitHub automatic rendering and Sequence diagram numbers. https://play.d2lang.com

V lang had a rough launch from what I can tell, with the author overselling and mistakenly underestimating the amount of work needed to fulfill their vision.

V still has a ways to go, but it is in constant heavy development with lots of contributors. It also has a wide gambit of interesting hobby projects using it.

I'd recommend taking a look at the the examples here:https://github.com/vlang/v/tree/master/examples

I think the language has a lot of potential.

Pattern matching has finally made it out of ML land and getting increasingly implemented in mainstream languages. I'm not sure if Rust is the main driver here, but I'm glad to see it.

The recordings are on YouTube with time stamps to each talk.

https://www.youtube.com/live/uzuKqiFVNZM?si=p4GEDK4xanGcw5rJ

The developer experience is very similar to Godot, especially if you work on your scripts with external editors. Everything that has to do with building and running the app is faster than Godot though.

Initial builds with Defold are very fast, it has on demand hotreload, and very small binary sizes. The small binary size makes it well suited for working on web games.

The Godot Editor is still a tad bit nicer to use, but I do like the fact that the Defold editor is written in Clojure. I imagine it makes extending it fairly quick.

The main reason I see myself sticking with Defold over Godot is because scripting is done in Lua.

The Lua ecosystem has a lot history in the game dev space making it easy to search for answers. Lua is trivial to extend and has multiple statically typed options that compile to it. Notable statically typed languages are Typescript and Haxe. Also Lua has a lot practical use in many domains outside of the Defold editor unlike GDScripts lock-in to Godot.

Defold has no where near the size of the community of Godot, but the developers seem very active on the forum and GitHub.

I need to play around with it more before I’m 100% sold. Both Godot and Defold are great looking choices for 2D.

Emmy and Clojure2d have also adopted clerk for their docs with impressive results: https://clojure2d.github.io/clojure2d/docs/notebooks/noteboo...

https://emmy.mentat.org

Orion[1] is another recent MacOS browser that released before Arc in 2021 and has vertical tabs. Edge had vertical tabs as an experiment back in 2020[2] and is full feature now. Vivaldi has had vertical tabs since 2015[3]. It might not count since it's not built in, but Firefox has had vertical tab extensions since 2007[4].

[1]https://browser.kagi.com/

[2] https://www.howtogeek.com/697986/how-to-enable-and-use-verti...

[3]https://www.maketecheasier.com/vertical-tabs-browsers/

[4]https://github.com/piroor/treestyletab/graphs/contributors

In the Netherlands you'll see Bakfiets/cargo bikes. https://www.bakfiets.com/

MicroLED is more akin to OLED where each pixel is self emitting. MicroLED is almost the holy grail of displays and will more than likely obsolete MiniLED.

The nightly builds should probably be promoted to patch releases more often though.

The language is a bit verbose, but I prefer it and generally add type annotations instead of using type inference (unless I’m dealing with a super gnarly generic type).

The language shines in the graphics space since some of the Flash community gravitated to Haxe. I’ve found that it works great as a client/server language similar to a typescript frontend/backend stack. The benefit with Haxe is that the backend isn’t limited to Node, it can run on JVM, bare metal with C++, Openresty with Lua, and anywhere Python runs. It’s pretty easy to implement F# style type providers with the macro system as well.

There is also a C# target, however, there are talks of deprecating. Hopefully we will see a revival with Reflaxe, another way to make new targets, or maybe even a CLR target. https://github.com/RobertBorghese/reflaxe

Lastly, I’m very excited about Ammer the universal FFI for Haxe by Aurel. https://aurel300.github.io/ammer/ My hope is that the community will rally around Ammer and bring in a lot of native libraries to all targets.