Khawar

Software Engineer

[kozue @0xkozue]

https://t.co/CVNHS65aIt

[OS Dev @OSdev_]

One of the most shocking discoveries in computer architecture wasn't a CPU bug, it was that repeatedly accessing memory could corrupt other memory.

That vulnerability became known as RowHammer.

For decades, DRAM was assumed to be reliable as long as software interacted with it through the standard memory interface.

Then, in 2014, researchers showed that simply repeatedly activating ("hammering") the same DRAM row could induce bit flips in physically adjacent rows.

Why?

Each DRAM bit is stored as electrical charge in a tiny capacitor. As DRAM cells became smaller and more densely packed, repeatedly opening and closing one row introduced enough electrical disturbance that neighboring rows could lose charge faster than expected.

If a neighboring cell lost sufficient charge before it was refreshed, its stored value could flip from 0→1 or 1→0.

This wasn't caused by defective RAM or buggy software.

It was a hardware disturbance effect emerging from the physics of modern DRAM scaling.

What made RowHammer revolutionary was that researchers realized these bit flips weren't just reliability issues, they could become security vulnerabilities.

Subsequent work demonstrated attacks that could:
• Escalate privileges
• Break isolation between applications and virtual machines
• Corrupt sensitive data structures
• Trigger bit flips from environments as restricted as JavaScript (on vulnerable systems and browsers at the time)

The industry responded with several mitigations:
• Increased refresh rates (with performance and power costs)
• Target Row Refresh (TRR) in newer DRAM devices
• ECC memory, which improves reliability but is not a complete defense against sophisticated RowHammer attacks

Even today, RowHammer remains an active area of research. New attack techniques such as TRRespass, Blacksmith, Half-Double, and more recent work continue to demonstrate that some mitigation strategies can be bypassed under certain conditions.

The lasting impact of RowHammer wasn't just exposing a vulnerability.

It fundamentally changed how computer architects viewed DRAM.

Memory was no longer considered a perfectly reliable storage medium. Its analog electrical behavior could directly affect system correctness, reliability, and security.

Sometimes the most critical security vulnerability isn't hidden in millions of lines of software.

It's hidden in the physics of the hardware itself.

[Shauray @Shauray7]

this is gold ! Crazy they only credited @tqchenml for XGBoost, he literally maintains TVM and the FFI, also I see TIRx in here !!

[Suraj Sharma @suraj_sharma14]

If I had 6 months to become an AI Reliability Engineer.

I'd do this.

Stage 1: Python + Observability Foundations
asyncio, FastAPI, structured logging, OpenTelemetry, Prometheus metrics, distributed tracing basics.

Stage 2: AI System Failure Modes
Hallucinations, context overflow, tool failures, rate limit errors, non-determinism, cascading agent failures.

Stage 3: Evaluation + Quality Gates
Automated eval harnesses, RAGAS/DeepEval, LLM-as-a-judge, regression testing, quality thresholds on CI.

Stage 4: Monitoring + Alerting for AI
Latency SLOs, token/cost dashboards, hallucination alerts, drift detection, anomaly detection on outputs.

Stage 5: Guardrails + Safety Enforcement
Input/output filtering, prompt injection defense, PII redaction, policy-as-code, sandboxed execution, audit trails.

Stage 6: Resilience Patterns for AI Workflows
Retry logic with backoff, circuit breakers, fallback models, graceful degradation, idempotent agent execution.

Stage 7: Incident Response + Runbooks for AI
Playbooks for hallucination spikes, model degradation, cost anomalies, rollback procedures, post-mortem templates.

Stage 8: Testing Strategies for Non-Deterministic Systems
Property-based testing, snapshot testing for prompts, shadow deployments, A/B testing AI outputs, canary releases.

Stage 9: Cost Reliability + Budget Controls
Token budgeting per feature, cost anomaly detection, autoscaling by budget, model routing by cost/latency, chargeback dashboards.

Stage 10: Data + Concept Drift Management
Monitoring input distribution shifts, output quality decay, automated retraining triggers, feedback loop instrumentation.

Stage 11: Open Source + Portfolio
Ship reliability tooling publicly, write incident post-mortems, record SLO design walkthroughs, contribute to eval/observability libs.

