Espruino VS v8.dev

Espruino

The Bangle.js 2 is an excellent device. As a former Pebble user, this is the first device that I consider an adequate replacement for my Pebble (which by now has a diminished battery life and corroded charging contacts).

Here is my impression of the Bangle.js 2:

- Battery: Lasts about 3 weeks on a charge, constantly connected to my phone, when the watch is used to display notifications and alarms. This is a major advantage over Apple Watches and Android/Wear OS watches.

- Display and buttons: The 1.3" 8-color transflective display is comparable to the Pebble Time series' 64-color transflective display. The display is always on, and the backlight activation is highly configurable. The Bangle.js 2 has a touchscreen and 1 button, while Pebble watches have no touchscreen and 3 buttons.

- Software: Runs on the completely free and open source Espruino JavaScript interpreter,[1] which was my main motivation for purchasing this device. There are currently 336 apps in the web-based Bangle.js app loader (app store), including utilites and clocks (watch faces), all of which are FOSS. The bootloader and firmware can be updated directly from the app loader. On Android, there is a distribution of Gadgetbridge (built from the same code base as Gadgetbridge) with internet access enabled that integrates the Bangle.js app loader into Gadgetbridge, which makes it very easy to use the watch.[2]

- Build: Built on the same device body as the SMA Q3.[3] The casing is plastic, and the watch is compatible with standard 20 mm watch straps. The IP67 water/dust resistance makes the watch usable for sports.

Overall, I highly recommend the Pebble.js 2 watch, which is the best FOSS-focused watch I have found to date.

[1] Espruino JavaScript interpreter: https://github.com/espruino/Espruino

[2] Bangle.js Gadgetbridge (distribution): https://www.espruino.com/Gadgetbridge

[3] SMA Q3: https://www.smawatch.com/details?product_id=130

This is the firmware repo for the BangleJS : https://github.com/espruino/Espruino

This makes use of a JS interpreter made for embedded devices: Espruino

More details in the Espruino repo: https://github.com/espruino/Espruino

There are subsets of JS for embedded device e.g. Espruino https://github.com/espruino/Espruino for BangleJS https://shop.espruino.com/banglejs also with 4MB or JerryScript https://jerryscript.net

- Espruino (2.2k stars)

Semi-related - I saw this trick on https://v8.dev a while back, but `filter: hue-rotate(180deg) invert();` can be a neat CSS trick to 'dark mode' some kinds of graphics. The `hue-rotate` help a bit to keep 'blues blue' etc.

It's far from perfect, but it's a neat trick to be aware of.

V8 is a high-performance JavaScript engine developed by Google. Its purpose is to convert JavaScript code into machine code for execution by the underlying hardware. Primarily developed by the V8 team at Google, the engine focuses on speed and efficiency. In particular, it relies on just-in-time compilation and uses inline caching for high performance.

V8

Exactly the same as JavaScript engines. Be it Mozilla's SpiderMoneky, Google's V8, Apple's Webkit, or Microsoft's Chakra. No matter how specific we draft a specification there is always room for interpretation. Every team has a different take on what part of a spec is describing. Oftentimes it's just a matter of varying pros and cons of different approaches on the road to matching spec; various teams just kind of have to pick a direction and run with it. Other times a spec is not only too vague, but clearly short-sighted to boot.

Remember that we earlier established that every source gets parsed into an AST at some point before it gets compiled or interpreted. For example, platforms like Nodejs and chromium-based browsers use Gooogle's V8 engine behind the scenes to run JavaScript and of course, some AST parsing is always involved before the interpreter kicks in. I looked V8's source and I discovered it uses its own internal parser to achieve this.

While Node.js uses Google's V8 engine that power's Chrome browser, Bun uses JavaScriptCore (JSC), which is an open source JavaScript engine developed by Apple for Safari.

While the idea of server-side JavaScript was not novel, what powered Node.js was! The V8 engine, birthed by Google for Chrome, was now driving Node.js, bringing unparalleled speed and performance to JavaScript execution.

V8 JavaScript Engine

Node runs on the V8 JavaScript engine, which handles memory allocation. The entirety of memory used for a running Node application is held in what is known as a Resident Set. This includes: