Tagged articles
generator
62 articles · Page 1 of 1

Qborfy AIApr 15, 2026 · Artificial Intelligence
The article analyzes why a single AI struggles to self‑evaluate, presents Anthropic’s three‑agent (Planner, Generator, Evaluator) architecture with concrete DAW‑building examples, sprint contracts, cost‑benefit tables, and step‑by‑step processes that show how each role solves specific problems and improves overall quality.
AI ArchitectureEvaluatorPlanner
0 likes · 24 min read


Java OneMar 28, 2026 · Artificial Intelligence
This guide translates Google Cloud Tech's Agent Skills design patterns, detailing five reusable architecture patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—that help developers create modular, maintainable, and composable AI agents using the Agent Development Kit (ADK).
AI agentGoogle ADKInversion
0 likes · 16 min read


o-ai.techMar 25, 2026 · Artificial Intelligence
Anthropic’s article dissects a three‑role harness—planner, generator, evaluator—for building long‑running AI applications, explaining how structured specs, sprint contracts, iterative evaluation, and context management transform a single model into a reliable software‑engineering pipeline, with concrete front‑end and full‑stack case studies.
AI agentsEvaluatorHarness
0 likes · 23 min read

The article shows how to diagnose and dramatically cut Python’s memory usage by using built‑in tools such as sys.getsizeof, psutil, __slots__, generator expressions, memory‑mapped files (mmap) and string interning, providing concrete code examples, benchmarks and practical tips to avoid common pitfalls.
Memory OptimizationPython__slots__
0 likes · 15 min read


Wuming AIMar 18, 2026 · Artificial Intelligence
This article dissects five practical design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—explaining when each solves a specific problem, showing concrete SKILL.md examples, step‑by‑step instructions, and a GitHub optimizer tool that automatically refines your agent skills.
AI agentsSkill Developmentdesign patterns
0 likes · 13 min read

Python generator functions, using the yield keyword, enable lazy evaluation and memory-efficient data processing, with examples covering basic syntax, differences from regular functions, Fibonacci sequence generation, large file reading, two-way communication via send(), and control methods like throw() and close(), highlighting their advantages.
Code ExamplesPythongenerator
0 likes · 4 min read

The article explains why you should challenge yourself to avoid explicit for loops in Python and demonstrates how to replace them with list comprehensions, generator expressions, map/reduce, and itertools, resulting in shorter, more readable, and better‑structured code.
Loop Optimizationcode refactoringfunctional programming
0 likes · 7 min read

This article walks through a Python list‑deduplication problem, showing the original data, the expected result, and five distinct code solutions—including itertools, list comprehensions, loops, generators, and enumerate—each illustrated with output screenshots.
Pythongeneratoritertools
0 likes · 5 min read

This article demystifies Python’s for-loop by explaining how iterable objects and iterators work under the hood, illustrating the iterator protocol with code examples, and providing practical custom iterator implementations, common pitfalls, and tips for efficient data processing.
IterablePythondata processing
0 likes · 9 min read

This article walks through a common Python data‑processing challenge—removing consecutive duplicate elements from a list—by presenting five distinct solutions, including itertools.groupby, list comprehensions, explicit loops, generator functions, and enumerate, each illustrated with code snippets and output screenshots.
Pythongeneratoritertools
0 likes · 5 min read

The article explains how PHP generator functions can create infinite iterable objects, such as a Fibonacci sequence, to process large data sets efficiently by yielding values on demand, reducing memory usage and improving performance, with practical code examples and discussion of advantages and use cases.
BackendLarge DataPHP
0 likes · 5 min read

This article explains PHP generator functions introduced in PHP 5.5 and enhanced in PHP 7, demonstrating how to implement infinite iterable objects such as a Fibonacci sequence, and discusses their advantages for processing large data sets, memory efficiency, and typical use cases like log handling and pagination.
Large Data ProcessingMemory OptimizationPHP
0 likes · 5 min read

Python comprehensions provide concise syntax for creating lists, sets, dictionaries, nested structures, and generator expressions, allowing developers to replace explicit loops and conditional logic with readable one‑liner constructs, as illustrated with practical code examples and guidance on their appropriate use.
ComprehensionsPythongenerator
0 likes · 6 min read

This article explains Python iterators, iterables, and generators, detailing their definitions, core methods, advantages, disadvantages, and practical code examples—including iterator objects, generator creation via comprehensions and the yield keyword, decorator integration, and mutable data handling—providing a comprehensive guide for developers.
DecoratorIterablePython
0 likes · 14 min read

