标签：#disc

The fix was one line. if not items: return [] Enter fullscreen mode Exit...

We’ve all been there: staring at a messy medicine cabinet, wondering which box is for allergies and which one expired in 2022. In the world of Computer Vision and AI Healthcare , digitizing physical assets is a classic challenge. Today, we're building a "Medicine Box Expert"—a sophisticated pipeline that uses YOLOv8 for precision detection and OpenAI CLIP for multimodal understanding to turn a pile of pills into a searchable digital database. By the end of this tutorial, you'll understand how to bridge the gap between raw pixels and structured medical data. We are moving beyond simple classification; we are building a robust system capable of handling complex lighting, varied angles, and the tiny typography common in pharmaceutical packaging. The Architecture: A Multi-Stage Vision Pipeline To achieve high accuracy, we don't rely on a single model. Instead, we use a "Detect-Extract-Embed" workflow. graph TD A[User Uploads Image] --> B[YOLOv8: Box Detection] B --> C{Box Found?} C -- Yes --> D[Crop & Preprocess] C -- No --> E[Error: No Box Detected] D --> F[Tesseract OCR: Text Extraction] D --> G[OpenAI CLIP: Visual Embedding] F & G --> H[SQLite Query: Semantic Search] H --> I[Result: Drug Info & Dosage] Prerequisites Before we dive into the code, ensure you have the following tech_stack installed: YOLOv8 : For real-time object detection. OpenAI CLIP : To handle semantic image-text matching. Tesseract OCR : For reading the fine print on the boxes. SQLite : To store and query our medicine metadata. pip install ultralytics transformers torch pytesseract Step 1: Detecting the Medicine Box with YOLOv8 First, we need to locate the medicine box within the frame. A generic YOLOv8 model (like yolov8n.pt ) is surprisingly good at detecting "books" or "cell phones," but for the best results, you should fine-tune it on the Open Images Dataset specifically for "Box" or "Medical Packaging." from ultralytics import YOLO import cv2 # Load the model model = YOLO ( ' yolov8n.pt ' ) def

