标签：#m

Bending Spoons remains largely unknown, even as its portfolio of products has served more than a billion people.

It's good to know how long your phone will get updates before you purchase.

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

I’ve spent thousands of dollars over the years on smart home gear. Like many tech enthusiasts, I started with the usual suspects: smart bulbs, plugs, sensors, voice assistants, and eventually more “advanced” hubs. Every time, the marketing promised intelligence. Every time, I got glorified timers and motion detectors wearing a fancy label. After multiple attempts, I’ve reached the same conclusion many others quietly reach: most “smart home” products are not smart. They are automated, and there’s a massive difference. What “Smart” Actually Means A genuinely smart home system should do three things well: Understand context. Not just that a door opened or motion was detected, but why and what it means right now. Integrate devices meaningfully. Devices shouldn’t just talk to each other; they should share rich, semantic information so the system can reason across them. Be predictive and proactive. It should anticipate needs based on patterns, current state, and human behavior, instead of waiting for a trigger. Current systems almost never do any of these at a level that feels intelligent. The Core Problems (From Someone Who Actually Tried) Take a simple example: the dishwasher. A basic automation might detect the door was opened and then closed, then start the cycle. But it has zero idea whether: Dishes were actually loaded Someone was just checking if the cycle finished More dishes are coming in 30 seconds The person is about to run a quick rinse first The same gap appears everywhere: Lighting at night. The system doesn’t know if you just got up to use the bathroom, you’re wide awake working, or there was an emergency. It just sees “motion after 11 p.m.” and either blasts you with light or leaves you in the dark. Multi-person households. One person’s preference for dim evening lighting conflicts with another person’s need for bright light. Guests have no idea how anything works and accidentally trigger routines. “I’m just doing a quick house tour” vs. actual activity. T

I'm probably not the only one who checks every few months whether a GPU alternative has finally shipped, mostly so I can cancel a few subscriptions. Nobody doubts it's physically possible or that people have tried. The real question is why it hasn't actually happened, and the answer is economic and structural, not technical. GPUs are not uniquely ideal. They're uniquely general LLM workloads are dense matmul, high parallelism, memory-bandwidth-bound compute. GPUs handle this well but weren't built for it specifically. An ASIC purpose-built for transformer inference should beat a GPU on perf-per-watt and perf-per-dollar, and in narrow slices, it already does: Groq's LPU beats GPUs on single-stream inference throughput for models that fit its architecture Cerebras' WSE cuts interconnect overhead by putting the whole model on one wafer Google TPUs have run production workloads for years and are now sold externally via GCP So specialized hardware can win, sometimes even in production. The real question isn't whether something can beat a GPU, it's why none of these have dented Nvidia's share. 1. The capital barrier Custom silicon needs hundreds of millions in NRE cost, access to TSMC's leading-edge nodes with multi-year allocation queues, and several iterations before a design is commercially viable. That caps the field to hyperscaler balance sheets or venture funding measured in billions. The barrier isn't just the chip either. CUDA, the surrounding tooling, and production pipelines took a decade of capital and engineering to mature, and matching that means rebuilding all of it, not swapping a part. That's a second capital sink on top of the silicon itself. There's also a timing risk specific to fixed-function silicon: if the underlying model architecture shifts significantly, an ASIC taped out for today's transformer variant can become dead weight, while a GPU just needs a software update to run whatever comes next reasonably well. That risk hasn't actually played out,

