标签：#go

Beyond the consumer surfaces most people know, the Gemini app and Gemini Notebook (formerly NotebookLM), Google offers a whole set of AI tools and interfaces built for developers and enterprise teams. At first glance, it's a lot to wrap your head around. AI Studio, Gemini Enterprise Agent Platform, the Gemini Enterprise app, Antigravity in its various forms. The names overlap, the marketing language overlaps, and it's not obvious where one tool's job ends and another's begins. AI Studio is for prototyping and building web and Android apps AI Studio is where you test a prompt, try a multimodal input, or compare models before committing to anything. It also builds full applications straight from a prompt, complete with backend infrastructure. When your app needs to store data or handle sign-ins, AI Studio provisions a database and authentication for you, either Cloud Firestore or Cloud SQL for a relational setup, and Firebase Authentication, without you configuring any of that by hand. It also connects to Google Workspace APIs, so an app you build there can work with a user's real Gmail, Docs, Sheets, or Calendar data. It supports mobile app development as well, for native Android apps. Use AI Studio when you want to validate an idea or ship a lightweight web or Android app fast, with real backend support, and without provisioning any Google Cloud infrastructure yourself. Gemini Enterprise Agent Platform is where agents actually get built This is the next generation of Vertex AI. Google folded Vertex AI's entire service catalog, model access, custom training, evaluation, pipelines, all of it, into what's now called the Agent Platform. If you go looking for Vertex AI in the console today, it redirects you here. This is the one-stop shop for the full agent development lifecycle. You build with Agent Studio, the low-code visual builder, or the Agent Development Kit for code-first development in Python, Go, Java, or TypeScript. Agent Engine handles the managed runtime, Mo

Google is rolling out an update that will finally allow you to connect your Fitbit workouts, steps, vitals, and other data to Apple Health, as reported earlier by 9to5Mac. With Google Health's 5.05 update, you can now tap your profile icon, select "Partner apps," and choose Apple Health to link your data directly. Previously, you […]

The orbiting observatory in minifigure scale.

This story originally appeared in The Algorithm, our weekly newsletter on AI. To get stories like this in your inbox first, sign up here. Humanoid robots usually elicit more cringe than awe: They stumble, kick children, and despite advances are still worse at using their hands than my toddler. It’s a nascent industry, and such robots…

Google's AI assistant can "use your logged-in accounts and saved passwords to handle tedious web errands."

Hugging Face has published a detailed timeline of the attack. From the summary: The agent was running an internal OpenAI cyber-capability evaluation based on the ExploitGym benchmark, which tasks an AI agent with finding and exploiting software vulnerabilities. OpenAI ran this on its own infrastructure, and the ExploitGym maintainers and their infrastructure had no involvement in the deployment or operation of that evaluation environment. As far as we were able to infer, across the course of being evaluated on this benchmark, the agent inferred that Hugging Face may host that benchmark’s models, datasets, and reference solutions. We believe the entire intrusion was, from the agent’s point of view, an attempt to cheat the evaluation: reach our production systems and steal the test solutions rather than solve the challenge on its own...

House spending records show OpenAI's ChatGPT dominates paid AI use on Capitol Hill, with congressional offices relying on the chatbot to draft memos, summarize legislation, and assist constituent communications.

Series: Platform engineering with Go | Topics: Go, Kubernetes, Cobra, client-go, metrics-server, Platform Engineering This is part of the Platform Engineering with Go series. This post builds on the Cobra CLI patterns from post 4 and client-go from post 3. Read post 4 first if you haven't yet. kubectl top tells you what's happening. It doesn't tell you how close to the edge you are. In post 3 and post 4 , we built a health reporter and learned how to structure a Go CLI with Cobra. Now we put both together into something with real operational value. kubectl top pods -n production NAME CPU ( cores ) MEMORY ( bytes ) go-api-7d6b9f8c4-xk2pq 240m 490Mi go-api-7d6b9f8c4-mn9rt 180m 210Mi go-api-7d6b9f8c4-p8wvz 200m 198Mi That first pod is using 490Mi of memory. Is that fine or is that a problem? Without knowing the limit, you can't tell. You'd have to run kubectl describe pod go-api-7d6b9f8c4-xk2pq , find the resources section, do the mental arithmetic, and repeat for every pod you care about. ferctl top does all of that in one command: ferctl top -n production NAMESPACE NAME CPU USE CPU REQ CPU LIM CPU% MEM USE MEM REQ MEM LIM MEM% STATUS production go-api-7d6b9f8c4-xk2pq 240m 250m 500m 48% 490Mi 256Mi 512Mi 95% !! CRITICAL production go-api-7d6b9f8c4-mn9rt 180m 250m 500m 36% 210Mi 256Mi 512Mi 41% OK production go-api-7d6b9f8c4-p8wvz 200m 250m 500m 40% 198Mi 256Mi 512Mi 38% OK One pod is at 95% of its memory limit. In production, that's a page waiting to happen. ferctl top catches it before it becomes an incident. What you'll learn How to extend the Cobra CLI structure from post 4 with a real subcommand How to query the metrics-server API using k8s.io/metrics How to correlate live metrics with pod specs to show usage vs limits How to implement configurable near-limit warnings How to format clean aligned output with tabwriter How to verify the tool against your real minikube cluster Prerequisites Posts 1–4 read; client-go patterns from post 3 , Cobra CLI structure from pos

