标签：#m

Speaking as someone who just had to buy a new garbage disposal on his lunch break, I know firsthand how much home maintenance can cost, so I’m always excited to find inexpensive home tech that feels like an upgrade. Prime Day is a great time to score deals on video doorbells and cameras, novel methods […]

We talk a lot about what AI can build. Code generation. Faster prototypes. Automated debugging. One-shot apps. Entire products created in hours. And yes, AI is powerful. But there is a quieter cost we are not talking about enough: AI hype is starting to weaken the motivation to learn core engineering deeply. That should worry us. 1. The "Why Bother?" Mindset When the dominant narrative says AI can generate code instantly, many engineers start asking: Why should I spend months mastering frameworks, architecture, databases, networking, or system design? At first, that sounds practical. If a tool can help, why not use it? But there is a difference between using AI to move faster and using AI to avoid understanding. Core engineering is not just about writing code. It is about knowing why something works, where it breaks, how it scales, and how to fix it when the generated answer is wrong. If we skip that learning, we create engineers who can prompt systems but cannot reason deeply about systems. That is a dangerous tradeoff. 2. The Funding and Praise Monopoly Right now, AI gets most of the attention. Budgets move toward AI. Leadership praises AI initiatives. Teams are pushed to add AI features even when the fundamentals are still weak. Meanwhile, excellent core engineering often goes unnoticed. The people improving reliability, performance, developer experience, infrastructure, security, and maintainability are still doing high-impact work. But in many places, that work is being treated as less exciting simply because it is not branded as AI. This creates pressure. Engineers feel they must pivot to AI, not always out of interest, but out of fear. Fear of being left behind. Fear of being replaced. Fear that their existing expertise is no longer valued. That is not innovation. That is anxiety disguised as progress. 3. The "AI-First" Discount There is another subtle problem. When someone builds something impressive today, the reaction is often: AI probably generated that.

Hello, I'm currently working on my dissertation and feel like I could really use some advice from someone who looks at the problem with fresh eyes. I appreciate all input. The Problem: Multi Agent Path Finding is the problem of finding paths for several agents to their destinations. Lifelong MAPF is the same, but upon task completion an agent is assigned a new task. For my dissertation (and usually in research) agents move on a grid-like graph and time is discrete. Each timestep an agent can move to an adjacent tile or wait. A good LMAPF algorithm creates paths which maximise average jobs completed per timestep. Some LMAPF algorithms can also work on weighted graphs where each edge to an adjacent node (or itself) has its own cost. Such a graph is called guidance graph and the choice of edge weights can influence which paths the LMAPF algorithm creates also impacting throughput. My supervisor wanted to explore whether Evolutionary algorithms can be suitable for finding a guidance graph that improves throughput without changing the underlying LMAPF algorithm. A guidance graph is scenario specific meaning it is optimised for a specific LMAPF algorithm, map, and agent count. My algorithm so far: So far I've implemented a very basic evolutionary algorithm. An initial population of guidance graphs is randomly initialized (Limited to 10 at the moment). Then each candidate is plugged into the LMAPF algorithm for a certain amount of time steps and the completed jobs are counted to create that candidates fitness score. The top (2) candidates are selected and the rest are discarded. The top candidates are used to make a new set of candidates (no crossover). These step are repeated indefinitely. Issues I've has so far: The simulation can use a seed and is deterministic. The seed determines which nodes the jobs appear on. Using the same guidance graph but different seeds yields random fitness scores. The higher the simulation time the lower the coefficient of variation (standard