Stage 12: Apply
AI Reliability Engineer, AI SRE, LLMOps Engineer, AI Platform Reliability, Responsible AI Infrastructure roles.

Most people stay stuck watching tutorials.

Builders get hired.

#AIEngineering #SRE #LLMOps #Reliability #CareerGrowth @suraj_sharma14

[Sony Thăng @nxt888]

If "individualism" is the cultural variable that explains Western dominance, the thing that allowed power to scale logarithmically and "run away with the game," then the logical implication is that the peoples who were dominated were dominated because of their own cultural characteristics.

The Indian weaver who watched the British Parliament ban his products from European markets was not a victim of policy.

He was a victim of his own "collectivist wiring."

The Congolese people under Leopold II, whose hands were cut off when rubber quotas were not met, were not victims of a specific Belgian colonial system of extraction.

They were experiencing the natural consequence of a power differential produced by cultural evolution.

The enslaved person in a Virginia tobacco field was not there because of a specific, documented, legally constructed system of racial chattel slavery.

They were there because their culture had not produced individualist institutions capable of competing with European power scaling.

I am not suggesting you believe these things.

I am suggesting that the argument you are making, followed to its logical conclusion, produces these things.

And the reason the culture thesis is politically useful, the reason it reappears in every generation with new vocabulary, is precisely because its logical conclusions excuse the specific mechanisms that actually produced the outcomes it is trying to explain.

Name the mechanism, you have accountability.

Name the culture, you have destiny.

[Roy Carrilho @RuiCarrilho5]

found this absolutely beautiful resource. shows you how the ins and outs of how a compute works. amazing technical depth, while always extremely readable

man I wish I had discovered this earlier.

[Sony Thăng @nxt888]

Your three peasants in 1500 is a genuinely elegant framing.

It is also doing something very specific that needs to be named.

It begins the story at a point before European colonialism restructured the global economy.

Which means it can then present the divergence that followed as something that emerged from within European society: from English ingenuity, from Protestant work ethic, from whatever cultural or institutional qualities you might want to attribute it to.

But here is what was happening to the Indian peasant between 1500 and 1750 while the Englishman was "pulling ahead":

The British East India Company was in the process of capturing the most sophisticated textile manufacturing economy in the world.

In 1750, India produced approximately 25% of global GDP.

Its textile industry was so advanced that British manufacturers lobbied Parliament to pass laws banning the import of Indian cloth because they could not compete with it.

Parliament passed those laws.

Then it went further.

It systematically deindustrialized India to turn it into a raw material supplier and a captive market for British manufactured goods.

The Indian peasant did not "fall behind" because the Englishman innovated faster.

The Indian peasant "fell behind" because the British Empire dismantled the industry above his head, extracted the surplus, and wrote the story afterward as a tale of two different levels of ingenuity.

Your starting point of 1500 is not neutral.

It is the last moment before the mechanism of divergence was switched on.

[Nandkishor @devops_nk]

Someone built Kubernetes that runs entirely in your browser.

This might be the easiest way to learn Kubernetes.
- No Docker.
- No Minikube.
- No Kind.
- No EKS.
- No installation.

Just open a webpage and start exploring Pods, Deployments, ReplicaSets, Nodes, scheduling, networking, and more.

The engineering behind it is incredible.
Kubernetes is written in Go, but instead of compiling it to the browser, the developer rewrote major Kubernetes components in TypeScript so they could run natively inside the browser.
This is one of the best examples of using AI I've seen.

AI helped port thousands of lines of Kubernetes code, while the developer manually reviewed everything and validated it with extensive tests to make sure it behaves like a real cluster.

⚠️ It's not for running production workloads.

It's built for learning, teaching, experimenting, and preparing for DevOps interviews.

Imagine onboarding new engineers or teaching Kubernetes without asking everyone to spend an hour installing Docker, configuring Minikube, or creating an EKS cluster.

I genuinely think projects like this will change how we learn infrastructure.

Interactive labs > Static documentation.

Blog Post: https://t.co/57kzSGIkyb

[Youssef Hosni @YoussefHosni951]

Most engineers don't fail at CUDA because it's hard.

They fail because they read the right books in the wrong order.

