BestHub
Sign in
Tagged articles

Functional Programming

271 articles · Page 3 of 3
ByteFE
ByteFE
Mar 17, 2021 · Frontend Development

A Comprehensive Guide to JavaScript's Array reduce Method and Its Versatile Applications

This article explains the syntax and behavior of JavaScript's reduce method, compares it with map, forEach, filter and find, and demonstrates numerous practical patterns such as flattening arrays, counting occurrences, grouping by property, deduplication, and finding extrema, all illustrated with clear code examples.

ArrayFunctional ProgrammingJavaScript
0 likes · 10 min read
A Comprehensive Guide to JavaScript's Array reduce Method and Its Versatile Applications
政采云技术
政采云技术
Mar 16, 2021 · Fundamentals

Understanding Programming Paradigms: Imperative, Declarative, Functional, and Object‑Oriented in JavaScript

This article explains core programming paradigms—imperative, declarative, functional, and object‑oriented—illustrating their concepts, differences, and practical JavaScript examples, while discussing features like first‑class functions, currying, composition, and OOP principles such as encapsulation, inheritance, and polymorphism.

CurryingDeclarativeFunctional Programming
0 likes · 14 min read
Understanding Programming Paradigms: Imperative, Declarative, Functional, and Object‑Oriented in JavaScript
Programmer DD
Programmer DD
Feb 19, 2021 · Backend Development

Mastering Lazy Initialization and Stream Laziness in Java 8

This article explains the difference between eager and lazy evaluation, shows when and how to use lazy initialization in Java, demonstrates Supplier‑based lazy loading, virtual proxy patterns, and stream laziness with infinite streams and prime number generation, all with concrete code examples.

Functional ProgrammingLazy InitializationStream
0 likes · 12 min read
Mastering Lazy Initialization and Stream Laziness in Java 8
MaGe Linux Operations
MaGe Linux Operations
Feb 18, 2021 · Fundamentals

Why OOP Is Overkill in Python: Embrace the Function‑Bag Style

The article argues that object‑oriented programming is often unnecessary in Python, demonstrates a functional‑style alternative with dataclasses and plain functions, and lists exceptions and drawbacks of OOP, encouraging a simpler, more readable codebase.

Code styleFunctional ProgrammingOOP
0 likes · 6 min read
Why OOP Is Overkill in Python: Embrace the Function‑Bag Style
21CTO
21CTO
Feb 6, 2021 · Fundamentals

Why Are Reusable Components So Hard? A FP vs OO FizzBuzz Experiment

The article explores why building truly reusable components is challenging by comparing a concise functional F# implementation of FizzBuzz with a more verbose object‑oriented C# version, highlighting how language paradigms and design assumptions affect modularity, coupling, and extensibility.

C++F*Functional Programming
0 likes · 11 min read
Why Are Reusable Components So Hard? A FP vs OO FizzBuzz Experiment
Bitu Technology
Bitu Technology
Feb 2, 2021 · Backend Development

Recap of the Online Scala Meetup: Reactive Ad Platform, Functional Programming, Scala 3 Typeclasses, and Spring‑Akka Microservices

The 2021 Online Scala Meetup organized by Tubi featured four technical talks covering a fully reactive ad‑serving platform built with Scala and Akka‑Streams, a pragmatic take on functional programming, Scala 3 typeclass implementation, and a Spring‑Akka microservice integration, followed by summaries and recruitment information.

AkkaFunctional ProgrammingReactive Programming
0 likes · 4 min read
Recap of the Online Scala Meetup: Reactive Ad Platform, Functional Programming, Scala 3 Typeclasses, and Spring‑Akka Microservices
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Jan 19, 2021 · Fundamentals

Understanding Functor, Applicative, and Monad in JavaScript with Practical Examples

The article explains JavaScript’s Functor, Applicative, and Monad abstractions—showing how map, ap, and chain (flatMap) on Box types such as Either, LazyBox, and a lazy Task can replace nested try‑catch and null checks, enable composable synchronous and asynchronous code, and support parallel execution with Task.ap.

ApplicativeFunctional ProgrammingJavaScript
0 likes · 20 min read
Understanding Functor, Applicative, and Monad in JavaScript with Practical Examples
Programmer DD
Programmer DD
Dec 15, 2020 · Fundamentals

Master Java Method References: Simplify Lambdas for Cleaner Code

