Bild otillgänglig
Färg:
-
-
-
- För att visa den här videonedladdningen Flash Player
Grokking Simplicity: Taming Complex Software with Functional Thinking Pocketbok – 11 Juni 2021
Summary
Distributed across servers, difficult to test, and resistant to modification--modern software is complex. Grokking Simplicity is a friendly, practical guide that will change the way you approach software design and development. It introduces a unique approach to functional programming that explains why certain features of software are prone to complexity, and teaches you the functional techniques you can use to simplify these systems so that they're easier to test and debug.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the technology
Developers rightly fear the unintended complexity that infects most code. This book shows you how to write software that keeps complexity close to its inherent minimum. As you write software you should distinguish between code that alters your system's state, and code that does not. Once you learn to make that distinction, you can refactor much of your state-altering "actions" into stateless "calculations." Your software will be simpler.
About the book
The book also teaches you to solve the complex timing bugs that inevitably creep into asynchronous and multithreaded code. In advanced sections of the book you learn how composable abstractions help avoid repeating code and open up new levels of expressivity.
What's inside
Patterns for simpler code
Powerful time modeling approaches to simplify asynchronous code
How higher-order functions can make code reusable and composable
About the reader
For intermediate and advanced developers building complex software. Exercises, illustrations, self-assessments, and hands-on examples lock in each new idea.
About the author
Eric Normand is an expert software developer who has been an influential teacher of functional programming since 2007.
Table of Contents
1 Welcome to Grokking Simplicity
2 Functional thinking in action
PART 1 - ACTIONS, CALCULATIONS, AND DATA
3 Distinguishing actions, calculations, and data
4 Extracting calculations from actions
5 Improving the design of actions
6 Staying immutable in a mutable language
7 Staying immutable with untrusted code
8 Stratified design, part 1
9 Stratified design, part 2
PART 2 - FIRST-CLASS ABSTRACTIONS
10 First-class functions, part 1
11 First-class functions, part 2
12 Functional iteration
13 Chaining functional tools
14 Functional tools for nested data
15 Isolating timelines
16 Sharing resources between timelines
17 Coordinating timelines
18 Reactive and onion architectures
19 The functional journey ahead
- Längd (tryckt bok)592 sidor
- UtgivareManning Publications
- Publiceringsdatum11 Juni 2021
- ISBN-101617296201
- ISBN-13978-1617296208
Kunder som tittade på denna artikel tittade även på
Product description
Om författaren
Produktinformation
- Utgivare : Manning Publications (11 Juni 2021)
- Pocketbok : 592 sidor
- ISBN-10 : 1617296201
- ISBN-13 : 978-1617296208
- Kundrecensioner:
Kundrecensioner
Kundrecensioner, inklusive stjärnrecensioner av produkter, hjälper kunder att lära sig mer om produkten och avgöra om det är rätt produkt för dem.
Vi använder inte ett enkelt medelvärde för att beräkna den totala stjärnrecensionen och den procentuella fördelningen per stjärna. Istället tar vårt system hänsyn till saker som till exempel hur nyligen en recension har gjorts och om recensenten köpte artikeln på Amazon. Det analyserar också recensioner för att verifiera deras trovärdighet.
Läs mer om hur kundrecensioner fungerar på AmazonPopuläraste recensionerna från andra länder
0 - 2 years: most of this book is understandable; you may need someone more senior to help you with the larger concepts
2 - 5 years: I can all but guarantee you will learn something extremely valuable from this book
5+ years: this book can remind you of things you forgot you knew as you guide those more junior
I can't wait for the sequel!
Definitely recommending this book to my colleagues. I’d put it up there with my personal favourites like Effective Java
I thought this book was brilliant. There are other books that cover functional programming in JS, but this actually makes the underlying concepts super clear, in an easy to understand way.
To note, this book does require that you at least understand some Javascript (or Java, or C... similar syntax). So it is NOT for complete beginners, but would probably be understandable for someone who has completed a Javascript basics or web development bootcamp.
Normand uses older syntax at the beginning of the book for a purpose. He later mentions more modern and functional array methods, but only after he explains why they exist and how to create them yourself. Having said that, I think this is one of the greatest didactic books on programming (and functional programming in particular) ever written. I'll leave my initial review untouched below:
---
Eric Normand has a gift for teaching, and explaining topics in simple terms. I came to this book already having an understanding of the basic concepts of functional programming, but wanted to fill in some gaps in my understanding. This book did that for me.
The one thing that remains a mystery for me, was why a book on functional JavaScript published in 2021, written by someone with an otherwise superb understanding of JavaScript, seems to not be aware of some JavaScript syntax that at this point can't really even be called "new".
For example, when talking about the "copy-on-write" principle, and how to copy objects, Normand tells us that we should use `var object_copy = Object.assign({}, object)`. That's OK, and the old way of doing it, but for years now JavaScript has had the spread operator, which works very well with a functional style: `const objectCopy = { ...object }`.
Notice also how Normand uses the older `var` instead of a `let` or `const`. There are a handful of other examples of older syntax, and missing current (and often, preferred) syntax.
This is really a small issue, even though I spent a lot of words on it. So don't let this deter you from the book. It's just that I love this book so much, that it pains me to see the lack of current syntax in places. Other than that, it will go down as one of my favorite programming books I've ever read, and it taught me a lot.
When Smalltalk and C++ were new, I recall the difficulties figuring out how to think in a new paradigm. It wasn't enough to learn the syntax, what we needed to do was figure out how to build large systems using classes and objects. Over the years object oriented methodologies and patterns emerged. Though I've been tinkering with functional programming for quite a while, crossing the chasm to building large systems has been elusive.
This book provides access to wisdom that I have been seeking for a long time. Personally I feel that it ranks with classics like "The Little Schemer" as one of the few books that has profoundly changed the way that I think about programming. It's hard to count how many times I thought about how the ideas in this book would have improved systems I've worked on. I wish I had this wisdom decades ago.