Lenovo is expected to release some of the first Googlebook models later this year, and leaked images have now given us a good idea of what they might look like. Leaked press images shared by Digital Citizen and Android Headlines include a laptop and a 2-in-1 tablet, all of which feature Googlebook branding on the […]

GitHub热门项目 | DeepSeek-native AI coding agent for your terminal. Engineered around prefix-cache stability — leave it running. | Stars: 29,612 | 877 stars today | 语言: Go

If you just want the recommendation: build the uptime poller yourself, put exponential backoff with jitter in front of every health check, and treat a 429 as a scheduling signal instead of an error you swallow. Query-style observability APIs hand you metrics and logs, not threshold rules or notification channels, so the polling worker is the thing that has to decide what "down" means and who gets woken up. That decision is the whole job. I got burned by exactly this. What follows is the pattern that survived the postmortem, the alternatives I weighed before writing a line of it, and the conditions where you should not do any of this yourself. The 429 my retry loop ate for six hours Last spring I was running a homegrown health checker for 40 internal services. One goroutine per service, all driven off the same 15-second ticker, which meant every check landed inside the same 200ms window. The status API we polled had a per-minute quota I'd never bothered to read, and for months it didn't matter, because 40 checks a minute sat comfortably under the ceiling. Then a colleague onboarded 12 more services, we crossed the quota, and the API started answering with HTTP 429. My retry wrapper caught it, retried three times in a tight loop, and on the last attempt returned the previous cached result — which said healthy . It logged the rate limit at debug level. Nobody reads debug. Six hours. Green dashboard. Dead queue consumer. We found out when a customer asked where their export was. The consumer had died on an unrelated deploy, the checker never noticed, and when I finally restarted it the backlog got re-processed on top of a manual replay I'd already run — two customers got the same notification twice. Duplicate deliveries are the specific thing I lose sleep over, and I had caused a batch of them with a retry loop that was trying to be helpful. The postmortem produced one line I now paste into every runbook: a check that can't reach the API reports unknown, never healthy.

TL;DR: Google’s Gemini AI agents identified and helped remediate 1,072 Chrome security flaws in 60 days, dramatically shrinking the window for attackers. The race to protect 3.5 billion Chrome users has taken a high‑tech shortcut. Instead of relying solely on human researchers, Google deployed its Gemini‑powered AI agents to hunt for bugs, triage findings, and even suggest patches. The result? Over a thousand vulnerabilities squashed in just two months—a pace that would have taken years using traditional methods. How Gemini’s AI Agents Accelerated Chrome’s Bug Hunt Google’s internal security team integrated Gemini, the company’s latest large‑language‑model platform, into its vulnerability‑scanning pipeline. The AI agents performed three core tasks: Automated code analysis – By ingesting Chrome’s massive codebase, the models flagged risky patterns, unsafe API calls, and legacy modules that often hide bugs. Prioritization and risk scoring – Gemini assigned a severity score to each finding, allowing engineers to focus on exploits with the highest potential impact. Patch drafting assistance – For many low‑complexity issues, the AI generated candidate code changes, which senior engineers then reviewed and merged. The system worked in a loop: the AI scanned, reported, received feedback, and refined its heuristics. This iterative approach cut the average time‑to‑detect from weeks to hours and reduced manual triage effort by an estimated 40 %. The Scale and Impact of Fixing 1,072 Vulnerabilities During the 60‑day sprint, the AI‑augmented process uncovered 1,072 distinct security bugs across Chrome’s rendering engine, JavaScript runtime, and networking stack. Roughly half were classified as “high‑severity,” meaning they could have enabled remote code execution or data exfiltration. Key outcomes include: Reduced exposure window – The median time between bug discovery and patch release dropped from 45 days (historical average) to under 7 days. Broad coverage – The AI identifie

