Tagged articles
lazy evaluation
25 articles · Page 1 of 1
This article explains how Java 8's computeIfAbsent reduces HashMap grouping from three separate lookups (containsKey, put, get) to a single atomic operation, covering lazy evaluation, concurrency safeguards, null handling, nested grouping patterns, and when to prefer computeIfAbsent over Collectors.groupingBy for streaming data.
HashMapJava 8Map methods
0 likes · 7 min read

The seq library introduces left‑to‑right chainable lazy collections for Go, letting developers write pipelines that read like Scala, explains why Go waited for generic methods until version 1.27, showcases concrete examples, design decisions, limitations, and how to get started.
GenericsGocollection pipelines
0 likes · 14 min read

This article introduces Java 8's Stream API, explaining its lazy, declarative processing model, how to create streams from collections or arrays, and demonstrates core intermediate and terminal operations with concrete code examples and a practical employee‑salary use case.
CollectJava Streamfilter
0 likes · 10 min read

The article shows that Polars, a query‑compiling DataFrame library, can accelerate ten‑million‑row GroupBy workloads by 6‑10× compared with Pandas, explains the underlying optimizer, Arrow columnar engine and Rust parallelism, provides a 20‑item syntax map, three real migration scenarios, streaming for out‑of‑memory data, and AI‑pipeline use cases, and offers a step‑by‑step migration guide.
Apache ArrowDataFramesPandas
0 likes · 21 min read


21CTOAug 19, 2025 · Backend Development
This article explains how PHP lazy evaluation using generators and the Iterator API can dramatically reduce memory consumption when loading huge CSV files, provides side‑by‑side code examples and benchmarks, and offers guidance on when to choose each approach for real‑world data processing tasks.
PHPcsv-processinggenerators
0 likes · 7 min read

This article explains what Python closures are, how they capture outer‑scope variables, demonstrates typical patterns such as data hiding, stateful counters, factory functions, callbacks and lazy evaluation, and highlights important pitfalls like memory use and late‑binding bugs.
CallbackPythonclosure
0 likes · 9 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

This article explores Java Stream's advanced capabilities, including multi‑level grouping and partitioning with Collectors, parallel stream performance tips, creation of infinite streams, stream concatenation and transformation, short‑circuit operations, primitive stream optimizations, and how to build custom collectors and streams, all illustrated with concrete code examples and step‑by‑step demonstrations.
CollectorsInfinite StreamJava
0 likes · 12 min read

This article introduces Python’s built‑in itertools module, explains its infinite, finite, and combinatorial iterator utilities, demonstrates advanced techniques like grouping and pipeline construction, and compares its lazy evaluation memory benefits to traditional list comprehensions for large‑scale data processing.
data-processingfunctional-programmingiterator
0 likes · 10 min read

This article explains Python's built‑in range function, covering its lazy generation, memory efficiency, syntax variations, practical examples, common pitfalls, and advanced techniques such as reverse iteration and enumeration.
iterationlazy evaluationmemory efficiency
0 likes · 7 min read

This article explains the internal workings of Java's Stream API pipeline, covering how intermediate and terminal operations are recorded, combined, and executed via stages and Sink interfaces, illustrating lazy evaluation, stateful vs stateless operations, and the mechanisms behind parallel and sequential processing.
Intermediate OperationsJavaPipeline
0 likes · 21 min read

This article explains the core principles of Java Stream, covering its three main characteristics, pipeline construction, intermediate and terminal operations with code examples, and how lazy execution and sink generation produce results only when a terminal operation is invoked.
Java 8Stream APIbackend development
0 likes · 10 min read

This article explains the concept, operation, and advantages of PHP generators, demonstrating how they provide memory‑efficient, lazy‑evaluated iteration for large data sets and streams, and includes practical code examples and best‑practice tips for backend developers.
PHPbackend developmentgenerators
0 likes · 9 min read

Java 8’s Stream API introduces a declarative, lazy-processing model for collections, and this article details multiple ways to create streams—including from collections, arrays, static factory methods, files, generators, and iterators—providing code examples and explanations to help developers harness its expressive and efficient data‑handling capabilities.
JavaJava 8Stream API
0 likes · 5 min read

This article presents ten practical Python examples illustrating lazy evaluation using generators and iterators, covering infinite sequences, large data processing, file streaming, and on-demand computation, highlighting memory efficiency and performance benefits for handling big data and infinite streams.
Infinite SequencesPythongenerators
0 likes · 7 min read

This article explains lazy evaluation in functional programming and presents ten Python code examples that demonstrate how generators and iterators can efficiently handle infinite sequences and large‑scale data by computing values only when needed.
Infinite SequencesPythongenerators
0 likes · 7 min read

This article explores how closures, currying, pure functions, thunks, and ES6 generators enable lazy evaluation in JavaScript, illustrating the concepts with code examples and showing how they can reduce unnecessary computation, control execution order, and even create infinite sequences.
CurryingJavaScriptThunks
0 likes · 11 min read

The article explains how a C++ LINQ‑style pipeline, built on concepts like _Can_pipe and composable _Pipeline classes, provides lazy, type‑safe range operations using the pipe operator, serving as the foundation for the C++20 ranges library and future execution framework.
C++ LINQC++20 RangesPipeline pattern
0 likes · 10 min read

This article compares Log4j2 with older Java logging frameworks, highlighting its superior asynchronous performance, zero‑GC design, flexible parameter formatting, simplified configuration options, and practical usage examples, ultimately showing why it should replace Logback and Log4j1 in modern applications.
ConfigurationJava loggingLog4j2
0 likes · 14 min read

This article explains functional programming concepts, their importance, and how to apply them in Swift through high‑order functions, lazy evaluation, custom operators, and composable image‑filter pipelines, while also addressing common pitfalls such as nested callbacks and OCP violations.
RxSwiftSWIFTcode composition
0 likes · 19 min read

The article introduces pure functions and shows how JavaScript functors like Box can lazily transform values with map, uses LazyBox to defer side effects until fold, then extends the concept to applicative functors and Either for composable validation via ap and liftA2 helpers.
JavaScriptPure Functionsapplicative functor
0 likes · 20 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 explains Python iterators and generators, compares their memory usage and performance, shows how to implement them with Fibonacci examples, and introduces generator expressions as a concise alternative to list comprehensions for handling large data streams.
Pythongeneratorsiterators
0 likes · 5 min read

This article explains what currying is, its advantages, and provides a generic JavaScript currying function, demonstrating how to transform multi‑parameter functions into single‑parameter chains to improve code reuse, enable lazy evaluation, and enhance overall code quality in functional programming.
JavaScriptcode reusefunctional programming
0 likes · 10 min read


ITPUBDec 16, 2015 · Frontend Development
Discover how Lo‑Dash’s lazy evaluation and pipelining can cut execution time by over a third, by processing only the necessary elements, avoiding intermediate arrays, and deferring computation until .value() is called, with concrete code examples and performance benchmarks.
JavaScriptLo-DashPipelining
0 likes · 6 min read
