标签：#AR

Researchers have demonstrated they can make coffee comparable to conventional espresso using ultrasonic waves. Because the process doesn’t need hot water, it consumes 75 percent less energy.

I can't remember the last time I got excited about a fan. Normally, I just buy whatever Vornado or Dreo model fits my budget, but that was before I started testing the battery-powered Standing Circulator Fan from SwitchBot. As the name indicates, the SwitchBot fan is a 3D circulator - a fancy way of saying […]

Why I built GigVorx, a SaaS tool to help freelancers and agencies manage client briefs and invoices more professionally. Freelancers and small agencies often have one messy problem: Client details are everywhere. Some requirements come through WhatsApp. Some come through calls. Some are sent as voice notes. Some are inside Google Docs. Some are buried in old messages. At the start, this feels normal. But later, it creates problems. You forget important requirements. You ask the client the same question again. Invoices are created manually. Project details are not organised. The whole process looks less professional. That is the problem I wanted to solve with GigVorx . What is GigVorx? GigVorx is a client intake and invoicing tool for freelancers and small agencies. It helps users: Collect client requirements professionally use ready-made brief templates organise client details create professional invoices avoid scattered WhatsApp chats, calls, and docs The goal is simple: Help freelancers and agencies manage client intake and invoicing from one dashboard. Who is it for? GigVorx is mainly for: web designers developers graphic designers video editors SEO freelancers social media agencies digital marketing agencies small service businesses These people usually talk to many clients and need a better way to collect requirements before starting work. Why I built it I noticed that many freelancers lose time before the project even starts. They ask questions manually. They collect details in random chats. They create invoices separately. They do not have one organised place for client information. This makes the work slower and sometimes confusing. So I wanted to create a simple tool that gives freelancers a more professional workflow. Current status GigVorx is already live in early access. Right now, I am not focusing on making it perfect. I am focusing on getting real users' feedback and improving the product based on what freelancers actually need. What I am learning Bui

The cycle number on a lithium battery's spec sheet is true and almost useless, because it describes a life the battery will live only in a temperature-controlled lab being cycled gently by a machine that never has a bad day. A cycle, in that test, means a full charge and a full discharge under mild, steady conditions, repeated until the pack fades to some fraction of its original capacity, often eighty percent. Your warehouse does none of that. It charges in bursts, discharges to whatever the shift demanded, bakes the pack in summer and chills it in winter, and counts a cycle as whatever happened between two plug-ins. Depth is the lever nobody quotes The single biggest mover of cycle count is how deep you run the pack on each outing, and that figure almost never shares the page with the headline number that sells the battery. The relationship is steeply nonlinear, which is the part that surprises people. Drain a lithium pack to nearly empty every time and you spend cycles fast. Use the top half and tuck it back on charge, and the same cell can deliver many times the number of shallow cycles before reaching the same faded state. The chemistry is mechanical about it: every deep swing stretches and contracts the electrode structures further, and the wider the swing the more wear each one inflicts. Two fleets on identical batteries can see lifespans years apart purely from how hard they drain them. This is why opportunity charging does double duty. It keeps the truck running, and it keeps each cycle shallow, which stretches the pack's life as a side effect. It also means a published cycle figure measured at full depth understates what a top-up fleet will see, while a figure measured shallow oversells what a run-it-flat operation will get. The same battery, the same number, two outcomes the sheet never warned you about. You have to know the test depth to know what the promise means. Heat is the other clock Cycles are only one of two clocks ticking on a battery, and the s