This essay originally appeared in Foreign Policy . Earlier this month, two of OpenAI’s models broke out of their containment sandbox and attacked another AI company. The story is kind of wild . OpenAI was running security tests on two of its models: GPT-5.6 Sol and an unreleased model that is almost certainly GPT-6. In particular, it was running the ExploitGym benchmark, which measures how good a model is at turning security vulnerabilities into working exploits: basically, offensive cyberattacks. Since these were internal tests, OpenAI locked those models in a secure sandbox that denied them access to the internet. But it was running the models without any safety filters that would prevent them from offensive cyber-actions. That meant that there was nothing to prevent the models from trying to ...

I Built a Language Where AI Calls Are Sandboxed by Default The 30-line Python problem Last month I needed a script that reads server logs, classifies errors with an LLM, summarizes them, and writes a report. In Python, it looked like this: Import the SDK Initialize the client Handle the API response Parse JSON Add asyncio.gather() because sequential calls took 8 seconds Write a custom sandbox because I don't trust LLMs with exec and file writes Package it in Docker because requirements.txt always breaks on the server 80 lines later , it worked. But it felt wrong. I wasn't building logic — I was plumbing. So I asked myself: What if AI operations were language primitives, not library calls? Meet Pipe Pipe is a small runtime (~10 MB, single binary, zero dependencies) that treats summarize , translate , classify , and ask as first-class citizens — on the same level as + , sort , or len . Try it Browser Playground (WASM, no install): pipe-lang.com Source: github.com/MachuraHarry/pipe Docs: pipe-lang.com/docs

Microsoft has released TypeScript 7.0, featuring a native compiler that improves build speeds by 8x to 12x. Notable performance enhancements were evidenced in real codebases. The version lacks a stable programmatic API, anticipated in 7.1. Transitioning includes a compatibility package for existing tooling, and TypeScript remains an open-source project. By Daniel Curtis

Let's see how this "frontier community for techno-optimists" is doing ...

Table of Contents Introduction Putting the 10x Claim Into Perspective How Did We Get Here? This Was an Extensive Evaluation The Priority Was Compatibility Why Not Rust? Why Not C#? Why Go Fit the Existing Compiler A Port, Not a Simple Translation Where Does the Performance Come From? Native Execution Parallel Processing Memory Efficiency and Larger Projects The Benchmarks Memory Usage The JavaScript API Trade Off Is It Still TypeScript? The F1 Analogy Large Companies Helped Test TypeScript 7 Should You Upgrade? Final Thoughts Introduction At the end of March 2025, I published this article: Go-ing Beyond TypeScript: Microsoft Picks Go: How Will This Change the Landscape? Giorgi Kobaidze Giorgi Kobaidze Giorgi Kobaidze Follow Mar 31 '25 Go-ing Beyond TypeScript: Microsoft Picks Go: How Will This Change the Landscape? # microsoft # typescript # go # csharp 1 reaction 2 comments 12 min read At the time, Microsoft's decision to port the TypeScript compiler to Go sparked quite a bit of discussion and controversy. Many people questioned whether moving such a critical piece of the ecosystem away from TypeScript was the right choice. And boy, did Microsoft deliver what it promised: an order-of-magnitude performance improvement on some of the world's largest TypeScript codebases. The results are here, and the benchmarks speak for themselves. Putting the 10x Claim Into Perspective The phrase "10x faster" describes the scale of the improvement Microsoft has demonstrated. It does not guarantee that every codebase will become exactly ten times faster. The results depend on the size of the project, the work being performed, and the available hardware. Some projects might see a 5x improvement, while others could reach 8x, 10x, 12x, or potentially even more. No, this doesn't make every TypeScript developer a 10x developer , But it does mean that compiling a TypeScript project, loading it in an editor, and receiving diagnostics could become dramatically faster after moving to the nat

Despite predictions that AI agents could make traditional apps obsolete, developers are shipping new software faster than ever. From smarter bookmarking tools and neighborhood marketplaces to digital pen pals and nature journals, here are the latest App Store finds worth adding to your Home Screen.