I just joined DEV to explore the community and get into the habit of writing about what I'm learning. I also set up a blog on Hashnode — figuring out how the two fit together. Here's a quick code block to test formatting: ​ function greet ( name ) { console . log ( `Hello, ${ name } !` ); } greet ( " DEV " ); ​ ``` More to come as I find my way around 👋

Welcome to this week's Top 7, where the DEV editorial team handpicks their favorite posts from the...

AI Agent Guidelines for CS336 at Stanford Meta Description: Discover the official AI Agent Guidelines for CS336 at Stanford — what they cover, why they matter, and how students can navigate them effectively in 2026. TL;DR Stanford's CS336 (Language Models from Scratch) has specific guidelines governing the use of AI agents in coursework. These rules define what's permissible, what's prohibited, and how students should document AI assistance. Whether you're enrolled, curious, or building a similar policy framework, this article breaks down everything you need to know — with practical advice on staying compliant while still learning effectively. Introduction: Why AI Agent Guidelines Matter in Graduate CS Courses Artificial intelligence is no longer just the subject of computer science courses — it's actively reshaping how those courses are taught and completed. Stanford's CS336, one of the most rigorous language model courses in the world, sits at a fascinating crossroads: it teaches students to build large language models from scratch, while simultaneously having to govern how AI tools can be used during that learning process. The AI Agent Guidelines for CS336 at Stanford represent one of the first serious, detailed attempts by a top-tier institution to define the boundaries of AI-assisted work in an advanced ML course. For students, researchers, and educators alike, understanding these guidelines offers a window into the broader conversation about academic integrity in the age of generative AI. What Is CS336 at Stanford? CS336, officially titled Language Models from Scratch , is a graduate-level course offered through Stanford's Computer Science department. It's designed for students who want to go beyond using pre-trained models and actually understand — and implement — the full stack of modern language model development. Core Topics Covered in CS336 Transformer architecture and attention mechanisms Tokenization and vocabulary design Pre-training data pipelines and

Everyone keeps saying AI will replace developers. Meanwhile I was sitting at 3:17 AM staring at a bug...

It took me some time to write this post, but now it says exactly what I wanted to say. When people...

New article: “ Responsible Disclosure in the Age of AI: A Call for Urgent Action ,” by Melissa Hathaway. Abstract: Artificial intelligence is fundamentally reshaping the balance between vulnerability discovery and remediation. Frontier AI models are now capable of autonomously identifying exploitable software vulnerabilities at unprecedented speed and scale. This development exposes decades of accumulated technical debt created by a software industry that prioritized rapid deployment over secure-by-design engineering practices. Drawing on the evolution of software assurance, vulnerability disclosure frameworks, and U.S. cyber policy, this perspective argues that the current moment represents a strategic inflection point for governments, industry, and critical infrastructure operators. The author examines the growing tension between offensive and defensive equities in cyberspace, the emergence of AI-enabled vulnerability discovery capabilities in both the U.S. and China, and the increasing risks posed by unsupported legacy systems and AI-assisted code generation practices. Responsible disclosure can no longer remain a reactive or fragmented process, but must become a coordinated national and international resilience effort involving governments, software vendors, infrastructure operators, and emergency response organizations. The article concludes with an urgent call for accelerated remediation, large-scale patch management coordination, and sustained investment in automated vulnerability repair capabilities before adversaries exploit this rapidly narrowing window of opportunity...

The loop I didn't notice closing Seven weeks ago I started using AI for work. Two weeks after that, I published an article. Seven weeks after that — today — the article is one of sixteen, and they are all in a memory file that the AI reads at the start of every new conversation. I didn't notice the loop until I named it. This is a note about that loop, what it is, what it isn't, and why I keep publishing even though the loop doesn't strictly need me to. The shape It runs like this: I decide what to do. I work it out with the AI — usually in dialogue, sometimes by pasting raw code or data. The dialogue becomes a record. Sometimes a memory entry. Sometimes a published article. The record becomes context for the next conversation, which informs the next decision. It didn't look this clean while it was happening. The numbering is hindsight. From inside, the steps overlap. The first step is the one I keep. Direction is mine: what to build, what to write, what to negotiate. The history that shapes those decisions — twenty-four years of solo work, my company, my family, my health — is also mine. The AI is not setting direction. The second step is where most of the leverage is. I describe what I want to do as completely as I can, sometimes by handing over source code. Then I ask: does this look right? Is there a path I'm missing? Where would this break? I'm opening drawers — possibilities I half-saw in my own head — and checking which ones open cleanly. When one opens cleanly, that is the GO signal. Not "will this succeed" but "this is doable, so do it." The third step happens almost without effort. The conversation already exists as text. Some of it becomes a memory entry I add deliberately. Some of it becomes raw material for an article. The article writes itself partly because I have already explained the thing to the AI. The fourth step is the one that took longest to arrive — and the one I want to be most careful about describing. Three phases, not one The loop didn't

Meme Monday! Today's cover image comes from the last thread. DEV is an inclusive space! Humor in...

Based on real system architecture decisions. About a $660K AI platform, three AI agents that kept the dashboard green, and a P0 incident that cost $3.15M over one weekend. Act 1 · The All-Hands Meeting Wang Lei, VP of Product, stood in front of the big screen, a smile on his face. Behind him, a dashboard rolled data from the "Axon AI Client Engineering Platform — Q1 Performance Report." Numbers cascaded across the wall: Metric Axon Platform Human Team (Last Q1) Improvement Avg daily tickets processed 847 312 +171% Avg first response time 12s 4h 17m ↓ 99.92% Customer satisfaction 4.8/5 4.1/5 +17% Monthly operating cost $52K $133K −61% Twelve department heads sat in the room. Dead silence. Wang Lei planted both hands on the table and scanned the room. His eyes landed on me. "Alex. Your team processed 312 tickets last Q1. Axon processed more than that in a single day last month." He smiled. Not a friendly smile. A sentencing smile. "And Axon costs less than a third of your team's operating expense." "We invested $660K in the whole platform. At current operating costs, it pays for itself in eighteen months." "After management review — the Client Engineering technical liaison function is being fully transitioned to the Axon platform." He clicked to the next slide. "Employees in replaced roles will complete exit interviews within the week." Someone inhaled sharply. I didn't. I opened my notebook to page 37. "Wang, what dimensions are these numbers from?" "What do you mean, 'what dimensions'?" His smile tightened. "Of those 847 daily tickets — how many are auto-tagging and routing, and how many are actual technical resolutions?" The room went quiet for about five seconds. Wang Lei looked at me. "Axon's ticket closure rate is ninety-three percent." "What's the reopen rate?" He paused. "What?" "After Axon replies — how many customers reopen the same ticket within twenty-four hours?" "We're still collecting that —" "Let me save you the trouble." I turned my notebook toward th

A survival guide for when everything goes wrong in production. Your Redis dashboard looks perfect. Hit ratio: 99.2%. Latency: sub-millisecond. Memory usage: 60% of available. Every metric says healthy. Then at 2:47 PM, your API starts returning 500s. Response times spike to 30 seconds. Users can't log in. The dashboard still shows 99% hit ratio because the cache is working — it's serving cached errors to everyone equally fast. Redis is doing exactly what you told it to do. The problem is what you told it to do. Why Single-Threaded Is Fast (Until It Isn't) Redis processes commands on a single thread. No locks. No context switching. No synchronization overhead. One CPU core, fully utilized, can handle 100K+ operations per second because it never waits for another thread to release a lock. The event loop model (similar to Node.js) multiplexes thousands of client connections on a single thread using non-blocking I/O. Read a request, process it, write the response, move to the next. When your commands are simple — GET, SET, INCR — each one takes microseconds. The trap: slow commands block everything. KEYS * on a million-key database? That's a full keyspace scan on the main thread. While it runs, every other client waits. SORT on a large set? Same. LRANGE on a list with 10 million elements? Same. Redis 6.0 introduced I/O threading ( io-threads config) for reading and writing network data on multiple threads, but command execution is still single-threaded. Redis 7.0 improved this further, but the fundamental model hasn't changed. Long-running commands on the main thread stall everything. Rules: Never use KEYS in production. Use SCAN instead — it's cursor-based and returns results incrementally. Watch out for O(N) commands on large data structures: LRANGE , SMEMBERS , HGETALL on million-element structures. Use SLOWLOG to find commands that are blocking the event loop. Pipelining: The Easiest 10x You'll Ever Get Every Redis command involves a network round trip: send request

The honest decision framework, not another flame war. The SQL vs NoSQL debate has been running for 15 years and it still generates more heat than light. Here's the framework that actually helps you decide. The Real Question It's not "SQL or NoSQL." It's: what does your access pattern look like? If your application is mostly reading and writing related data through well-defined queries — orders with line items, users with addresses, products with categories — relational databases are purpose-built for this. JOINs are not expensive when they're indexed. Transactions are not slow when they're scoped correctly. PostgreSQL handles 50 million rows comfortably on a single node. If your application is reading and writing self-contained documents with predictable access by a primary key, and you rarely need cross-document queries — user profiles, product catalogs, content management — a document database simplifies your code. No ORM mapping hell. No migration files for adding a field. If your application writes massive volumes and reads by partition key with eventual consistency — time-series data, IoT telemetry, activity feeds at scale — wide-column stores like Cassandra were built for this specific workload. The 2026 Reality PostgreSQL has eaten NoSQL's lunch in many areas. JSONB support means you can store and query unstructured data inside PostgreSQL with GIN indexes. You get the document model flexibility without giving up transactions, JOINs, and a 30-year ecosystem. For 80% of startups and mid-size companies, PostgreSQL is the only database you need. MongoDB has gotten more relational. Multi-document ACID transactions (since 4.0), schema validation, aggregation pipelines that look suspiciously like SQL. It's converging toward what PostgreSQL already does, but with a different starting point. DynamoDB dominates serverless. If you're in AWS and your access pattern is simple key-value with known query patterns, DynamoDB's pricing model (pay-per-request) and operational s

A survival guide for when everything goes wrong in production. There's a moment every engineer who works with Kafka experiences. You check the producer. Messages are sending. You check the consumer. Nothing. The consumer group shows zero lag because there's nothing to lag behind — as far as the consumer knows, the topic is empty. But it's not empty. The messages are there. Somewhere. In some partition, at some offset, behind some configuration you set six months ago and forgot about. Kafka doesn't lose messages. But it's very good at hiding them from you. Consumer Lag: The Number Everyone Watches Wrong Consumer lag is the difference between the latest offset in a partition and the offset your consumer group has committed. Simple concept. Dangerous in practice. The mistake: treating lag as a single number. Lag is per-partition. If you have 30 partitions and one consumer is stuck on partition 17 while the others are healthy, the total lag looks manageable. But partition 17's data is hours behind, and whatever downstream system depends on that data is serving stale results. Monitor lag per partition. Tools like Burrow, Kafka Exporter for Prometheus, or even kafka-consumer-groups.sh --describe break it down. If one partition's lag is growing while others are stable, you have a stuck consumer, a hot partition, or a poison message. A poison message is a record your consumer can't process — malformed data, unexpected schema, null where it shouldn't be null. The consumer throws an exception, the offset doesn't commit, and it retries the same message forever. Lag grows. The consumer looks "alive" because it's processing — just not making progress. The fix: dead letter queues. After N retries, move the message to a separate topic, commit the offset, and move on. Alert on the dead letter topic. Investigate later. Don't let one bad record block millions of good ones. Rebalance Storms: The Silent Killer Consumer rebalancing is Kafka's mechanism for redistributing partitions acro

A few weeks ago I posted about building a desktop app that automates GitHub commits because...

A child laughs on a playground. Pure. Unbothered. The world owes him nothing yet and he owes it nothing back. Then he grows up. He does everything right. Studies. Works. Sends his resume. Waits. Rejected. Sends it again. Rejected. Again. Rejected. The smile disappears. Not slowly. Suddenly. The day you realize the system was never built for you. An empty stomach has no dignity. A person denied the right to work is not just unemployed, they are being told their existence has no value. That is not a glitch. That is a choice someone made. 72 million rejections per year in the US alone. The algorithm decides in 0.8 seconds. No human ever reads his name. AI did not build this system. Humans did. AI just made the discrimination invisible, scalable, and deniable. So I built BiasLens. Paste your rejection. 30 seconds. Scans for documented discrimination patterns under US employment law. Free. Anonymous. No account. The hardest part was not building the scanner. It was forcing the AI to say "no bias found" when there isn't any, instead of manufacturing injustice to seem useful. How do you stop AI from missing the bias that's actually there, without inventing bias that isn't? I am still solving that. For that child. For every human who deserves to keep smiling. https://biaslens-justice.vercel.app/

Martin Fowler's May 27 Fragments brings together four arguments with direct implications for teams working with AI agents. All four are worth covering. Ian Johnson: build quality gates before releasing the agent Ian Johnson published a series about restructuring a gnarly codebase: three months, 258 commits, moving from a Laravel monolith with no tests to an application with automated quality gates and an AI agent shipping production code with minimal supervision. The insight Fowler highlights is about the transition from in-the-loop to on-the-loop: "For the first two months of this project, I used Claude Code with auto-approve turned off. Every file edit, every terminal command, every change… I reviewed it before it executed. The results were good. The code was clean. But I was doing most of the thinking and half the typing. The agent was a fancy autocomplete with better suggestions." Ian Johnson Manual review of every change is not how you build trust in the agent. Trust comes from building the structure that ensures the agent will do the right thing, then stepping back. The sequence: characterization tests first, static analysis, architectural patterns that make things flow correctly. Fowler notes this is exactly the sequence he would use himself. Adam Tornhill: roughly 2 hours of cognitive endurance Adam Tornhill observes that agentic work has a decision density that is mentally more expensive than it appears. The estimate is roughly two hours as a sustainable limit, not a full day of work. The implication: adding more parallel agents does not solve the problem, because the bottleneck is the coordinating engineer's cognitive capacity, not available processing volume. The solutions are smaller tasks, automation, and verification mechanisms, not more parallelism. NHS: closing open source repositories NHS (UK National Health Service) closed open source repositories citing LLM threats to code security. The UK Government Data Services countered directly: making code p

TL;DR I've missed a lot of opportunities simply because I didn't know they existed. So every...

Hey everyone! I bring you my development journey on what I have discovered, accomplishments for this...