标签：#disc

As a backend developer, I sometimes help companies evaluate candidates by reviewing their recorded technical interviews. However, over time, I’ve noticed a deeply ingrained misconception. When discussing memory management or data streaming, many developers explicitly state: "Iterators in Python are inherently eager. If you want true lazy loading or lazy evaluation, you have to use generators and the yield keyword." This misconception is common. Many popular bootcamps and online courses introduce lazy evaluation exclusively through generators . Custom class-based iterators are usually skipped or dismissed as boilerplate-heavy OOP theory rarely used in production Python. This confusion is further reinforced by two common educational simplifications : The List vs. Generator Expression Analogy: Beginners are taught that square brackets [...] (list comprehensions) are eager and take up memory, while parentheses (...) (generator expressions) are lazy. This often creates a false binary mental model: "generators = lazy, everything else = eager." Standard "Textbook" Examples: When courses demonstrate a custom iterator, they usually write a basic class that accepts an already fully loaded list in its __init__ and simply increments an index in __next__ . While this is valid for in-memory data, it leads developers to assume that custom iterators inherently require loading all data upfront. In reality, generators are a specialized language feature designed to implement the iterator protocol automatically . They comply with the exact same interface ( __iter__ and __next__ ). A generator is lazy not because of some magical property of the yield keyword, but simply because it adheres to this underlying contract. To show that custom iterators can be lazy without using any generators or yield keywords, I’ve put together a lightweight and reproducible benchmark. 🧪 The Experiment: Proving Lazy Loading with Custom Iterators Suppose we need to read a database export file ( test_users_db.

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI . For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here . <span>Tutorial</span> <span>Advanced</span> <span>⏱ 45 min read</span> <span>© Gate of AI 2026-06-16</span> Learn how to fine-tune large language models (LLMs) to enhance communication capabilities in specialized domains, such as homeless shelters, using modern AI tools and techniques like LoRA. Prerequisites Python 3.10+ OpenAI API key (latest version) Familiarity with machine learning concepts What We're Building In this tutorial, we will embark on a journey to fine-tune a large language model (LLM) to cater to the specific communication needs of homeless shelters. By leveraging a bespoke dataset compiled from the Youth Spirit Artworks (YSA) Tiny House Empowerment Village website, we aim to create a model that can effectively assist in the nuances of communication required in such environments. The finished project will result in a model capable of generating contextually relevant and empathetic responses to inquiries typical within the homeless shelter community. This involves structuring data into a standardized question-and-answer format to enhance the training process, ensuring the model's outputs are aligned with the communication style and needs of the target audience. Setup and Installation To begin, we need to set up our development environment with the necessary tools and libraries for model fine-tuning. We'll be using Python along with the OpenAI library to interact with the LLMs. pip install openai pandas numpy Additionally, you'll need to configure environment variables to securely store your API keys. This ensures that sensitive information is not hardcoded into your scripts. .env file OPENAI_API_KEY=your_openai_api_key Step 1: Data Collection and Preparation The first step in fine-tuning our model involves collecting and

I built a tool called "kaggle-dingdong" that automatically fetches Kaggle competition information and sends notifications to Email, Slack, and Discord. It runs daily on a schedule via GitHub Actions, and you get notified whenever a new competition is published. https://github.com/asherish/kaggle-dingdong Why I Built This Checking the Kaggle competitions page every day is tedious. Featured competitions in particular have entry deadlines, so missing them means losing the opportunity. While RSS feeds and official notification features exist, I wanted notifications delivered directly to the channels I actually use (Discord and Slack), so I built my own. Tech Stack Python 3.13 uv — Package manager and build tool (by Astral) Kaggle Python SDK v2.0.0 — Fetching competition info GitHub Actions — Automated daily execution at 09:00 UTC pytest — Testing Three notification channels are supported: Channel Method Format Email SMTP HTML (card layout) Slack Incoming Webhook Block Kit Discord Webhook Rich Embed Architecture GitHub Actions (cron: daily at 09:00 UTC) ↓ Fetch competition list via Kaggle API ↓ Filter by conditions in config.json ↓ Compare with sent history to extract unnotified competitions ↓ Send notifications to configured channels ↓ Update sent history (max 200 entries) The project structure is as follows: kaggle-dingdong/ ├── src/kaggle_dingdong/ │ ├── __main__.py # Entry point │ ├── config.py # Configuration loading │ ├── competitions.py # Fetch & filter competitions from Kaggle API │ ├── email_sender.py # Email notifications │ ├── slack_sender.py # Slack notifications │ ├── discord_sender.py # Discord notifications │ └── history.py # Sent history management ├── tests/ # pytest tests ├── config.json # Filter configuration └── .github/workflows/ └── notify.yml # GitHub Actions workflow Implementation Highlights Fetching and Filtering Competitions The Kaggle SDK is used to fetch the competition list. In addition to the default sort order, it also fetches with recentl

Something feels different about security incidents lately. Breaches, leaks, account takeovers, phishing campaigns they're not new. But their frequency, sophistication, and scale seem to be growing at a pace that feels genuinely alarming. Instagram accounts hacked overnight. Corporate systems compromised in hours. Phishing emails that sound disturbingly human. As someone studying AI & Big Data, I can't help but ask: is AI responsible for this? And if so, how? I think the honest answer is: yes but in two very different ways. The two faces of AI in cybersecurity When we talk about AI and cyberattacks, most people imagine one scenario: hackers using AI to attack systems faster and smarter. That's real. But it's only half the picture. The other half is something we talk about far less: the vulnerabilities that come from integrating AI into systems in the first place. These are two very different problems. And conflating them leads to the wrong solutions. Problem 1: AI is expanding the attack surface Every time a platform integrates an AI feature, they're adding something new to their infrastructure. And new infrastructure means new potential vulnerabilities. AI systems require: Massive data pipelines more data flowing through more systems APIs connecting multiple services more endpoints that can be exploited Third-party models and tools more external dependencies, more trust relationships Real-time processing less time to detect anomalies before damage is done Many organizations are integrating AI features faster than their security teams can audit them. And the consequences are already visible. In June 2026 , hackers reportedly manipulated AI-powered support systems to gain unauthorized access to Instagram accounts. The attack didn't target traditional software vulnerabilities it targeted the AI system itself , exploiting the automated account recovery flow that Meta had built with AI. This is the new reality: attackers are no longer just targeting your code. They're ta

There is a persistent myth that to build a worthy code assistant, you absolutely must use GPT or Claude. This is false. You don't need a 1-trillion parameter model. You need a small local model and extremely rigorous engineering around it. This is the direction history is taking for companies. As Mark Zuckerberg mentioned, the future isn't a single omniscient model, but "every company having its own specialized AI" . And this specialization necessarily involves fine-tuning and local deployment (or on sovereign servers) to guarantee data security. The thesis behind the construction of Vibrisse Agent can be summed up in one sentence: Small models, Great tools. In this article, I will detail the technical stack and concrete engineering solutions I implemented to tame a local model and make it reliable in production: LangGraph, Ollama, FastAPI, React (no build step, with embedded custom CSS) , all running on a machine with 32 GB of RAM. For the curious who want to run the agent on their machine right now: // MacOs / Linux curl -sSL https://agent.vibrisse-studio.dev/install.sh | bash // Windows irm https://agent.vibrisse-studio.dev/install.ps1 | iex Architecture: Why a State Machine (LangGraph)? At first, when building an LLM application, we tend to think in sequential chains: Input -> Prompt -> Tool -> Output . The problem is that if one node fails, the whole chain stops without us being able to catch the error or understand the context of the crash. That's where LangGraph comes in. Vibrisse's architecture isn't a chain, it's a state machine . Every node in the graph has a very precise responsibility, shares a global conversation state, and uses conditional transitions to move to the next node. I implemented the Supervisor / Worker pattern: The Supervisor analyzes the user's intent. It does nothing else but route. It dispatches the task to specialized Workers (the RAG Worker, the Search Worker, the Ghost Worker...). If a Worker fails or needs more information, it can se

Il y a un mythe persistant selon lequel pour construire un assistant de code digne de ce nom, il faut absolument utiliser GPT ou Claude. C'est faux. Vous n'avez pas besoin d'un modèle à 1 trillion de paramètres. Vous avez besoin d'un modèle local de taille réduite et d'une ingénierie extrêmement rigoureuse autour de lui. C'est d'ailleurs le sens de l'histoire pour les entreprises. Comme l'évoquait Mark Zuckerberg, l'avenir n'est pas à un modèle omniscient unique, mais à "chaque entreprise avec sa propre IA spécialisée" . Et cette spécialisation passe obligatoirement par le fine-tuning et le déploiement local (ou sur serveurs souverains) pour garantir la sécurité des données. La thèse derrière la construction de Vibrisse Agent tient en une phrase : Small models, Great tools. Dans cet article, je vais détailler la stack technique et les solutions d'ingénierie concrètes que j'ai mises en place pour dompter un modèle local et le rendre fiable en production : LangGraph, Ollama, FastAPI, React (sans build step, avec CSS custom embarqué) , le tout tournant sur une machine avec 32 Go de RAM. Pour les curieux qui souhaitent lancer l'agent sur leur machine dès maintenant : // MacOs / Linux curl -sSL https://agent.vibrisse-studio.dev/install.sh | bash // Windows irm https://agent.vibrisse-studio.dev/install.ps1 | iex L'Architecture : Pourquoi une Machine à États (LangGraph) ? Au début, quand on construit une application LLM, on a tendance à penser en chaîne séquentielle : Input -> Prompt -> Outil -> Output . Le problème, c'est que si un nœud échoue, toute la chaîne s'arrête sans qu'on puisse rattraper l'erreur ou comprendre le contexte du plantage. C'est là qu'intervient LangGraph . L'architecture de Vibrisse n'est pas une chaîne, c'est une machine à états . Chaque nœud du graphe a une responsabilité très précise, partage un état global de la conversation, et utilise des transitions conditionnelles pour passer au nœud suivant. J'ai implémenté le pattern Supervisor / Worker : L

Disclaimer: Please read the full post before commenting. Hey everyone! If you do not know me, my...

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

A story about an AI content moderation system that flagged 347 posts since launch — and what...

This advice is everywhere now: Stack ten indicators, wait for three of five to agree, then size up...

Two weeks ago I published a piece explaining exactly why AI detectors are unreliable. Then Sloan...

👋 Hey there, Tech Enthusiasts! I'm Sarvar, a Cloud Architect who loves turning complex tech problems...

Hi everyone, I’m working on a new programming language called Zentax. It is still in early development, but the goal is to build a modern language focused on: Performance and low-level control Simple and clean syntax Native desktop application support A modular compiler and runtime design Zentax is not trying to replace existing languages — it is an experiment in building a unified approach for systems programming and UI development. Current Status Compiler: in development Runtime: early design stage Renderer: experimental Standard library: planning phase Looking for Contributors I’m open to collaboration from anyone interested in: Programming language design Compiler development Runtime systems Graphics / rendering engines Open-source tooling Even feedback and ideas are welcome at this stage. Links Git Hub Repo Discord Thanks for reading. Dr. Zoha Tariq Anoneurx

A story about an AI alert model that cut false alarms from 60% to 7% — and what happened when...

Hey all! I have this thought in mind that we should all come together as a community to celebrate...

This is a submission for the June Solstice Game Jam 🎮 Play the Game: Letters to Tomorrow 💻 Source...

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

Mine got flagged twice in one day. Both essays generated more engagement than anything else I've...

Word scrambling is a deceptively simple mechanic. Rearrange the letters of a word, ask someone to restore the original — that's the entire game loop. But underneath that simplicity is a cognitive process that language researchers find genuinely interesting, and that developers building educational tools keep returning to. The Cognitive Mechanics of Unscrambling When a learner attempts to unscramble a word, they're engaging several parallel cognitive processes: pattern recognition (matching letter combinations to phonemes they know), memory retrieval (searching their lexical database), and hypothesis testing (trying a mental arrangement before committing). It's a lightweight version of the same cognitive work that makes retrieval practice so effective in spaced repetition systems. For language learners specifically, this is high-value low-stakes practice. The scrambled form gives enough context to confirm the answer upon success — no ambiguity like a multiple-choice distractor — while requiring genuine active recall. Implementation Considerations for Developers If you're building a word scramble feature into an educational app, a few things matter: Avoiding anagram collisions: "SILENT" → "LISTEN" is a classic example. Your scrambling algorithm needs to detect valid English words in the output and regenerate if it creates a different real word. A dictionary API lookup on the scrambled result handles this. Difficulty calibration: Longer words and words with repeated letters (like "BALLOON") are objectively harder to unscramble. A good difficulty curve starts with 4–5 letter words and increases length progressively. First/last letter anchoring: Keeping the first and last letters in position is a widely used technique to reduce cognitive load. It's psychologically effective — people anchor on word edges more than the interior. Using Existing Tools vs. Building Your Own For most educational content creators and teachers (non-developers), building their own tool isn't feas

It's widely accepted that as AI writes more and more of our code, opportunities decrease for newcomers to gain the skills needed to become professional programmers. At the same time, experienced people bemoan the way AI is causing them to gradually lose the skills they took so long and worked so hard to gain. Programming, like mathematics and perhaps music, sits in the middle between science and art. As science, it's all about capturing and organising knowledge, and as art, it's the application of creativity to problem-solving. Enjoyment - deep satisfaction or an emotional rush - can be had from either or both of these. But the perception is that AI is depriving us of opportunity, both to learn and to be creative. Code written by a human reveals a lot about the coder. Their depth of knowledge of the coding language, their creative use of variable and function names, and even the visual layout of a script. You can often tell at a glance whether the writer truly cared about the code they wrote, or whether it was just a means to an end, to ensure their next pay packet arrives on time. As AI improves, it makes fewer mistakes, but it also produces code that is increasingly hard for any human to read and truly understand. Since the job of a human in the coding loop is increasingly not to write but to validate code, this is becoming a problem. So here's my recent story, a series of happy accidents. I've been using agentic AI for about a year. First with Copilot in VS Code, then more recently with Claude Code at the command line. At the start, I found Copilot to make a lot of mistakes and to produce rather repetitive, poorly-structured code, but looking back, a lot of that was probably down to my own ignorance of how to control the process. The biggest problem I had was in validating JS or Python code. There was just so much of it, often using features of both languages I never fully got to grips with. I've never been a first-class programmer and most of my own code is pure