Before reading this : I'd recommend skimming Part 3's "Parser" section and Part 4's summary to understand how the parser outputs a domain.Contract . This post assumes you already know the parser can turn .meph into a struct. I. A Narrative Engine's Fourth Problem: How Do You Keep Behavior Stable? The parser is written. But it's code that gets maintained long-term — requirements change, formats expand, bugs get fixed. Every change risks breaking existing behavior. The tension here is: creators depend on stable behavior, while developers depend on freedom to change. If every code change requires manually testing every known scenario, the developer will fear refactoring. If you don't test, broken behavior reaches the creator — but the creator doesn't care that you refactored the parser. The solution is to "freeze" parsing behavior: use a fixed set of contracts as watchdogs. After every change, automatically compare parse results against expectations. This is what integration tests do: take a fixed set of .meph contracts as "watchdogs," run them after every change, and verify that behavior hasn't been accidentally altered. II. Golden File Testing: Freezing Parse Results The most straightforward approach: prepare a standard contract, parse it, serialize the result to JSON, and save it. On every subsequent test run, compare the current parse result against that JSON file. The project's testdata/sample.meph is that standard contract. Here's the test flow: func TestParseSample ( t * testing . T ) { got , err := ParseFile ( "testdata/sample.meph" ) if err != nil { t . Fatalf ( "parse failed: %v" , err ) } goldenPath := "testdata/sample.golden" var want domain . Contract if err := loadGolden ( goldenPath , & want ); err != nil { // Golden file doesn't exist — generate it automatically saveGolden ( goldenPath , got ) t . Log ( "Golden file generated. Please review and re-run the test." ) t . FailNow () } // Compare got and want if diff := cmp . Diff ( want , got ); diff != ""

📅 เขียนเมื่อ: กรกฎาคม 2026 ⚠️ ตรวจสอบข้อมูลจาก Go Specification, APL documentation, และบันทึกของผู้พัฒนา ถ้าคุณเขียน Go มาระยะหนึ่ง คุณคงเคยเห็น iota — เจ้า identifier ประหลาดที่ไม่มีใครรู้ว่ามันคืออะไรตอนเจอครั้งแรก const ( Monday = iota + 1 // 1 Tuesday // 2 Wednesday // 3 ) มันไม่ใช่ keyword, ไม่ใช่ type, ไม่ใช่ function — มันคืออะไรกันแน่? และที่สำคัญ — ทำไมต้องชื่อ iota ? คำตอบพาเราย้อนกลับไปถึงปี 1962 — ถึงนักคณิตศาสตร์ชาวแคนาดาคนหนึ่ง และภาษาโปรแกรมมิ่งที่เปลี่ยนโลก iota คืออะไรใน Go ใน Go spec — iota คือ predeclared identifier ที่ใช้ เฉพาะใน const declaration เท่านั้น มันทำสิ่งเดียว: นับเลขให้อัตโนมัติ const ( _ = iota // 0 (skip) KB = 1 << ( 10 * iota ) // 1 << 10 = 1024 MB // 1 << 20 = 1,048,576 GB // 1 << 30 ) ค่า iota เริ่มที่ 0 และเพิ่มทีละ 1 ทุกครั้งที่เจอบรรทัดใหม่ใน const block — แม้ว่าบรรทัดนั้นจะไม่ได้ใช้ iota ก็ตาม สิ่งที่ทำให้ iota ทรงพลังคือมันเป็น expression (ไม่ใช่แค่ตัวเลข) — คุณเอาไปคูณ บวก ลบ shift ได้หมด const ( Read = 1 << iota // 1 << 0 = 1 Write // 1 << 1 = 2 Execute // 1 << 2 = 4 ) นี่คือวิธีมาตรฐานในการสร้าง enum, bitmask, และ constant series ใน Go — ทั้งหมดด้วย keyword เดียว iota — อักษรกรีกตัวเล็กที่สุด ก่อนจะเป็นชื่อใน Go — ιώτα (iota) คืออักษรตัวที่ 9 ของกรีกโบราณ: ι มันคืออักษรที่ เล็กที่สุด ในภาษากรีก — แค่เส้นตรงหนึ่งเส้น ไม่มีหาง ไม่มีขีด ในพระคัมภีร์ไบเบิล มีวลี famous: "not one iota" — แปลว่า "ไม่แม้แต่นิดเดียว" — เพราะ iota คือสิ่งที่เล็กที่สุด และมันคือชื่อที่สมบูรณ์แบบสำหรับสิ่งที่ "เพิ่มทีละหนึ่ง" จุดเริ่มต้น — APL และ Kenneth Iverson นักคณิตศาสตร์ผู้สร้างภาษา ปี 1962 — Kenneth E. Iverson ตีพิมพ์หนังสือ "A Programming Language" (ที่มาของชื่อ APL) Iverson เป็นนักคณิตศาสตร์ชาวแคนาดา (ต่อมาได้ Turing Award ปี 1979) — เขาไม่ได้แค่ออกแบบภาษาใหม่ แต่ปฏิวัติวิธีคิดเรื่อง programming แทนที่จะเขียน for i = 1 to 10 — Iverson คิดว่า programming ควรเหมือนคณิตศาสตร์: สั้น, สัญลักษณ์, และทรงพลัง เกิดเป็น ⍳ (iota) ใน APL, Iverson สร้าง operator ⍳ — เรียกว่า iota — ที่ทำสิ่งเดียว: สร้างลำดับเลข ⍳ 5 → 1 2 3 4 5 ⍳ 10 → 1 2 3 4 5 6 7 8 9 1