CUDA has a reputation for breaking people. The usual advice, "just read PMPP", drops a beginner straight into the deepest book in the field and then wonders why they quit by chapter 4.

The book isn't the problem. The sequence is. After going through the whole shelf, here's the order that actually compounds: each book earns the next one:

1️⃣ 𝐂𝐔𝐃𝐀 𝐛𝐲 𝐄𝐱𝐚𝐦𝐩𝐥𝐞 (Sanders & Kandrot): Don't learn kernels yet. Learn to feel the GPU. This builds the intuition that every later book assumes you already have.

2️⃣ 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 𝐌𝐚𝐬𝐬𝐢𝐯𝐞𝐥𝐲 𝐏𝐚𝐫𝐚𝐥𝐥𝐞𝐥 𝐏𝐫𝐨𝐜𝐞𝐬𝐬𝐨𝐫𝐬 (Hwu, Kirk, El Hajj): The foundation. This is where the mental model gets built: threads, blocks, parallel patterns. Now it lands, because Book 1 gave you something to attach it to.

3️⃣ 𝐏𝐫𝐨𝐟𝐞𝐬𝐬𝐢𝐨𝐧𝐚𝐥 𝐂𝐔𝐃𝐀 𝐂 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 (Cheng, Grossman, McKercher): The architecture book. Memory hierarchy, streams, and the why behind every performance cliff you're about to hit.

4️⃣ 𝐆𝐏𝐔 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 𝐂++ 𝐚𝐧𝐝 𝐂𝐔𝐃𝐀 (Motta): The modern workflow. Nsight profiling, the full dev loop, packaging kernels into libraries you can call from Python.

5️⃣ 𝐓𝐡𝐞 𝐂𝐔𝐃𝐀 𝐇𝐚𝐧𝐝𝐛𝐨𝐨𝐤 (Wilt): The reference you grow into. You don't read this cover to cover. You reach for it when "works on my machine" stops being enough.

6️⃣ 𝐂𝐔𝐃𝐀 𝐟𝐨𝐫 𝐃𝐞𝐞𝐩 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠 (Arledge): The payoff. Where kernels stop being an exercise and start accelerating the models you actually ship.

The pattern across all six: intuition before theory, theory before architecture, architecture before application.

Most people quit at the wrong book. Almost nobody quits in the wrong order, because nobody told them that order was the thing.

[Max For AI @MaxForAI]

一个刚在浙大读完CS硕士的日本人，写了一篇《中国AI为什么发展》，比很多中文互联网的自嗨分析更接近现实。

它的核心不是夸中国，也不是骂日本，而是指出一个很朴素的事实：

中国AI人才不是凭空出现的，而是被一整套残酷但有效的系统训练出来的。

高考决定学校和专业，进了大学也不轻松，因为好工作有限，很多人一进本科就开始准备考研。

作者认为，中国学生等于经历了两轮高强度筛选：
一次高考，一次考研，所以基础数学、英语、学习耐力都会被拉得很高。

然后到了研究生阶段，压力继续加码。

以他所在的浙大CS硕士为例，毕业要过校内审查、外部专家审查、答辩委员会，还需要CCF认可的会议/期刊论文，或者中国专利。

作者因此认为中国AI相关专利多，不只是因为企业申报多，也和高校毕业机制有关。

他还提到博士要求更狠，CCF会议分A/B/C类，A类包括CVPR、NeurIPS、AAAI等顶会。

按他的说法，中国博士毕业需要A会2篇、B会1篇，这套机制会稳定产出“能力被证明过”的博士。

他还有几个有意思的判断：
第一，他认为中国AI能发展，是因为CS真的能改变命运。一个平均收入不高的国家，顶尖CS新卒可以拿到远高于平均水平的收入，所以父母和学生都会把资源压向CS。

第二，他认为中国擅长追赶式创新，但破坏式创新比较难。原因是教育系统太体系化，大家更擅长在系统内优化，而美国更擅长探索。

第三，他认为GPU管制是有效的。没有GPU，大学很难做有影响力的AI研究，所以优秀学生会去有GPU的大厂实习。没有算力的学校，只能做更小规模的研究。

第四，他对华为芯片判断比较冷淡，说长期可能有价值，但现阶段还没到实用水平，并且他没见过真正对华为芯片很乐观的中国AI学生。

