标签：#m

submitted by /u/DataBaeBee [link] [留言]

Programming languages are fascinating. Learning how they work shouldn’t feel like fighting a dragon. On Monday, August 3, 2026, I’m launching Tiny Interpreters , a new blog and newsletter about learning how programming languages work, one tiny interpeter at a time. We’ll begin by building the interpreters in Elm, one language feature at a time. It’s for Elm developers, functional programmers, and anyone curious about programming languages who would rather begin with something small and understandable than confront an entire compiler at once. Each interpreter will introduce one carefully chosen idea and follow it through the language’s design and implementation. We’ll build up our understanding gradually, allowing the deeper ideas to emerge from programs we can see, run, and reason about. Tiny Interpreters is the path into programming languages I wish I could have followed when I first tried to learn the subject. It took me years—and one unsuccessful encounter with a dragon—to find that path for myself. My first encounter with the dragon I became interested in programming languages when I discovered that studying, designing, and building them brought together several fields I enjoyed: mathematics, computer science, and software development. My university didn't offer a course in programming languages or compiler construction while I was there, so I had to explore the subject on my own. A professor whose opinion I respected pointed me towards Compilers: Principles, Techniques, and Tools , better known as the Dragon Book—the textbook the university had used when it still offered the compilers course. I ordered a copy through the university bookstore. When it arrived, I eagerly began working through it, but I didn't get very far. I learned a great deal about parsing and syntax-directed translation, but I still lacked a clear framework for understanding how programming language features were designed, implemented, and made to work together. In hindsight, the Dragon Book

Overview mise is one of the cleanest ways to make a repository's tool environment explicit. It can tell contributors, CI, and agents which runtime versions and command environment a project expects. That matters. But a resolved environment is not the same thing as accepted repository execution. mise helps answer: Which tools and versions should this repo use? Ota answers a different question: Is the selected repo path ready, safe, canonical, and verified? Those two layers work well together because they solve different parts of the same operational problem. For modern repositories, especially ones touched by AI agents, that distinction matters. The failure is not always "wrong Node version" or "missing Python". Many repo failures happen after the right tools are already present. The repo still needs to declare setup, task truth, readiness, verification, agent safety, runtime mode, and proof boundaries. That is Ota's layer. What mise Is Good At mise is good at environment and tool resolution. It gives a repo a compact way to declare things like: which Node version should be used which Python, Go, Ruby, or other tools matter which tool versions should be installed or activated which command environment should be entered which repo-owned task aliases should exist That is valuable for contributors and agents because it reduces host guesswork. Without a tool manager, a new contributor may have the wrong runtime, a stale global binary, or an old package manager sitting on PATH . With mise , the repo can make more of that explicit. That is a strong foundation. Where Environment Resolution Stops The problem starts when teams treat environment resolution as repository acceptance. They are not the same thing. The right tools can be installed and the repo can still be ambiguous about: which setup path is canonical whether dependencies have been hydrated whether services are required whether test , check , ci , or verify is the accepted lane whether local and CI execution agree

Hello Im Turbo i Want To Develop A Graphical App With "OpenGL" And "C++" My App Is The Simulator Of Gravity For Using The OpenGL I Need To Learn "GLSL" Language Or No And I Can Write All Program With The "C++" Language ؟ ؟؟؟؟؟؟

Across New York City, London, and Washington, DC, ads for Meta's smart glasses have been plastered over with satirical posters from activist groups. One guerrilla ad calls these "the biggest advancement in pervert technology since the trenchcoat." Another transposes the words "mass surveillance predator glasses" over influencer Kylie Jenner's face, calling her out for partnering […]

Elena van Engelen discusses how to eliminate serverless vendor lock-in without sacrificing native cloud capabilities. She explains how to structure FaaS applications using Clean Architecture, Spring Cloud Function, and Gradle modules to isolate business logic. Finally, she shares a live demo deploying portable Kotlin services across AWS and Azure using Terraform CDK for multi-cloud IaC. By Elena van Engelen

Yet another Israeli mass surveillance company : Made by Israeli surveillance company Cognyte, the tech simulates a mobile phone tower, which forces nearby phones to connect to it. That enables cops to keep tabs on any phones in the vicinity ­ whether they’re owned by a suspect in a case or not. Cognyte’s contract with the state of Texas reveals that the simulator, called FalcoNet, can be concealed within the vehicles, hidden in a backpack for on-foot missions or attached to a helicopter. It’s the same technology as the infamous Stingray, one of the original cell-site simulators made by defense giant L3Harris...

