207 private links
Display train/bus stops on a Kindle 😄
The author goes really in-depth 👍
All the most-impactful projects in the data engineering world are now written in Rust. More than the classics fast, safe and high-level language and C interop. The author provides highlight on:
The TL;DR is that most organizations don't even have that much [big] data, a few hundreds GB to single-digit TB for the 98%
One server is enough. [The industry] is instead focusing on simpler solutions.
Rust provides reusability! "For example, Arroyo, Ballista, delta-rs, InfluxDB and many more all use the Apache DataFusion query engine."
This is a massive piece of engineering that they don't have to re-invent themselves and can instead benefit from a software package built and continuously improved by many organizations that have a vested and shared interest in making it great.
- a new cargo info subcommand
- macOS on 64-bit ARM is now Tier 1
- mac Catalyst targets are now Tier 2
- precise capturing use<..> syntax
- native syntax for creating a raw pointer
- Safe items with unsafe extern: make code safe inside unsafe
and more low-level stuffs
An experiment to replace Nginx with Axum.
How to map integer types to rust integer types and more.
How to tackle C macros and inline functions in Rust?
Guo put together a ""hack"". His idea was to use Clang to compile helpers.c into LLVM bytecode. Then, for each Rust crate, ask the compiler to emit bytecode as well. Once everything is in the form of LLVM bytecode, it can be fed back into Clang with LTO turned on to produce a combined object file with the helpers inlined.
and more challenging topics.
A competitor to dig
There is also a dedicated section for JS https://shaarli.lyokolux.space/shaare/DhH-Zw
- Copy and Clone can diverge
- Really long place expression (if)
- krate vs crate_
- Rust has reference variables! kinda..
- &* is actually useful
About high and low-programming languages
Human feedbacks
Are we web yet? Well yes but with extra work. A lot of work.
The author provides its experience.
All the things I love about Django, could we have those for a Rust web framework so that we can reap the benefits of Rust without having to go needlessly slowly?
An attempt: https://git.sr.ht/~ntietz/newt
One approach for achieving compile-time checks, might be having two different structs for alive and dead player, and have the necessary methods implemented for them respectively.
why it’s bad:
- the API is not clean. We are storing the same fields in both Dead and Alive player, while they are both just Players.
- the end-user has to know when to create an instance of Alive player and Dead player. It might be simple to guess in this example, but imagine much more complex/abstract types. If possible, our API should be responsible for when to use which type, not the end user.
Solution 3 is better with an struct that uses a state! The state determines how is the player and different functions are implemented for a player state.
Note it is similar to typescript with an interface or type such as Player<'alive'> of type Player<T> = { state: T, ...}
A web browser with emphasis on local-first data storage.
Repository: https://github.com/OkuBrowser/oku.
Discussions: https://discu.eu/q/https://okubrowser.github.io/