Enterprise Design Patterns in Python: Repository & Unit of Work 🐍🏗️ Series: Enterprise Application Architecture | Source: Fowler's EAA Catalog | Code: GitHub Repository 🧠 What Are Enterprise Design Patterns? Martin Fowler's Patterns of Enterprise Application Architecture (2002) is one of the most influential books in software engineering. It documents recurring architectural solutions — patterns — that solve common problems in enterprise systems: how to organize domain logic, how to talk to databases, how to handle transactions, and more. In this article, we'll explore two of the most powerful and widely-used patterns from that catalog: Pattern Category Core Purpose Repository Data Source Abstracts data access behind a collection-like interface Unit of Work Data Source Tracks object changes and commits them as a single transaction These two patterns work beautifully together — and you'll see exactly why with a real-world example. 🛒 The Problem: An E-Commerce Order System Imagine you're building a backend for an online store. When a customer places an order: A new Order is created Each Product 's stock is decremented A Payment record is registered If any of these steps fail midway, the entire operation should roll back — no partial state. This is exactly the problem the Unit of Work pattern solves, and the Repository pattern makes it all cleanly testable. 📁 Repository Pattern Definition "A Repository mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects." — Martin Fowler, PoEAA The Repository acts as an in-memory collection of domain objects. Your business logic never knows if it's talking to PostgreSQL, SQLite, or even a mock list — it just calls .add() , .get() , .list() . Domain Model # models.py from dataclasses import dataclass , field from typing import List from uuid import uuid4 @dataclass class Product : id : str name : str price : float stock : int @dataclass class OrderItem : product_id : str qua

A working prompt library is the main event, not an appendix. The industry still treats prompts as some half-baked spitball left in a README, or, worse, a plaintext blob stapled to package.json and forgotten. That's a waste of compute and credibility. What powers reliable AI-assisted refactoring, onboarding, or even next-gen code IDEs is not the size of the model but the clarity and context supplied by the actual, shipped prompt set. OTF kits turn this lesson into a repeatable deliverable: every paid template includes 20+ production-tested prompts tied to the real file structure, component API, and product-specific conventions. This is not a suggestion; it's structural. The takeaway: a real prompt library is as important as your component library. Treat it like one. Start with the pain: why blank chat boxes don't scale The web is full of “integrations” that paste a blank chat input over your codebase and call it an “AI coding assistant.” The result: hallucinated function names, invented conventions, broken import paths. Here’s what happens in real life: Dev: "Add a social login button." AI (blank prompt): "Sure! Insert <SocialLoginButton> in your LoginScreen.js." Dev: (There’s no such component. There's not even a LoginScreen.js.) Short: A generic prompt with zero context simply can't know your conventions, files, or patterns. The agent will either fail, hallucinate, or pepper you with clarifying questions you have already answered in your product architecture. Takeaway: Prompting without context is coding without types — fragile guesses instead of structured outcomes. What a first-class prompt library enables When the prompt library ships with the codebase, it looks like this: Every prompt knows the folder structure (e.g., features/auth , screens/Settings/index.tsx ). Conventions are hard-coded: naming, import styles, design token usage. Endpoints and integration points (e.g., “update the Stripe webhook handler in api/webhooks/stripe.ts ”) are spelled out. The promp

Manually converting invoice data from PDF or Excel files into CSV format is one of the most time-consuming tasks in accounting and data management workflows. It often involves repetitive copy-pasting, formatting adjustments, and a high risk of human error. In many real-world scenarios, invoices arrive in different formats such as PDF, XLS, XLSX, or even HTML. Handling them individually can slow down reporting pipelines and create inconsistencies in structured data storage. The Problem with Manual Conversion Traditional invoice processing usually involves: Extracting line items manually from PDFs Reformatting Excel sheets for database compatibility Fixing inconsistencies in columns and values Rechecking for missing or misaligned data As invoice volume increases, these tasks quickly become inefficient and error-prone. Automated Approach to Invoice Conversion A more efficient approach is using tools that automatically parse invoice documents and convert them into structured CSV format. These tools typically: Read multiple file formats (PDF, XLS, XLSX, HTML) Detect table structures and line items Normalize data into rows and columns Export clean CSV files ready for spreadsheets or databases For example, uploading a multi-page invoice PDF can result in fully structured rows representing each item, without manual formatting adjustments. Why CSV Output Matters CSV remains one of the most widely used formats for: Accounting software imports Database ingestion Data analysis workflows Spreadsheet processing Having clean CSV output ensures compatibility across systems and reduces preprocessing work. Practical Impact Automating invoice-to-CSV conversion helps reduce: Repetitive manual data entry Formatting inconsistencies Processing time for bulk invoices It also improves accuracy when handling large datasets. Closing Note As data-driven workflows become more common in finance and operations, automating repetitive tasks like invoice conversion can significantly improve efficien