中国AI的强，不是神话，也不是奇迹，是很多人从十几岁开始一路卷出来的产物。

这个写的非常不错，可以说是血淋淋的现实了。

[zack @zack_overflow]

Who are your top 5 programmers of all time and why?

Mine:

1. Fabrice Bellard (ffmpeg, tinycc, quickjs)
2. John Carmack (doom, quake)
3. John McCarthy (lisp, father of AI, invented GC, timesharing)
4. Linus (linux man)
5. Dennis Ritchie (C and unix, K&R book)

[Spencer Baggins @bigaiguy]

A French engineer who lives quietly in Paris has spent 30 years writing software that the entire internet now runs on without knowing his name.

He wrote the code that streams every YouTube video, every Netflix show, every TikTok clip. He wrote the code that runs the virtual servers underneath AWS, Google Cloud, and Microsoft Azure. He calculated more digits of pi than anyone in history. He has no Twitter. He has no marketing. He just keeps shipping.

His name is Fabrice Bellard.

Here is the story, because almost nobody outside the systems programming world knows what one man has built.

Fabrice was born in 1972 in Grenoble, France. He studied at École Polytechnique, the top French engineering school. He never went to Silicon Valley. He never built a startup empire. He just wrote code.

In 2000 he started a project called FFmpeg, an open-source multimedia framework for encoding, decoding, and streaming video. He was 28. The project did one thing nobody else had done well. It handled every video and audio format that existed, in one library, on every operating system. He led it himself for years.

Today FFmpeg is the invisible engine of the internet. YouTube uses it. Netflix uses it. VLC uses it. Chrome and Firefox use parts of it. Every Android phone, every iPhone, every smart TV, every video editing tool you have ever touched runs FFmpeg somewhere underneath. If you have watched a video on a screen in the last 20 years, Fabrice's code processed it.

He was not done.

In 2003 he started QEMU, a machine emulator and virtualizer. He wrote it solo until version 0.7.1 in 2005. QEMU lets you run any operating system on any other operating system. It became the foundation of modern virtualization. KVM, the Linux kernel hypervisor, runs on top of QEMU. Every major cloud provider, AWS, Google Cloud, Microsoft Azure, IBM Cloud, runs virtual machines on infrastructure built around it. The Quick Emulator is the most cited piece of cloud infrastructure code on Earth.

He kept going.

In 2001 he won the International Obfuscated C Code Contest with a small C compiler that grew into TCC, the Tiny C Compiler. TCC can compile and boot a Linux kernel from source in under 15 seconds. In 2004 he calculated the most digits of pi ever computed at the time, using a personal desktop computer and an algorithm he derived himself called Bellard's formula. In 2011 he wrote a complete PC emulator in pure JavaScript that runs Linux in your browser, a project called JSLinux that engineers still cannot believe is real.

In 2019 he released QuickJS, a small but complete JavaScript engine that fits where V8 cannot. In 2021 he released NNCP, a neural network based lossless data compressor that immediately took the lead on the Large Text Compression Benchmark.

Then he turned his attention to large language models. He built TextSynth Server, a web server with a REST API for running LLMs locally. He released ts_zip and ts_sms, compression utilities that use language models to compress text and short messages at ratios traditional algorithms cannot reach. He released TSAC, a very low bitrate audio compression system. In December 2025 he released Micro QuickJS, a new JavaScript engine for microcontrollers, separate from QuickJS, designed for environments with almost no memory.

Fabrice co-founded a telecom company called Amarisoft in 2012, where he serves as CTO. Amarisoft builds 4G and 5G base station software used by carriers and labs around the world. He has been running it for over a decade while continuing to ship personal projects from his own home page at bellard dot org

He has no Twitter. He has no Instagram. He gives almost no interviews. His personal website is a flat list of projects with no styling, no fonts, no marketing copy. Just titles and links.

A quiet French engineer who never moved to Silicon Valley wrote the code that quietly runs the internet.

He is still shipping.

[adah @alohaproxy]

Rust + Tokio → Backend Engineer
Rust + Actix → API Engineer
Rust + Axum → Systems Backend Engineer

