标签：#r

The tech world has spent the last year buzzing about the complete rewrite of the TypeScript compiler. Now that TypeScript 7.0 is officially out, the headline is clear: a native Go port delivering 8x to 12x build speedups and an instant editor experience. But if we look past the raw performance numbers, TypeScript 7.0 represents something much deeper. It is the most aggressive modernization sweep in the language's history. The TypeScript team used this architectural migration to eliminate a decade of technical debt, kill off legacy web standards, and restructure how the compiler interacts with the JavaScript ecosystem. If you are planning to upgrade your frontend or backend repositories, here is what actually matters, why the team chose Go, and the breaking changes you need to prepare for. 1. The Architectural Plot Twist: Why Go and Not Rust? When Microsoft first announced they were moving away from a bootstrapped JavaScript compiler to a native binary, the collective internet assumed they would choose Rust—the darling of the modern frontend tooling space (used by SWC, Turbo, and Oxc). Instead, the team chose Go , sparking heavy debate across the community. The reasoning reveals exactly how the TS team prioritizes stability over absolute micro-benchmarks: Bug-for-Bug Compatibility: The goal wasn't to write a brand-new compiler from scratch; it was a 1:1 faithful translation of the massive, decade-old TypeScript codebase. Go’s straightforward syntax allowed a clean mapping of existing JavaScript logic. The Memory Model Challenge: Compilers are inherently full of deeply nested, circular object graphs (ASTs, symbol tables, type structures). Managing these in Rust without heavily leaning on unsafe blocks or running into a brick wall with the borrow checker would have taken years. Garbage Collection Alignment: Go’s built-in garbage collection mirrors JavaScript’s memory model elegantly. This allowed the team to achieve multi-threaded parallelism safely and ship a stable p

Hi everyone! I’m a developer at the beginning of my journey, and I’ve just finished working on a small project that brought me a lot of joy: Capybara Game. It’s a cute game where you feed your capybara and improve her happiness level. You can choose between 5 different types of food or pick your own snack. If the capybara likes the snack, her happiness level rises; if she doesn't like it, the happiness level falls. Your progress is saved automatically. Keep in mind that your capybara gets hungry over time, so make sure to check back and feed her regularly! I went for a minimalist, cozy design. The interface is clean and intuitive, focusing on a relaxing user experience that lets the player focus entirely on the capybara. I built this project using HTML, CSS, and JavaScript. Hope you're interested in playing! You can do it here: Play the game here I’d love to hear your thoughts! If you have any ideas for new features or if you find any bugs, feel free to let me know in the comments.

TL;DR Welcome back to Dev Opportunity Radar. This is a weekly series where I share opportunities,...

The CEO of Foundation Future Industries, which counts the president’s son as its chief strategy adviser, tells WIRED it’s exploring some “kinetic things.”

QCon AI Boston 2026 focused on the operational challenges of deploying AI agents, emphasizing the need for robust production infrastructure. Key themes included improving context management, ensuring security through a "harness" around agents, and adopting a comprehensive engineering model for AI. By Tatiana Fesenko

Perimenopause has entered the chat. Perimenopause—and its better-known relative, menopause—used to be considered taboo. Not anymore, thanks at least in part to TV doctors and social media influencers. Perhaps it’s my age, but these days, both my algorithm and my conversations with friends increasingly swing toward perimenopause. Menopause is defined as the life stage that…

Every morning, airline dispatchers, grid operators, and farmers around the world make decisions based on the same thing: a weather forecast. While these forecasts are something that most people glance at for two seconds, weather predictions influence major strategic decisions in many industries, with real money, livelihoods, and even actual lives at stake. Farmers use…

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

Coca-Cola halts the US operations of its dairy company fairlife due to a ransomware attack.