This article explains Java's method reference feature, covering its four types, practical code examples for static methods, instance methods, constructors, and highlighting limitations compared to lambda expressions, helping developers write more readable and concise Java 8 code.

Functional ProgrammingJava 8Method References
0 likes · 7 min read
Master Java Method References: Simplify Lambdas for Cleaner Code
vivo Internet Technology
vivo Internet Technology
Nov 18, 2020 · Backend Development

Understanding Java 8 Stream API Pipeline and Its Internal Implementation

Java 8’s Stream API builds a lazy pipeline where each intermediate operation is recorded as a stage and only a terminal operation triggers a single-pass execution, using internal classes like ReferencePipeline, Slink, and Sink to efficiently combine stateless, stateful, and short‑circuiting operations.

Functional ProgrammingStream APIbackend development
0 likes · 8 min read
Understanding Java 8 Stream API Pipeline and Its Internal Implementation
Top Architect
Top Architect
Nov 18, 2020 · Backend Development

A Comprehensive Guide to Google Guava: Collections, Functional Utilities, and Caching in Java

This article introduces the core features of Google Guava—including Joiner, Splitter, CharMatcher, primitive type helpers, Multiset, immutable collections, Multimap, BiMap, Table, functional utilities like Functions and Predicates, Optional, Preconditions, and a powerful local Cache—showcasing how they simplify Java development and improve code readability, safety, and performance.

CollectionsFunctional ProgrammingGuava
0 likes · 9 min read
A Comprehensive Guide to Google Guava: Collections, Functional Utilities, and Caching in Java
Python Crawling & Data Mining
Python Crawling & Data Mining
Nov 17, 2020 · Fundamentals

Unlock Python’s Power: Master Lambda Anonymous Functions in Minutes

This article introduces Python’s lambda anonymous functions, explains their syntax and differences from regular functions, showcases practical one‑line examples, explores functional programming tools like map, filter, and reduce, and highlights how lambdas can reduce code size while enhancing readability.

Functional ProgrammingLambdaPython
0 likes · 9 min read
Unlock Python’s Power: Master Lambda Anonymous Functions in Minutes
Bitu Technology
Bitu Technology
Oct 23, 2020 · Fundamentals

Cat Talks Series: Lens, CPS Transformation, and F‑Algebra Sessions

The article summarizes a series of technical talks held in August and September covering functional programming concepts such as Lens, Continuation‑Passing Style transformation, and F‑algebra with detailed explanations, demos, and theoretical insights for developers and researchers.

CPSCategory TheoryF-algebra
0 likes · 4 min read
Cat Talks Series: Lens, CPS Transformation, and F‑Algebra Sessions
Programmer DD
Programmer DD
Oct 11, 2020 · Fundamentals

Unlock Java 8: Master Lambda Expressions and Stream API with Real Code Examples

This article introduces Java 8’s key functional programming features—lambda expressions, functional interfaces, and the Stream API—explaining concepts such as lazy and eager evaluation, and demonstrating common operations like filter, map, flatMap, collect, reduce, and grouping with clear code examples.

Functional InterfacesFunctional ProgrammingJava 8
0 likes · 15 min read
Unlock Java 8: Master Lambda Expressions and Stream API with Real Code Examples
FunTester
FunTester
Oct 10, 2020 · Backend Development

Understanding Java Stream map() vs flatMap() with Practical Code Samples

This article explains the functional differences between Java Stream's map() and flatMap() methods, demonstrates their behavior with simple and nested list examples, and clarifies how each transforms or flattens data in Java 8 streams.

Functional ProgrammingJava8Stream API
0 likes · 7 min read
Understanding Java Stream map() vs flatMap() with Practical Code Samples
JD Cloud Developers
JD Cloud Developers
Oct 9, 2020 · Fundamentals

4 Programming Habits to Unlearn for Cleaner, More Efficient Code

This article identifies four common programming patterns—loops, conditional statements, vague variable names, and global scope—that hinder code clarity and maintainability, and shows how to replace them with higher‑order functions, data‑driven structures, purposeful naming, and encapsulation techniques.

Code RefactoringFunctional ProgrammingJavaScript
0 likes · 9 min read
4 Programming Habits to Unlearn for Cleaner, More Efficient Code
Bitu Technology
Bitu Technology
Sep 25, 2020 · Backend Development