Lightweight, powerful, and generally inexpensive, the handheld vacuum is the perfect household helper.

Ads on Instagram, TikTok, and YouTube are painting prescription stimulants in a negative light while promoting supplements for ADHD that lack evidence.

Traditional API gateways assume deterministic services and simple schemas - assumptions agentic AI breaks. Discover why enterprise engineering leaders are adopting AI Gateways as an evolutionary architecture seam. Centralize guardrails, model routing, agent identity, action policy, and semantic audit within a single control plane to prevent costly incidents while keeping core platforms stable. By Joe Price, Branimir Đurek, Pavlos Migkiros, Trevor Dearham

“It’s not an argument with two sides, it’s an argument with 10 sides,” one senior administration official tells WIRED about how US AI policy is being shaped.

On Monday, the network announced a $1.6 million seed round from top players in the media ecosystem, including Powerhouse Capital, Axel Springer SE (which owns Business Insider and Politico), the popular media publication LadBible, and angel investors from OpenAI and DeepMind. With this fresh capital, the network is announcing its largest expansion yet.

📌 TL;DR Three months ago, I decided to start writing consistently on DEV. Twenty-five articles...

Most teams blame their model provider when the inference bill spikes. They're looking at the wrong line item. The real leak is architecture — and it's the difference between a token bill that scales with value and one that scales with chaos. Here's what we see shipping agentic systems in production. The hidden multiplier: agent loops A "2-minute task" is never one call. An agent fires 30–60 tool calls per run, and most frameworks stuff the entire conversation history into every prompt. So a job you'd estimate at ~4K tokens becomes 40 calls × 8K context = 320K tokens — billed at frontier rates. Frontier pricing per call looks cheap. Multiplied by agent-loop iterations, it quietly becomes the largest line in your cloud bill. The 80/20 of inference Not every call needs a frontier model. ~80% of agent traffic is routing, extraction, formatting, classification, summarization. Trivial. Leading efficient models — including top China models — handle these at near-parity. ~20% is genuine reasoning, open-ended generation, ambiguous planning. That's where frontier earns its price. Route the 80% to efficient models and reserve frontier for the 20%. Same output quality. A fraction of the bill. A unified gateway beats a drawer of API keys The trap most teams hit: they wire 4 providers with 4 clients, then let a naïve router "roam" between them. On failover it loses cache affinity, re-embeds context, and your 1.5x cost target drifts back toward ~1x — or worse. A single OpenAI-compatible endpoint across OpenAI + Gemini + leading China models fixes this: One client, one code path. Provider pinning holds cache locality; it only fails over on hard error, not price drift. Your application code never changes when you swap a model. In SEA, "PDPA-aligned" is the baseline, not a premium For Malaysia and SEA teams, inference isn't just a cost question — it's a compliance one. PDPA requires 72-hour breach notification and a designated DPO. In-region data residency (SG-hosted) is now the defa

As part of the Förderverein AWS Community DACH e.V. I joined the selection committee for talks again this year. Third year in a row (I wrote about the previous editions and my broader community journey in my 2025 year in review ). The process is always inspiring, fair, and full of incredibly well-crafted abstracts. How the evaluation works Sessionize uses a Comparison Evaluation Mode based on the Elo rating system (from chess). Three sessions are shown at the same time and you rank them relative to each other. You don't assign absolute scores; you just decide "this one is better than that one." Each comparison produces three "games" (A vs B, B vs C, C vs A) and the algorithm adjusts ratings accordingly. After a first pass through all sessions, the system gets smarter about which triplets to show next, targeting sessions with similar ratings for more precise differentiation. It's fast, focused and surprisingly fair, because you only ever think about the three in front of you, not all others. You can also use "Strong opinion" options: Top (this is excellent), Doesn't fit (wrong conference), or Ignore (conflict of interest, can't judge). These signal the algorithm without distorting the ranking. In my case: I marked 2 as "Doesn't fit" (not because they lacked quality; they were actually interesting but too inspirational for a technical community day, better suited for a different audience). The other 2 ignored were my own submissions : Vibecoding in Between Meetings and Serverless vs Kubernetes - The Final Showdown . The full process The behind-the-scenes post by Philipp Garbe explains the whole pipeline in detail. In short: Round 1 (Screening): Board members filter out spam, incomplete proposals, marketing pitches, non-AWS topics, and speakers outside EMEA. Round 2 (Content Evaluation): Every association member can participate. This is the Elo-based comparison round. Members must disclose personal connections and skip sessions they can't rate objectively. Round 3 (Fin

