标签：#AR

Apple built a tool for people with cognitive disabilities, but I accidentally discovered it’s also the best kids’ phone setup no one is talking about—not even Apple.

I didn’t set out to become a systems architect. In fact, I didn’t even know that’s what I was becoming. There was no grand plan, no formal training, no moment where someone handed me a title. It happened the same way most systems failures happen: slowly, then all at once. What I did have was a habit. Whenever something broke — a workflow, a process, a piece of software, an organisation — I couldn’t leave it alone. I needed to understand why. Not the surface‑level “why,” but the structural one. The hidden one. The one nobody sees until it’s too late. Most people move on when something fails. I map it. I started noticing patterns. The same failure modes appeared everywhere: unclear ownership, mismatched incentives, brittle assumptions, invisible dependencies, and the classic “we built this fast and hoped it wouldn’t collapse.” Different domains, same architecture problems. I wasn’t trying to fix things. I was trying to understand them. But understanding inevitably leads to repair, and repair inevitably leads to design. Eventually I realised I wasn’t just analysing systems — I was architecting them. Not officially. Not ceremonially. Just… functionally. I became the person who could see the structure beneath the mess. The person who could explain why something was breaking and what would happen next. The person who could redesign the thing so it wouldn’t break again. People started asking me questions that only architects get asked. “Why is this happening?” “How do we stop it?” “What should this look like instead?” “What’s the underlying pattern here?” I didn’t have a job title for it. I didn’t need one. The work defined itself. Over time, I realised that “systems architect” was simply the most accurate description of what I was already doing. Not in the traditional enterprise sense — no UML diagrams, no formal frameworks, no ivory‑tower abstractions. More like: the person who sees the real structure beneath the chaos and can articulate it clearly enough that others fin

Sony shared an announcement with the console market: physical disc production for all PlayStation games will completely stop in January 2028. You can read the official announcement on the PlayStation Blog . From a pure engineering perspective, modern internet infrastructure has rendered physical distribution redundant. We no longer need plastic circles to transport megabytes. The gamer community response isn't about data transfer speeds. It is over true digital ownership, consumer rights, and software preservation. In this article, we break down the details, look at the history leading to this moment and explore why console makers would pursue this direction. 🔍 The Announcement Break Down The 2028 Deadline: The mandate strictly applies to new games launching after January 1, 2028. Legacy Back Catalog: Discs pressed before this date will still function (assuming future hardware maintains optical drive compatibility). "Code-in-a-Box" Retail: Stores will still sell physical cases on shelves, but they will contain a paper download voucher instead of a disc. I am no sustanability poster boy, seems wasteful to preserve retail shelf presence. 🛑 The Illusion of Ownership: "Buying" vs. "Renting" When you hit "Buy" on a digital storefront, you aren't purchasing a game. You are purchasing a conditional license to stream or download it—a long-term rental agreement that can be unilaterally altered or revoked. No Secondary Market: Players completely lose the ability to resell, trade, or lend games to friends. Monopoly Pricing: Eliminating discs removes competitive pricing from retailers like GameStop, JB Hi-Fi, or Amazon, leaving users locked to a single proprietary storefront. Delisting Vulnerability: If a publisher loses IP rights, the software vanishes instantly. 🎮 Case Study: My Close Call with Digital Erasure Look no further than Star Trek: Resurgence for proof of how fragile digital stores are. In April 2026, the publishers suddenly lost their IP distribution rights. Within