This article explains the fundamentals of C++20 coroutines, describing their lightweight asynchronous execution model, key language constructs such as co_await, co_yield, and co_return, the underlying components like promise objects and coroutine handles, and demonstrates real‑world usage through comprehensive code examples for networking, file I/O, generators, and task scheduling.
C++20Coroutinesco_await
0 likes · 32 min read

This article explains Python's iteration protocol, detailing how iterable objects and iterators work, and provides multiple code examples—including custom iterables, generators, and iterator-based test data handling—to demonstrate their use in building flexible and memory‑efficient applications.
Iterablegeneratoriteration-protocol
0 likes · 11 min read

This article explains Python generator functions, their memory‑efficient iteration mechanism, and demonstrates through multiple examples—including basic generators, Fibonacci sequences, large file processing, HTTP streaming, and API test data generation—how they can streamline and optimize interface automation testing workflows.
api-testingautomationgenerator
0 likes · 10 min read

This article presents ten advanced Python iteration techniques—including list, dictionary, and set comprehensions, zip, enumerate, itertools utilities, and generator expressions—each illustrated with clear code examples to help developers write more concise, efficient, and readable code.
generatoritertools
0 likes · 5 min read

This article explains how PHP generator functions can create infinite iterable objects, demonstrating with a Fibonacci sequence example to efficiently handle large data sets while reducing memory usage and improving performance in backend development.
Infinite SequenceLarge DataMemory Optimization
0 likes · 5 min read

This article demonstrates how Python generator functions can be applied in API automation testing to process large data streams, batch requests, infinite sequences, file handling, dynamic test data generation, recursive file traversal, lazy calculations, data filtering, response processing, retry logic, and test report creation, thereby improving memory efficiency and test flexibility.
api-testinggeneratormemory-management
0 likes · 6 min read

This article presents ten advanced Python techniques—including list comprehensions, lambda functions, decorators, context managers, generators, metaclasses, asyncio coroutines, enums, slicing, and exception handling—each illustrated with detailed code examples to help readers deepen their mastery of Python programming.
DecoratorMetaclassadvanced
0 likes · 6 min read

This article provides a comprehensive introduction to C++20 coroutines, covering fundamental concepts, stackful versus stackless implementations, detailed code demos—including a simple coroutine, a generator for Fibonacci numbers, and a task framework—while explaining the underlying compiler transformations and practical usage.
C++20CoroutinesStackless
0 likes · 31 min read

The article explains how avoiding explicit for‑loops in Python encourages the use of more expressive constructs such as list comprehensions, generator expressions, map/reduce, and itertools, leading to shorter, more readable, and better‑structured code while showcasing practical examples and best‑practice recommendations.
Pythoncode optimizationfunctional programming
0 likes · 7 min read

This article explains PHP 7 generators, describing their concept, memory‑saving benefits, and how to implement them with a practical example that reads a large file and yields squared numbers, demonstrating efficient data processing and lazy loading in backend development.
Memory OptimizationPHPbackend development
0 likes · 5 min read

This article presents practical Python performance optimization techniques, including using local variables, minimizing function calls, employing mappings over conditionals, iterating directly over sequences, preferring generator expressions, pre‑compiling code, and structuring modules with functions to reduce overhead and improve efficiency.
Pythonbest-practicescoding
0 likes · 6 min read

JavaScript Generators, introduced in ES6, allow functions to pause and resume execution, yielding multiple values; this article explains their syntax, basic usage, advanced features like yield* and data exchange, and demonstrates practical scenarios such as asynchronous flow control, memory-efficient data processing, and state machine implementation.
JavaScriptasyncdata processing
0 likes · 11 min read

This article provides a detailed tutorial on setting up MyBatis Generator in a Spring Boot application, covering configuration file placement, XML adjustments, Maven dependencies, execution steps, and the resulting model, mapper, and XML files with full code examples.
JavaMyBatisMySQL
0 likes · 7 min read

The article explains why you should avoid writing explicit for‑loops in Python, demonstrates how list comprehensions, generator expressions, map/reduce, and itertools can replace them, and shows how extracting functions improves readability and reduces code size.
code-optimizationfunctional programminggenerator
0 likes · 7 min read

This article explains why Python developers should avoid explicit for loops, demonstrating how list comprehensions, generator expressions, map/reduce, itertools, and function extraction can produce more concise, readable, and maintainable code while reducing indentation and improving structure.
Code ReadabilityPythonfor loop
0 likes · 6 min read

This article introduces the EGBAD model, an efficient GAN‑based anomaly detection method that replaces AnoGAN's costly latent variable search with an encoder, provides detailed PyTorch code for data loading, model construction, training, and inference, and compares its testing speed with AnoGAN.
DiscriminatorEGBADEncoder
0 likes · 18 min read

