by Paul Chiusano and Rúnar Bjarnason · 13 Sep 2014
For more information on this and other Manning titles go to www.manning.com www.it-ebooks.info brief contents PART 1: INTRODUCTION TO FUNCTIONAL PROGRAMMING 1. What is functional programming? 2. Getting Started 3. Functional data structures 4. Handling errors without exceptions 5. Strictness and laziness 6. Purely functional state PART 2: FUNCTIONAL
…
-ebooks.info 1 P Preface P.1 About this book This is not a book about Scala. This book introduces the concepts and techniques of functional programming (FP)—we use Scala as the vehicle, but the lessons herein can be applied to programming in any language. Our goal is to give you
…
the foundations to begin writing substantive functional programs and to comfortably absorb new FP concepts and techniques beyond those covered here. Throughout the book we rely heavily on programming exercises, carefully chosen and
…
to further reading. P.2 How to read this book The book is organized into four parts, intended to be read sequentially. Part 1 introduces functional programming, explains what it is, why you should care, and walks through the basic low-level techniques of FP, including how to organize and structure small
…
can explore on your own if that interests you. Have fun and good luck. www.it-ebooks.info 5 1 What is Functional Programming? 1.1 The fundamental premise of functional programming Functional programming (FP) is based on a simple premise with far-reaching implications: We construct our programs using only pure functions. In other words
…
that we can still write all of the same programs—programs that can do all of the above and more—without resorting to side effects. Functional programming is a restriction on how we write programs, but not on what programs we can write. And it turns out that accepting this restriction is
…
3mIn practice, programmers don't spend time mechanically applying substitution to determine if code is pure—it will usually be quite obvious. 1.4 Why functional programming? We said that applying the discipline of FP buys us greater modularity. Why is this the case? Though this will become more clear over the
…
to be illustrative, and the sort of factoring we did here is something you've perhaps done many times before. It's been said that functional programming, at least in small examples, is just normal separation of concerns and "good software engineering". We will be taking the idea of FP to its
…
the outside that handles effects. We will return to this principle again and again throughout the book. 1.5 Conclusion In this chapter, we introduced functional programming and explained exactly what FP is and why you might use it. In subsequent chapters, we cover some of the fundamentals—how do we write
…
write programs in the Scala language just by combining pure functions. This chapter is mainly intended for those readers who are new to Scala, to functional programming, or both. As with learning a foreign language, immersion is a very effective method, so we will start by looking at a small but complete
…
many more examples of this throughout this book. www.it-ebooks.info 24 2.5.1 Annonymous functions Functions get passed around so often in functional programming that it's convenient to have a lightweight way to declare a function, locally, without having to give it a name. Scala provides a syntax
…
stick things together using the local 'rules of the universe' established by the type signature. The style of reasoning required here is very common in functional programming—we are simply manipulating symbols in a very abstract way, similar to how we would reason when solving an algebraic equation. EXERCISE 4 (hard): Let
…
of the style of reasoning and thinking you'll use when writing such functions. 2.7 Conclusion In this chapter we have learned some preliminary functional programming concepts, and enough Scala to get going. We learned how to define simple functions and programs, including how we can express loops using recursion, then
…
functional programming, how do we define them in Scala, and how do we operate over these data structures? In this chapter we will learn the concept of
…
structure and how to define and work with such structures. We'll use this as an opportunity to introduce how data types are defined in functional programming, learn about the related technique of pattern matching, and get practice writing and generalizing pure functions. This chapter has a lot of exercises, particularly to
…
concern of evaluation makes our descriptions more reusable than when these concerns are intertwined. This kind of separation of concerns is a central theme in functional programming. EXERCISE 4: Implement forAll, which checks that all elements in the www.it-ebooks.info 71 Stream match a given predicate. Your implementation should terminate
…
. These terms aren't that important to our www.it-ebooks.info 74 discussion, but you will hear them used sometimes in the context of functional programming. If you are curious to learn where they come from and understand some of the deeper connections, follow the references in the chapter notes. EXERCISE
…
by receiving it in their argument, and they write to the program state simply by returning a value. SIDEBAR Aren't imperative and functional programming opposites? Absolutely not. Remember, functional programming is simply programming without side-effects. Imperative programming is about programming with statements that modify some program state, and as we've seen
…
it's entirely reasonable to maintain state without side-effects. Functional programming has excellent support for writing imperative programs, with the added benefit that such programs can be reasoned about equationally because they are referentially transparent. We
…
little adventures. You don't need any special license to do this sort of exploration, and you don't need to be an expert in functional programming either. Just dive in and see what you find. Let's see if we can avoid the above pitfall of combining unit and get. If
…
to state and prove properties about an API. This certainly isn't something typically done in ordinary programming. Why is it important in FP? In functional programming, it is easy, and expected, that we will factor out common functionality into generic, reusable, components that can be composed. Side effects hurt compositionality, but
…
" is already a perfectly good name in common use. The name comes from category theory, a branch of mathematics that has inspired a lot of functional programming concepts. The name "monad" is intentionally similar to "monoid", and the two concepts are related in a deep way. See the chapter notes for more
…
and mutable state 14.1 Introduction In the first chapter of this book we introduced the concept of referential transparency, setting the premise for purely functional programming. We declared that pure functions cannot mutate data in place or interact with the external world. In the previous chapter on I/O, we learned
…
to some programs and not others. 14.2 Purely functional mutable state Up until this point, you may have had the impression that in purely functional programming we're not allowed to use mutable state. But if we look carefully, there is nothing about the definitions of referential transparency and purity that
…
intensionality www.it-ebooks.info 266 15 Stream processing and incremental I/O 15.1 Introduction We said in the introduction to part 4 that functional programming is a complete paradigm. Any program that can be imagined can be expressed functionally, including those that interact with the external world. But it would
…
the IO monad, we have to reason about our programs much like we would in ordinary imperative programming. We can do better. Not only can functional programs embed arbitrary imperative programs; in this chapter we show how to recover the high-level, compositional style developed in parts 1-3 of this book
…
small. While good design is always hard, over time, expressing code functionally becomes effortless. By this point, you have all the tools needed to start functional programming, no matter the programming task. FP is a deep subject, and as you apply it to more problems, new ideas and techniques will emerge. Enjoy
by Andrew Johnson · 29 May 2018 · 303pp · 57,177 words
specific hot topic that we are recruiting an author for, or submit your own idea. Table of Contents Title Page Copyright and Credits Hands-On Functional Programming in Rust Packt Upsell Why subscribe? PacktPub.com Contributors About the author About the reviewer Packt is searching for authors like you Preface Who this
…
is for What this book covers To get the most out of this book Download the example code files Conventions used Get in touch Reviews Functional Programming – a Comparison Technical requirements Reducing code weight and complexity Making generics more generic Functions as values Iterators Compact legible expressions Strict abstraction means
…
safe abstraction Scoped data binding Algebraic datatypes Mixing object-oriented programming and functional programming Improving project architecture File hierarchy, modules, and namespace design Functional design patterns Metaprogramming Summary Questions Further reading Functional Control Flow Technical requirements Designing the
…
instead of stringly typed interfaces Using the heartbeat pattern for long running processes Validating input and output Finding and fixing bugs Metaprogramming Summary Questions Assessments Functional Programming – a Comparison Functional Control Flow Functional Data Structures Generics and Polymorphism Code Organization and Application Architecture Mutability, Ownership, and Pure Functions Design
…
Enjoy Leave a review - let other readers know what you think Preface Thanks for your interest in functional programming in Rust. Rust is a very young programming language and is particularly new to the functional programming community. Despite its age, the language provides a wealth of tools that are both practical and sophisticated
…
. In this book, we will introduce general functional programming principles and how they apply to Rust specifically. Our goal is to provide knowledge and a perspective on Rust that will outlast small changes to
…
Similarly, some concepts that are only briefly explained in the introductory material will be explained in detail. What this book covers Chapter 1, Functional Programming – a Comparison, introduces functional programming in Rust. Comparisons are drawn between functional style and other paradigms that are prevalent or influential to Rust. The chapter also serves as a
…
Functional Control Flow, introduces Rust control flow structures while explaining how they are relevant to the functional style of programming. The expression-centric nature of functional programming and Rust is illustrated through examples. Limiting as it may be, the chapter also begins an ongoing project using only the procedural expression style of
…
Structures, introduces the reader to the various, highly expressive data types available in Rust. Notably, the enum type is introduced, which holds particular significance in functional programming. The project continues to grow to incorporate a variety of these data types. Chapter 4, Generics and Polymorphism, explains the concepts of parameterization of data
…
thus no engineering procedure can capture the nuances of software development. In this chapter, we provide the best tools available, and specifically, the best that functional programming has to offer. Chapter 6, Mutability, Ownership, and Pure Functions, digs into some of the more unique features in Rust. This chapter introduces the concepts
…
spaghetti that a naive Rust programmer might generate when attempting to circumvent the rules of ownership in Rust. Chapter 7, Design Patterns, lists as many functional programming cheat codes that can fit into a single chapter. The concept of functors and monads are explained with examples and some casual definitions. The chapter
…
for Mac 7-Zip/PeaZip for Linux The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-Rust. In case there's an update to the code, it will be updated on the existing GitHub repository. We also have other
…
about our products, and our authors can see your feedback on their book. Thank you! For more information about Packt, please visit packtpub.com. Functional Programming – a Comparison Functional programming (FP) is the second most popular programming paradigm, behind only object-oriented programming (OOP). For many years, these two paradigms have been separated into
…
https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub, here: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Reducing code weight and complexity
…
Functional programming can greatly reduce the amount and complexity of code required to accomplish tasks. Particularly in Rust, proper application of functional principles may simplify the
…
<F,T>(f: F, x: T) -> T where F: Fn(T) -> T { f(x) } Functions as values Functions are nominally the big feature of functional programming. Specifically, functions as values are the keystone of the whole paradigm. Glossing over much detail, we will also introduce the term closure here for future
…
|x,y| x+y); Iterators Iterators are a common feature of OOP languages, and Rust supports this concept well. Rust iterators are also designed with functional programming in mind, allowing programmers to write more legible code. The specific concept emphasized here is composability. When iterators can be manipulated, transformed, and combined, the
…
or simple deadlock, then the compiler will stop you. We call this fearless concurrency. Algebraic datatypes In addition to structs/objects and functions/methods, Rust functional programming includes some rich additions to definable types and structures. Tuples provide a shorthand for defining simple anonymous structs. Enums provide a type-safe approach to
…
following code snippet, in intro_datatypes.rs: trait BehaviorOfShow { fn show(&self) -> String; } Mixing object-oriented programming and functional programming As mentioned before, Rust supports much of both object-oriented and functional programming styles. Datatypes and functions are neutral to either paradigm. Traits specifically support a hybrid blend of both styles. First, in
…
} } fn get_a(&self) -> u32 { self.a } fn get_b(&self) -> f32 { self.b } fn get_c(&self) -> String { self.c.clone() } } Adding support for functional programming onto an object is as simple as defining traits and methods that use functional language features. For example, accepting a closure can become a great
…
F: Fn(u32,f32,String) -> R { f(self.a, self.b, self.c.clone()) } } Improving project architecture Functional programs encourage good project architecture and principled design patterns. Using the building blocks of functional programming often reduces the number of design choices to be made in such a way that good options become obvious
…
extern crate package; use package::inner_module::f1; These are the basic building blocks of Rust modules, but what does this have to do with functional programming? Architecting a project in functional style is a process, and lends itself to certain routines. Typically, the project architect will start by designing the core
…
provided: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Designing the program To design the program, let
…
the function would potentially call itself again. When a function calls itself, this is called recursion. Recursion is an extremely common and important pattern in functional programming. However, this specific type of recursion, known as tail recursion, is not recommended in Rust currently (see RFC #271 (https://github.com/rust-lang/
…
: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Adjusting to changing the scope of the project
…
provided: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Staying productive during downtime There will be some
…
provided: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Shipping a product without sacrificing quality The client
…
MotorController1 { ... } //Motor Controller 2 ... //Motor Controller 3 ... The entire code for these is present in the GitHub repository at: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST. Writing the buildings.rs module The building module is again grouped by type. There should be a common trait interface that is implemented
…
developer from certain classes of errors, such as double free memory or hanging pointers, but also create constraints that can feel unmerited at times. Functional programming may help ease some of this conflict by encouraging the use of immutable data and pure functions. In this chapter, we will look at a
…
provided: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Recognizing anti-patterns of ownership Consider the following
…
problems. In the next chapter, we will formally explain many functional design patterns. This will be a good opportunity to learn the extent to which functional programming principles apply and are relevant to Rust. If nothing in the next chapter seems cool or useful, then the author has failed. Questions What
…
and ownership? How can you be sure that a function is safe? What is memory corruption and how would it affect a program? Design Patterns Functional programming has developed design patterns just like object-oriented or other communities. These patterns, unsurprisingly, make use of functions as a central concept. They also emphasize
…
provided: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Using the functor pattern A functor is approximately
…
provided: https://www.rust-lang.org/en-US/install.html This chapter's code is also available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Using subprocess concurrency A subprocess is a command
…
through most problems. Using functional design for concurrency Concurrency forces the programmer to be more careful about information sharing. This difficulty coincidentally encourages good functional programming practices, such as immutable data and pure functions; when computation is not context-sensitive, it tends to also be thread-safe
…
are many trade-offs in concurrent programming. Letting the programmer make decisions regarding these trade-offs is the current state-of-the-art. So, from functional programming, what patterns have proven useful? There are many patterns for concurrent programming, but here we will introduce a few primitives: Actors: Threads and patterns
…
two threads sending messages back and forth. Is this really much different than any of the previous examples? There is a fairly common saying in functional programming that "a closure is a poor man's object, and an object is a poor man's closure". According to object-oriented programming, objects
…
. In the design pattern section, we introduced the actor design pattern. This popular technique combines some elements of object-oriented programming with other concepts from functional programming. The result is a programming tool designed specifically for complex resilient concurrency. In the next chapter, we will explore performance, debugging, and metaprogramming. Performance
…
examples provided: https://www.rust-lang.org/en-US/install.html This chapter's code is available on GitHub: https://github.com/PacktPublishing/Hands-On-Functional-Programming-in-RUST Specific installation and build instructions are also included in each chapter's README.md file. Writing faster code Premature optimization is the root
…
, address = 0x000000010000191c Now that our breakpoint is set, run the r command: (lldb) r Process 99468 launched: '/Users/andrewjohnson/subarctic.org/subarctic.org/Hands-On-Functional-Programming-in-RUST/Chapter09/target/debug/deps/performance_polynomial3-8048e39c94dd7157' (x86_64) Process 99468 stopped * thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint
…
and practical considerations for Rust programming. Performance and debugging are certainly not problems that are exclusive to Functional Programming. Here we tried to introduce tips that are generally applicable but also highly compatible with functional programming. Metaprogramming in Rust may be considered a functional feature by itself. Logic programming and thereby derived functionality
…
book. There is an enormous amount of material available on these subjects and any path taken will surely further improve your understanding of Rust and functional programming. Questions How is release mode different from debug mode? How long will an empty loop take to run? What is linear time in Big
…
with multiple error conditions? What is a token tree? What is an abstract syntax tree? Why do procedural macros need to be compiled separately? Assessments Functional Programming – a Comparison What is a function? A function defines a transformation, accepts data, and returns the result of the transformation. What is a functor?
by Gil Durán · 17 Aug 2026 · 317pp · 114,570 words
. in a story headlined “Controversy Rages Over ‘Pro-Slavery’ Tech Speaker Curtis Yarvin.” “Some sponsors have dropped out. A website has appeared for an alternative functional programming conference called MoonConf, slated for the same dates and in the same city as LambdaConf.” Yarvin responded with a long post in which, addressing conference
by David Sawyer McFarland · 28 Oct 2011 · 924pp · 196,343 words
’s HTML has loaded before the browser executes any of the JavaScript programming. That function also accepts an anonymous function as an argument: $(document).ready(function() { // programming goes inside this // anonymous function }); this and $(this) When using the each() function, you’ll naturally want to access or set attributes of each element
…
You’ll also find JavaScript debuggers with similar functionality in Chrome, Opera, Safari, and Internet Explorer 9. Debugging is the process of fixing an incorrectly functioning program—getting the bugs out. To really understand how a program is functioning (or malfunctioning), you need to see how the program works, step-by-step
by Chris Eagle · 16 Jun 2011 · 1,156pp · 229,431 words
by Eldad Eilam · 15 Feb 2005 · 619pp · 210,746 words
of it. In the software world, this translates to seemingly innocent files that actually contain some kind of malicious code underneath. Most Trojans are actually functional programs, so that the user never becomes aware of the problem; the functional element in the program works just fine, while the malicious element works behind
by Robert Mecklenburg and Andrew Oram · 19 Nov 2004 · 471pp · 94,519 words
by Paul Graham · 8 Sep 1993 · 423pp · 21,637 words
Why Lisp (or When) Functions Functions as Data Defining Functions Functional Arguments Functions as Properties Scope Closures Local Functions Tail-Recursion Compilation Functions from Lists Functional Programming Functional Design Imperative Outside-In Functional Interfaces Interactive Programming Utility Functions Birth of a Utility Invest in Abstraction Operations on Lists Search Mapping I/O
…
begins with several chapters on functions. Chapter 2 explains what Lisp functions are and the possibilities they offer. Chapter 3 then discusses the advantages of functional programming, the dominant style in Lisp programs. Chapter 4 shows how to use functions to extend Lisp. Then Chapter 5 suggests the new kinds of abstractions
…
are so powerful, for example. Most of the techniques described in this book depend on the ability to write programs which manipulate Lisp expressions. * * * 3. Functional Programming The previous chapter explained how Lisp and Lisp programs are both built out of a single raw material: the function. Like any building material, its
…
overall shape of the building what it's made of. The character of Lisp functions has a similar influence on the structure of Lisp programs. Functional programming means writing programs which work by returning values instead of by performing side-effects. Side-effects include destructive changes to objects (e.g. by rplaca
…
to read, test, and debug. Lisp programs have not always been written in this style, but over time Lisp and functional programming have gradually become inseparable. An example will show how functional programming differs from what you might do in another language. Suppose for some reason we want the elements of a list in
…
Lisp has it built-in. It is worth looking briefly at this function, because it is one that often brings to the surface misconceptions about functional programming. Like good-reverse,the built-in reverseworks by returning a value--it doesn't touch its arguments. But people learning Lisp may assume that, like
…
, remove, or substitute. If you want side-effects, use setq on the return value. This very rule suggests that some side-effects are inevitable. Having functional programming as an ideal doesn't imply that programs should never have side-effects. It just means that they should have no more than necessary. It
…
(x) (values x (sqrt x) (expt x 2))) POWERS > (multiple-value-bind (base root square) (powers 4) (list base root square)) (4 2.0 16) Functional programming is a good idea in general. It is a particularly good idea in Lisp, because Lisp has evolved to support it. Built-in operators like
…
, like values and multiple-value-bind, have been provided specifically to make functional programming easier. 3.2 Imperative Outside-In The aims of functional programming may show more clearly when contrasted with those of the more common approach, imperative programming. A functional program tells you what it wants; an imperative program tells you what to do
…
on dry land--if you use skates. Till then you will be left wondering what people see in this sport. What skates are to ice, functional programming is to Lisp. Together the two allow you to travel more gracefully, with less effort. But if you are accustomed to another mode of travel
…
more as a source of contagion than a source of pleasure. Usually it would be bad style to write such a macro. The ideal of functional programming applies as well to macros: the preferred way to communicate with a macro is through its parameters. Indeed, it is so rarely necessary to use
…
they return in much the same way that functions return values. In fact, with the exception of being nondeterministic, ATNs behave a lot like a functional programming language. The ATN defined in Figure 23.1 is nearly the simplest possible. It parses noun-verb sentences of the form "Spot runs." The network
by Robert Sedgewick · 2 Jan 1992
by Tom White · 29 May 2009 · 933pp · 205,691 words
building production search indexes because they found themselves solving the same problem over and over again (and MapReduce was inspired by older ideas from the functional programming, distributed computing, and database communities), but it has since been used for many other applications in many other industries. It is pleasantly surprising to see
by Unknown · 2 Jan 2010 · 448pp · 71,301 words
by Francesco Cesarini · 496pp · 70,263 words
by Unknown
by Graham Hutton · 31 Aug 2016
by Roberto Ierusalimschy · 14 Jul 2016 · 489pp · 117,470 words
by Stuart Halloway and Aaron Bedra · 17 Apr 2012 · 536pp · 73,482 words
by Tom Kleenex and Joshua Suereth · 2 Jan 2010 · 554pp · 108,035 words
by Chas Emerick, Brian Carper and Christophe Grand · 15 Aug 2011 · 999pp · 194,942 words
by Scott Meyers · 16 Jun 2001 · 474pp · 91,222 words
by Toby Segaran · 17 Dec 2008 · 519pp · 102,669 words
by Anthony Williams · 1 Jan 2009 · 818pp · 153,952 words
by Marijn Haverbeke · 15 Nov 2018 · 560pp · 135,629 words
by Bryan O'Sullivan, John Goerzen, Donald Stewart and Donald Bruce Stewart · 2 Dec 2008 · 1,065pp · 229,099 words
by Graham Hutton · 5 Feb 2007 · 184pp · 13,957 words
by Wes McKinney · 30 Dec 2011 · 752pp · 131,533 words
by Miran Lipovaca · 17 Apr 2011 · 559pp · 130,949 words
by Harold Abelson, Gerald Jay Sussman and Julie Sussman · 1 Jan 1984 · 1,387pp · 202,295 words
by Michael Fogus and Chris Houser · 28 Nov 2010 · 706pp · 120,784 words
by Richard Bird · 15 Sep 2010
by Kees Doets, Jan van Eijck and Jan Eijck · 15 Jan 2004
by Benjamin C. Pierce · 4 Jan 2002 · 647pp · 43,757 words
by Axel Rauschmayer · 3 Oct 2015
by Kevlin Henney · 5 Feb 2010 · 292pp · 62,575 words
by Jeff Forcier
by Lee Phillips · 15 Feb 2012 · 199pp · 47,154 words
by Stuart Russell and Peter Norvig · 14 Jul 2019 · 2,466pp · 668,761 words
by Peter Seibel · 22 Jun 2009 · 1,201pp · 233,519 words
by Shayne Fletcher and Christopher Gardner · 3 Aug 2009 · 246pp · 16,997 words
by Nathan L. Ensmenger · 31 Jul 2010 · 429pp · 114,726 words
by Steven Bird, Ewan Klein and Edward Loper · 15 Dec 2009 · 504pp · 89,238 words
by Federico Biancuzzi and Shane Warden · 21 Mar 2009 · 496pp · 174,084 words
by L.G. Meredith · 214pp · 14,382 words
by Stuart Sierra and Luke Vanderhart · 24 Oct 2012 · 135pp · 31,098 words
by Christopher Allen and Julie Moronuki · 1 Jan 2015 · 1,076pp · 67,364 words
by Peter Van-Roy and Seif Haridi · 15 Feb 2004 · 931pp · 79,142 words
by Vaughn Vernon · 16 Aug 2015
by Scott Donaldson, Stanley Siegel and Gary Donaldson · 13 Jan 2012 · 458pp · 135,206 words
by Scott Rosenberg · 2 Jan 2006 · 394pp · 118,929 words
by Jim Blandy and Jason Orendorff · 21 Nov 2017 · 1,331pp · 183,137 words
by Steve Klabnik and Carol Nichols · 14 Jun 2018 · 821pp · 178,631 words
by Chris Hanson and Gerald Sussman · 17 Feb 2021
by Robert P. Baker · 4 Oct 2015
by Joel Spolsky · 25 Jun 2008 · 292pp · 81,699 words
by Zed Shaw · 1 Jan 2010 · 249pp · 45,639 words
by Q. Ethan McCallum · 14 Nov 2012 · 398pp · 86,855 words
by Ray Kurzweil · 14 Jul 2005 · 761pp · 231,902 words
by Harold Abelson, Gerald Jay Sussman and Julie Sussman · 25 Jul 1996 · 893pp · 199,542 words
by Michael Snoyman · 22 Apr 2012 · 485pp · 74,211 words
by Douglas Crockford · 15 Nov 2008 · 273pp · 46,214 words
by Michael Feathers · 14 Jul 2004 · 508pp · 120,339 words
by Ben Goertzel and Pei Wang · 1 Jan 2007 · 303pp · 67,891 words
by Benjamin H. Bratton · 19 Feb 2016 · 903pp · 235,753 words
by Diomidis Spinellis and Georgios Gousios · 30 Dec 2008 · 680pp · 157,865 words
by Axel Rauschmayer · 25 Feb 2014 · 692pp · 95,244 words
by Andreas M. Antonopoulos and Gavin Wood Ph. D. · 23 Dec 2018 · 960pp · 125,049 words
by Jan Kunigk, Ian Buss, Paul Wilkinson and Lars George · 8 Jan 2019 · 1,409pp · 205,237 words
by Drew Neil · 2 May 2018 · 241pp · 43,252 words
by Bjarne Stroustrup · 2 Jan 1986 · 923pp · 516,602 words
by Norman Matloff · 404pp · 43,442 words
by Malestrom
by Nicholas Monje, Allen Downey
by Joshua B. Smith · 30 Sep 2006
by Amy Brown and Greg Wilson · 24 May 2011 · 834pp · 180,700 words
by Nilanjan Raychaudhuri · 27 Mar 2012
by Robin Sharp · 13 Feb 2008
by Erik Westra · 23 May 2013
by Martin Kleppmann · 17 Apr 2017
by Patrick Mulder · 18 Jun 2014 · 190pp · 52,865 words
by Martin L. Abbott and Michael T. Fisher · 1 Dec 2009
by David Gerard · 23 Jul 2017 · 309pp · 54,839 words
by Fabio Nelli · 27 Sep 2018 · 688pp · 107,867 words
by Titus Winters, Tom Manshreck and Hyrum Wright · 17 Mar 2020 · 214pp · 31,751 words
by Simon St.Laurent and J. David Eisenberg · 20 Dec 2016
by John Ousterhout · 28 Jan 2018 · 211pp · 58,677 words
by Martin Kleppmann · 16 Mar 2017 · 1,237pp · 227,370 words
by Ben Grynhaus, Jordan Hudgens, Rayon Hunte, Matthew Thomas Morgan and Wekoslav Stefanovski · 28 Jul 2021 · 739pp · 174,990 words
by Boris Cherny · 16 Apr 2019 · 629pp · 83,362 words
by Paul Raines and Jeff Tranter · 25 Mar 1999 · 1,064pp · 114,771 words
by Kevin C. Baird · 1 Jun 2007 · 309pp · 65,118 words
by Martin Odersky, Lex Spoon and Bill Venners · 15 Jan 2008 · 754pp · 48,930 words
by Venkat Subramaniam · 1 May 2009 · 226pp · 17,533 words
by Timothy Budd · 17 Feb 2009 · 263pp · 20,730 words
by Noah Gift and Jeremy M. Jones · 29 Jun 2009 · 603pp · 141,814 words
by Steve Oualline · 15 Nov 2011 · 544pp · 96,029 words
by Paul Graham · 12 Nov 1995 · 450pp · 569 words
by Zachary Kessin · 9 May 2011 · 210pp · 42,271 words
by Thomas A. Limoncelli, Strata R. Chalup and Christina J. Hogan · 27 Aug 2014 · 757pp · 193,541 words
by Olivier Cure and Guillaume Blin · 10 Dec 2014
by Saša Jurić · 30 Jan 2019
by Kenneth Payne · 16 Jun 2021 · 339pp · 92,785 words
by Dan Bader · 14 Oct 2017 · 262pp · 60,248 words
by Steve Klabnik and Carol Nichols · 27 Feb 2023 · 648pp · 183,275 words
by Lars George · 29 Aug 2011
by Mark Jason Dominus · 14 Mar 2005 · 525pp · 149,886 words
by Yuxing Yan · 24 Apr 2014 · 408pp · 85,118 words
by Chris Okasaki · 12 Apr 1998 · 230pp
by Marc Wandschneider · 18 Jun 2013
by Ray Kurzweil · 31 Dec 1998 · 696pp · 143,736 words
by M. Mitchell Waldrop · 14 Apr 2001
by Regina O. Obe and Leo S. Hsu · 2 May 2015
by James Turnbull · 1 Dec 2014 · 514pp · 111,012 words
by Will Larson · 19 May 2019 · 227pp · 63,186 words
by Dipanjan Sarkar · 1 Dec 2016
by Vikram Chandra · 7 Nov 2013 · 239pp · 64,812 words
by Unknown · 13 Jan 2012 · 470pp · 109,589 words
by Michael S Collins · 23 Feb 2014 · 446pp · 102,421 words
by Aaron Swartz and Lawrence Lessig · 5 Jan 2016 · 377pp · 110,427 words
by Yevgeniy Brikman · 13 Mar 2017
by Trey Grainger and Timothy Potter · 14 Sep 2014 · 1,085pp · 219,144 words
by Nick Montfort and Ian Bogost · 9 Jan 2009
by Regina O. Obe and Leo S. Hsu · 2 May 2015
by Joel Spolsky · 1 Jun 2007 · 194pp · 36,223 words
by Ivan Idris · 23 Jun 2015 · 681pp · 64,159 words
by Andrea Passaglia · 27 Apr 2017 · 550pp · 84,515 words
by David Graeber · 14 May 2018 · 385pp · 123,168 words
by Anna Wiener · 14 Jan 2020 · 237pp · 74,109 words
by Dr. Axel Rauschmayer · 14 Apr 2020
by Rob Kitchin,Tracey P. Lauriault,Gavin McArdle · 2 Aug 2017
by Arvid Kahl · 24 Jun 2020 · 461pp · 106,027 words
by David Flanagan · 15 Dec 2010 · 211pp · 37,094 words
by Pete Warden · 20 Sep 2011 · 58pp · 12,386 words
by Witold Rybczynski · 2 Sep 2002 · 317pp · 76,169 words