As the US sees its highest number of measles cases in decades and vaccination rates fall, researchers are developing drugs to help those who contract the virus or who are particularly vulnerable.

After you deploy half a dozen AI agents across a team, something weird happens. Friday afternoon, release day. The PM says their AI summarized the change impact. The dev says their AI reviewed the code and found nothing. QA says their AI ran the test suite and everything passed. Then production breaks. You dig through the logs and all you see is "system call." No way to tell which agent made which call, when, on what context, acting on whose behalf. Three agents sharing one service account, one API key, zero accountability. The humans end up taking the fall, and you can't even figure out which human to talk to. This isn't a thought experiment. It's what happens when you bolt AI assistants onto existing infrastructure without thinking about identity. Buy a batch of API credits, create a service account, share it across the team, done. That works fine when one person uses one assistant for their own work. It falls apart the moment multiple agents run in parallel across different roles. Permissions break first. A competitive research agent needs access to all project channel discussions. A code review agent should only see PRs and repository messages. That distinction doesn't exist in the service account model, which has a single binary switch: can access or cannot access. Teams work around it by manually creating groups, forwarding messages, and setting permission boundaries by hand. Add more agents and this manual isolation starts to crack. Some teams we've talked to ended up with over a dozen separate groups just to control agent visibility, with humans acting as message routers between them. At that point the AI is making things slower. The work history problem is more concrete. An engineer who's been on the team for three months, you know what they're good at, what they're sloppy at, which module they crushed last sprint. Next time you assign work, you use that information. An agent that's run a hundred tasks? Completion rate, rejection count, which task types it

Clear a corner of your workbench and gather a handful of parts, because this palm-sized television is an afternoon build, not a semester project. Here is the shopping list for a Scanwheel of your own: A Raspberry Pi Pico to run the show An A4988 stepper driver A 21-02485 stepper motor (or a similar small NEMA-style unit) Five LEDs, plus current-limiting resistors A 3D-printed case and spinning disk The Scanwheel, built by a maker who goes by [Ancient], is a mechanical TV that fits in your hand. Instead of a glowing panel, it leans on persistence of vision: your eye holds each flash of light for a fraction of a second, so a row of blinking LEDs seen through a moving slit reads as a solid picture. Spin the disk fast enough and the flicker melts into an image. How the picture actually forms The disk sitting on top of the case carries 20 small holes spaced evenly around its edge, each drilled at a slightly different height. As the motor turns, only one hole passes in front of the LEDs at a time, so light escapes in a scanning line rather than a wash. The Pico drives the stepper up to roughly 900 RPM through the A4988, then fires the LEDs in a precise order timed to the disk position. Get that timing right and the holes trace out a grid. The payoff is a 20x20 pixel color display in the center, flanked by two more 20x20 black-and-white panels that can each show a different image. Five LEDs feed all three. The whole coordination job lives on the Pico's GPIO pins, which is why the wiring stays simple enough to manage on a breadboard before you commit anything to a soldered protoboard. Small light baffles in the base keep the LEDs from bleeding into each other, a detail worth copying if your first image looks smeared. Give it a spin The full build guide, firmware, and disk files are on the project's GitHub repository , so you can match the hole spacing and LED timing exactly. If your image drifts or tears, start by trimming the RPM and re-checking when each LED switches rela