This article explains how avoiding explicit for‑loops in Python encourages the use of advanced, idiomatic constructs such as list comprehensions, generator expressions, functional tools like map and reduce, and the itertools module, resulting in shorter, more readable, and flatter code.
Code Readabilityfunctional programminggenerator
0 likes · 7 min read

The article explains how deliberately avoiding for‑loops in Python encourages the use of advanced language features such as list comprehensions, generator expressions, built‑in functions, and itertools, resulting in shorter, more readable, and flatter code structures while also showcasing practical code examples and a concluding recommendation to minimize explicit loops.
code optimizationfunctional-programminggenerator
0 likes · 8 min read

This article presents ten useful Python techniques—including string joining, list comprehensions, enumerate, zip, itertools, Counter, dictionary creation, generators, multiple return values, and the sorted function—each explained with clear examples and performance comparisons to help developers write cleaner and faster code.
code tricksgeneratoritertools
0 likes · 10 min read

Learn five practical Python techniques—including itertools.groupby, list comprehensions, loops, generators, and enumerate—to efficiently eliminate consecutive duplicate elements from a list, with clear code examples and visual results that help you understand and apply each method.
Listdeduplicationgenerator
0 likes · 5 min read


Code DAOJun 3, 2022 · Artificial Intelligence
This article walks through building and analyzing a minimal GAN—PointGAN—that learns to output the single value 1, covering the linear generator, a two‑layer discriminator, training loops, loss visualizations, instability diagnostics, and practical fixes such as loss easing, weighted examples, weight decay, and noisy generator parameters.
DiscriminatorGANNoise Injection
0 likes · 24 min read

This article provides concise explanations of ten fundamental Python topics, covering differences between lists and tuples, arrays and lists, append versus extend, equality operators, shallow and deep copying, loop control statements, variable scopes, range versus xrange, decorators, and the concepts of iterators and generators.
COPYDecoratorList
0 likes · 7 min read

This article explains how Python list comprehensions provide a concise, memory‑efficient way to create lists, compares them with loops and map(), shows advanced features like conditional logic, nested comprehensions, set and dictionary comprehensions, and discusses when to avoid them for better readability and performance.
Conditional LogicPythondictionary comprehension
0 likes · 14 min read

This tutorial explains Python's iteration concepts, how to identify and create iterable objects, implement custom iterables and iterators, use the iter() and next() functions, build generators with yield, control execution with coroutines, and leverage greenlet and gevent for cooperative multitasking.
Geventcoroutinegenerator
0 likes · 22 min read

This article translates and explains PEP 343, which introduces the ‘with’ statement and the context‑manager protocol (__enter__ and __exit__) in Python, detailing its motivation, design decisions, syntax, example implementations, and its impact on resource handling and code clarity.
PEPcontext managergenerator
0 likes · 25 min read

This article introduces five advanced Python features—lambda functions, map, filter, the itertools module, and generator functions—explaining their concepts, typical use cases, and providing clear code examples to demonstrate how they simplify data processing and improve memory efficiency.
Advanced FeaturesPythongenerator
0 likes · 8 min read

This article explains Python's comprehension syntax—including list, dictionary, set, and generator expressions—provides multiple code examples, demonstrates advanced usage such as conditional and nested comprehensions, and presents a common interview question illustrating variable scope with lambda functions.
Interviewcomprehensiondictionary comprehension
0 likes · 7 min read

This article explains Python's variable‑length arguments (*args, **kwargs), anonymous lambda functions, package creation with __init__.py, memory‑efficient generators using yield, and powerful decorators—including practical code examples for each concept.
DecoratorPackagegenerator
0 likes · 11 min read

This article explains PHP's Generator feature introduced in version 5.5, demonstrating how the yield keyword enables memory‑efficient iteration, how to implement custom xrange functions, and how to control generators with methods like next, current, valid, send, rewind, and throw.
generatoriteratormemory-efficient
0 likes · 6 min read


政采云技术Nov 17, 2020 · Frontend Development
This article explains the various asynchronous techniques in JavaScript—callback, Promise, async/await, and generator—compares them, and demonstrates practical patterns for handling callback hell, parallel and sequential async operations to write cleaner, more maintainable frontend code.
CallbackPromiseasync
0 likes · 10 min read

Coroutines, also known as micro‑threads, allow a single thread to pause and resume functions, offering higher efficiency than traditional multithreading by eliminating context‑switch overhead and lock contention, with Python’s generator‑based implementation enabling lock‑free producer‑consumer patterns and seamless multi‑core utilization via processes.
ConcurrencyProducer-ConsumerPython
0 likes · 7 min read

This article explains how to create a counter using Python closures, explores three different implementations—including mutable objects, generators, and the nonlocal keyword—while clarifying the behavior of immutable vs. mutable objects and demonstrating the practical use of nonlocal in nested functions.
Pythonclosurefundamentals
0 likes · 7 min read

