Hal Abelson is a member of the IEEE and the Class of 1922 Professor of Computer Science and Engineering at Massachusetts Institute of Technology. He founded Creative Commons, Public Knowledge, and the Free Software Foundation. He is also a co-chair of the MIT Council on Educational Technology. Panasonic Professor of Electrical Engineering Gerald Jay Sussman teaches at MIT. He is the author of Structure and Interpretation of Computer Programs, one of the best books on functional programming.

Over the last decade, Structure and Interpretation of Computer Programs has had a significant impact on computer science curricula. This long-awaited revision includes changes to the entire text. Most of the major programming systems in the book, including the interpreters and compilers, have new implementations, and the authors have incorporated many small changes that reflect their experience teaching the course at MIT since the first edition was published. A new theme has been introduced that emphasizes the importance of various approaches to dealing with time in computational models: objects with state, concurrent programming, functional programming with lazy evaluation, and nondeterministic programming. There are new example sections on higher-order graphics procedures and stream processing applications in numerical programming, as well as many new exercises. Furthermore, all of the programs have been rewritten to run in any IEEE-compliant Scheme implementation.

Author: Gerald Jay Sussman, Harold Abelson and Julie Sussman

Link to buy: https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871

Ratings: 4.7 out of 5 stars (from 591 reviews)

Best Sellers Rank: #22,144 in Books

#3 in Computer Programming Languages

#20 in Computer Software (Books)

#22 in Software Development (Books)

Scott Wlaschin is an F# expert, the author of the popular F# site fsharpforfunandprofit.com, and a member of the F# Software Foundation's board of directors. Scott is a popular speaker known for his non-academic approach to functional programming. He has spoken at NDC, F# Exchange, DDD Europe, and other conferences around the world.

You want higher customer satisfaction, shorter development cycles, and less work waste. The innovative combination of domain-driven design (DDD) and functional programming will get you there. In this practical, down-to-earth guide, you'll learn how applying functional programming's core principles can result in software designs that model real-world requirements elegantly and concisely - often more so than an object-oriented approach. Practical examples in the open-source F# functional language, as well as examples from well-known business domains, demonstrate how to use these techniques to create business-focused, flexible, and high-quality software.

Domain-driven design is a well-established approach to software design that ensures domain experts and developers work effectively together to create high-quality software. This is the first book to combine DDD with statically typed functional programming techniques. Domain Modeling Made Functional is ideal for those who are new to DDD or functional programming because it introduces and explains all of the techniques required.

Model a complex domain precisely with the F# type system, producing compilable code that is also readable documentation—-ensuring that the code and design are always in sync. Make illegal states unrepresentable by encoding business rules in the design and having "compile-time unit tests." Assemble a set of small, testable functions into a complete use case, and then combine these individual scenarios to create a large-scale design. Learn why combining functional programming and DDD naturally leads to service-oriented and hexagonal architectures. Finally, build a functional domain model that works with traditional databases, NoSQL, and event stores, and securely expose it via a website or API.

Solve real-world problems by focusing on real-world software requirements. The book is regarded as one of the best books on functional programming.

Author: Scott Wlaschin

Link to buy: https://www.amazon.com/Domain-Modeling-Made-Functional-Domain-Driven/dp/1680502549

Ratings: 4.7 out of 5 stars (from 226 reviews)

Best Sellers Rank: #455,263 in Books

#41 in Functional Software Programming

#180 in Data Modeling & Design (Books)

#197 in Object-Oriented Design

Raoul-Gabriel Urma is the CEO and co-founder of Cambridge Spark, the United Kingdom's leading learning community for data scientists and developers. He is also the Chairman and Co-Founder of Cambridge Coding Academy, a rapidly growing community of young coders and pre-university students. Raoul is the bestselling author of "Java 8 in Action," which has sold over 20,000 copies worldwide.

Mario Fusco is a Red Hat senior software engineer who works on Drools, the JBoss rule engine. He created the open source library lambdaj, an internal Java DSL for functional collection manipulation.

Alan Mycroft is a University of Cambridge Professor of Computer Science who studies programming languages, their semantics, optimization, and implementation. He is a Raspberry Pi Foundation Trustee and co-founder.

Microservices, reactive architectures, and streaming data are examples of innovative designs used in modern applications. Modern Java features such as lambdas, streams, and the long-awaited Java Module System make it much easier to implement these designs. It's time to brush up on your abilities and face these challenges head on!