Scala Meetup Recap: Akka State Management, Parsec Combinators, and ZIO Overview

The article summarizes a 2020 Scala online meetup, covering Akka's distributed state‑management for ad‑serving, Parsec parser combinators for arithmetic expression evaluation, AST manipulation with ANTLR, and an introduction to the functional ZIO library, while reflecting on personal takeaways.

AkkaFunctional ProgrammingMeetup
0 likes · 12 min read
Scala Meetup Recap: Akka State Management, Parsec Combinators, and ZIO Overview
Programmer DD
Programmer DD
Sep 9, 2020 · Backend Development

Mastering Java 8’s Map.merge(): Simplify Grouped Summations

This article explains Java 8’s Map.merge() method, demonstrating how to replace traditional looping logic with concise functional code to aggregate student scores, includes full code examples, compares it with conventional approaches, and discusses related map methods and practical use cases.

Functional ProgrammingJava 8Map.merge
0 likes · 6 min read
Mastering Java 8’s Map.merge(): Simplify Grouped Summations
Programmer DD
Programmer DD
Sep 7, 2020 · Fundamentals

Master Java Method References: Simplify Lambdas with Clean Code

This article explains Java method references, shows how they simplify lambda expressions with practical code examples, outlines reference formats, discusses readability benefits, and provides guidance for adopting this Java 8 feature in everyday programming.

Code SimplificationFunctional ProgrammingLambda Expressions
0 likes · 6 min read
Master Java Method References: Simplify Lambdas with Clean Code
Architect's Tech Stack
Architect's Tech Stack
Aug 8, 2020 · Backend Development

Simplifying Collection Processing with Java 8 Streams and Lambdas

This article explains how Java 8's Stream API and lambda expressions can replace verbose loops with concise, declarative operations for filtering, sorting, mapping, and grouping collections, while also covering stream creation, intermediate and terminal operations, and advanced collectors for data analysis.

CollectionsFunctional ProgrammingJava8
0 likes · 13 min read
Simplifying Collection Processing with Java 8 Streams and Lambdas
Top Architect
Top Architect
Jul 30, 2020 · Backend Development

Using Java 8 Optional to Eliminate Null Checks and Simplify Code

This article explains the Java 8 Optional class, demonstrates how it replaces traditional null‑checking with functional methods such as of, ofNullable, map, orElse, filter, and provides best‑practice guidelines for creating and using Optional objects to write cleaner backend code.

Functional ProgrammingJava8NullPointerException
0 likes · 9 min read
Using Java 8 Optional to Eliminate Null Checks and Simplify Code
Top Architect
Top Architect
Jul 18, 2020 · Backend Development

Java Streams: Comparing Collection Processing in Java 7 and Java 8

This article demonstrates how Java 8 streams simplify collection processing compared to Java 7 by showing code examples that filter, sort, map, and reduce dishes, explains stream concepts, intermediate and terminal operations, and provides practical usage tips for parallel processing and common stream methods.

Collection ProcessingFunctional ProgrammingJava8
0 likes · 12 min read
Java Streams: Comparing Collection Processing in Java 7 and Java 8
Python Programming Learning Circle
Python Programming Learning Circle
May 15, 2020 · Fundamentals

Understanding Python Closures and Decorators

This article explains Python closures and decorators, illustrating how closures capture free variables and how decorators can wrap functions to log calls, handle parameters, and preserve metadata, with clear code examples and step‑by‑step explanations.

Functional ProgrammingPythonclosures
0 likes · 5 min read
Understanding Python Closures and Decorators
Bitu Technology
Bitu Technology
Apr 27, 2020 · Fundamentals

Recap of the 2020 Online Scala Meetup: Design Patterns, ZIO STM, Scala‑Java Integration, and Shapeless

On April 18, the inaugural 2020 Online Scala Meetup organized by Tubi featured four speakers who explored Scala design patterns, demonstrated ZIO STM usage, shared best practices for integrating Scala into Java codebases, and introduced Shapeless’s type-level programming, offering valuable insights for developers.

Design PatternsFunctional ProgrammingScala
0 likes · 6 min read
Recap of the 2020 Online Scala Meetup: Design Patterns, ZIO STM, Scala‑Java Integration, and Shapeless
Python Programming Learning Circle
Python Programming Learning Circle
Mar 30, 2020 · Fundamentals

Common Misuses of Python Lambda Functions and How to Avoid Them