Most agents drag their entire past into every turn. A better default: keep a thin index of what was said hot, and fetch only the few turns you actually need — intact, on demand. Code: github.com/NirajPandey05/jit_context There is a quiet assumption baked into how most agents handle memory: that more context is safer than less. If the model might need something, put it in the window. The conversation grows, every prior turn rides along on every new request, and we trust the model to find the part that matters. That assumption breaks twice. It breaks on cost , because an agent loop re-sends its whole window on every step — a hundred stale turns aren't paid for once, they're paid for on turn 101, 102, and every step after. And it breaks on quality , because models don't read a long window evenly. Relevant facts buried in the middle get underweighted; irrelevant bulk competes for attention with the thing that actually answers the question. Past a point, a bigger context produces a worse answer, not just a costlier one. So the interesting question isn't "how do we fit more in?" It's "how do we keep the window small and dense without losing the one old turn that matters?" This post is the design we built around that question — for the specific case of long conversation history — plus the benchmark we used to keep ourselves honest. 01 · The mechanism: a hot index over a cold store The design borrows directly from how computers have always managed memory that doesn't fit: a small fast tier that's always present, a large slow tier that holds the bulk, and a rule for moving things between them. Virtual memory pages between RAM and disk. We page between the context window and an external store — for attention instead of address space. Concretely, there are two tiers. The cold store holds every turn at full fidelity, keyed by id — nothing is thrown away. The hot index holds one compact entry per turn: a short summary, a little metadata (entities, whether the turn recorded a dec

French serial entrepreneur and open-source legend Jean-Baptiste Kempf has been building Kyber, an infrastructure layer to control remote devices in real time.

AI isn't coming for your job. It already showed up, merged its first PR, and doesn't need a code review. The question developers keep dancing around — but rarely say out loud — is this: If GitHub Copilot, Cursor, and Claude can do what a junior dev does in a fraction of the time, what happens to junior devs? And more uncomfortably: what happens to mid-level devs in three years? The Uncomfortable Data Points This isn't speculation. It's already showing up in hiring data. Entry-level developer roles are contracting. Stanford's Digital Economy Lab (2025) found measurable decline in entry-level employment in AI-exposed roles — and software development is one of the most exposed. One senior dev + AI tools = the output of a small team. Brynjolfsson, Li & Raymond (NBER, 2023) showed generative AI productivity gains that compress what used to require multiple headcount into one. Goldman Sachs (2023) estimated significant white-collar labour market exposure — knowledge workers, not factory workers, are the primary target this time. This isn't the loom replacing weavers. It's the IDE replacing the person using the IDE. The Counter-Argument (And It's Not Weak) Here's where it gets interesting — because the doomsayer take isn't the whole story either. Every major technology wave destroyed jobs and created more than anyone predicted: The ATM didn't eliminate bank tellers — it lowered branch costs, banks opened more branches, teller roles increased for a decade The spreadsheet didn't kill accountants — it created an entire industry of financial analysts The internet didn't destroy publishing — it exploded the number of people who could publish The argument: AI raises developer productivity so dramatically that it expands the total addressable market for software. More products get built. More tools get created. More companies can afford to build what previously required a $500k engineering team. More demand for developers, not less. Where It Gets Complicated for Devs Specifically