Modern Java in Action connects new Java language features to their practical applications. This book respects your time by using clear examples and paying close attention to detail. It will help you broaden your knowledge of core Java by mastering modern additions such as the Streams API and the Java Module System, exploring new approaches to concurrency, and learning how functional concepts can help you write code that is easier to read and maintain.

What's on the inside?

• Manning's best-selling Java 8 in Action has been completely revised.
• Java 8, Java 9, and Beyond: New Features
• Data streaming and reactive programming
• The Java Module System (JMS)

Author: Raoul-Gabriel Urma, Mario Fusco and Alan Mycroft

Link to buy: https://www.amazon.com/Modern-Java-Action-functional-programming/dp/1617293563

Ratings: 4.5 out of 5 stars (from 165 reviews)

Best Sellers Rank: #306,392 in Books

#21 in Functional Software Programming

#114 in Object-Oriented Design

#412 in Software Development (Books)

Eric Normand has been a functional programmer since 2001 and a functional programming instructor since 2007. He is the author of Grokking Simplicity.

Modern software is complex. It is distributed across servers, difficult to test, and resistant to modification. Grokking Simplicity is a friendly, practical guide that will change your perspective on software design and development. It introduces a novel approach to functional programming by explaining why certain software features are prone to complexity and teaching you functional techniques for simplifying these systems so that they are easier to test and debug.

Developers are right to be concerned about the unintended complexity that pervades most code. This book teaches you how to write software that keeps complexity to a bare minimum. When writing software, you should distinguish between code that changes the state of your system and code that does not. Once you've mastered that distinction, you'll be able to refactor many of your state-altering "actions" into stateless "calculations." Your software will be easier to use.

The book will also teach you how to troubleshoot the complex timing bugs that inevitably appear in asynchronous and multithreaded code. In the book's advanced sections, you'll learn how composable abstractions can help you avoid repeating code and open up new levels of expressivity.

What's on the inside?

• Code simplification patterns
• Effective time modeling techniques for simplifying asynchronous code
• Higher-order functions make code more reusable and composable.

Author: Eric Normand

Link to buy: https://www.amazon.com/Grokking-Simplicity-software-functional-thinking/dp/1617296201

Ratings: 4.7 out of 5 stars (from 69 reviews)

Best Sellers Rank: #113,863 in Books

#1 in Functional Software Programming

#41 in Object-Oriented Design

#131 in Software Development (Books)

Alvin took a roundabout path to software development. He graduated from Texas A&M University with a degree in Aerospace Engineering despite the fact that all he wanted to do was play baseball. After becoming a practicing engineer, he realized he preferred software and programming to engineering. So he taught himself Fortran, C, Unix, network administration, sed, awk, Lisp, Perl, Java, JavaScript, Python, Ruby, JRuby, PHP, and Scala in roughly that order. During this time, he established a software consulting firm, grew it to fifteen employees, sold it, and relocated to Alaska.

You're not alone if you've struggled to learn Functional Programming (FP). Alvin Alexander — author of the Scala Cookbook for O'Reilly, the Scala Book for the official Scala website, and former teacher of Java and Object-Oriented Programming (OOP) classes — writes about his own struggles with FP and how he eventually conquered it (and you can too!).

In Functional Programming, Simplified, he teaches FP in a straightforward manner, avoiding abstract concepts such as functors, monads, and category theory. Instead, he explains FP through a steady stream of small, practical code examples.

For example, he discovered that experienced FP developers (FPers) are motivated by two goals: to use only immutable values and to write only pure functions. He later discovered the larger truth: FPers have these goals because their true desire — or mental model — is for all of their code to look and work exactly like algebra.

While this appears to be a simple task, it turns out that these objectives necessitate the use of some advanced Scala features, which they frequently employ simultaneously. As a result, their code may appear completely alien to inexperienced FP developers. "When you first see their code, it's easy to ask, 'Why would you write code like this?'" writes Mr. Alexander.

Mr. Alexander then responds to the "Why?" question by explaining the benefits of writing pure functional code. Once you've grasped those benefits — your motivation for learning FP — he shares five programming rules in the book:

• All fields must be immutable.
• Every function must be a pure function.
• Null values are not permitted.
• If you use a 'if,' you must also use a 'else.'
• Instead of creating OOP classes that encapsulate data and behavior, you'll design data structures with Scala 'case' classes and write pure functions that operate on those data structures.

In the book, you'll learn how to write pure, functional code that reads like algebra by following five simple rules. He also shares another learning Golden Rule: Always ask “Why”? Among the lessons in the book are:

• Why and how should you write only pure functions?
• Why are pure function signatures far more valuable than OOP method signatures?
• How to write recursive algorithms and why recursion is a natural tool for functional programming
• Because the Scala 'for' expression is so important in FP, dozens of pages are dedicated to explaining how it works.
• Finally, you'll realize that monads aren't all that difficult because they're a natural extension of the Five Rules.
• The book concludes with lessons on FP data modeling as well as two major approaches for organizing your pure functions.

Author: Alvin Alexander

Link to buy: https://www.amazon.com/Functional-Programming-Simplified-Alvin-Alexander/dp/1979788782

Ratings: 4.6 out of 5 stars (from 170 reviews)

Best Sellers Rank: #235,411 in Books

#15 in Functional Software Programming

#168 in Microsoft Programming (Books)

Cristian Salcescu is the author of the book series "Functional JavaScript" and "Functional React." He is a technical lead who is passionate about front-end development and enjoys sharing ideas. He took on various roles and was involved in all aspects of software development. Cristian Salcescu is a Medium writer and JavaScript trainer.

You will learn how to use JavaScript as a functional programming language in Functional Programming in JavaScript. JavaScript, it turns out, has everything it needs to be used as a functional language. We simply need to remove features from the language that begin with the keyword 'this.'

Values are functions. Functions can perform operations on other functions. Even after the outer functions have been executed, inner functions can access variables from the outer functions. Functional programming simplifies the reading, understanding, testing, and debugging of code.

Here are a few examples of what you will learn:

• Using a linter, disable 'this' and enable immutable data objects.
• What is the best way to work with immutable objects and collections?
• How to perform data transformations with core operations such as filter, map, sort, and reduce
• How to use if and switch statements in a functional way
• How to build pipelines and use currying to pass extra data
• Learn about functors and monads.
• Working with promises and observables
• Recognize the Elm Architecture

Author: Cristian Salcescu

Link to buy: https://www.amazon.com/Functional-Programming-JavaScript-React/dp/B08F6RCCSF

Ratings: 4.6 out of 5 stars (from 16 reviews)

Best Sellers Rank: #443,408 in Books

#140 in JavaScript Programming (Books)

#1,143 in Programming Languages (Books)

#1,495 in Internet & Social Media

Dr. Ivan uki has been teaching modern C++ techniques and functional programming at Belgrade's Faculty of Mathematics for over a decade and has been working with C++ for over 20 years. Before and during his PhD studies, he researched functional programming in C++ and applied the techniques in real-world projects. He is a core developer in KDE, the world's largest free/libre open source C++ project.

Functional Programming in C++ teaches developers the practical side of functional programming as well as the tools provided by C++ to create software in the functional style. This comprehensive guide is packed with useful diagrams that will help you understand FP concepts and begin to think functionally.

As you gain a powerful new perspective on C++ coding, Functional Programming in C++ helps you unleash the functional side of your brain. There are dozens of examples, diagrams, and illustrations that explain the functional concepts you can use in C++, such as lazy evaluation, function objects and invokables, algebraic data types, and more. As you read, you'll be able to match FP techniques with practical scenarios where they'll be most useful.

What's on the inside?

• Writing safer code while incurring no performance penalties
• Using the type system to explicitly handle errors
• C++ is being extended with new control structures.
• Task composition using DSLs

Author: Ivan Cukic

Link to buy: https://www.amazon.com/Functional-Programming-programs-functional-techniques/dp/1617293814

Ratings: 4.5 out of 5 stars (from 65 reviews)

Best Sellers Rank: #911,407 in Books

#154 in C Programming Language

#237 in C++ Programming Language

#557 in Computer Programming Languages

Will Kurt is currently employed at Quick Sprout as a Data Scientist. He is fascinated by explaining complex technical topics as clearly and broadly as possible, having a formal background in both Computer Science (MS) and English Literature (BA). He has taught a Haskell course section and given Functional Programming workshops at the University of Nevada, Reno. He also writes about probability on his blog, CountBayesie.com.

Get Programming with Haskell introduces you to the Haskell programming language without drowning you in academic jargon or complex functional programming theory. Working through 43 simple lessons, you'll learn Haskell the best way possible—by doing Haskell!

Programming languages frequently differ only on the margins—a few keywords, libraries, or platform options. Haskell provides you with an entirely new perspective. A change in perspective, according to software pioneer Alan Kay, can be worth 80 IQ points, and Haskellers agree on the dramatic benefits of thinking the Haskell way—thinking functionally, with type safety, mathematical certainty, and more. That's exactly what you'll learn to do in this hands-on book.