The Evolution of Junior Developer Roles in the Age of AI In the tech industry, a pressing question has emerged: Is the role of junior developers disappearing? With the rapid advancement of artificial intelligence (AI), particularly generative models like ChatGPT, there's growing concern about the future of entry-level software development jobs. While some predict a decline, the reality is more nuanced. AI is transforming these roles, not eliminating them, creating new opportunities for junior developers who adapt to the changing landscape. TL;DR AI advancements are reshaping junior developer roles rather than removing them. AI tools reduce the need for routine coding tasks but create opportunities for those focusing on higher-order skills like problem-solving and collaboration. Junior developers should embrace AI tools to enhance creative problem-solving. Companies must adapt talent strategies to nurture junior developers for future senior roles. The Transformation of Junior Developer Roles AI's Impact on Routine Coding Tasks Artificial intelligence has significantly automated routine coding tasks. AI models, such as ChatGPT, can generate code snippets, debug errors, and optimize performance. This capability shifts junior developers' focus from these tasks, traditionally a large part of their responsibilities. Code Generation : AI can produce boilerplate code, reducing the time spent on repetitive tasks. Error Detection : AI-driven tools identify and propose fixes for common coding errors, streamlining debugging. Performance Optimization : AI algorithms can automatically enhance code efficiency, which previously required manual intervention. Changing Nature of Junior Developer Roles The employment rate for junior developers aged 22-25 has declined nearly 20% from its peak in 2022. This trend indicates a shift in how entry-level positions are perceived and utilized within tech companies. With AI handling routine tasks, the role of a junior developer is evolving to em