Hello everyone, I am currently building a high-performance API gateway that integrates business logic components—implemented via WASI and running within Wasmtime—as HTTP/TCP/QUIC handlers. I am exploring the best design approach to achieve a zero-copy data path from the upstream network layer—specifically hyper for HTTP/1.x and HTTP/2, and h3-quinn (based on Quinn) for HTTP/3—to the wasi:http guest environment. Given that: hyper and h3-quinn each manage their own internal buffer pools (e.g., bytes::Bytes ), asynchronous read/write streams, and frame decoders. Wasmtime's wasmtime-wasi-http implements the wasi:http (WASIp2) specification, which relies on resource types such as InputStream and OutputStream . I aim to minimize memory copying and CPU overhead when passing large request bodies or streaming responses across the sandbox boundary. For those experienced with bridging I/O between the host and guest in Wasmtime, I have a few architectural questions: Buffer ownership and memory mapping: How can host-side bytes::Bytes (from hyper or h3-quinn ) be mapped or bridged into Wasm linear memory (and vice versa) without requiring a CPU-based memcpy ? Does Wasmtime's resource streaming support direct memory views, or are we essentially limited to copying data chunks via guest memory pointers? Adapting stream abstractions: hyper uses http_body_util::combinators / http_body::Body , h3 uses its own stream primitives, while wasi:http uses wasi:io/streams . What is the idiomatic way to efficiently adapt these asynchronous streams on the host side (i.e., within the wasmtime-wasi-http handler implementation) without blocking the tokio runtime? Backpressure propagation: How can backpressure signals be correctly propagated from the Wasm guest (e.g., when the guest's InputStream is consuming data slowly) all the way back to the Quinn congestion controller or Hyper connection pool, thereby avoiding unbounded buffering on the host side? If anyone has built similar high-performance ga

இன்னும் ஜோஷ்! 🔥 முதல் நாள் St. Joseph's Institute of Technology, சென்னையில ஜோர்தான் இருந்தது. இரண்டாம் நாள் வந்ததும் என்னன்னா, க்ரவுட் இன்னும் அமைதியா, ஆனா உள்ள ஆர்வம் இன்னும் ஜாஸ்தியா இருந்துச்சு. எல்லாரும் "இன்னிக்கி ரொம்ப tech-ஆ போகணும்" னு மனசுல வெச்சிட்டு உட்கார்ந்திருந்தாங்க. இண்டு "தமிழன் நினைச்சா முடியாதது இல்ல" ங்கிற வார்த்தை என் மனசுல ஓடிக்கிட்டே இருந்தது — ஒரு சின்ன அறையில கூட, கம்ப்யூட்டர் screen-ல open source code-ஐ பார்த்துக்கிட்டே இருந்தா, அது எவ்ளோ பெரிய புரட்சின்னு தெரியும். FOSS-ன்னு சொல்ற ஒவ்வொரு லைனும், நம்ம மொழியில நம்ம கம்யூனிட்டியால எழுதப்படுற ஒவ்வொரு code-உம் ஒரு சிறிய வெற்றி தான். Session 1: வேகமா App கட்டணுமா? Meet Framework இருக்கே! 🚀 முதல் session-ல Meet Framework அறிமுகமானது — Python + JS ரெண்டையும் சேர்த்து ஒரே கூரையின் கீழ கொண்டு வர்ற ஒரு full-stack framework. இது என்ன பண்ணுது தெரியுமா? "Setup fatigue" ங்கிற பெரிய பிரச்சனையை ஒரே அடியில தீர்க்குது. Backend, frontend, database எல்லாத்தையும் தனித்தனியா தேடி, ஒட்டி, configure பண்ணி — இதெல்லாம் இல்லாம, ஒரே framework-ல எல்லாமே ready-ஆ இருக்கும். Speaker live-ஆ ஒரு app-ஐ கட்டி காமிச்சாங்க — routing, models, ஒரு simple UI எல்லாம் நிமிஷங்களில ready! அது பார்க்கும்போதே ஒரு எனர்ஜி கிடைச்சது. "Idea இருந்தா போதும், tool நம்ம கூட இருக்கு" ங்கிற நம்பிக்கை தான் FOSS-ன்ற அழகே. சின்ன Motivation: ஒரு framework கத்துக்கிறதும், ஒரு புது மொழி கத்துக்கிறதும் ஒண்ணுதான். ஆரம்பத்துல கஷ்டமா தான் தெரியும், ஆனா ஒரு அடி எடுத்து வெச்சா, மொத்த பாதையும் தெளிவா தெரியும். "தொடங்குறது தான் பாதி வெற்றி!" Session 2: NPM vs NixOS — ஒரு "Love-Hate" Relationship 😅 இரண்டாவது session ரொம்ப relatable-ஆ இருந்தது — NixOS-ல npm use பண்றது! அறையில இருந்த பலருக்கும் இது தெரிஞ்ச பிரச்சனை தான், எல்லாரும் தலையாட்டிட்டே இருந்தாங்க. பிரச்சனை என்னன்னா — Nix ரொம்ப strict-ஆ இருக்கும், file system-ஐ read-only-ஆ வெச்சிருக்கும். அதனால npm சாதாரணமா install பண்ற மாதிரி இங்க straight-ஆ வேலை செய்யாது. Speaker மூணு வழிகள் சொன்னாங்க: Local user prefix வெச்சு — npm-ஐ ஒரு writable இடத்துல install பண்ண வைக்கிறது. node2nix use பண்ணி — npm dependencies-ஐ