This article explains the four most common misuses of Python lambda functions—replacing built‑in functions, assigning lambdas to variables, improper use of higher‑order functions, and overly complex expressions—and offers best‑practice recommendations to improve code readability and maintainability.

Functional ProgrammingLambdacode readability
0 likes · 9 min read
Common Misuses of Python Lambda Functions and How to Avoid Them
Programmer DD
Programmer DD
Dec 18, 2019 · Backend Development

Master Java 8 Streams: From Basics to Advanced Operations

This article introduces Java 8's Stream API, explains why functional streams improve code readability and performance, and provides detailed examples of common operations such as filter, map, flatMap, reduce, collect, Optional handling, parallel processing, and debugging techniques for efficient data processing.

Data ProcessingFunctional ProgrammingJava 8
0 likes · 16 min read
Master Java 8 Streams: From Basics to Advanced Operations
Qunar Tech Salon
Qunar Tech Salon
Dec 3, 2019 · Fundamentals

Five Emerging Programming Languages with a Bright Future

An overview of five emerging programming languages—Elm, Kotlin, Rust, Elixir, and Crystal—highlighting their key features, advantages, and potential impact on software development, illustrating how they address modern development needs and may shape the future of the industry.

Functional ProgrammingProgramming Languagesemerging languages
0 likes · 9 min read
Five Emerging Programming Languages with a Bright Future
Programmer DD
Programmer DD
Nov 30, 2019 · Backend Development

Master Java 8 Stream: When to Use map vs flatMap

This tutorial explains how Java 8's Stream API's map and flatMap operations work, showing practical examples of extracting student ages from collections and demonstrating why flatMap is needed to flatten nested lists, with clear code snippets and diagrams.

Functional ProgrammingJava 8Stream API
0 likes · 4 min read
Master Java 8 Stream: When to Use map vs flatMap
Bitu Technology
Bitu Technology
Nov 15, 2019 · Backend Development

Recap of the Scala Meetup: Cats Introduction and Akka Applications

The November 3 Scala Meetup featured senior expert Deng Caoyuan’s whiteboard brainstorming and Tencent engineer Qu Guodong’s Cats tutorial, followed by a deep dive into Akka with real‑world examples such as a financial computing platform, real‑time article recommendation, web crawling, streaming, and practical tips for Scala developers.

AkkaCatsFunctional Programming
0 likes · 7 min read
Recap of the Scala Meetup: Cats Introduction and Akka Applications
Youzan Coder
Youzan Coder
Nov 15, 2019 · Fundamentals

Functions as Data Transformations: Recursion, Tail Calls, and Efficient Exponentiation & Fibonacci Implementations

The article treats functions as pure data‑to‑data mappings and demonstrates how common mathematical operations such as factorial, exponentiation, and Fibonacci can be expressed in TypeScript/JavaScript using recursive, tail‑recursive, iterative, and logarithmic‑time algorithms that illustrate functional transformation techniques and efficient algorithm design.

AlgorithmFibonacciFunctional Programming
0 likes · 8 min read
Functions as Data Transformations: Recursion, Tail Calls, and Efficient Exponentiation & Fibonacci Implementations
vivo Internet Technology
vivo Internet Technology
Nov 6, 2019 · Fundamentals

Writing High‑Quality JavaScript Functions with Functional Programming Techniques

The article demonstrates how to write high‑quality JavaScript functions by applying functional‑programming concepts such as composition, higher‑order functions, immutability, declarative array methods, reusable utilities like a curried tap, and memoization, showing refactored examples that replace hard‑coded DOM manipulation and imperative loops with clean, reusable code.

Code RefactoringCurryingFunctional Programming
0 likes · 22 min read
Writing High‑Quality JavaScript Functions with Functional Programming Techniques
JD Retail Technology
JD Retail Technology
Oct 16, 2019 · Fundamentals

Understanding Programming Paradigms: Object‑Oriented, Procedural, Functional, and Imperative

This article introduces programming paradigms—object‑oriented, procedural, functional, and imperative—explaining their definitions, underlying philosophies, and how each can be used to implement a simple calculator, while comparing their advantages and illustrating their conceptual relationships.

Functional ProgrammingObject-OrientedProcedural
0 likes · 7 min read
Understanding Programming Paradigms: Object‑Oriented, Procedural, Functional, and Imperative
macrozheng
macrozheng
Sep 2, 2019 · Backend Development