A 2023 HotOS paper by Sanjay Ghemawat (MapReduce/Bigtable co-author) and Amin Vahdat (Google Fellow) got repackaged by tech media as "microservices are dead." It said no such thing. Three years later, the misreading has traveled further than the paper itself. This post does three things: reconstructs what the paper actually claims, maps its three structural gaps, and introduces a variable the authors couldn't have predicted — AI code generation — which, I'll argue, undermines the paper's central solution more than any of those gaps. The AI section uses my own open-source project ReqForge as evidence. Flagging the conflict of interest up front: this isn't neutral analysis, it's a design rationale. Which is exactly why it's more honest than a hypothetical example. What the paper actually said The paper is Towards Modern Development of Cloud Applications (HotOS '23, 8 pages). Its core claim in one sentence: The fundamental problem with microservices is that they bind the logical boundary to the physical boundary. You let "how the code is organized" dictate "how the code is deployed" — two questions that should never have been welded together. From that claim, the paper proposes a three-layer solution: Logical monolith — developers write a cleanly modularized monolith; deployment is someone else's problem. Automated runtime — a smart platform that decides at runtime whether components should be merged or split, based on load. Atomic deployment — all components on a request path share one consistent version, avoiding half-old/half-new. Prototype numbers: 15× lower latency, 9× lower cost. That's it. The paper never says "microservices are wrong," never says "everyone should go back to monoliths," and gives no implementable plan. It's a vision paper — written to provoke discussion at a workshop, not an engineering whitepaper. A ruler Before dissecting it, here's a ruler you can apply to any architectural claim (this is a common framing in the engineering literature — you'r

From cooling hybrids to organic latex beds, these are the mattresses WIRED reviewers actually sleep on and recommend.

Table of Contents Setting a New Benchmark for Myself My Most Productive Six Months Yet 2...

From order, chaos. From courage, fear. From strength, weakness. — The 36 Stratagems, "Make a Sound...

I’ve wanted to build a text editor for a long time. Not because I thought the world needed another one — it clearly doesn’t — but because editors are one of those projects where you end up touching everything: rendering, input handling, text buffers, undo, plugins, configuration, even OS integration. It felt like the most honest way to learn how these tools actually work. So I finally did. cdin is a lightweight, keyboard-centric text editor with Vim-style modal editing. It started as a fork of lite , but over time it became something more personal. I kept the parts I liked, removed the parts I did not, and reshaped the rest to match the way I actually work. A big reason for that was my computer. I have a weak machine, and that made heavier text editors feel frustrating to use. They were often slow, laggy, or just too much for what I needed. That is how I discovered lite in the first place. It was close to what I wanted, but not quite there. So I forked it, renamed it to cdin, and started making it mine. That meant more than just small tweaks. I removed features I did not need, changed the things that felt awkward, moved from SDL2 to SDL3, and rewired a lot of the project structure along the way. The result is cdin: a small editor built around speed, simplicity, and hackability. The name itself is simple too. cdin means “CODE in”. The code is split between C and Lua. The C side handles the window, renderer, and SDL bindings. Everything else — behavior, plugins, keybindings, config — is loaded in Lua at runtime. That keeps the editor flexible without making it feel heavy. If you want to explore the project, here are the main docs: Overview · Getting Started · Building from Source · Configuration · Vim Keybindings · Plugins · Command Reference There is still a lot I want to improve, but cdin already feels like something that belongs to me in a way no other editor ever did. If you check it out, please leave a star, fork it, or send an Issue or PR if you find a bug or wa

Introduction: The Illusion of Productivity Metrics Traditional software development metrics—velocity charts, commit counts, bundle size—are the comfort objects of the coding world. They sit on dashboards, glowing with the promise of insight, but in reality, they’re often lagging vanity numbers . They don’t capture the narrative of a week’s work; they don’t reveal the decisions , the reversals , or the patterns that define progress. Instead, they deform the truth by oversimplifying it, much like a rubber band stretched too thin—it snaps under pressure, failing to hold the complexity of real work. Consider the mechanical process of a commit. A commit is a snapshot , a frozen moment in time. But software development isn’t a series of snapshots; it’s a sequence . When you string commits together without context, you miss the heat of decision-making—the back-and-forth, the undoing, the redoing. This is where traditional metrics fail. They don’t account for the thermal expansion of ideas, the way a decision made on Monday might cool by Friday, only to be reheated and reshaped. Without a narrative, these metrics are like a machine running without lubrication: they friction against reality, wearing down under the weight of their own inadequacy. The Mechanism of Metric Failure Let’s break down the causal chain: Impact: Developers rely on metrics like commit counts to gauge productivity. Internal Process: These metrics are lagging indicators , reflecting past actions without context. They don’t capture the why behind the numbers—the decisions, the reversals, the thought process. Observable Effect: Developers miss critical patterns, such as repeated decision reversals, leading to inefficiencies and missed opportunities for improvement. It’s like trying to diagnose a car’s engine by looking only at the speedometer—you’ll never catch the misalignment in the gears. Narrative-Driven Insights: The Optimal Solution Contrast this with a narrative-driven approach . When you narrate a

Why I'm Building the Fast Series I'm building the Fast Series because creator software has gotten too complicated. Plenty of tools are powerful, but they make you fight the software before you can make anything. You want to record a tutorial, stream a game, clip a useful moment, compress a file, or turn an idea into a short video. Instead, you're digging through settings, codecs, plugins, device permissions, export presets, and cryptic error messages. That's the problem I keep running into, and the Fast Series is my attempt to solve it: practical Windows software where each tool does one job clearly and reliably. Not everything needs to be a giant all-in-one platform. Sometimes the better product is a small tool that opens quickly, gives you sensible defaults, explains what's happening, and gets out of your way. That's the direction I'm taking with Sturm Technologies. The Problem With Creator Tools There are already great tools for recording, streaming, editing, clipping, and compressing. OBS is powerful. Professional editors are powerful. FFmpeg is powerful. There are cloud tools, browser tools, AI tools, and creator suites that promise to do everything. But power is not the same thing as clarity. Most creators don't want to become experts in capture APIs, bitrate math, encoder settings, audio routing, or export pipelines. They want to make something and publish it. The pain usually shows up in small moments. You record a video and the audio is missing. You compress a file and it still doesn't meet the upload limit. You spend more time scrubbing a long video than actually clipping it. You hit an error and the app hands you a technical dump instead of telling you what to fix. That's where I think there's room for better software. Not bigger software. Better software. Start With FastCast The first product in the series is FastCast , a Windows recording and streaming app for people who want OBS-level practicality without OBS-level setup. FastCast focuses on screen cap

TIL: Streaming Data in Go with iter and yield While building RagPack , a library that chunks files for embedding, I needed a common way to stream parsed content from multiple file formats. RagPack supports CSV, PDF, DOCX, HTML, XLSX, Markdown, JSON and more. Each format has its own parser, but the ingester that consumes them should not care which one it is talking to. I needed a shared contract. In Java I would have reached for an Iterator<T> or an InputStream , but in Go the answer turned out to be the iter package, introduced in Go 1.23. The Parser interface The iter package introduces two types. Seq[V] yields a single value at a time, and Seq2[K, V] yields a pair: type Seq [ V any ] func ( yield func ( V ) bool ) type Seq2 [ K , V any ] func ( yield func ( K , V ) bool ) Seq2 is the right fit here because each iteration naturally produces two things: a parsed unit and any read error. This matches Go's standard (value, error) convention and lets the caller handle errors inline without wrapping them in a struct. That made iter.Seq2[Unit, error] a natural return type for the Parser interface: type Parser interface { Parse ( ctx context . Context , r io . ReadCloser ) iter . Seq2 [ Unit , error ] } Every sub-parser, CSVParser , PDFParser , DocxParser , HTMLParser and so on, implements this one method. The ingester does not need to know which format it is dealing with. Implementing a parser Here is what a parser implementation looks like: func ( p * Parser ) Parse ( _ context . Context , r io . ReadCloser ) iter . Seq2 [ Unit , error ] { return func ( yield func ( Unit , error ) bool ) { defer r . Close () reader := bufio . NewReader ( r ) for { line , err := reader . ReadString ( '\n' ) if err == io . EOF { break } if err != nil { yield ( Unit {}, err ) return } if ! yield ( Unit { Text : strings . TrimRight ( line , " \n " )}, nil ) { return } } } } The if !yield(...) { return } part is the key. If the caller breaks out of the loop early, yield returns false and we

Over the past week, the AI hardware news I've been tracking adds up to more than $610 billion in capital deployed globally — in just seven days. Not valuations. Not market cap. Actual capital expenditure commitments. Korea $550B, Japan $6B, Qualcomm's new accelerator, Kawasaki Heavy Industries' $1B AI infrastructure bond — this round of moves has already surpassed the wildest half-year of the 2000 dot-com bubble in scale. But this time the money isn't flowing into web pages. It's flowing into chips, memory, and power. Watching all of this over the past few days, I've been thinking: for investors and for builders like us making products on top of AI, what does this gamble actually mean? The Real Story Behind AI Training Bottlenecks: From GPU Scarcity → Memory Scarcity → Power Scarcity Honestly, everyone watches AI through the lens of models, but the real bottleneck was never the models — it's been the hardware. From 2023 to 2025, the bottleneck shifted from GPU scarcity to memory scarcity, and is now pushing toward power scarcity. When GPUs were tight, everyone scrambled for H100s and NVIDIA raked it in — but the part that actually throttled the H100 wasn't the GPU core, it was the HBM high-bandwidth memory. On the B200, the HBM3E stacked on top has its capacity locked up entirely by NVIDIA at SK Hynix, while Samsung is chasing hard but its yields can't keep up. That's why South Korea just committed $518B to build 4 memory fabs plus $52B for the central regions, totaling $550B ( TechCrunch ). This isn't just about filling upstream capacity — the key is that Samsung + SK Hynix are trying to flip themselves from being NVIDIA's downstream suppliers into becoming the dominant players in AI hardware. Why did downstream hardware investment kick off so late? Because for the past two years people were still watching and waiting to see if "this AI hype cycle would cool down again." By 2026, GPT-6, Claude 4, and Gemini 3 are all live, inference costs have come down, user numbe

A gente sempre ouve falar que o sistema operacional impede que um processo veja a memória do outro ou que o programa fale diretamente com o hardware, mas normalmente não explicam o "como". Eu sempre achei isso meio mágico até que eu resolvi ir atrás da resposta, e é bem interessante. Vou me basear na arquitetura x86, mas é provável que outras arquiteturas sejam parecidas. O problema: a CPU Pra CPU não existe processo, kernel, sistema operacional. Existe só endereços de memória de onde ela lê a próxima instrução e executa. Se a CPU pode falar direto com a RAM, SSD, teclado, mouse, tela... O que me impede de escrever um programa pra ler suas senhas e tokens direto da RAM? Ou de ler arquivos e alterar arquivos sensíveis direto no SSD? Por outro lado, se o kernel fiscalizasse cada instrução que da CPU antes dela executar, isso seria extremamente lento... Outro problema: os interrupts Se a CPU só executasse sequencialmente, seu sistema poderia executar várias coisas e esquecer de checar se uma tecla foi apertada, se o mouse mexeu, etc... Então certos eventos interrompem o que quer que a CPU esteja fazendo para serem tratados assim que possível. Alguns exemplos de interrupt são: Teclas do teclado pressionadas ou soltas Botões e movimento do mouse Timers Operações de disco assíncronas Pacotes de rede recebidos/transmitidos Uma solução: rings Os processadores da arquitetura x86 tem o esquema de rings. Pense em rings como grau de limitação. Ring 0 significa limitação zero, ou seja, acesso a todas as instruções da CPU e consequentemente acesso total ao hardware e memória. O kernel roda em ring 0, ou kernel mode. O kernel assim que é carregado configura todos os interrupts handlers da CPU para executar o handler apropriado do kernel, em kernel mode, claro. Em ring 3 a CPU fica limitada e não pode fazer instruções consideradas privilegiadas. E obviamente em ring 3 a CPU não consegue se colocar em ring 0 sozinha, pois dessa forma qualquer programa conseguiria se pôr em ring 0. O

EDRSR — the Unified State Register of Court Decisions — is effectively all of Ukraine's judicial practice in open access. Today Qdrant holds **44M+ vectors : criminal (19M), civil (14.3M), commercial (5.1M), misdemeanors (5.6M). Vectorization of civil cases (CPC, justice_kind=1) — the largest cohort at 33.7M documents — runs on a dedicated EC2 instance (r6a.xlarge, 32 GB RAM, 2 TB gp3). Here's what's under the hood: models, pipeline, cost, rakes, and current status. Why Vectorize Courts When a lawyer searches "is there case law on recovering bank prepayment fees" — they don't want to open 40 decisions and read them through. They want the system to surface the top 5 most relevant ones, pull out key paragraphs, and show how courts reasoned. Full-text search (FTS) over keywords doesn't give that — it returns every document containing the word "fee", and there are thousands. For this semantic task you need vector representations of text. The model turns a paragraph from a decision into a point in a 1024-dimensional space; semantically similar paragraphs sit near each other. A kNN search in Qdrant returns the top K nearest, and an LLM composes the answer from exactly those relevant fragments. The only problem: the register is big. Very big. Scale Our prod database holds full texts of decisions starting from 2006. Breakdown by procedural type: Civil (CPC) — 33.7M documents. The largest category. Consumer, housing, labor, family. Criminal (CrPC) — 12M+ Administrative (CAS) — 14M+ Commercial (CC) — 6M+ Misdemeanors (CUaP) — 6M+ The Qdrant collection edrsr_decisions on a dedicated EC2 currently holds 44M+ vectors (122 segments, on_disk=true): | Proceeding type | justice_kind | Vectors | |—|—|—| | Criminal (CrPC) | 2 | 19,036,347 | | Civil (CPC) | 1 | 14,328,427 | | Misdemeanors (CUaP) | 5 | 5,579,432 | | Commercial (CC) | 3 | 5,098,662 | | Total | | 44,042,868 | Civil cases processed: 14.3M out of 33.7M — that's 42%. After CPC completes there will be roughly 63M+ vectors in

I build and run one of the tools on this list (AGenO — full disclosure below), and I use every other tool here regularly. This is what "free" actually gets you on each one, including the catches. The AI tool landscape has a dirty secret: almost nothing labeled "free" is free. Most tools give you a taste — ten messages, three images, one song — and then the paywall lands. So instead of another list of forty tools nobody has tried, here are nine that give you real value at $0, organized by what you're trying to make, with the actual limits spelled out. Quick comparison Tool Best for What's actually free The catch ChatGPT General chat & writing ~10 msgs/5h on the flagship model Silently switches you to a weaker model after the limit Claude Long documents, nuanced writing 10–25 msgs/5h, varies with demand Limits shrink when servers are busy Gemini Image generation & editing Generous with a Google account Best features drift to the paid tier Perplexity Research with citations Unlimited basic searches Pro searches are capped Suno AI music ~10 songs/day No commercial use on free; failed generations can eat credits Leonardo AI Stylized art & game assets Daily token allowance Confusing token system; images are public on free Character.AI Roleplay & AI characters Unlimited chat Heavy filters; your chats train their models AGenO All of it in one place Images, songs with vocals, chat, characters, stories, coding problems — daily free allowance One-person project — busy hours can mean a short queue Canva Magic tools Quick social graphics 50 text-to-image uses Design-tool add-on, not a real generator Chat and writing ChatGPT is still the default for a reason — the free tier includes the flagship model and it's good at nearly everything. The catch nobody tells you about: after roughly ten messages in five hours, it quietly downgrades you to a mini model without making it obvious. If your answers suddenly get dumber mid-conversation, that's why. Claude writes the most natural prose

Hi everyone, I want to share textparser, a high-performance, lightweight text parsing and AST generation library written in pure C. 💡 The Core Idea & Why It's DifferentTraditional parser generators (like Flex/Bison) come with a steep learning curve and rigid code generation. On the other end, hand-writing recursive descent parsers or state machines becomes an unmaintainable mess as your language grows.textparser bridges this gap using a hybrid JSON + Python + C workflow:You define your tokens, syntax patterns, and color styles in a clean, human-readable JSON grammar file. A lightweight Python compiler tool processes the JSON, runs optimizations, and emits a dense, static C header array.The C runtime engine loads these pre-compiled arrays instantly. It processes raw text strings into an abstract token tree (textparser_token_item) using a highly optimized regular expression engine (crpe2).By offloading the grammar overhead and heavy state-machine parsing logic to the Python build step, the actual runtime C library stays incredibly lean, memory-efficient, and fast. 🚀 Features At A Glance30+ Languages Out-of-the-Box: Includes ready-to-use JSON grammars for C, C++, Rust, Python, JavaScript, HTML, SQL, and dozens more.Rich Token Metadata: Every parsed token tracks exact code coordinates, structural flags, and custom syntax styling options.Zero Bloat: Ideal for terminal text editors, syntax highlighters, custom linters, and lightweight static analysis tools where bringing in a massive compiler front-end is overkill.

The rise of AI has brought an avalanche of new terms and slang. Here is a glossary with definitions of some of the most important words and phrases you might encounter.

Hi everyone, I built H64LM, a research project to better understand modern LLMs by implementing one from scratch in PyTorch. Instead of relying on high-level training frameworks, I implemented the core components myself attention, MoE routing, normalization, and the training loop. Features 249M-parameter Transformer Grouped Query Attention (GQA) Sparse Mixture-of-Experts (8 experts, Top-2 routing) with 3 auxiliary routing losses SwiGLU, RoPE, RMSNorm Sliding-window attention Mixed-precision training, gradient accumulation Custom training loop (no Trainer abstractions) Checkpointing and resume support The included checkpoint was trained on a subset of WikiText-103 to validate the pipeline end-to-end, not to be a strong model it's visibly overfit past epoch 10 (best val PPL ~40.5). Known limitations are documented in the README, including batch-size-1-only generation and no true DDP (falls back to DataParallel). GitHub: https://github.com/Haiderkhan64/H64LM Feedback on the implementation or architecture is very welcome. submitted by /u/Loose_Literature6090 [link] [留言]

There's a phase almost every developer gets stuck in. You're consuming tutorials, bookmarking articles, finishing courses, and buying books you'll read "eventually." You're learning constantly — but you're not producing anything. You're just... absorbing. That's the learning vacuum. And if you've been there, you know how easy it is to confuse staying busy with making progress. At some point, the shift has to happen. You stop being a sponge and start being a signal. Here's how I started making that turn. Start a Daily or Weekly Code Journal You don't need a blog, a brand, or an audience for this. Just a file. A note. Anything. Write down what you built, what broke, and what you figured out. Even one sentence counts. I like to write a quick sentence and how many hours, just like if you were filling in an invoice for contract work. The act of putting it into words forces you to actually process what you learned instead of letting it blur into the background noise of your brain. Over time, those entries start to look like a roadmap — and you realize you've come further than you thought. Code Something You Actually Want to Build Pick something dumb. Pick something fun. A browser game, a weird UI experiment, a tool that solves exactly one tiny problem in your life. I signed up for DEV Challenges , Summer Bug Challenge and upcoming Weekend Challenge to get my ball rolling. The best projects I've ever worked on had no real-world utility. They were just interesting to me. And that interest kept me showing up even when things got hard. A tutorial can't give you that. Only a project you actually care about can. Find Your People Whether it's here or a Discord server, a local meetup, a dev community on Farcaster or Lens, or just a forum thread you keep coming back to — find somewhere to show up regularly. Lurking is fine at first. But eventually, drop a comment. Answer a question you know the answer to. Share something you built. Community is where isolated learning becomes shar

We built a model diffing method that recovers verbatim content from narrowly finetuned LLMs using only grey-box logit access (no weights, no activations, no probe corpus). Recent work (Minder, Dumas et al., "Narrow Finetuning Leaves Clearly Readable Traces in Activation Differences") showed that finetuning leaves detectable traces in activation differences between base and finetuned models. Their method, Activation Difference Lens (ADL), steers generation using these differences, but it's whitebox (needs full weight access) and only recovers a vague, domain-level description of what the finetuning was about. We introduce Contrastive Decoding Diffing (CDD), the output-level analog. Instead of steering with activation differences, we contrast the base and finetuned model's logits directly. A single default configuration, no per-organism calibration, no layer selection, achieves a verbatim recovery score of 4+/5 on 19/20 organism x model pairs across four model families (1B to 32B params) on the SDF benchmark. ADL never exceeds 3/5 on the same benchmark, despite requiring full weight access. One unplanned finding: across four semantically unrelated finetuning domains (fake FDA drug approval, fake baking protocols, fake Roman concrete research), the same fictional persona kept showing up in the recovered text: "Dr. Elena Rodriguez." Turns out this is a name Claude Sonnet 3.6 disproportionately favors when asked to generate a fictional scientist for synthetic data generation, so it got baked into every finetune that used LLM-generated training data, and CDD pulled it back out. We wrote up this specific finding on its own a few weeks back if you want the more accessible version first: ghost couple Paper: paper Code: code submitted by /u/CebulkaZapiekana [link] [留言]