Most engineers learn system design backwards.
They jump to Kubernetes before they understand what a network packet even does.
Here’s the order that actually makes you dangerous:
1. Networks first
HTTP. TCP. DNS. Latency vs throughput.
This is the part nobody studies.
This is like trying to bench 300lbs without learning to squat.
2. Databases second
SQL vs NoSQL, indexes, replication, and partitioning.
If you can’t reason about data -> you can’t reason about scale.
3. Caching
Redis, CDNs, TTLs, eviction policies.
70% of scaling wins come from avoiding queries.
4. Queues & Streams
Kafka, RabbitMQ, SQS.
This is how you decouple timelines and handle spikes without blowing up servers.
5. Load Balancing
Round robin vs least connections vs consistent hashing.
You understand how to scale horizontally without chaos.
6. Build 5 classic designs yourself
- URL shortener
- Rate limiter
- Chat app
- Feed system
- Notifications
7. Read real-world post-mortems
Real learning is failure exposure.
You see what broke. You see WHY.
You don’t become good at system design by memorizing diagrams.
You become good by understanding the physics of distributed systems.
Latency. Durability. Throughput. Availability. Cost.
Those 5 forces rule everything.
Microsoft has released a 4B parameter model that turns any image into a 3D asset in 3 seconds.
It uses a new geometry format called O-Voxel that converts to a textured mesh in under 100ms on CUDA.
Outputs GLB files with full PBR textures, ready for Blender, Unity, and Unreal.
100% Open Source.
Collaborating with the awesome Jonni Walker on this Vancouver AIS visual featuring @Kpler data on top of what is probably the most stunning map I've seen created in @Mapbox! Kudos Jonni 🙌
#dataviz#motion#gis#maps#ais
Someone built an AI-driven 3D particle simulator that runs 100% in your browser.
It lets you generate and visualize complex particle systems with prompts and then export them as HTML, React, or Three.js simulations.
100% Free
4 GitHub Repositories to Prepare for 4 Different Types of Software Engineering Interviews:
1. System Design Interviews: https://t.co/pkVpi6LxSV
2. Low Level Design Interviews: https://t.co/ewnEgFdlfF
3. Coding Interviews: https://t.co/oTez9H4sGh
4. Behavioral Interviews: https://t.co/NsN4Ki0wlz
♻️ Repost to help others in you network
OpenTUI Keymap is a host agnostic key/cmd engine for DOM like apps.
It allows extreme customisation of a generic core, from key stroke syntax parsing to to command resolution and dispatch behaviour. It composes layers of bindings and commands into a single adaptive dispatch model.
Demo link in the replies.
There are many such systems, most of which stop at the key binding part. Apps often are expected to implement their own command layer on top of these. This disconnects the bindings from the actual command registry.
Looking for a proper solution usable in OpenCode I couldn't find anything that fulfilled the need of being extremely extensible to allow plugins to fully control key mapping and command behaviour. I wanted it to always be able to know exactly which keys and commands are reachable at any point in time, no matter from where and how the mappings are manipulated.
The main driver was enabling a which-key like plugin and vim like bindings in a mostly declarative way. While any other plugin could extend the keymap even further with a custom config syntax for key strokes for example. So addons for it are mostly composable and it comes with a variety of addons providing common behaviour.
It can also power other discovery features directly from live state. Help views, command palettes and graph/debug UIs can all ask the engine what is active, reachable, shadowed, pending, or dispatchable instead of rebuilding that knowledge separately.
The core is intentionally very much generic: hosts adapt focus, hierarchy, input events, and lifecycle, while addons extend parsing, tokens, sequence patterns, command metadata, resolvers, interceptors, and event matching. The result is a keymap that plugins can compose with rather than work around.
This could all be built directly into OpenCode and just be app specific. Working on OpenTUI though I want applications to have an out-of-the-box solution to build keyboard-first apps easily. Well, at least agents can.
It is extremely over-engineered. And I love it.
I hope some of you will too.
Map2World
Generate 3D worlds from any segment map and text.
This framework ensures global-scale consistency across expansive environments, while a detail enhancer network preserves fine-grained details without compromising scene coherence.
12 years ago, I started building a game engine from scratch.
Today, Spartan just passed 3,000 stars on GitHub ⭐️
I didn't build it for people to use. I built it to learn, create a portfolio, get a job, and eventually make a cutting edge racing game and do my own thing.
Now I'm 33, turned my life around, and I'm finally able to focus on it, and the passion is stronger than ever.
I'm just getting started. ♥️🔥
Repo: https://t.co/1QjgJkYBEf
Here's what it looked like back then vs no
Algorithms by Jeff Erickson - one of the best algorithm books out there.
The illustrations make complex concepts surprisingly easy to follow. Highly recommend this.
https://t.co/8G06RjGnMA
Just discovered https://t.co/aDBzFiHuxM and it's kind of wild
a browser-based system design tool where you can:
▫️ design distributed systems visually
▫️ connect component flows
▫️ run live traffic simulations
▫️ inject chaos scenarios to test resilience
finally a whiteboard that fights back
https://t.co/aDBzFiHuxM
If I had to start with LLM from scratch, I'd learn these 30 concepts:
1 LLM
2 Token
3 Tokenization
4 Embeddings
5 Latent Space
6 Parameters
7 Pre-training
8 Base Model
9 Instruct Model
10 Fine-Tuning
11 Alignment
12 RLHF
13 Prompt
14 System Prompt
15 User Prompt
16 Context Window
17 Zero-Shot Learning
18 Few-Shot Learning
19 Chain-of-Thought
20 Inference
21 Latency
22 Temperature
23 Hallucination
24 Grounding
25 RAG
26 Workflow
27 Agent
28 Multimodality
29 Benchmarks
30 Guardrails
What else should make this list?
visualizing the gravitational basins of the Laniakea supercluster in three.js / WebGPU: 55k real galaxies by default, with a slider to add up to 1 million procedural galaxies flowing through the Cosmicflows-4 velocity field.
https://t.co/faY8wTmKUy