Master Java 8 Stream API: From Basics to Tree Structures

This article introduces Java 8's Stream API, explains core concepts like streams, sources, and aggregation operations, and demonstrates common methods such as filter, map, limit, count, sorted, skip, and collect with practical code examples that build hierarchical permission trees.

Functional ProgrammingJava 8Stream API
0 likes · 8 min read
Master Java 8 Stream API: From Basics to Tree Structures
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 2, 2019 · Fundamentals

Introduction to Java 8 Stream API: Creation, Intermediate and Terminal Operations

This article introduces Java 8’s Stream API, explaining its purpose, key characteristics, how to create streams from collections or directly, and demonstrating common intermediate operations such as filter, map, limit, sorted, distinct, as well as terminal operations like forEach, count, and collect, with code examples.

CollectionsFunctional ProgrammingIntermediate Operations
0 likes · 9 min read
Introduction to Java 8 Stream API: Creation, Intermediate and Terminal Operations
21CTO
21CTO
Aug 23, 2019 · Fundamentals

Why Object-Oriented Programming Is Failing and Functional Programming Is the Future

Object-oriented programming, once hailed as the pinnacle of software design, is criticized for its complexity, mutable state, and poor testability, while functional programming offers simpler, more reliable code through immutability and pure functions, prompting a call to abandon OOP in favor of functional paradigms.

ComplexityFunctional ProgrammingImmutability
0 likes · 29 min read
Why Object-Oriented Programming Is Failing and Functional Programming Is the Future
Sohu Tech Products
Sohu Tech Products
Jul 24, 2019 · Backend Development

Ten Years of Erlang: Evolution, Knowledge Ladder, and Future Directions

Over the past decade, Erlang has evolved from a niche functional language into a robust platform with powerful concurrency, fault tolerance, and a rich ecosystem, illustrated by its key applications, knowledge ladder, recent improvements, and future prospects for both Erlang and its Elixir community.

ElixirFunctional ProgrammingOTP
0 likes · 21 min read
Ten Years of Erlang: Evolution, Knowledge Ladder, and Future Directions
Ctrip Technology
Ctrip Technology
Jul 3, 2019 · Frontend Development

Building a Standalone Vue 3 Reactivity Library: CycleJS‑like Reactive View, Immer‑like State, RxJS‑like Operators, and React‑Hooks‑like Mechanisms

This article explores Vue 3's function‑based reactivity API, demonstrates how to implement a lightweight, framework‑agnostic reactivity library with watchable objects, functional combinators, and immutable updates, and shows practical examples such as a reactive counter, a todo list, immer‑style state handling, RxJS‑style pipelines, and React‑hooks‑style utilities, while discussing the underlying concepts and limitations.

FrontendFunctional ProgrammingReactivity
0 likes · 12 min read
Building a Standalone Vue 3 Reactivity Library: CycleJS‑like Reactive View, Immer‑like State, RxJS‑like Operators, and React‑Hooks‑like Mechanisms
AutoHome Frontend
AutoHome Frontend
Jun 24, 2019 · Frontend Development

Unlock the Power of JavaScript’s reduce: 5 Creative Uses Beyond Simple Summing

This tutorial explores why the .reduce() method feels intimidating, demonstrates its basic usage with addition and multiplication, and then showcases five unconventional applications—including converting arrays to objects, flattening nested arrays, performing dual calculations in a single pass, merging map and filter, and sequencing asynchronous calls—while providing clear code examples and performance considerations.

Functional ProgrammingJavaScriptWeb Development
0 likes · 14 min read
Unlock the Power of JavaScript’s reduce: 5 Creative Uses Beyond Simple Summing
NetEase Game Operations Platform
NetEase Game Operations Platform
Apr 27, 2019 · Frontend Development

Functional Programming in JavaScript: Refactoring User List Processing

This article demonstrates how to apply functional programming concepts in JavaScript by refactoring an example that reads user data from an API, filters active SREs, and formats output, illustrating the benefits of pure functions, higher‑order utilities like map, filter, reduce, and improved code readability and maintainability.

Functional ProgrammingHigher-Order FunctionsPure Functions
0 likes · 22 min read
Functional Programming in JavaScript: Refactoring User List Processing
Java Backend Technology
Java Backend Technology
Apr 16, 2019 · Backend Development

