https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch

Awesome

The current nightly preview to run rust file as scripts.

alias cargo-script='cargo +nightly -Zscript -q' is my new friend.

An accessibility decision tree for the alt attribute

an interactive tutorial series on building realtime collaborative applications using the Yjs CRDT library.

How to prototype in Rust?

• use simple types: String, Vec, Box, Rc and Arc<Mutex> to avoid ownership and lifetime issues.
• make use of type inference
• use .unwrap(), and quick context with bail!() und with_context of the crate anyhow
• run the code (and tests) automatically with bacon
• have a look to cargo-script
• Use println! and dbg! for debugging: dbg! has advantages such as printing file name and line number, outputs the expression adn less syntax-heavy. dbg!(x)
• Design through types
• rely on the todo! macro
• rely on the unreachable! for assumptions of dead code branches: it documents assumptions
• rely on assert! for invariants: it documents assumptions
• avoid generics and lifetimes: use concrete types and owned types
• keep a flat hierarchy (of files), then only starts playing with mod around. All in the same file.
• start small

• Springy easing with linear()
• Typed custom properties
• View transitions for page navigation
• Transition animation for
  and [popover]
• Transition animation for
• Animated adaptive gradient text

A blog post.
An RSS feed for it.
An index.html.

Then more blog post.

They are great! They are key-value pairs at the end of a commit message.

Interning works by ensuring that there’s only one canonical copy of each distinct string in memory.

This is huge:

Cores may stay idle for seconds while ready threads are waiting in runqueues. In our experiments, these performance bugs caused many-fold performance degradation for synchronization-heavy scientific applications, 13% higher latency for kernel make, and a 14-23% decrease in TPC-H throughput for a widely used commercial database.

DOI: https://dl.acm.org/doi/10.1145/2901318.2901326

It may be useful to read it completely.

Fixes:

• compare the minimum load of each scheduling groups instead of the average
• Linux spawns threads on the same core as their parent thread: a node can steal threads from a another node by comparing the average load
  and two others

It is useful to read their tools (online sanity checker for invariants such as "No core remains idle while another core is overloaded")

During the 00s,dozens of papers described new schedling algorithms, [... but] a few of them were adopted in mainstream operatin systems, mainly because it is not clear how to integrate all theseideas in scheduler safely.

Similar the part Related Work describes the current state of the research on other domains: performance bugs, kernel correctness, tracing.

The resources are available on Github: https://github.com/jplozi/wastedcores

CGP makes use of Rust's trait system to define generic component interfaces that decouple code that consumes an interface from code that implements an interface. This is done by having provider traits that are used for implementing a component interface, in addition to consumer traits which are used for consuming a component interface.

We can expect a x8 speedup for a big transaction.

Video elements can be responsive now. Here's how.

Sometimes ARIA is needed to convey informations such as a link pointing to the current page.
The example for form error is great too !

Everything needed to build a proper pagination in HTML