A practical, end-to-end walkthrough of taking a read-only slice of an enterprise source system and exposing it to an AI agent as a set of Model Context Protocol (MCP) tools — using Azure Logic Apps, API Management, and Agent Foundry. All identifiers below are placeholders; swap in your own. The goal We wanted a simple outcome: a user asks a business question in plain language and gets a straight answer — no dashboards, no field names, no training on the underlying system. That means an AI agent with safe, read-only access to a backend system of record, exposed as discrete tools the model can call. The constraints shaped every decision: Read-only. The agent can retrieve and analyze, never write. Safe. Records in most business systems contain free text (notes, subjects, descriptions) that could carry prompt-injection payloads. Tool output must be treated as data, never instructions. Composable. The agent should see many small, well-described tools — "list records", "aggregate by category", "record change history" — not one giant "query the system" tool. The architecture Five layers, one direction of flow: Agent (Agent Foundry) │ MCP (JSON-RPC over HTTP) ▼ MCP server (API Management) │ REST operation per tool ▼ API gateway (API Management) │ single POST, routed by body ▼ Tool executor (Logic App) │ OAuth token + REST calls ▼ Source system (REST API) The key design choice: one backend endpoint, many logical tools. The Logic App exposes a single HTTP trigger that accepts { "tool": "records.list", "parameters": { ... } } and routes internally. API Management then fans that single endpoint out into many named operations, and its MCP feature turns those operations into agent tools. This keeps the backend trivial to maintain while the agent still sees a rich, typed tool catalog. Step 1 — Design the tools Start from the questions , not the schema. A useful toolset usually falls into a few families: Records: list / get / search / filter for the core business entities. Activity

GitHub announced enterprise-managed OpenTelemetry export for Copilot activity from VS Code and Copilot CLI on July 8, 2026. Primary source: GitHub Changelog, July 8, 2026 . Export availability is only the start. The receiving collector becomes an enterprise ingress point. This is an unexecuted operating plan; signal types, attributes, endpoint requirements, and controls must be checked against current GitHub documentation. Isolate the path managed clients -> private telemetry ingress -> dedicated OTel Collector pool -> field policy + bounded queue -> dedicated backend dataset Do not point every developer client directly at the primary observability backend. Give the collector write-only destination credentials, separate its dataset from production application telemetry, and define retention before rollout. Isolation is not anonymity. Stable user, device, organization, or repository identifiers may still be sensitive. Start with a field budget Category Initial policy Product and version Keep bounded values Operation and status Keep documented enums Timing and counts Keep numeric measures Raw prompts or generated code Drop by default File paths and repository URLs Drop or transform after review User identity Prefer scoped pseudonymous identity Free-form errors Drop raw text; keep reviewed classes These categories are recommendations, not a description of GitHub's payload. Inspect a restricted canary before naming actual keys. processors : memory_limiter : check_interval : 1s limit_mib : 512 spike_limit_mib : 128 attributes/field_budget : actions : # Illustrative keys only; replace after payload review. - key : user.email action : delete - key : file.path action : delete - key : command.arguments action : delete batch : send_batch_size : 512 timeout : 5s Verify processors against the chosen Collector distribution. A valid startup does not prove that records satisfy policy. Drill three failures Backend outage: block the exporter. Retries must be bounded, queue growth vi

OpenAI published an audit of SWE-Bench Pro on July 8, 2026 and estimated that roughly 30% of its tasks are broken. The reported issues make a familiar leaderboard assumption unsafe: every task in the denominator is a valid, equally interpretable trial. Primary source: OpenAI, “Separating signal from noise in coding evaluations” . The operational response should not be “ignore all benchmarks.” It should be: version task validity, preserve disputed cases, and publish how conclusions change across plausible denominators. Model task state separately from model result task validity: unreviewed | valid | broken | disputed model result: pass | fail | infrastructure_error | missing Never convert infrastructure_error to model failure without reporting that policy. Never delete broken tasks while retaining an old score label. A row needs provenance: { "task_id" : "repo-issue-17" , "dataset_revision" : "sha256:..." , "harness_revision" : "git:..." , "model_config" : "immutable-config-id" , "validity" : "disputed" , "result" : "pass" , "review_revision" : 3 , "evidence" : [ "fixture.log" , "review.json" ] } Publish three denominators Let: P_v , N_v : passes and total among reviewed-valid tasks; P_a , N_a : passes and total across all attempted tasks; D : disputed tasks. Report: valid-only score = P_v / N_v all-attempted score = P_a / N_a uncertainty interval = score if every disputed task hurts conclusion .. score if every disputed task helps conclusion This interval is not a statistical confidence interval. It is a sensitivity bound for unresolved task validity. A tiny sensitivity calculator #!/usr/bin/env python3 import json , sys rows = [ json . loads ( line ) for line in open ( sys . argv [ 1 ]) if line . strip ()] valid = [ r for r in rows if r [ " validity " ] == " valid " ] disputed = [ r for r in rows if r [ " validity " ] in ( " unreviewed " , " disputed " )] attempted = [ r for r in rows if r [ " result " ] in ( " pass " , " fail " )] rate = lambda passed , total : pa