Master Java Stream API: From Basics to Advanced Operations

This article introduces Java 8's Stream API, explains why functional streams improve code readability and performance, and walks through core operations such as filter, map, flatMap, reduce, collect, Optional handling, concurrency, and debugging techniques with clear examples and illustrations.

Functional ProgrammingJava 8Stream API
0 likes · 7 min read
Master Java Stream API: From Basics to Advanced Operations
Big Data Technology & Architecture
Big Data Technology & Architecture
Mar 14, 2019 · Fundamentals

Scala Pattern Matching and Case Classes: Syntax, Examples, and Usage

This article explains Scala's powerful pattern matching mechanism, demonstrates matching on integers, strings, and types with code examples, compares it to Java's switch, and introduces case classes as special classes optimized for pattern matching, highlighting their automatically generated methods and usage.

Case ClassesFunctional ProgrammingPattern Matching
0 likes · 5 min read
Scala Pattern Matching and Case Classes: Syntax, Examples, and Usage
Big Data Technology & Architecture
Big Data Technology & Architecture
Mar 9, 2019 · Fundamentals

Introduction to Scala: A Beginner's Guide

This article provides a concise overview of Scala for beginners, covering its multi‑paradigm nature, object‑oriented and functional features, powerful static type system, extensibility mechanisms, and seamless Java interoperability, laying a foundation for later Spark learning.

Functional ProgrammingObject-OrientedProgramming Language
0 likes · 4 min read
Introduction to Scala: A Beginner's Guide
UC Tech Team
UC Tech Team
Nov 13, 2018 · Fundamentals

Understanding Higher-Order Functions in JavaScript

This article explains what higher‑order functions are, why JavaScript supports functional programming, demonstrates built‑in methods like map, filter and reduce with code examples, and shows how to create your own higher‑order function for clearer, more concise code.

Functional ProgrammingHigher-Order FunctionsJavaScript
0 likes · 8 min read
Understanding Higher-Order Functions in JavaScript
Node Underground
Node Underground
Nov 8, 2018 · Frontend Development

Why Pure Functions Matter in JavaScript: Benefits, Examples, and Best Practices

Pure functions are deterministic, side‑effect‑free routines that always return the same output for identical inputs, and this article explains their definition, observable side effects, practical JavaScript examples of pure and impure functions, and why they improve testability, refactoring, and code quality in modern front‑end development.

Functional ProgrammingPure Functionscode quality
0 likes · 6 min read
Why Pure Functions Matter in JavaScript: Benefits, Examples, and Best Practices
Node Underground
Node Underground
Oct 12, 2018 · Frontend Development

Why map and filter Beat forEach in JavaScript: Cleaner, Testable Code

Using map and filter instead of forEach when creating new arrays in JavaScript offers semantic separation, easier testing, better readability, and async compatibility, making code more functional and maintainable while avoiding side‑effects and unnecessary complexity.

Functional Programmingarray methodsfilter
0 likes · 6 min read
Why map and filter Beat forEach in JavaScript: Cleaner, Testable Code
Youzan Coder
Youzan Coder
Sep 21, 2018 · Fundamentals

First Encounter with Lazy List: Implementing Lazy Evaluation in JavaScript

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.

Functional ProgrammingInfinite ListIterator
0 likes · 10 min read
First Encounter with Lazy List: Implementing Lazy Evaluation in JavaScript
Youzan Coder
Youzan Coder
Sep 15, 2018 · Big Data

How Data Empowers Operations: Insights from Youzan & NetEase’s Big Data Summit

On September 15, Youzan’s big-data team and NetEase YouShu hosted a technical sharing titled “The Road to Data-Driven Operations,” where speakers explored the evolution of Youzan’s data warehouse metadata system, the architecture of its big-data development platform, and the application of functional programming in visual data analysis, highlighting current trends and future directions.

Data VisualizationData WarehouseFunctional Programming
0 likes · 4 min read
How Data Empowers Operations: Insights from Youzan & NetEase’s Big Data Summit
Liulishuo Tech Team
Liulishuo Tech Team
Apr 11, 2018 · Mobile Development

Understanding map, flatMap, and compactMap in Swift

This article explains the differences between map, flatMap, and compactMap in Swift, covering the three overloads of flatMap, their behavior with sequences and optionals, the rationale behind renaming one overload to compactMap, and when to prefer optional chaining versus optional mapping.