Code generation tools are powerful and can significantly accelerate development work. Their main limitation is not capability, but context. Without access to organizational knowledge, internal conventions, and system-specific patterns, generated output often requires careful verification. This is why generation tools work best when paired with AI code search, as the latter provides immediate visibility into the existing codebase, making it easier to align AI-generated changes with the realities of the system. In regulated environments, the adoption model may look different. Security or compliance constraints can restrict the use of cloud-based code generation. AI code search still improves developer efficiency across implementation, review, and documentation workflows by enabling fast navigation and comprehension of large multi-repository codebases. What is AI code intelligence, and how does it help in practice? Code intelligence tools help developers find and understand existing code. If a search returns a poor result, the developer simply searches again. Nothing changes in your codebase. Code search also integrates without friction. No new review processes, no changes to CI/CD, no new permissions. Generation tools require policies for AI-written code that stall many pilots before they produce data. Clear metrics for measuring AI code intelligence An AI code search assistant only reads your code, which makes it much easier to measure its impact. You can track simple things like: • how long it takes to find the right piece of code • how quickly new developers get up to speed • how many hours the team spends searching each week If your team of 20 developers each spends 5 hours weekly understanding code, that equals 100 hours of engineering time. At $75 per hour, that’s $360,000 per year. Assume 10% reduction recovers $36,000, a realistic input for an AI ROI framework for tech teams. Faster path to Phase 3 expansion Code generation tools face tough questions from secu

The agents were doing exactly what I told them to. That was the problem. I'd built a pipeline where AI agents could take a spec file, implement a feature, run the tests, review the result, and commit — without me writing a line of code. It mostly worked. Dozens of features shipped. But I kept reviewing the output and feeling like something was off. Not broken. Just subtly wrong in a way that was hard to name. I spent a while blaming the models. Then the prompts. Then the validation steps. Eventually I had to sit with the obvious: the agents were implementing exactly what I'd written. My specs were underspecified. The bottleneck was always me, at the planning stage. The thing most people throw away There's something that feels right about vibe coding. You're operating at the level of intent — describing what you want and letting the model handle the mechanics. That part is genuinely useful. But watch what most people do with the output: Traditional development: Source code → Compiler → Binary (keep the source; regenerate binary anytime) Vibe coding done wrong: Prompt → LLM → Generated code (delete the prompt; commit the code) You've shredded the source and carefully version-controlled the binary. The prompt — your structured description of what you wanted, why, and what "correct" meant — is the valuable artifact. The generated code is what compiles from it. When you discard the prompt and commit only the output, you've lost the thing that actually mattered. The practical consequence shows up six months later: you're staring at code you wrote and spending twenty minutes reverse-engineering your own intent. The spec would have been a thirty-second read. What a spec-driven pipeline is I built what I call an SDLC (Software Development Lifecycle) harness — a system where instead of writing code directly, you write a spec describing what needs to be built, and AI agents handle the implementation, testing, review, and documentation. The spec is the source. The code is what

In the last essay I played a game with twelve people. Twelve apostles, one teacher, one set of events — and twelve sharply distinct ways of failing and succeeding to understand the same thing. Peter acts before he reflects, Thomas demands the marks in the hands, Matthew counts and structures, Judas asks what you'll give him. I called it pre-cognitive-science cognitive science: the Gospels did the hard work of selecting twelve incompatible human responses to one encounter, and every century since has projected its newest psychology onto that fixed set and found it fits. That essay had a quiet move in it I want to pull on now. The thing that doesn't change, I wrote, is the twelve people. The cognitive vocabularies come and go; the diversity of minds is the invariant. So here is the obvious next question, the one I couldn't stop turning over after I published: what happens when you stop counting people and start counting cultures? Not twelve apostles meeting one teacher, but N civilizations meeting one world. The same exercise, zoomed out A culture is not just a cuisine and a flag. It is a way of thinking that a few million people inherited without choosing it — an implicit operating system for what counts as obvious, what counts as rude, what counts as a good life, what counts as a threat. And like the apostles, each one is an answer to a question . You can describe any of them, I think, with three coordinates. A driver — the deep need the culture is organized around. Survival, honor, harmony, freedom, salvation, mastery, belonging. The thing that, if you threaten it, the culture treats as an attack on existence itself. A provoking question — the founding question the culture exists as a standing answer to. How do we survive the winter together? How do we live rightly before the gods? How do we stay free? How do we keep the harmony so the group doesn't tear itself apart? Cultures are old answers to questions most of their members have forgotten were ever asked. A thin

