1. Writing mode
2. Gap in flex or grid layouts
3. Flip with transform
4. scroll-behavior: smooth;
5. Scroll-snapping with scroll-snap-type for the container and scroll-snap-align for the children
6. Resize elements both with overflow: auto; resize: both;
7. Line clamp based on how many lines is expected.
8. Linear gradient and apply the gradient on text only
9. object-fit: cover to avoid the fill effect of images. The image is not fully displayed thoughts.
10. pointer-events: none; make elements not selectable anymore.

Well I knew them 😁

A kind is a type constructor that takes a type, and produces a new type.

The quthor recreates a map function

The Mozilla Documentation Network published a curriculum to become a frontend developer.

It seems to contain relevant resources, also for confirmed developers.

What's your favorite solution for not-quite-component components?

With those I mean components that are more boilerplates to be expanded upon, instead of actual ready-to-go components you just tweak a few details of. Components that would grow too complex if you'd need to account for all possible interaction and design versions through props or CSS custom properties.

I think often the alternative is composability: ie. what's the minimum functionality that the cookie consent component could have? Could it be a wrapper that provides cookie-setting functionality to whatever UI component it wraps? Could it be a little JS module different components could import to reuse?

Now I get it.

How to apply css for RSS feeds

Maybe useful for later

Every couple of years in software development, the meta changes. Libraries and frameworks are rotated in and out of popularity, languages evolve and best practices change. These are some of my personal beliefs1 on what the current meta is, and what parts are worth adopting.

Now is better than never.
Although never is often better than right now.

1. Use statically typed languages over dynamically typed languages
2. Use automatic formatting
3. Parse, don’t validate
4. Use union types
5. Parse, don't validate
6. Avoid abstracting too early
7. Be aware of monads and functors
8. Accept that generative AI is here to stay
9. Prefer integration tests over unit tests
10. Be kind during code reviews
11. Respect a candidate’s time
12. Pair or mob program frequently
13. Pick a git commit format and stick to it
14. Use Dependabot and friends for dependency maintenance
15. Write infrastructure-as-code
16. Use platforms that allow developers to focus on the code
17. Use queues as data sources

Find relevant indexes to set based on the usage of the postresSQL database.

Avoid a round trip for the slow start TCP algorithm. Depending of the internet connexion it can save 100s of ms.

This cookbook is intended for new Rust programmers, so that they may quickly get an overview of the capabilities of the Rust crate ecosystem. It is also intended for experienced Rust programmers, who should find in the recipes an easy reminder of how to accomplish common tasks.