Functional ProgrammingOptionalSwift
0 likes · 8 min read
Understanding map, flatMap, and compactMap in Swift
Meituan Technology Team
Meituan Technology Team
Oct 12, 2017 · Frontend Development

Managing Software Complexity with Abstraction, Composition, and Functional Programming in Redux/React

By using abstraction to model common concepts and composition to build complex behavior from simple, pure‑function building blocks like map, filter, and reduce, the article shows how functional programming techniques underpin Redux and React, providing a systematic way to tame front‑end software complexity.

Functional ProgrammingHigher-Order FunctionsReAct
0 likes · 22 min read
Managing Software Complexity with Abstraction, Composition, and Functional Programming in Redux/React
Hujiang Technology
Hujiang Technology
Oct 12, 2017 · Fundamentals

Functional Light JavaScript: A Practical Introduction to Lightweight Functional Programming

This article introduces the Chinese translation of "Functional Light JavaScript," explaining the book’s focus on lightweight functional programming concepts in JavaScript, the author’s journey, the core philosophy, a detailed table of contents, and where to find the open‑source translation.

Functional ProgrammingJavaScriptProgramming Paradigms
0 likes · 12 min read
Functional Light JavaScript: A Practical Introduction to Lightweight Functional Programming
21CTO
21CTO
Jun 5, 2017 · Frontend Development

How Classic Writing Rules Can Sharpen Your JavaScript Code Style

This article adapts William Strunk Jr.'s timeless seven writing principles to JavaScript development, showing how functions that do one thing, minimal code, active voice, logical grouping, avoiding spaghetti, feature‑based file organization, and true‑value naming can produce cleaner, more maintainable front‑end code.

Code styleFunctional Programmingbest practices
0 likes · 16 min read
How Classic Writing Rules Can Sharpen Your JavaScript Code Style
Taobao Frontend Technology
Taobao Frontend Technology
Mar 16, 2017 · Frontend Development

Unlocking JavaScript Functional Programming: Practical Patterns and Pitfalls

JavaScript functional programming, once a niche topic, has surged in popularity since ES6, and this article explores practical implementations—showcasing functional code versus traditional approaches, benefits like clearer semantics and reusability, common models such as closures, higher‑order functions, currying, and composition, plus optimization techniques.

CurryingFunctional ProgrammingHigher-Order Functions
0 likes · 12 min read
Unlocking JavaScript Functional Programming: Practical Patterns and Pitfalls
Architecture Digest
Architecture Digest
Oct 31, 2016 · Fundamentals

One Week with Elixir – Language Design Reflections

Over the course of a week, the author explores Elixir’s design and features—covering its pipe operator, sigils, macro quoting, version handling, and differences from Erlang—while reflecting on language ergonomics, code readability, and functional programming concepts illustrated with concrete code examples.

ElixirFunctional ProgrammingPipe Operator
0 likes · 21 min read
One Week with Elixir – Language Design Reflections
Node Underground
Node Underground
Oct 18, 2016 · Frontend Development

Master Functional Programming in JavaScript: Pure Functions, Currying, and More

Discover the core concepts of functional programming for JavaScript developers—including pure functions, function composition, currying, monads, functors, immutability, lazy evaluation, and Clojure-inspired patterns—through a concise, practical guide that bridges theory and real-world application.

CurryingFunctional ProgrammingMonads
0 likes · 2 min read
Master Functional Programming in JavaScript: Pure Functions, Currying, and More
AI Cyberspace
AI Cyberspace
Sep 11, 2016 · Fundamentals

Master Python: 4 Essential Skills Every Developer Must Master

This guide summarizes key resources on functional programming, performance optimization, testing strategies, and coding standards, showing how mastering these four areas can transform any Python programmer into a highly effective and sought‑after developer.

Functional ProgrammingPythonbest practices
0 likes · 6 min read
Master Python: 4 Essential Skills Every Developer Must Master
WeChatFE
WeChatFE
Jul 29, 2016 · Fundamentals

Master JavaScript Currying: Boost Code Quality with Functional Design

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.

Functional ProgrammingJavaScriptcode reuse
0 likes · 10 min read
Master JavaScript Currying: Boost Code Quality with Functional Design
21CTO
21CTO
Feb 20, 2016 · Fundamentals

What’s the Real Difference Between Lambdas and Closures in Java?