This article introduces Python's advanced features—list comprehensions, dictionary and set comprehensions, iterators, and generators—explaining their syntax, providing interview‑style examples, and showing how they improve code readability, efficiency, and memory usage.
Pythongeneratoriterator
0 likes · 10 min read

This article explains the concepts and differences between Python iterables, iterators, and generators, shows how to create custom iterable and iterator classes, demonstrates the use of __iter__ and __next__ magic methods, and provides practical generator examples for efficient lazy evaluation.
Iterablefundamentalsgenerator
0 likes · 8 min read

This tutorial shows how to quickly generate 200 activation codes in the xxxx-xxxx-xxxx-xxxx format using a Python generator and then tally the occurrence of each character with a dictionary, providing both the code and sample output.
activation codecharacter countingcode generation
0 likes · 3 min read

This article explains how Python determines whether an object is iterable by using the built‑in iter function, detailing the roles of __iter__, __getitem__, iterator protocols, and showing concise implementations with generators and generator expressions.
IterablePythongenerator
0 likes · 7 min read

This article explains the purpose and behavior of Python's yield keyword, how generators work, their difference from regular functions, and demonstrates practical examples including iterator concepts, itertools utilities, and memory‑efficient looping techniques.
Memory OptimizationPythongenerator
0 likes · 10 min read

This article walks through the evolution of Python's coroutine support—from early generator‑based yield/send patterns, through the introduction of @asyncio.coroutine and yield from, to the modern async and await syntax—explaining concepts, execution flow, and providing clear code examples.
Async/AwaitAsynchronous ProgrammingPython
0 likes · 10 min read

This guide explains why MyBatis Generator appends to existing mapper.xml files causing duplicate BaseResultMap errors, and shows how to upgrade to version 1.3.7 and add the UnmergeableXmlMappersPlugin to ensure mapper files are overwritten and the application runs smoothly.
BackendJavaMyBatis
0 likes · 4 min read


58 TechApr 17, 2019 · Frontend Development
This article explains why JavaScript needs asynchronous handling, describes the browser's multithreaded architecture and event‑loop, compares callbacks with Promises, introduces Generators for flow control, and shows how ES7 Async/Await combines their advantages with practical code examples.
Async/AwaitPromiseasync
0 likes · 16 min read

This article explains the concept of coroutines, compares them with threads, outlines their pros and cons, and demonstrates multiple Python implementations using yield, send, and decorators, culminating in a practical generator‑based file‑search utility that mimics the Linux grep command.
Pythoncoroutinefile search
0 likes · 11 min read

This article explains ES6 JavaScript generators, covering their syntax, how they differ from regular iterators, the role of the yield keyword, available generator methods, and practical examples such as custom generators, random number streams, throttling, Fibonacci sequences, and integrating generators with HTML to simplify iterative tasks.
ES6JavaScriptasynchronous
0 likes · 13 min read

The article explains Haskell‑style lazy lists, shows why lazy evaluation is useful, and walks through implementing lazy lists in JavaScript using custom classes, the ES6 iterable protocol, and generator functions, providing examples such as repeat, cycle, iterate, range and lazy operators like map, filter, take, and zip.
ES6Infinite ListJavaScript
0 likes · 10 min read

This article explores ten puzzling Python behaviors—from implicit dictionary key conversion and generator timing quirks to list‑iteration deletions, else clause nuances, the difference between is and ==, loop variable leakage, + versus +=, try‑finally returns, mutable True/False assignments, and subtle for‑loop mechanics—providing clear explanations and code examples for each.
LoopPythondict
0 likes · 11 min read

This article explains why Python sequences are iterable by detailing how the built‑in iter function, __iter__ and __getitem__ methods work, and shows multiple implementations—including classic iterator classes, generator functions, and generator expressions—to create custom iterable objects.
Iterablefundamentalsgenerator
0 likes · 7 min read

This article explains the concept of coroutines, compares them with threads, outlines their advantages and drawbacks, demonstrates how to implement them in Python using yield, next, send and decorators, and applies them to build a grep‑like file‑search utility.
Pythonasynccoroutine
0 likes · 12 min read

This article explains the ES6 yield keyword, its role in generator functions, how the .next() method controls execution flow, how parameters affect yielded values, and provides practical examples to help JavaScript developers master asynchronous iteration.
ES6frontendgenerator
0 likes · 10 min read

This tutorial explains how to create a Node.js command‑line generator from scratch by initializing a module, adding a CLI binary, integrating a template engine, parsing arguments and paths, and finally publishing the package to npm, all with clear code examples.
CLINode.jsNunjucks
0 likes · 12 min read
