psytrx

This is what annoys me the most when developing web components. You never know which context your component might be used in, and your <hX> element might be just plain wrong.

I prefer not using them and fall back to using <header> elements inside sections, but styling them globally makes it rather difficult and ugly to work with. What's other people's solution to this? Or am I just picky when it comes to semantics?

I'm wearing mine for a few weeks now, but it's been rather unstable for me. BTLE disconnects are common, and I'm not sure what the source of the problem might be. Also, it sometimes freezes in an infinite loop and drains battery really quickly when that happens.

These are all problems fixable with software updates, and it's very early stages of the project. The app store grew from 80 to 130 apps in the last 3 weeks.

The hardware on the other hand is great. It doesn't feel cheap, but it's really lightweight, which I enjoy. The e-ink display is crisp and clear, easily readable in direct sunlight, and it has 8 colors, which is a cool feature for an e-ink display.

Didn't get my hands dirty with the SDK yet, but will hopefully find some time during the holidays. It looks well thought out though, and the web IDE and emulator seem useful.

Really looking forward to dig into it.

I love flow fields. They are simple, yet elegant and efficient. They are flexible, which Tyler Hobbs shows very nicely in the linked article.

A few months ago I stumbled over that article, and it made me instantly want to try them out. Here's an experiment I made for my website (WIP):

https://preview.fdumont.net/generative/flow-field

For me, there is no single go-to project that fits all languages. Each language has it's own purpose.

Go and Rust are fairly similar in terms of parallelization and performance. Both are general purpose languages and are great at solving system problems. Choosing a toy project that requires these perks will yield the most satisfying results and enables you to get a good grasp of why those languages exist, and where their differences are.

Both languages empower you to build inter-system applications, both languages are highly performant and both let you build safe and tested programs. A distributed ray tracing engine comes to my mind - it would allow you to let both languages collaborate, compare solutions to problems between the languages and get into the nitty gritty details of memory management, allocations, garbage collection etc.

This would probably be my pick, because you can build and improve it for years if you really want to put the effort in it.

Here's a great primer on that topic - it's still actively developed and made me look at modern ray tracing technology in awe.

https://raytracing.github.io/