This article explains the distinct concepts of lambdas and closures, illustrates how Java historically handled closures, shows Python lambda behavior, and discusses the implications of variable capture and finality in Java 8 lambda expressions.

Functional ProgrammingLambdaPython
0 likes · 5 min read
What’s the Real Difference Between Lambdas and Closures in Java?
21CTO
21CTO
Feb 9, 2016 · Frontend Development

Why Using map Beats for Loops: Cleaner, Declarative JavaScript

This article explains how replacing traditional for‑loops with JavaScript’s map method leads to more declarative, readable code, reduces boilerplate, improves maintainability, and offers comparable performance, while also discussing functional programming principles, browser support, and best practices for naming helper functions.

Functional ProgrammingJavaScriptdeclarative programming
0 likes · 7 min read
Why Using map Beats for Loops: Cleaner, Declarative JavaScript
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Oct 27, 2015 · Fundamentals

Introducing Erlang: Concurrency, Fault Tolerance, and Simple Syntax

This article introduces Erlang as a general‑purpose concurrent language, highlighting its fault‑tolerant runtime, simple 550‑line syntax, pattern‑matching capabilities, process creation with spawn, and practical examples using the ibrowse HTTP library to demonstrate message passing and distributed computing.

Functional ProgrammingPattern Matchingerlang
0 likes · 8 min read
Introducing Erlang: Concurrency, Fault Tolerance, and Simple Syntax
21CTO
21CTO
Sep 30, 2015 · Frontend Development

Why JavaScript Evolved from a Toy to the Backbone of Modern Web

After 15 years in software, the author reflects on JavaScript’s transformation from a simple validation script in the early 2000s to a pivotal language powering both front‑end interfaces and back‑end services, highlighting functional programming, ecosystem growth, and the market forces that drove its rise.

Functional ProgrammingNode.js
0 likes · 9 min read
Why JavaScript Evolved from a Toy to the Backbone of Modern Web
21CTO
21CTO
Sep 10, 2015 · Fundamentals

Why Erlang’s BEAM VM Is Unique: Garbage Collection and Async IO

Eric Merritt explains how Erlang’s BEAM VM differs from other VMs with its actor‑based, per‑process garbage collection and efficient asynchronous I/O, discusses the motivations behind Joxa, offers a balanced view on Elixir, explores language laziness, type‑system considerations, and mentions emerging technologies like micro‑kernels and Nix.

BEAMFunctional ProgrammingVM
0 likes · 5 min read
Why Erlang’s BEAM VM Is Unique: Garbage Collection and Async IO
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Sep 10, 2015 · Industry Insights

Why Erlang’s BEAM VM Stands Out: Expert Insights from Eric Merritt

In this interview, Erlang VM veteran Eric Merritt explains how BEAM’s actor‑based garbage collection, built‑in asynchronous I/O, and design choices differentiate it from other VMs, while also discussing the motivations behind Joxa, his views on Elixir, laziness, type systems, and emerging technologies he follows.

BEAMElixirFunctional Programming
0 likes · 5 min read
Why Erlang’s BEAM VM Stands Out: Expert Insights from Eric Merritt
Baidu Tech Salon
Baidu Tech Salon
Aug 14, 2014 · Fundamentals

Static vs Dynamic Languages, Functional Programming, Garbage Collection, and Recommended Programming Languages for the Future

The article compares static and dynamic typing, functional programming, garbage collection, and virtual machines, then advises developers to focus on versatile, future‑proof languages such as JavaScript/HTML5/CSS3, C#, Java, PHP, Swift, and optionally Erlang, emphasizing deep mastery over fleeting trends.

Functional ProgrammingGarbage CollectionLanguage Selection
0 likes · 14 min read
Static vs Dynamic Languages, Functional Programming, Garbage Collection, and Recommended Programming Languages for the Future
Baidu Tech Salon
Baidu Tech Salon
May 22, 2014 · Fundamentals

Reflections on Clojure: Design, Simplicity, and Development Flow

After years of using Ruby, I discovered that Clojure’s carefully designed, concise, and functional nature not only makes prototyping feel natural but also provides instant feedback and encourages thoughtful refactoring, turning development into a smooth, enjoyable flow that has quickly become my favorite language.

ClojureDevelopment WorkflowFunctional Programming
0 likes · 8 min read
Reflections on Clojure: Design, Simplicity, and Development Flow