What happens when you stop writing controllers, services, repositories and mappers - and let PostgreSQL be the backend. MIT-licensed, and yes, I built it. Full disclosure right away: I built the thing I'm about to show you. It's called NpgsqlRest , it's MIT-licensed, there is no paid tier, no telemetry, no "book a demo" button. I'm just a guy who spent two years deleting layers from his stack and now wants to show someone the hole where the backend used to be. The standard pattern The standard data access pattern for modern business applications looks like this: UI → Fetch → Controller → Service → Repository → ORM → SQL → Database Seven arrows. And if you look closely at what most of those layers actually do - they take data from one side and pass it to the other side, slightly renamed. The Controller maps the request to a DTO. The Service passes it to the Repository. The Repository asks the ORM nicely. The ORM generates SQL that you then inspect in a log because you don't trust it (correctly). We built entire careers on maintaining this pipeline. I know because I did, for decades. But once you realize database-aware tests are trivial to wire up, you can drop the Repository. Once you get good at SQL, you can drop the ORM. And then you look at the Controller and realize it's just boring glue code that ships bytes between HTTP and the database. Glue code can be automated. So: UI → Database That's it. That's the architecture. Show me or it didn't happen Fine. This is a file called users.sql . Not a function, not a stored procedure - a plain SQL file sitting in your repo: /* HTTP GET /users/ @authorize admin, user @cached @cache_expires_in 30sec @timeout 5min @param $1 department_id text */ select id , name , email , role from users where $ 1 is null or department_id = $ 1 ; You run npgsqlrest (a single native executable, no runtime to install) pointed at your PostgreSQL, and: $ curl -s 'localhost:8080/users/?department_id=1' | jq [ { "id": 1, "name": "Alice", "email":

OpenAI published “Why teens deserve access to safe AI” on July 16, 2026, describing its approach around learning, age-appropriate safeguards, parental controls, and work with external experts and organizations. Primary source: OpenAI, “Why teens deserve access to safe AI” . This raises a concrete product-design question for any teen-facing AI experience: after a safeguard intervenes, can the user understand what happened and continue toward a legitimate goal? A generic “I can't help with that” may block harmful output, but it can also strand a learner, conceal an emergency path, or encourage prompt reformulation without increasing safety. Below is a design hypothesis and research plan—not a claim about OpenAI's current interface. Design three outcomes, not one refusal request -> proceed with age-appropriate help -> redirect to a safer learning path -> escalate urgent risk to immediate support options The system should not expose its detection thresholds or provide a bypass recipe. It should explain the next safe action in plain language. Annotated response pattern [1] Clear boundary I can't help plan ways to hurt yourself. [2] Immediate check Are you in immediate danger right now? [3] Reachable actions [Call local emergency services] [Contact a trusted adult] [View crisis resources] [4] Safe continuation I can stay with you while you choose someone to contact, or help write a message. [5] Privacy explanation If this experience shares information with a parent or guardian, explain what, when, and why before asking the user to continue, except where law or immediate safety obligations require otherwise. Annotations: Boundary names the category without scolding. Check uses a direct, answerable question. Actions are not hidden in a paragraph. Continuation gives the conversation a safe purpose. Privacy avoids promising confidentiality the product cannot guarantee. Emergency resources must be localized and maintained by qualified teams. Do not hard-code one country's numb

GitHub announced Copilot Vision general availability on July 1, 2026, allowing developers to attach screenshots to Copilot conversations as visual context. Primary source: GitHub Changelog, “Copilot Vision is generally available” . A screenshot can shorten “make this component look like that.” It can also become an invisible source of truth: unlabeled attachment controls, image-only requirements, generated markup with no semantics, and an error state communicated only by a thumbnail badge. The accessibility target should be stronger than “a screen reader can upload a file.” A keyboard or screen-reader user must be able to understand the supplied requirements, remove or replace the image, follow processing state, and verify the generated interface. Add a text contract beside the screenshot Use a structured alternative, not a filename: <fieldset> <legend> Reference design </legend> <label for= "shot" > Screenshot </label> <input id= "shot" type= "file" accept= "image/png,image/jpeg" /> <label for= "requirements" > Required behavior and content </label> <textarea id= "requirements" aria-describedby= "requirements-help" ></textarea> <p id= "requirements-help" > Describe text, controls, order, states, and behavior that must not be inferred from appearance alone. </p> <p id= "upload-status" role= "status" aria-live= "polite" ></p> </fieldset> Example text contract: Dialog title: Delete workspace? Body: This cannot be undone. Focus starts on Cancel. Tab order: Cancel, Delete, close button. Escape closes and returns focus to the launch button. Delete is destructive; color is not its only indicator. The screenshot communicates spacing and visual hierarchy. The text carries names, order, behavior, and safety requirements. Model attachment states explicitly type AttachmentState = | { kind : ' empty ' } | { kind : ' reading ' ; name : string } | { kind : ' ready ' ; name : string ; alt : string } | { kind : ' error ' ; name : string ; message : string }; Render each state with

