Let's learn about Functional Programming via these 159 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the Learn Repo or LearnRepo.com to find the most read blog posts about any technology.
Dig Recursion? Welcome to functional programming
1. Real-world Use Cases of Dynamic Programming
Applications of dynamic programming
2. Function Composition with Lodash
Have you been reading JavaScript posts lately? Maybe you’ve noticed that functional programming is really popular right now. It’s a really powerful way to program, but can be overwhelming to get started with. Thankfully the most popular NPM package (with 48 million downloads this month) has a very useful functional programming package to help us get started!
3. The Basics of The Firmware Development Process
Firmware development is a necessary process in creating a new device and an embedded system. All the features and functionality of a device depend on its firmware. In simple words, firmware lies between software and hardware parts. So, it helps run software on a device and makes hardware perform required functions without involving users.
4. How to use componentWillMount with Functional Components in React
Functional components are far more efficient than class based components. Less code is needed to be written to achieve the same goal.
5. Including Files and Deeply Directories in Rust
One of the things that's been criticized by newbies in Rust is the file include mechanism. About 2 days ago, I spent around 5 hours on how I was supposed to include a file that was referenced deep down in a directory tree. The docs didn't help, as they were simple structures. Here I'll show you how you can include your code in different parts of the application, even when the structure is complex, and save you hours on how to do this supposedly trivial task.
6. Mastering Synchronization Primitives in Go
Golang's Goroutines make it easy to run code concurrently. We can simply add the keyword “go” in front of a function call to make it run in a separate routine, or asynchronously.
7. Creating a Middleware in Golang for JWT based Authentication
8. 9 Functional Programming Concepts Everyone Should Know
This article will introduce functional programming concepts that every programmer should know. Let's begin by defining what functional programming is (FP from now on). FP is a programming paradigm where software is written by applying and composing functions. A paradigm is a "Philosophical or theoretical framework of any kind." In other words, FP is a way for us to think of problems as a matter of interconnecting functions.
9. Functional Programming With JavaScript: A Deep Dive
Unlock the power of functional programming in JavaScript! Learn key concepts, practical examples, and unleash its potential in your projects.
10. Inheritance vs Composition: Using a Role-Playing Game in JavaScript as an Example
How to avoid inheritance problems using composition and functional programming
11. Object-oriented Programming vs. Functional Programming: Which Is Better?
Let’s dive in to learn about object-oriented programming and functional programming. What is object-oriented programming/OOP? What's functional programming/FP?
12. Practice with Functional Programming in Go
Take a look at a functional programming paradigm in Go
13. Inheritance vs Composition in JavaScript
Inheritance vs Composition in JavaScript. What is better, when use inheritance, when use composition. We will look at different examples on JS.
14. Choosing Your First Programming Language: A Beginners' Guide
Choosing the best programming language to learn first can be overwhelming. We are reviewing popular languages and giving resources to learn them for FREE.
15. Modern Style of Javascript with Arrow Functions
16. State Machines Can Help You Solve Complex Programming Problems
The notion of state machines is extremely useful in programming. It streamlines the process of developing more complicated use case apps.
17. Functional Programming is a Lie
Or a small rant against Elixir.
18. Learn Advanced TypeScript
Despite the popularity of currying and the rise of functional programming (and of TypeScript), it is still a hassle today to make use of curry and have proper type checks. Even famous libraries like Ramda do not provide generic types for their curry implementations (but we will).
19. Multiclass Classification with Keras
In the article the author describes the common pipelane of multilass classification solution using keras
20. How To Implement Simple State Container From Scratch
Let's imagine that we have a component, a simple counter. The counter has a state and two buttons to manipulate with this state. We also have a function to render the state.
21. Inserting 'User Profile Info' into your React Navbar
This article shows you how to insert the profile information of any user into the react navigation bar, so as to make it sign-in aware.
22. Patterns from Other Languages and Frameworks to Enhance Your Frontend Projects
Drawing from 12 years of programming across various languages, I'll share how I've applied principles from these to my frontend projects.
23. This is How You Can Learn All Programming Languages, Yes - “all”
24. Functional Programming: An Effective Approach for Experienced Programmers
Functional programming is a way of writing code that relies on the use of functions to solve problems.
25. How To Design Domain Model in Kotlin
Type-safe domain modeling in Kotlin. If it compiles, it works. With Valiktor and Konad
26. Farewell, Ramda
Ramda, Functional programming, Native JavaScript, TypeScript, Lodash, ES2020, Code readability, Performance optimization, Coding style
27. React Functional Components are the future
React Functional Components grabbed all the attention after the introduction of Hooks. They sidelined Class Components to become the main hero of React apps.
28. The Best Programming Languages for Working with AI
You will require coding skills if you want to work in the field of artificial intelligence (AI). How do you begin? and Which programming language to use?
29. Model-View-Controller Architecture Pattern: Usage, Advantages, Examples
How the MVC architecture is built, how the code is structured and it can benefit your work.
30. Everything You Need to Know About Using Elixir for Web Development
The Erlang VM-based programming language, Elixir, is slowly but surely gaining popularity. Let's take a look at some benefits of Elixir development.
31. A Deeper Look into Method References in Java
What Are Java Method References And Kinds Of Method References Available?
32. Exploring the Potential of Bioinformatics with C#
In this article, we'll examine how to apply bioinformatics and C# coding to effectively deal with biological information.
33. Say Goodbye to Null-Checking and Exceptions: Using the Maybe Monad in Symfony
Functional programming is old. But it did not become popular, and probably for a reason.
34. Functional Programming is not What Makes Haskell Great
This post is substantially directed to non Haskellers. Haskell frequently appears on hackernews or /r/programming but the content is commonly evangelizing some aspect of functional programming, strong types, and purity.
35. Understanding Currying, Closures, and Coupling in JavaScript
Here's a problem. You have an object in your code exposed via an export. You also have a function in the same file (also exported) consuming that object directly.
36. 105 Stories To Learn About Functional Programming
Learn everything you need to know about Functional Programming via these 105 free HackerNoon stories.
37. How the TypeScript NonNullable Type Works
The NonNullable type is a utility type in TypeScript which creates a new type, whilst removing all null or undefined elements.
38. How to Implement the Perceus Reference Counting Garbage Collection
Experience in implementing the Perceus reference counting algorithm in the Pen programming language
39. What Is Haskell, Who Uses It, And Where Can You Learn To Code It
Haskell language (and functional programming approach) has become more and more popular in the industry – businesses need robust and safe software solutions, and some of the problems can’t be solved without an advanced technological stack.
40. Elm in Production: Developer Reflections After 34k Lines of Code
(Photo by Diego Madrigal from Pexels)
41. Why My Brain Is Wired for Clojure
The world according to Clojure is nothing but data.At any point in time, it’s one piece of data.
42. Telegram Bot In Scala 3 With Bot4s + http4s + Doobie for CI notifications
Scala 3 is finally here, but have you seen many real-world applications written in it? In this article, I will show you an example of such an application!
43. Either Monad: A Functional Approach to Error Handling in C#.
Dive into error handling in C# with the Either monad using LanguageExt. Learn to differentiate success (Right) and errors (Left) effectively.
44. Functional Programming Techniques in Java with Examples
If you’re a Java developer, I’m sure that you have seen code similar to the featured image snippet above at least once. The code in the snippet above is an example of functional programming paradigm implementation in Java, which will filter and transform the List<String> in the request to another List<String>.
45. 4 Steps to a Better Imports List in Haskell
So your thoughts on seeing this title might be “Holy cow, an article about imports…could there be anymore more boring?” But bear with me. This is actually something that is <strong>pretty easy</strong> to do correctly. But if you’re even a bit lazy (as I often am), you’ll do it wrong. And that can have <strong>really bad effects</strong> on you and your teammates’ productivity.
46. Array Filter vs Array Reduce vs For Loop
Array reduce is a powerful functional programming technique that can be used to simplify complex data manipulation tasks. One of the main advantages of using array reduce over traditional for loops and filter operations is that it allows for more concise and expressive code.
47. Javascript: From Objects to Factory Functions And Modules
Objects
48. How to Use Azure Functions to Build a QR Code Generator
How to build a fun QR code project and learn about Azure Functions at the same time. Using the latest .NET technologies.
49. How DevOps Evolved Into DevSecOps
The rise in cybercrime and the sophistication of attacks has made security a crucial part of the development process and not just an afterthought.
50. Welcome to the OOP pattern matching: Visitor Pattern
Visitor pattern is dead. Long live to Visitor pattern. (With Kotlin examples)
51. Demystifying SOLID Programming (Part 1): Single Responsibility Principle
We dive deep into the first principle of SOLID programming, the Single responsible principle. It states "A class should have one and only one reason to change"
52. Rethinking Web3: How to Build Faster Using Scrypto
How to use the new programming language to build more efficiently.
53. Where is Your Deep Object in the Query?
From version v3, the OpenApi standard brings another way to introduce query parameters via DeepObject.
54. Functional Programming in Python (with Examples)
Simply put, functional programming is a programming style that relies exclusively on functions.
55. How To Create Simple API Client with ZIO and Http4s
Discussing with a brazilian friend about the situation in our country, we realised how difficult it is to find information about public spending, and when available, how difficult it can be to reason about it. Joining our forces, we decided to explore some data exposed by the Brazilian government, aiming to provide an easier way to visualise and understand how the public resources has been used.
56. Function Composition (Pipe, Compose) in JavaScript Explained
Functional programming is about developing small simple functions and combining them for the purposes of executing more complex tasks.
57. Why We Bet on Clojure and Built Freshcode Around It
Why we chose Clojure: functional programming that yields faster features, fewer bugs, smaller teams, and measurable delivery metrics for client projects.
58. 3 Things I Learned in 1 Year Working with Functional Programming
Just like the great majority of programming-related courses, I was introduced to programming with the object-oriented paradigm (OOP). Even though many languages are multi-paradigm, like Python, C++, JavaScript and Ruby, we still have OOP as the norm.
59. How to Design Pure Functions
Today I am going to talk about how to design Pure Function and help you understand the benefits of pure function.
60. Functional Programming In Ruby: How To Create Pure Functions
In functional programming, pure functions are at the core of this paradigm. When we speak of pure functions we mean that these functions satisfy two main conditions; the first is that they will not cause any side effects and the second is that depending on their arguments they will return the same result. When you create pure functions you should try to make them take care of one thing and only one, so your functions will be very easy to test and scale. Consider the following function:
61. Inside BEAM: How Elixir and Erlang Leverage a Shared Runtime for Resilient Applications
Explore the origins and guiding principles behind Erlang and Elixir to understand their full potential and innovation.
62. Building Your Own Programming Language From Scratch Part IV: Implementing Functions
Build your own Programming Language from Scratch Part 4, where we start new function constructions & implementing functions.
63. Become a Better Developer by Learning Functional Programming in JavaScript
Functional programming is a programming paradigm. This post tells you the basics and benefits of it and how to use it in JavaScript.
64. Forms of Composition in JavaScript and React
65. Functor Applicative and Monads
66. Functional Programming in Python For Beginners
Learn about functional programming, pure functions, map(), filter(), zip(), reduce() concepts
67. Functional Programming Paradigm in JavaScript
There’s nothing new about Functional Programming. Functional Programming has been around for much longer than OOP as it dates back to the 60s.
68. Higher Order Functions in C#: A Practical Example
If you have been programming for any length of time, you may well have come across higher-order functions but may not have fully appreciated them.
69. ClojureScript Macros: A (Not So) Long Journey [Part II]
70. Folding in C++ using Variadic Function Template
Template parameter pack was introduced in C++11. Today we will utilise it to write our fold function. To the ones who don't know what a fold function the expression fold(add, 1, 2, 3, 4, 5) , we will output (1 +(2 + (3 + (4 + 5)))) = 15 (which is left fold). Similarly for fold(mul, 1, 2, 3, 4, 5) , we will output 120. More about it can be found here.
71. JavaScript: The Apocalyptic Dumpster Fire That Has Coders Begging it to Stop
The Frankensteinian Hodgepodge That Puts Mr. Burns' Smithers in Charge of the Starship Enterprise and Leaves Coders Screaming 'Wubba Lubba Dub Dub!'"
In a real
72. My Experience with Length Control for a DC Actuator
It all started when we ordered an actuator, with an encoder, from China for a project. But something went wrong, and a month later, we received actuators withou
73. How To Build a Multilingual Text-to-Audio Converter With Python
Learn how to build a multilingual text-to-audio converter using Python. This guide covers essential libraries, techniques, and best practices
74. A Brief Introduction to Lambda Expressions in Python
Lambda expressions in python are one-time anonymous functions which we don’t need more than once.
75. Senior Engineer`s Opinion: Why Does Scala Win Against Kotlin?
This article is based on a story of one of our developers, ex Java now Scala developer, who decided to follow the Scala path because he found writing in Scala extremely developing and interesting.
76. Composable Resource Management in Scala
77. Functional Programming and Justice in a World Without Time
My grandfather was staring deeply into the television screen in the dimly lit living room. After his cataract had over matured, he swapped the newspaper he peeled through every morning for a news channel with as much depth as the flat screen it was served on.
78. How learning Elixir helped me build a SaaS for Marketers
79. Seeing Javascript Objects as Functions Changed How I Code
So you probably know that functions are objects in javascript (if not go up the prototype chain of a function to find out). But recently, I noticed that javascript objects can be treated like functions. Which leads to some pretty cool implications!
80. Go Beyond Functional Testing: How to Use Playwright for Front-End Performance Insights
Playwright isn’t just for UI testing — it can also measure front-end performance from a real user perspective.
81. Refactoring using Functional Programming
What
82. Break the Loop: How I Finally Understood Functional Programming (Without the Math)
Stop fighting the 'Celtic runes' of functional programming. Learn FP through a simple model of computation, from basic recursion to the magic of shared thunks.
83. Query Select All The Things!
Almost all the Codepens I've written this year have had some form of a JavaScript function that I call qs()(). That's not a typo! There are two sets of parenthesis following it, and it is good practice as this function uses closures. In just one line, I create a Swiss Army knife of several functions.
84. Hands-On Project: Oh-My-Bill
The first exercise for my mentees was to draw on a piece of paper the interface that they see for this application.
85. What is Functional Programming?
Most of what I will discuss in this article is knowledge accumulated from reading, “Functional Programming in JavaScript”, by Luis Atencio. Let’s dig right in…
86. Using Union Types to Improve Your TypeScript Code
What are union types and how you can use them to your advantage!
87. How to Build a GUI-Based Currency Converter App in Python
Build a Python currency converter with Tkinter. Learn API interaction, user input handling, and GUI design for real-time currency conversion.
88. Implementing a Java Stream Collector
Java Stream's Collectors methods fit most use-cases. They allow returning either a Collection or a scalar. For the former, you use one of the toXXX() method, for the latter, one of the reducing() one.
89. Understanding Chrome V8 - Chapter 24: How does V8 Describe Your JavaScript Function
"Let's Understand Chrome V8" are serial technology articles that explain the V8 code, it covers many V8 kernel functions and fundamentals.
90. Swift Dependency Injection With Functions
Implementing an architecture within an application can be challenging. There are rules we can follow (SOLID, Clean Architecture) and patterns to guide us (MVVM, MVP, MVI, Redux, …) but sometimes, things we thought were well established deserve a step back.
91. Сurrying 101: A Quick Guide for JavaScript Devs
The essence of currying is simple: to take a function of any arity (number of expected arguments) and make it into a unary function.
92. The .NET Framework Is The Most Suitable Language For Businesses And Here's Why
By far, Microsoft .NET is one of the best platforms for building secure, robust, and scalable desktop or web applications. Used by most Fortune 500 companies, Microsoft .NET is very popular for large-scale applications.
93. This One Programming Concept Made Me a Better Coder (and Planner)
How functional programming changed the way I write and think about code — with easy Python examples and lessons from real coding struggle.
94. Recursion Can Be Weirder Than You Think
I love recursion. I think it's a very elegant way of writing code, and sometimes it lets you write simple but yet effective pieces of code. And if you happen to use languages like Scala, then recursion is a must.
95. This One Programming Choice Completely Changed These Tech Firms—Here's How
Clojure is reshaping how teams build software, enabling small, focused groups to tackle complex challenges efficiently.
96. Eliminating Event Storms With Debouncing in JavaScript
Using debounce, the function will be executed only when a certain amount of time has passed since the last function call.
97. JavaScript Loops: for/forEach/for.. in/for.. of Explained
There are quite a few ways in Javascript to loop through an array of items or any other iterable item in Javascript. You may have seen them:
98. Higher-Order Function in JavaScript with ES6 Examples
In this article, we are going to learn higher-order functions in JavaScript, as well as see the ways you can use them.
99. ClojureScript Macros: A (Not So) Long Journey [Part I]
I’m learning the Clojure and ClojureScript craft and I must say, I enjoy it. This article explains what leads me on the track of learning Clojure/Script macro. This is the first part of my journey on this topic.
100. A Closer Look into Different Programming Styles and Paradigms
Imperative and declarative styles of programming.
101. 10 Questions for Aswin Ganesh, Noonie Nominee for Functional Programming
The 2020 #Noonies are here! And they are both much greener and much bigger than last year. Among the 2,000+ deserving humans nominated across 5 categories for over 200 award titles, we discovered Aswin Ganesh from India, who’s has been nominated for Hacker Noon's Contributor of the Year in our Functional Programming category. Without further ado, we present to you, our big techy world in 10 questions, from the perspective of Aswin.
102. I Built a Functional, Data-Oriented 3D Game Framework in Rust for Low-End PCs
A lightweight Rust game framework built with Macroquad and ECS, designed to run on low-end hardware while exploring functional programming patterns.
103. Essentials of Vintage QuickCheck - Property-Based Testing (Part 2)
Learn how the first property-based testing library, QuickCheck, works by implementing it in Python.
104. How To Use The Spread Operator on a Function
You can’t officially do it, but you can write a function that does virtually the same thing. Let’s see how and maybe why you should.
105. Researchers Revisit Codata, Dependent Types, and the Limits of the Expression Problem
A deep dive into codata, dependent types, and defunctionalization—reframing the expression problem through data–codata duality.
106. Deep Dive into Functional Programming in Javascript
functional programming emphasizes the use of pure functions, immutability, and advanced techniques like currying, memoization, and monads to create cleaner code
107. Would You Use Clojure Again? These Companies Say Yes — and Here’s Why
"Clojure in Product. Would you do it again?" podcast explores how teams use the language to grow their businesses.
108. Deriving Dependently-Typed OOP from First Principles
A new calculus unifies functional and object-oriented paradigms in dependently typed languages using duality and defunctionalization.
109. Hannes Mehnert on MirageOS and OCaml
Our backend engineer, Pavel Argentov, traveled to Marrakech, Morocco to attend the ninth MirageOS retreat, which was held from March 13-19, 2020. The goal of the event is to bring both experienced and brand new MirageOS users together to collaborate and sync various MirageOS subprojects, start new ones, and help each other fix bugs.
110. Why Mutable Developers are Essential for Learning New Paradigms
The process to learn functional programming can be daunting and slow as new concepts are involved. Here are 5 tips for you to consider when learning FP.
111. How I Extracted Meaningful Information from Inconsistent Data Using ChatGPT
Data Analyis Project using Spacy and Regular Expressions to extract specific strings from a data set.
112. An Introduction to F# as Microsoft's / .NET's Answer to a Functional-First Programming Language
Recently I've been learning how to write code in F#. For those who haven't heard of it, F# is Microsoft's/.NET's answer to a functional-first programming language. My motivation was to learn a functional programming language that would make coding for scientific computing and data analysis more expressive, concise, and maintainable, all while fitting seamlessly into the .NET ecosystem that I already know and love. F# fits that bill perfectly.
113. Some Ways to Apply Some Programming Wisdom in Real Lives - Exceptions
What would happen if we apply some wisdom from handling exceptions to handling negative emotions?
114. Your First Hardware Hacking Bench: The Only Tools That Matter
New to hardware hacking? Learn the essential tools you need to avoid costly mistakes. This guide covers the survival kit every beginner should have.
115. Default Parameters in JavaScript: Beginners Guide
In this short article we will cover Function Defaults and learn how to use it in our day to day JavaScript programming. This article assumes you have some familiarity with coding in the JavaScript ecosystem.
116. Kotlin Nullables: How to Compose Them Right
How to compose independently computed Kotlin nullables, in an easy and clean way
117. A Closer Look at Immediately Invoked Function Expressions (IIFE) in JavaScript
Immediately invoked function expressions, or IIFE, are functions that are run as soon as you define the function.
118. Higher-Order Functions Explained
Whether you are a beginner or a 10x developer, chances are that you have used the methods of the Array Object. The methods in the Array Object are classified into two different categories. One category takes a value as arguments( string, integer, array, object) and another category takes a function as arguments. l
119. How to Define an Active Menu Item in a Phoenix Framework Through Short-Circuit Evaluation
Use Elixir's short-circuit evaluation syntax to build lists and make it easier to define active menu item in Phoenix Framework.
120. 100 Days of Code: Death of Summer on the Island of NixOS
We are a hundred days deep in the Lambda Quadrant part of the galaxy, resting on a deep space Moonad, myself and my crew, my parter and my
lovematch, our infant son, and a cat. We study the properties and relations of Haskell abstract entities, enjoying meditating the pure functional programming vibe. It is deep work and we take time and turns. We also watch the second season of Star Trek Discovery and enjoy seeing the bright stars of its universe.
121. How Grammarly and Kasta Made Ukraine a Global Clojure Hotspot
Grammarly’s AI engine and Kasta’s e-commerce platform showcase functional programming at global scale.
122. Why Judgmental Equality Fails Under Defunctionalization
Exploring how defunctionalization breaks judgmental and eta equality—and the naming-based solution that preserves type safety.
123. What Sequent Calculus Teaches Us About Computation
A clear breakdown of how λμμ˜-calculus relates to sequent calculus, typing rules, and operational semantics like label/goto.
124. Have you Used the Streams API in Java?
Introduction to streams API
125. A Formal Core for Dependent Data and Codata with Type Soundness Guarantees
A formal core calculus for dependent data and codata with pattern matching, copatterns, call-by-value semantics, and type soundness proofs.
126. What Functional Programmers Can Learn from Sequent Calculus
Explore 5 powerful insights into the 𝜆𝜇𝜇˜-calculus, from first-class evaluation contexts to the elegant duality between data and codata types.
127. From Chaos to Control: Building a Standardized Dev Environment for 1,000+ Students
A standardized tech stack (ArTEMiS, VSCodium) for automated grading and collaboration in a large-scale Haskell course.
128. My Experience with Scala
If you are learning scala or wondering if you should use for new project in your organisation, I suggest that you do. As always, see if scala and scala’s ecosy
129. What is Lexical Functional Programming ?
Lexical functional programming - jargon and naming convention. How to standardize descriptive names?
130. The Proof Expression Problem, Reimagined Through Object-Oriented Lenses
A case study showing how dependently typed OOP enables modular web servers, extensible routes, and type-level enforcement of HTTP properties.
131. Understanding Algebraic Data and Codata Types in Functional Programming
Discover the dual nature of algebraic data and codata types in the Fun and Core languages—exploring pattern, copattern, symmetry, and lazy evaluation.
132. An Introduction to Evaluation Contexts in Programming Semantics
Evaluation contexts solve nested expression stalls in functional languages like Fun and Core by enabling precise operational semantics.
133. Rethinking OOP Through Dependent Types and Codata
A deep dive into dependently typed object-oriented programming, codata design, self-parameters, and verified interfaces.
134. How Typing Rules and Type Soundness Work in Core and Fun Programming Languages
Learn how typing rules and type soundness theorems ensure safe program evaluation in Core and Fun, including codata handling and recursive definitions.
135. Using Go Defer and Rust Drop to Defer the Call to Rollback
Forgetting to close things off in Go can potentially come back to bite you. The most basic and straightforward method is to call rollback or commit.
136. Code Smell 267 - Objects Aliasing
Discover the importance of using immutable objects in programming to prevent unexpected changes, reduce bugs, and improve code predictability.
137. What Codata, Control Flow, and Logic Teach Us About Programming
Learn how programming concepts like logic, control flow, and evaluation strategy shape the languages we use.
138. Shrinking for Easier Debugging - Property-Based Testing (Part 3)
An explanation and short implementation of how shrinking works in property-based testing
139. Programming Paradigms: All the Things We’ve Learned Not To Do
Programming paradigms don't give freedom—they take it away. Here's why Structured, OOP, and Functional might be the last paradigms we ever get.
140. Rethinking Data and Codata Through Matrix Transposition
A formal study shows de- and refunctionalization preserve typing and program well-formedness in a dependently typed language.
141. Too Scared to Ask? How We Solved the #1 Problem with Large University Lectures
To engage 1000+ students, lectures evolved from simple Q&A to a moderated live board, boosting synchronous interaction and solving the 'silent majority' problem
142. JavaScript Currying: The Secret Sauce to Smoother, Cleaner Code
Learn about currying in JavaScript and how it can enhance your coding experience.
143. Functional Programming in Javascript for Busy People
You’ve probably used map, reduce, and other functional methods in Javascript before, but there are a few use cases you probably haven’t thought about much or used before. In this post, I’d like to go over these methods (and a few other surprises!) to show what’s possible.
144. Code Smell 241 - Referential Transparency Violation
Learn how to write pure functions to enhance code readability, maintainability, and testability.
145. Your Toolkit for Teaching at Scale: Lessons from a 1000-Student Haskell Course
A toolkit of practical methods—bonuses, instant feedback, competitions, and workshops—used to engage 1000+ students in a large-scale Haskell course.
146. The Noonification: Bouncy Castle (1/19/2023)
1/19/2023: Top 5 stories on the Hackernoon homepage!
147. How Do You Teach I/O Before Monads? Inside a Radical Syllabus for a 1000-Student FP Course
The operational playbook for a 1000+ student Haskell course, detailing syllabus design, staffing logistics, and a practical-first pedagogical approach.
148. Understanding the background of the Hospital Bed Rental Industry
Healthcare organizations that follow HIPAA guidelines must be explicitly aware of security threats. Ethical hacking needs a more critical role in the framework.
149. How Let Bindings Improve Code Readability in Functional Programming
Explore let bindings, top-level definitions, and continuation semantics in λμμ˜-calculus and how they shape functional programming evaluation.
150. How Focusing Resolves Stuck Terms in Core Evaluation
Learn how focusing in Core helps eliminate stuck terms, optimize evaluation, and improve program compilation through static transformations.
151. Sequent Calculus vs CPS: A Compiler’s Perspective on Consumers and Evaluation Strategies
Explore how sequent calculus handles consumers, evaluation orders, and eta laws better than CPS, with insights on linear logic and functional compilers.
152. Why Type Soundness Matters in Functional Programming Languages
A breakdown of typing rules in Fun and Core languages, with insights into control flow, type soundness, and data vs codata handling.
153. The Try Block in Rust: Streamlining Error Management Beyond the '?' Operator
Discover how Rust's experimental try block feature simplifies error handling beyond the traditional ? operator.
154. What If Programming Languages Could Think Ahead?
Discover the λμμ̃-Calculus: a powerful tool for compiler writers that simplifies evaluation contexts without the complexity of CPS types.
155. From Campus to Cloud: Our Journey Teaching Functional Programming to Thousands During a Pandemic
A case study on engaging 2000+ students in a Haskell course with automated feedback, creative projects, and shareable tools for educators.
156. How Functional Languages Simulate Goto with Labels and μ-Bindings
Explore how first-class functions and control operators like label/goto are desugared and implemented in functional programming using codata and μ-bindings.
157. Why Compiler Writers Care About Case-of-Case
Explore the duality between let-bindings and control operators, and how λμμ˜ calculus enables powerful compiler optimizations like case-of-case.
158. Programmer's Version of Schrodinger’s Cat: Options for JavaScript
Bringing Options to JavaScript and TypeScript.
159. Why Arithmetic in Functional Languages Needs Sequent Calculus
Explore how arithmetic expressions in a functional language are translated into Core's sequent-calculus framework using producers, consumers, and statements.
Thank you for checking out the 159 most read blog posts about Functional Programming on HackerNoon.
Visit the /Learn Repo to find the most read blog posts about any technology.