This is Lowpass by Janko Roettgers, a newsletter on the ever-evolving intersection of tech and entertainment, syndicated just for The Verge subscribers once a week. The 2026 World Cup is breaking streaming records around the world: Brazil's CazéTV YouTube livestream of that country's opening game against Morocco surpassed 12 million concurrent viewers, a new milestone […]

You don't need to cut your own grass anymore. Most of the best robot mowers I've tested are on sale for Prime Day.

Apple just raised the prices on Macs and iPads in response to the rising costs of memory chips, right in the middle of Amazon Prime Day. That means existing discounts (even small ones) on Apple laptops like the MacBook Neo, MacBook Air, and MacBook Pro just became significantly better deals. As an example, the 13-inch […]

https://www.omegasyntax.com/domino/ Series of articles about Domino Tiling problem. submitted by /u/eugene [link] [留言]

Data Oriented Design is the practice of building code that's optimized for the hardware it runs on. Entity Component Systems help writing DOD-friendly code by laying out otherwise allocation-heavy game data in contiguous arrays. A challenge in gamedev however is that lots of game data is stored and accessed as hierarchies that change frequently, which makes them notoriously difficult to store as contiguous arrays. This article goes over a number of techniques an Entity Component System can use to integrate hierarchies with the core datamodel in a way that improves the performance of the ECS. Written mostly for gamedev, but also applies to other hierarchy-heavy applications, like UI. submitted by /u/ajmmertens [link] [留言]

IBM says it has created the world's first sub-1 nanometer chip

The Department of Commerce declined to give the Chinese-owned automaker a special authorization to keep selling EVs in the U.S.

Apple raises prices of MacBook Air and Pro along with iPad Air and Pro.

Now that Bungie has moved on from Destiny 2, the game studio is being hit with its latest round of layoffs. In a statement posted on X, the studio said that "we are announcing a reduction in force as we reorganize Bungie." No specific numbers were revealed. But in a separate statement, Hermen Hulst, CEO […]

Every day I see more projects where a layer-per-entity approach is created by default: UserService , UserRepository , OrderService , OrderRepository , and so on. My issue is not with layering itself, but with how these layers are used. In theory, a Service should represent application behavior: something that encapsulates real use cases or meaningful interactions with external systems (payments, emails, APIs, etc.). Something with enough significance to justify being isolated. A Repository , in theory, should exist when there is real complexity in data access: multiple data sources, non-trivial persistence logic, evolving storage mechanisms, etc. However, in practice, they often degrade into something else: services that simply delegate calls repositories that are thin wrappers around an ORM interfaces with no meaningful alternative implementation At that point, the abstraction starts to lose its purpose. Why not use the ORM directly when there is no real complexity to hide? Why do we default to intermediate layers that don’t truly represent either a service or a repository in their original sense? It often feels like they add files, indirection, and noise without improving clarity. I’m not saying these layers are inherently bad. I’m trying to understand why they are so often applied by default, even when they don’t serve their actual purpose. Does this approach really improve clarity, or does it just introduce unnecessary complexity? For example, instead of organizing code around generic services per model, we could structure it around explicit use cases for concrete system actions. These would still live within an application/service layer in the sense described by Fowler, but without forcing a generic ModelService structure for everything. The goal would be to design around intent rather than around structural templates—so the code reflects what the system does , not just how it is layered . submitted by /u/Character-Method-720 [link] [留言]

2 days left to lock in your spot at TechCrunch Founder Summit 2026 and save up to $190 before Early Bird rates expire on June 26 at 11:59 p.m. PT. Register here.

I wasn't surprised when I got the call that my dad was dying, even though we'd been estranged for many years. He'd suffered addiction for decades and eventually ran out of time, which also meant he ran out of time to reconcile with me. About 15 years after we stopped talking, my aunt and uncle […]

The Department of Transportation wants to remove the brake-pedal requirement for vehicles "designed to be driven exclusively by automated driving systems."

Europeans are baking under their second heat wave of the summer.