Rust + Diesel → Database Engineer
Rust + SQLx → Async Backend Engineer

Rust + WebAssembly → Web Performance Engineer
Rust + Yew → Frontend/WASM Engineer

Rust + Tauri → Desktop App Developer
Rust + egui → Native UI Engineer

Rust + Bevy → Game Developer
Rust + wgpu → Graphics Engineer

Rust + Embedded Rust → Embedded Systems Engineer
Rust + Linux Kernel → Systems Programmer

one language…multiple elite engineering paths 🫡

[Alex Zajac (🍔,🧠) @itsalexzajac]

A developer posted this on Reddit, and I haven't stopped thinking about it.

[H @hmmmmmm1458]

난 게임을 즐겨하지 않는데 이런건 진짜 유익함

만원으로 데이터 센터의 복잡한 구조와 컴퓨터 인프라를 이해하는 스팀게임 : Data Center

빈 방에서 시작해서
랙 구매 → 서버 장착 → 모든 케이블을 직접 손으로 하나하나 연결해야함

실제 데이터 센터처럼 고객 트래픽을 처리하는 시뮬레이션 게임

출시 48시간 만에 180개가 넘는 리뷰가 달렸고, 플레이어들은 “최근 본 시뮬레이션 게임 중 가장 몰입감 있다”, “컴퓨팅 인프라를 이해하는 데 최고”라는 평가를 하고 있습니다.

[Shubh @TheSuperEng]

Want to get into backend development?

- Build your own DNS
- Build your own BitTorrent
- Build your own Decentralized file system
- Build your own Interpreter
- Build your own kafka
- Build your won web scraper
- Build your own Redis
- Build your own Database Engine
- Build your own Distributed Job Queue
- Build your own Search Engine
- Build your own web server
- Build your own Reverse Proxy
- Build your own API gateway
- Build your own Load Balancer
- Build your own URL Shortener
- Build your own CDN
- Build your own Pub/Sub System
- Build your own Task Scheduler
- Build your own Email Service
- Build your own File Storage Service
- Build your own Logging System
- Build your own Metrics/Monitoring System
- Build your own Feature Flag System
- Build your own Payment Gateway Mock
- Build your own Rate Limiter
- Build your own Notification System
- Build your own WebSocket Server
- Build your own OAuth Server
- Build your own CI/CD Pipeline System

[David Okocha @davidokocha086]

finished my C systems programming curriculum. every project built from scratch. no libraries.

mini unix shell — fork, exec, pipes, signals.
memory allocator — malloc/free with coalescing.
process monitor — live reading from /proc.
file explorer — recursive directory walker.
HTTP server — raw sockets.
chat application — multi-client, TCP, select() for I/O multiplexing.
package manager — manifest parsing, tar.gz extraction, flat-file database.

all of this feeds into EduOS — the offline-first, AI-native OS i'm building for African schools.

github link in my bio.

next: assembly. posting everything i learn.

[bycloud @bycloudai]

they were pretty conservative with their paper

so here are some bold and cope potentials if it holds up at scale

> 3-4x memory reduction across the board without much quality loss
> train a small/mid sized LLMs on a single GPU
> if you can train each block independently without much comms: less all-reduce, fewer pipeline bubbles, and reduced comms overhead
> if it works on fine-tuning existing models: consumer GPUs/small clusters can fine-tune SoTA models
> if blocks are independent: partial fine-tuning gets cheaper, since you can update subsets of blocks instead of the whole model

feel free to shut me down

[gxjo @gxjo_dev]

every CS student should watch this before graduating

[Mustafa @oprydai]

study design engineering.

not just design.
not just engineering.

the bridge between both.

what it teaches you:
function → does it solve the problem?
form → does it feel clear, usable, and intentional?
materials → what should it be made from, and why?
manufacturing → can it actually be produced at scale?
ergonomics → how does the human body interact with it?
constraints → cost, weight, strength, time, repairability
systems thinking → how every part affects the whole product

design engineering is where ideas stop being pretty sketches
and become real objects people can use.

it forces you to think like an artist,
calculate like an engineer,
and execute like a builder.

the future needs people who can move from concept → prototype → product.

study design engineering if you want to build things that don’t just work.
but feel inevitable.