Vercel published an OpenAI Agents SDK with FastAPI template on July 17, 2026. A template can remove setup work, but successful generation is not the production boundary that usually breaks. Task ownership is. Primary source: Vercel template, “OpenAI Agents SDK with FastAPI” . Before adopting any agent starter, I would add one vertical test: Alice must be able to create and cancel her task; Bob must not be able to read, stream, or cancel it—even if he guesses the task ID. State the cross-layer contract UI -> POST /tasks -> ownership row -> worker UI <- GET /tasks/:id <- authorization <- state UI <- event stream <- authorization <- events UI -> POST /tasks/:id/cancel -> authorization -> cancellation Use explicit states: queued -> running -> succeeded -> failed queued|running -> cancelling -> cancelled The database, API response, stream, and UI must agree on the same task and owner. Minimal schema create table tasks ( id text primary key , owner_id text not null , state text not null check ( state in ( 'queued' , 'running' , 'succeeded' , 'failed' , 'cancelling' , 'cancelled' )), created_at text not null , updated_at text not null , revision integer not null default 0 ); create table task_events ( task_id text not null , revision integer not null , kind text not null , payload text not null , primary key ( task_id , revision ) ); Do not derive ownership from a browser-supplied field. Resolve the authenticated principal on the server and store it when creating the task. FastAPI authorization seam from fastapi import Depends , FastAPI , HTTPException app = FastAPI () def current_user (): # Replace with verified session/JWT middleware. return { " id " : " alice " } def load_owned_task ( task_id : str , user = Depends ( current_user )): task = db_get_task ( task_id ) # application function if task is None or task [ " owner_id " ] != user [ " id " ]: # Avoid revealing whether another user's task exists. raise HTTPException ( status_code = 404 , detail = " task not found " )

OpenAI's July 14 guidance for managing AI investments recommends five moves: improve visibility into usage and spend, evaluate efficiency by outcome ROI, govern advanced workflows before scaling, fund workflows that compound, and match capacity to proven demand. Primary source: OpenAI, “How to manage AI investments in the agentic era” . The hard part is the denominator. “This agent used $800” says little. “This workflow cost $14 per accepted reconciliation, including review and rework” can support a decision. Here is a one-page ledger I would require for an agent pilot. Define one accepted outcome Do not start with tokens, seats, or tasks launched. Define the business state that counts after review. workflow : vendor-invoice-reconciliation accepted_outcome : " invoice matched, exceptions reviewed, result posted" owner : finance-ops pilot_window_days : 21 minimum_sample : 100 invoices quality_gate : false_postings : 0 exception_recall : " >= 0.98" reviewer_minutes_p50 : " <= 3" A generated draft is not an outcome if a person must rebuild it. An agent run is not successful if its result never enters the system of record. Capture the complete cost AI cost + orchestration and observability + human review + rework + incident handling + allocated implementation cost = total workflow cost Use a table with declared variables: Variable Meaning Example only C_model model and tool-call spend $600 C_platform workflow infrastructure $200 H_review reviewer hours 35 R_hour loaded reviewer rate $45 C_build pilot build cost allocated to window $2,000 N_accept accepted outcomes 850 total = C_model + C_platform + H_review * R_hour + C_build cost_per_accepted_outcome = total / N_accept With the illustrative numbers, total cost is $4,375 , or about $5.15 per accepted outcome. These are not benchmark claims; replace every value with measured data. Compare against the real baseline The baseline must use the same unit and quality gate: Metric Manual baseline Agent pilot attempted invoices