Most prompts ask AI to explain things. The best ones ask it to show you something instead. That distinction sounds cosmetic. It isn't. It changes what the model generates, how you process it, and — more importantly — whether it actually sticks. I came across this idea while watching an interview with Amanda Askell — a philosopher and researcher at Anthropic whose work sits at the intersection of AI alignment and what you might loosely call Claude's inner life. She's a primary author of the document that defines Claude's values and character — the framework that governs how the model reasons when the rules run out. Almost as an aside near the end of the interview, she mentioned a prompting technique she uses to understand complex concepts. It stopped me cold. Not because it was elaborate. Because it was disarmingly simple, and it worked in a way I hadn't thought to ask for. The Exact Prompt Template Here it is, cleaned up and ready to use: I want to understand [concept]. Please explain it by writing a fable — an indirect, narrative version of the concept. The story should embody the concept completely without naming it directly. Ideally, the reader should only start to realize what the concept actually is near the end of the story. After the fable, add a short explanation that names the concept clearly and connects it back to the key moments in the story. That's it. No elaborate scaffolding. No chain-of-thought trigger. No persona assignment. Just a deliberate decision about the order in which understanding should arrive. Why This Works (and Why Direct Explanation Often Doesn't) When you ask AI to explain a concept directly, you get a definition. Definitions are accurate and forgettable. The model produces the statistical center of everything written about that concept — clear, complete, and utterly without friction. Friction, it turns out, is how things get encoded. When a concept arrives wrapped in a story, your brain does something different. It tracks characters,

Infrastructure as Code (IaC) has revolutionized how we provision and manage cloud resources. Tools like Terraform, Pulumi, and OpenTofu allow us to define infrastructure using code, making it versionable, repeatable, and scalable. However, with great power comes great responsibility. Misconfigurations in IaC can lead to massive security breaches, such as publicly exposed data storage or overly permissive access roles. This is where Static Application Security Testing (SAST) comes in. SAST tools analyze your source code to find security vulnerabilities before the code is deployed. In this article, we'll explore how to apply SAST to a Terraform project using Checkov , a popular open-source static analysis tool for IaC, and how to automate this process using GitHub Actions. (Note: We are intentionally avoiding tfsec for this demonstration to explore other powerful alternatives). Why Checkov? Checkov, created by Bridgecrew (now part of Prisma Cloud), is a static code analysis tool for IaC. It scans cloud infrastructure provisioned using Terraform, Terraform plan, Cloudformation, Kubernetes, Dockerfile, Serverless, or ARM Templates and detects security and compliance misconfigurations. It includes hundreds of built-in policies covering security and compliance best practices for AWS, Azure, and Google Cloud. The Demo Scenario: A Vulnerable S3 Bucket Let's start by creating a simple Terraform configuration for an AWS S3 bucket. We will intentionally introduce a security misconfiguration: making the bucket public without encryption. Create a file named main.tf : # main.tf provider "aws" { region = "us-east-1" } resource "aws_s3_bucket" "my_vulnerable_bucket" { bucket = "my-company-public-data-bucket-12345" } # Misconfiguration 1: Public Read Access resource "aws_s3_bucket_acl" "example" { bucket = aws_s3_bucket . my_vulnerable_bucket . id acl = "public-read" } If we were to deploy this, anyone on the internet could read the contents of this bucket. Let's see how Checkov can

Most developers use Git every day and understand almost none of it. That's not an insult, it's just the reality of how most people learn tools. You pick up the commands that get you through the day, you memorize the ones that fix the situations you keep breaking, and you build a working mental model that is almost entirely wrong at the mechanical level. The mental model most people carry looks something like this: Git tracks changes to files. When you commit, it saves a snapshot of what changed. Branches are pointers to different lines of work. That's roughly correct at a surface level, but it skips over the actual machinery in a way that leaves you confused every time something unexpected happens. Why does rebasing rewrite history? Why are commits immutable? Why does detached HEAD state exist? Why can you lose work in ways that feel impossible if Git is just tracking changes? The answers are all in the object model, and the object model is surprisingly simple once you sit with it. Git is a content-addressable filesystem Before any of the version control concepts, Git is a key-value store. You put content in, you get a hash back. You use that hash later to retrieve the content. That's the entire foundation, and everything else is built on top of it. The hash Git uses is SHA-1, producing a 40-character hexadecimal string. When you run git hash-object on a file, Git takes the content, prepends a small header describing the object type and size, and runs SHA-1 over the whole thing. The resulting hash is both the key and the identity of that content. Two files with identical content will always produce the same hash. A file whose content changes even slightly will produce a completely different hash. This is the first thing that breaks people's mental models. In most storage systems, identity is location: a file is "that file" because it lives at that path. In Git's object store, identity is content. The path a file lives at is separate metadata, not the file's identity

Last month our visual-diff monitor flagged 47 changes on a client's homepage in one run. Forty-six of them were a rotating testimonial carousel that happened to land on a different slide each time the page was captured. One was real. If you've built or used any screenshot-based monitoring, you already know this problem. Two screenshots of the exact same, unchanged page rarely match pixel-for-pixel. Carousels rotate. Cookie banners fade in on a timer. Lazy-loaded images pop in a beat late. Ads shift half a pixel. Fonts render with slightly different anti-aliasing depending on what else the browser was doing. Diff two raw captures and you get a wall of "changes," and within a week nobody on the team opens the alert anymore. Why the obvious fixes don't work The first instinct is usually to loosen the pixel-diff threshold. That just trades false positives for false negatives - now a genuinely moved button or a broken layout has to clear the same bar as carousel noise, so you miss the thing you built the tool to catch in the first place. The second instinct is manual exclusion zones: tell the tool to ignore the carousel <div> , the ad slot, the cookie banner. This works until the page changes - a redesign moves the carousel, a new banner ships with a different selector, and you're back to noisy alerts plus a pile of dead config nobody remembers writing. The third "fix" is tolerating the noise, which is what most teams actually do in practice, and it's a big part of why visual regression tooling has a reputation for being more trouble than it's worth. Make the page prove it's stable before you trust anything about it The fix that actually moved the needle for us wasn't a smarter diff algorithm. It was refusing to treat a single screenshot as ground truth at all. Before any comparison happens, the page goes through a stabilization pass: known cookie/consent overlays get removed (we track a couple hundred variants at this point — cookie banner vendors are not standardized),

This is The Stepback, a weekly newsletter breaking down one essential story from the tech world. For more on the bleak state of the video game industry, follow Andrew Webster. The Stepback arrives in our subscribers' inboxes on Sunday at 8AM ET. Opt in for The Stepback here. How it started Microsoft closed out Summer […]

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

Chemicals from accidents that injured or killed people increased by nearly 50 percent in recent years.

Don’t suffer the buffer. These WIRED-tested home routers will deliver reliable internet across your home, whatever your needs or budget.

Wildfire survivors call fire-prediction markets “morally reprehensible” and worry they could increase the risk of arson.

The heat of the Hadean may have come from impacts as well as the interior.

This massive 85-inch model is highly customizable but jaw-droppingly expensive.

Eight Sleep’s Pod 5 is great at its job, but its job is also watching you sleep.

Modern C# Features: A Deep Dive into Records, Pattern Matching, Async, and Performance A practical guide to the C# language features that have reshaped how we write .NET code — records, pattern matching, async/await improvements, nullable reference types, LINQ enhancements, Span<T> , and performance optimizations. Table of Contents Introduction Records Pattern Matching Async/Await Improvements Nullable Reference Types LINQ Enhancements Span<T> and Memory<T> Performance Optimizations Quick Reference Table Conclusion Introduction C# has evolved significantly since C# 8. Each release (9, 10, 11, 12, 13) has focused on three consistent themes: Conciseness — write less boilerplate to express the same intent. Safety — catch bugs at compile time instead of runtime (especially around null ). Performance — give developers low-level control without leaving the managed, safe world of .NET. This guide walks through the features that matter most in day-to-day development, with working code examples you can drop into a dotnet run project. 1. Records Introduced in C# 9 , record types give you immutable, value-based data models with almost no ceremony. Why records exist Before records, representing an immutable data object meant hand-writing a constructor, Equals , GetHashCode , ToString , and often a With -style copy method. Records generate all of this for you. // Before: a "plain" immutable class public class PersonClass { public string FirstName { get ; } public string LastName { get ; } public PersonClass ( string firstName , string lastName ) { FirstName = firstName ; LastName = lastName ; } public override bool Equals ( object ? obj ) => obj is PersonClass p && p . FirstName == FirstName && p . LastName == LastName ; public override int GetHashCode () => HashCode . Combine ( FirstName , LastName ); public override string ToString () => $"PersonClass {{ FirstName = { FirstName }, LastName = { LastName } }} " ; } // After: the same thing as a record public record Person ( stri

In-process cron ( node-cron , @nestjs/schedule , OS crontab) runs inside one Node process. That is fine for a single instance, but it does not survive restarts gracefully, deduplicate across replicas, or share infrastructure with your other background jobs. BullMQ stores queues and schedulers in Redis . Job Schedulers (BullMQ 5.16+) are the recommended way to enqueue recurring work on a cron pattern or fixed interval. The same workers that process one-off jobs also process scheduled ones, with retries, backoff, and concurrency you already get from BullMQ. This post covers Job Schedulers in plain Node.js, operations and pitfalls, a NestJS setup with @nestjs/bullmq , and a runnable demo with a fast cron heartbeat and a daily cleanup cron. Prerequisites Node.js version 26 Redis at redis://localhost:6379 (included in the demo docker-compose.yml , or use Postgres and Redis containers with Docker Compose ) npm i bullmq For the NestJS section: npm i @nestjs/bullmq bullmq BullMQ 2.0+ does not require a separate QueueScheduler instance. Use the Job Scheduler API ( upsertJobScheduler ), not the deprecated repeat option on queue.add() . Mental model Piece Role Queue Holds jobs waiting to run Worker Executes jobs Job Scheduler Factory that enqueues jobs on a schedule Scheduled job A job instance produced by a scheduler A scheduler id is stable across deploys. Calling upsertJobScheduler with the same id updates the schedule in place instead of creating duplicates. Queue and worker Share one Redis connection config between the queue and the worker: import { Queue , Worker } from ' bullmq ' ; const connection = { host : ' localhost ' , port : 6379 }; const queue = new Queue ( ' reports ' , { connection }); const worker = new Worker ( ' reports ' , async ( job ) => { console . log ( `[ ${ job . name } ]` , new Date (). toISOString (), job . data ); }, { connection }, ); worker . on ( ' failed ' , ( job , error ) => { console . error ( job ?. name , error . message ); }); Start the