Among the best books on functional programming, Get Programming with Haskell guides you through a series of short lessons, examples, and exercises designed to help you become familiar with Haskell. It includes clear illustrations as well as guided practice. You will write and test dozens of interesting programs as well as explore custom Haskell modules. You will gain a new perspective on programming as well as the practical ability to use Haskell in your daily life.

What's on the Inside?

• Thinking in Haskell
• Functional programming basics
• Programming in types
• Real-world applications for Haskell

Author: Will Kurt

Link to buy: https://www.amazon.com/Get-Programming-Haskell-Will-Kurt/dp/1617293768

Ratings: 4.6 out of 5 stars (from 65 reviews)

Best Sellers Rank: #1,220,987 in Books

#109 in Functional Software Programming

#582 in Object-Oriented Design

#1,895 in Software Development (Books)

Eric Elliott is the founder of Greenruhm.com, a music metaverse social network where music makers, artists, and fans can build communities and share valuable digital music experiences, identity, belonging, VIP access, and collections. He has received a Webby nomination. He assisted in the development of BandPage (now YouTube Artist Pages), which hosted 500k bands such as Usher, Frank Ocean, Metallica, and others. He was an early Adobe Creative Cloud contributor and the technical lead on a video social network used by CBS, NBC, BBC, ESPN, WSJ, and others.

Composition underpins all software design: the act of breaking complex problems down into smaller problems and then composing those solutions. Most developers are unfamiliar with compositional techniques. It's past time to change that.

Eric Elliott shares the fundamentals of composition, including both function composition and object composition, in Composing Software, and explores them in the context of JavaScript. The book covers the fundamentals of both functional and object-oriented programming to help the reader understand how to construct and structure complex applications using simple building blocks.

You will discover:

• Functional programming
• Object composition
• How to work with composite data structures
• Closures
• Higher order functions
• Functors (e.g., array.map)
• Monads (e.g., promises)
• Transducers
• Lenses

All of this takes place in the context of JavaScript, the world's most popular programming language. But the education does not end there. These lessons will be applicable to any language. This book is about the timeless principles of software composition, and the lessons it teaches will outlast today's hot languages and frameworks. Unlike most programming books, this one may be relevant in 20 years.

Composing Software began as a popular blog post series that drew hundreds of thousands of readers and influenced the way software is built at many high-growth tech startups and Fortune 500 companies.

Author: Eric Elliott

Link to buy: https://www.amazon.com/Composing-Software-Exploration-Programming-Composition/dp/1661212565

Ratings: 4.7 out of 5 stars (from 33 reviews)

Best Sellers Rank: #1,298,481 in Books

#484 in JavaScript Programming (Books)

#2,034 in Software Development (Books)

#4,074 in Programming Languages (Books)

Dean Wampler specializes in data engineering for scalable streaming data systems and machine learning and artificial intelligence applications. He works at Domino Data Lab as a principal software engineer. He previously worked at Anyscale and Lightbend on scalable machine learning with Ray and distributed streaming data systems with Apache Spark, Apache Kafka, Kubernetes, and other tools.

Learn about Scala, the JVM, JavaScript, and natively compiled language that combines functional programming with a modern object model and an advanced type system in Programming Scala. Among the best books on functional programming, this comprehensive book, packed with code examples, shows you how to be productive with the language and ecosystem right away. You'll discover why Scala is ideal for creating today's highly scalable, data-centric applications while increasing developer productivity.

While Java remains popular and Kotlin is gaining popularity, Scala is not. This third edition incorporates updates throughout the book to cover the new features in Scala 3.0. Scala Programming is ideal for intermediate to advanced developers who want a thorough understanding of Scala's design philosophy and features with a strong practical focus.

• Scala's concise and flexible syntax allows you to program faster.
• Investigate fundamental and advanced functional programming techniques.
• Create fantastic big data and distributed apps with Scala's functional combinators and tools such as Spark and Akka.
• With the sophisticated type system, mixin composition with traits, pattern matching, and other features, you can create concise solutions to difficult design problems.

Author: Dean Wampler

Link to buy: https://www.amazon.com/Programming-Scala-Scalability-Functional-Objects/dp/1492077895

Ratings: 4.5 out of 5 stars (from 30 reviews)

Best Sellers Rank: #917,096 in Books

#77 in Functional Software Programming

#171 in Software Design & Engineering

#1,352 in Software Development (Books)