If you've been following the AI market lately, you already know the headline numbers: DeepSeek V4 costs about 3% of what GPT-4o charges per token. GLM-4 runs benchmarks competitive with GPT-4 at roughly one-twentieth the price. Qwen delivers multilingual performance that rivals Claude for a rounding error in your cloud bill. The spreadsheets look incredible. The problem is actually using these models. Signing up for each provider means navigating Chinese-language dashboards, topping up separate wallets, managing six different API key formats, and dealing with SDKs that don't follow any consistent convention. Most developers give up after the second integration. That friction is why, despite the economics being objectively absurd in 2026, most teams still default to a single Western provider and eat the cost. AIWave exists to kill that friction. One API key. One endpoint. Fifty-plus models across eight Chinese labs, all speaking standard OpenAI-compatible format. Zero code changes to switch between DeepSeek, GLM, Qwen, MiniMax, and everything else. This post covers how the platform works under the hood, what the request lifecycle looks like, and how to integrate it in any language that can speak HTTP. The Fragmentation Problem, Quantified Before getting into the solution, here's what the Chinese LLM landscape actually looks like as of June 2026: Provider Flagship Model API Format Auth Method SDK Language DeepSeek V4-Pro Custom (DS format) Bearer token + signature Python, JS Zhipu GLM-4.5 OpenAI-compatible-ish JWT with expiry Python, Java Alibaba Qwen-3-Max DashScope (Alibaba) AK/SK + HMAC Python, Java, Go MiniMax MiniMax-Text-01 Custom REST API Key + Group ID Python Moonshot Kimi-K2 OpenAI-compatible API Key Python, JS Baidu ERNIE 4.5 Qianfan (Baidu) OAuth 2.0 Client Cred Python ByteDance Doubao-Pro Ark (Volcengine) IAM AK/SK + SigV4 Python, Go 01.AI Yi-Lightning OpenAI-compatible API Key Python Eight providers, seven different authentication schemes, four distinct A

Supervised vs. Unsupervised Machine Learning: How to Choose the Right Approach Supervised learning trains a model on data that's already labeled with the correct answer, so it learns to predict outcomes for new, unseen examples. Unsupervised learning works on unlabeled data and finds patterns or groupings on its own, without being told what the "right answer" looks like. Use supervised learning when you have historical examples of the outcome you want to predict; use unsupervised learning when you're trying to discover structure in data you don't yet understand. That's the short version. Here's what it actually means in practice, and how to know which one your project needs. What is supervised learning? In supervised learning, every training example comes with a label — the "correct answer" the model is trying to learn to predict. Feed a model thousands of emails, each tagged "spam" or "not spam," and it learns the patterns that separate the two. Once trained, it can label emails it's never seen before. The defining trait: you already know the outcome for your training data. You're not asking the model to discover something new — you're asking it to learn a pattern well enough to apply it to fresh cases. Common supervised tasks: Classification — sorting things into categories (spam vs. not spam, fraudulent vs. legitimate transaction) Regression — predicting a number (home price, next month's revenue) What is unsupervised learning? Unsupervised learning gets raw, unlabeled data and is asked to find structure in it — without anyone telling it what to look for. There's no "correct answer" to check against during training. The defining trait: you don't know the outcome in advance — you're trying to find it. A retailer might feed customer purchase histories into an unsupervised model not because they have a label called "customer segment" already assigned, but because they want the model to discover natural groupings on its own. Common unsupervised tasks: Clustering — gr

If you've been following the AI market lately, you already know the headline numbers: DeepSeek V4 costs about 3% of what GPT-4o charges per token. GLM-4 runs benchmarks competitive with GPT-4 at roughly one-twentieth the price. Qwen delivers multilingual performance that rivals Claude for a rounding error in your cloud bill. The spreadsheets look incredible. The problem is actually using these models. Signing up for each provider means navigating Chinese-language dashboards, topping up separate wallets, managing six different API key formats, and dealing with SDKs that don't follow any consistent convention. Most developers give up after the second integration. That friction is why, despite the economics being objectively absurd in 2026, most teams still default to a single Western provider and eat the cost. AIWave exists to kill that friction. One API key. One endpoint. Fifty-plus models across eight Chinese labs, all speaking standard OpenAI-compatible format. Zero code changes to switch between DeepSeek, GLM, Qwen, MiniMax, and everything else. This post covers how the platform works under the hood, what the request lifecycle looks like, and how to integrate it in any language that can speak HTTP. The Fragmentation Problem, Quantified Before getting into the solution, here's what the Chinese LLM landscape actually looks like as of June 2026: Provider Flagship Model API Format Auth Method SDK Language DeepSeek V4-Pro Custom (DS format) Bearer token + signature Python, JS Zhipu GLM-4.5 OpenAI-compatible-ish JWT with expiry Python, Java Alibaba Qwen-3-Max DashScope (Alibaba) AK/SK + HMAC Python, Java, Go MiniMax MiniMax-Text-01 Custom REST API Key + Group ID Python Moonshot Kimi-K2 OpenAI-compatible API Key Python, JS Baidu ERNIE 4.5 Qianfan (Baidu) OAuth 2.0 Client Cred Python ByteDance Doubao-Pro Ark (Volcengine) IAM AK/SK + SigV4 Python, Go 01.AI Yi-Lightning OpenAI-compatible API Key Python Eight providers, seven different authentication schemes, four distinct A

Anthropic’s Fable/Mythos shutdown is the first real model export-control shock The important AI story this week is not just that Anthropic launched bigger Claude models. It is that the US government then told Anthropic to switch two of them off for foreign nationals — and Anthropic says the practical answer was to disable them for customers while it works through compliance. That is a very different kind of platform risk than rate limits or pricing changes. If you are building on frontier models, model access can now move because of export-control decisions, safety claims, and geopolitical pressure. What happened Anthropic announced Claude Fable 5 and Claude Mythos 5 on June 9. Fable 5 was described as Anthropic’s most capable generally available model, with stronger performance across software engineering, knowledge work, vision, scientific research, and longer complex tasks. Mythos 5 was positioned above that: an upgrade to Claude Mythos Preview, with Anthropic calling out cyber-defence and life-sciences use cases. Three days later, Anthropic published a blunt update: the US government had issued an export-control directive requiring Anthropic to suspend all access to Fable 5 and Mythos 5 by any foreign national, whether inside or outside the United States — including foreign-national Anthropic employees. Anthropic said the order arrived at 5:21pm ET on June 12, did not include detailed specifics, and that its understanding was that the government believed it had become aware of a jailbreaking method for Fable 5. Anthropic said access to other models was not affected, but the “net effect” was that it had to abruptly disable Fable 5 and Mythos 5 for customers to ensure compliance. Al Jazeera’s follow-up on June 19 frames the downstream effect clearly: allied countries and companies are now being forced to think harder about dependence on US frontier-model access. It also reports that Anthropic had granted roughly 200 institutions across 15 countries access to Claud

For the last 30 years, stopping the flow of cybersecurity-related software has proven to be ineffective. It's unclear why it would work now with Anthropic’s cybersecurity model Mythos.

Every developer who has ever muttered "there is a bug in this" is repeating a word with a surprisingly literal origin. On September 9, 1947, the operators of the Harvard Mark II, an early electromechanical computer, traced a malfunction to its source and found something they did not expect: a moth wedged inside Relay #70. They removed the insect, taped it into the operations logbook, and wrote a now-famous line beside it: "First actual case of bug being found." That page, moth and all, survives today in the collection of the Smithsonian's National Museum of American History. It is one of the best-loved stories in computing, and like most good stories it is a little more complicated than the popular version. Worth getting right, because the discipline it gave us is the same one behind every connected device we build. What actually happened in 1947 The Mark II was a room-sized machine built from relays, switches, and thousands of moving parts. When a moth flew into one of those relays, it physically interfered with the contacts and caused a fault. The technicians who found it had a sense of humor: calling it the "first actual case of bug being found" was a joke precisely because engineers had already been using "bug" for years to describe mysterious faults in machinery. Thomas Edison used the term in his notebooks back in the 1870s. So the 1947 moth did not invent the word "bug." What it did was give the term a perfect, photographable origin story, and it cemented the companion word that really matters: debugging. The act of removing that moth was, quite literally, de-bugging the computer. The Grace Hopper connection The story is almost always told with Grace Hopper at its center, and that deserves a small correction. Hopper, a pioneering computer scientist who later helped develop COBOL, was part of the Mark II team in 1947, but the evidence suggests she did not personally find the moth or write the logbook entry. What she did do was tell the story, brilliantly and o

What’s the most cliche possible gift you can give a relative? A digital photo frame, displaying a rotating slideshow of family photos. Now Aura has completely refreshed this product space with its gorgeous Aura Ink frame, which uses e-ink to create a display that doesn’t even look digital. Digital frames have always been so popular […]

Synthetic monitoring tools all promise the same thing — catch the broken checkout before your users do — and then bill you in seven different ways for it. The hard part of choosing one is not the feature checklist; it is predicting what you will actually pay when a single browser check running every 30 seconds from three regions turns into 259,200 runs a month. We compared seven synthetic monitoring tools on what separates them in practice: browser engine and fidelity, how you author checks (code, recorder, or AI), location coverage, alerting and on-call, failure forensics, and — the one that surprises teams — the pricing model. Every price below was verified against official pricing pages in June 2026. For the concepts behind these tools, start with what synthetic monitoring is . TL;DR comparison Tool Best for Browser engine Authoring Pricing model Browser price Checkly Code-first teams running Playwright suites Chromium (+ suite) Code (TypeScript) Per-run, 3 separate bills ~$4–6.50 / 1k Datadog Enterprises that want APM correlation Chrome/FF/Edge Recorder + code Per-run × freq × locations ~$12–18 / 1k Grafana Cloud / k6 OSS-leaning teams, best free tier Chromium (k6) Code (k6) + convert Per-execution ~$50 / 10k Better Stack Bundled monitoring + on-call Chromium Code + codegen paste Per-minute + per-seat ~$1 / 100 PW-min New Relic Broad type matrix + compliance Selenium (Chrome/FF) No-code step + code Per-check + seats + ingest ~$50 / 10k Sematext Predictable per-monitor pricing Chromium Code Per-monitor / month ~$7 / browser monitor Site24x7 No-code recorder + many locations Chrome/FF Recorder Pooled "advanced checks" ~$10 / 10k runs How we evaluated Real synthetic monitoring is more than a scheduled ping, so we scored each tool on six dimensions. Browser fidelity : does it run a modern engine (Playwright/Chromium) or older Selenium, and how faithfully does it reproduce a real user? Authoring mode : can you write checks as code, record them point-and-click, or gen

The short answer is: sometimes, but it's complicated.

Stop Fighting Scikit-Learn Pipelines: How Metadata Routing Fixes Sample Weights & Groups A couple of months ago, I stumbled upon this video by Vincent D. Warmerdam about metadata routing in scikit-learn. I'll be honest, I had no idea what "metadata routing" even meant, but Vincent's explanation completely changed how I think about building ML pipelines. The video showed me that one of the most frustrating problems in scikit-learn; passing sample weights and groups through complex pipelines finally had an elegant solution. It piqued my curiosity enough that I dove deep into the feature, tested it extensively, and honestly, I was surprised by how little coverage this gets in technical blogs and articles. So I figured, why not write about it myself and share what I learned? If you've ever struggled with imbalanced datasets, grouped cross-validation, or just wanted to pass custom information through your pipelines, this article is for you. Let's start from the very beginning. What is "Metadata" in Machine Learning? Let's start with a concrete example. You're building a credit card fraud detection model with this data: # Your training data X = transaction_features # Amount, merchant, time, location, etc. y = is_fraud # 0 = legitimate, 1 = fraud # But you also have additional information: sample_weights = [ 1.0 , 1.0 , 10.0 , 1.0 , ...] # Fraud transactions weighted 10x customer_ids = [ 101 , 102 , 101 , 103 , ...] # Which customer made each transaction Metadata is the "extra information" beyond your features (X) and labels (y): sample_weight : How important is each transaction? (Fraud = 10x more important) groups : Which customer does each transaction belong to? (For proper cross-validation) Custom metadata : Transaction timestamps, confidence scores, data quality flags, etc. Why Metadata Matters: The Credit Card Fraud Problem Imagine you're building a fraud detection system for a financial company. You have: Imbalanced data : 99% legitimate transactions, 1% fraudulent T