Muutke küpsiste eelistusi

E-raamat: Functional and Concurrent Programming: Core Concepts and Features

5.00/5 (10 hinnangut Goodreads-ist)
  • Formaat: 528 pages
  • Ilmumisaeg: 16-Nov-2022
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780137466580
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 38,60 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Functional and Concurrent Programming: Core Concepts and FeaturesSuurem pilt
  • Formaat: 528 pages
  • Ilmumisaeg: 16-Nov-2022
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780137466580
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Leverage Modern Language Constructs to Write High-Quality Code Faster

The functional and concurrent programming language features supported by modern languages can be challenging, even for experienced developers. These features may appear intimidating to OOP programmers because of a misunderstanding of how they work. Programmers first need to become familiar with the abstract concepts that underlie these powerful features.

In Functional and Concurrent Programming, Michel Charpentier introduces a core set of programming language constructs that will help you be productive in a variety of programming languagesnow and in the future. Charpentier illustrates key concepts with numerous small, focused code examples, written in Scala, and with case studies that provide a thorough grounding in functional and concurrent programming skills. These skills will carry from language to languageincluding the most recent incarnations of Java. Using these features will enable developers and programmers to write high-quality code that is easier to understand, debug, optimize, and evolve.

Key topics covered include:





Recursion and tail recursion Pattern matching and algebraic datatypes Persistent structures and immutability Higher-order functions and lambda expressions Lazy evaluation and streams Threads and thread pools Atomicity and locking Synchronization and thread-safe objects Lock-free, non-blocking patterns Futures, promises, and functional-concurrent programming



As a bonus, the book includes a discussion of common typing strategies used in modern programming languages, including type inference, subtyping, polymorphism, type classes, type bounds, and type variance.

Most of the code examples are in Scala, which includes many of the standard features of functional and concurrent programming; however, no prior knowledge of Scala is assumed. You should be familiar with concepts such as classes, methods, objects, types, variables, loops, and conditionals and have enough programming experience to not be distracted by simple matters of syntax.
Foreword xxiii
Cay Horstmann
Preface xxv
Acknowledgments xxxv
About the Author xxxvii
Part I Functional Programming
1(214)
Chapter 1 Concepts of Functional Programming
3(6)
1.1 What Is Functional Programming?
3(1)
1.2 Functions
4(2)
1.3 From Functions to Functional Programming Concepts
6(1)
1.4 Summary
7(2)
Chapter 2 Functions in Programming Languages
9(12)
2.1 Defining Functions
9(1)
2.2 Composing Functions
10(2)
2.3 Functions Defined as Methods
12(1)
2.4 Operators Defined as Methods
12(1)
2.5 Extension Methods
13(1)
2.6 Local Functions
14(1)
2.7 Repeated Arguments
15(1)
2.8 Optional Arguments
16(1)
2.9 Named Arguments
16(1)
2.10 Type Parameters
17(2)
2.11 Summary
19(2)
Chapter 3 Immutability
21(18)
3.1 Pure and Impure Functions
21(2)
3.2 Actions
23(2)
3.3 Expressions Versus Statements
25(1)
3.4 Functional Variables
26(2)
3.5 Immutable Objects
28(1)
3.6 Implementation of Mutable State
29(2)
3.7 Functional Lists
31(1)
3.8 Hybrid Designs
32(3)
3.9 Updating Collections of Mutable/Immutable Objects
35(1)
3.10 Summary
36(3)
Chapter 4 Case Study: Active-Passive Sets
39(8)
4.1 Object-Oriented Design
39(2)
4.2 Functional Values
41(2)
4.3 Functional Objects
43(1)
4.4 Summary
44(3)
Chapter 5 Pattern Matching and Algebraic Data Types
47(16)
5.1 Functional Switch
47(1)
5.2 Tuples
48(2)
5.3 Options
50(1)
5.4 Revisiting Functional Lists
51(2)
5.5 Trees
53(3)
5.6 Illustration: List Zipper
56(3)
5.7 Extractors
59(1)
5.8 Summary
60(3)
Chapter 6 Recursive Programming
63(16)
6.1 The Need for Recursion
63(2)
6.2 Recursive Algorithms
65(2)
6.3 Key Principles of Recursive Algorithms
67(2)
6.4 Recursive Structures
69(2)
6.5 Tail Recursion
71(2)
6.6 Examples of Tail Recursive Functions
73(4)
6.7 Summary
77(2)
Chapter 7 Recursion on Lists
79(20)
7.1 Recursive Algorithms as Equalities
79(1)
7.2 Traversing Lists
80(2)
7.3 Returning Lists
82(2)
7.4 Building Lists from the Execution Stack
84(1)
7.5 Recursion on Multiple/Nested Lists
85(3)
7.6 Recursion on Sublists Other Than the Tail
88(2)
7.7 Building Lists in Reverse Order
90(2)
7.8 Illustration: Sorting
92(2)
7.9 Building Lists Efficiently
94(2)
7.10 Summary
96(3)
Chapter 8 Case Study: Binary Search Trees
99(16)
8.1 Binary Search Trees
99(1)
8.2 Sets of Integers as Binary Search Trees
100(2)
8.3 Implementation Without Rebalancing
102(5)
8.4 Self-Balancing Trees
107(6)
8.5 Summary
113(2)
Chapter 9 Higher-Order Functions
115(22)
9.1 Functions as Values
115(3)
9.2 Currying
118(2)
9.3 Function Literals
120(3)
9.4 Functions Versus Methods
123(1)
9.5 Single-Abstract-Method Interfaces
124(1)
9.6 Partial Application
125(5)
9.7 Closures
130(3)
9.8 Inversion of Control
133(1)
9.9 Summary
133(4)
Chapter 10 Standard Higher-Order Functions
137(20)
10.1 Functions with Predicate Arguments
137(3)
10.2 Map and foreach
140(1)
10.3 flatMap
141(5)
10.4 Fold and reduce
146(2)
10.5 iterate, tabulate, and unfold
148(1)
10.6 sortWith, sortBy, maxBy, and minBy
149(1)
10.7 groupBy and groupMap
150(2)
10.8 Implementing Standard Higher-Order Functions
152(1)
10.9 foreach, map, flatMap, and for-Comprehensions
153(2)
10.10 Summary
155(2)
Chapter 11 Case Study: File Systems as Trees
157(16)
11.1 Design Overview
157(1)
11.2 A Node-Searching Helper Function
158(1)
11.3 String Representation
158(2)
11.4 Building Trees
160(4)
11.5 Querying
164(4)
11.6 Navigation
168(1)
11.7 Tree Zipper
169(3)
11.8 Summary
172(1)
Chapter 12 Lazy Evaluation
173(22)
12.1 Delayed Evaluation of Arguments
173(1)
12.2 By-Name Arguments
174(2)
12.3 Control Abstraction
176(3)
12.4 Internal Domain-Specific Languages
179(1)
12.5 Streams as Lazily Evaluated Lists
180(2)
12.6 Streams as Pipelines
182(2)
12.7 Streams as Infinite Data Structures
184(1)
12.8 Iterators
184(3)
12.9 Lists, Streams, Iterators, and Views
187(3)
12.10 Delayed Evaluation of Fields and Local Variables
190(1)
12.11 Illustration: Subset-Sum
191(2)
12.12 Summary
193(2)
Chapter 13 Handling Failures
195(10)
13.1 Exceptions and Special Values
195(2)
13.2 Using Option
197(1)
13.3 Using Try
198(1)
13.4 Using Either
199(2)
13.5 Higher-Order Functions and Pipelines
201(3)
13.6 Summary
204(1)
Chapter 14 Case Study: Trampolines
205(10)
14.1 Tail-Call Optimization
205(1)
14.2 Trampolines for Tail-Calls
206(1)
14.3 Tail-Call Optimization in Java
207(2)
14.4 Dealing with Non-Tail-Calls
209(4)
14.5 Summary
213(2)
A Brief Interlude
215(38)
Chapter 15 Types (and Related Concepts)
217(36)
15.1 Typing Strategies
217(5)
15.2 Types as Sets
222(1)
15.3 Types as Services
223(1)
15.4 Abstract Data Types
224(1)
15.5 Type Inference
225(4)
15.6 Subtypes
229(3)
15.7 Polymorphism
232(3)
15.8 Type Variance
235(6)
15.9 Type Bounds
241(4)
15.10 Type Classes
245(5)
15.11 Summary
250(3)
Part II Concurrent Programming
253(180)
Chapter 16 Concepts of Concurrent Programming
255(6)
16.1 Non-sequential Programs
255(3)
16.2 Concurrent Programming Concepts
258(1)
16.3 Summary
259(2)
Chapter 17 Threads and Nondeterminism
261(10)
17.1 Threads of Execution
261(2)
17.2 Creating Threads Using Lambda Expressions
263(1)
17.3 Nondeterminism of Multithreaded Programs
263(1)
17.4 Thread Termination
264(2)
17.5 Testing and Debugging Multithreaded Programs
266(2)
17.6 Summary
268(3)
Chapter 18 Atomicity and Locking
271(14)
18.1 Atomicity
271(2)
18.2 Non-atomic Operations
273(1)
18.3 Atomic Operations and Non-atomic Composition
274(4)
18.4 Locking
278(1)
18.5 Intrinsic Locks
279(2)
18.6 Choosing Locking Targets
281(2)
18.7 Summary
283(2)
Chapter 19 Thread-Safe Objects
285(12)
19.1 Immutable Objects
285(1)
19.2 Encapsulating Synchronization Policies
286(2)
19.3 Avoiding Reference Escape
288(1)
19.4 Public and Private Locks
289(1)
19.5 Leveraging Immutable Types
290(3)
19.6 Thread-Safety
293(2)
19.7 Summary
295(2)
Chapter 20 Case Study: Thread-Safe Queue
297(10)
20.1 Queues as Pairs of Lists
297(1)
20.2 Single Public Lock Implementation
298(3)
20.3 Single Private Lock Implementation
301(2)
20.4 Applying Lock Splitting
303(2)
20.5 Summary
305(2)
Chapter 21 Thread Pools
307(14)
21.1 Fire-and-Forget Asynchronous Execution
307(2)
21.2 Illustration: Parallel Server
309(3)
21.3 Different Types of Thread Pools
312(2)
21.4 Parallel Collections
314(4)
21.5 Summary
318(3)
Chapter 22 Synchronization
321(16)
22.1 Illustration of the Need for Synchronization
321(3)
22.2 Synchronizers
324(1)
22.3 Deadlocks
325(3)
22.4 Debugging Deadlocks with Thread Dumps
328(2)
22.5 The Java Memory Model
330(5)
22.6 Summary
335(2)
Chapter 23 Common Synchronizers
337(18)
23.1 Locks
337(2)
23.2 Latches and Barriers
339(2)
23.3 Semaphores
341(2)
23.4 Conditions
343(6)
23.5 Blocking Queues
349(4)
23.6 Summary
353(2)
Chapter 24 Case Study: Parallel Execution
355(14)
24.1 Sequential Reference Implementation
355(1)
24.2 One New Thread per Task
356(1)
24.3 Bounded Number of Threads
357(2)
24.4 Dedicated Thread Pool
359(1)
24.5 Shared Thread Pool
360(1)
24.6 Bounded Thread Pool
361(1)
24.7 Parallel Collections
362(1)
24.8 Asynchronous Task Submission Using Conditions
362(5)
24.9 Two-Semaphore Implementation
367(1)
24.10 Summary
368(1)
Chapter 25 Futures and Promises
369(12)
25.1 Functional Tasks
369(2)
25.2 Futures as Synchronizers
371(3)
25.3 Timeouts, Failures, and Cancellation
374(1)
25.4 Future Variants
375(1)
25.5 Promises
375(2)
25.6 Illustration: Thread-Safe Caching
377(3)
25.7 Summary
380(1)
Chapter 26 Functional-Concurrent Programming
381(18)
26.1 Correctness and Performance Issues with Blocking
381(3)
26.2 Callbacks
384(1)
26.3 Higher-Order Functions on Futures
385(3)
26.4 Function flatMap on Futures
388(2)
26.5 Illustration: Parallel Server Revisited
390(3)
26.6 Functional-Concurrent Programming Patterns
393(4)
26.7 Summary
397(2)
Chapter 27 Minimizing Thread Blocking
399(18)
27.1 Atomic Operations
399(3)
27.2 Lock-Free Data Structures
402(3)
27.3 Fork/Join Pools
405(1)
27.4 Asynchronous Programming
406(1)
27.5 Actors
407(4)
27.6 Reactive Streams
411(1)
27.7 Non-blocking Synchronization
412(2)
27.8 Summary
414(3)
Chapter 28 Case Study: Parallel Strategies
417(16)
28.1 Problem Definition
417(2)
28.2 Sequential Implementation with Timeout
419(1)
28.3 Parallel Implementation Using invokeAny
420(1)
28.4 Parallel Implementation Using CompletionService
421(1)
28.5 Asynchronous Implementation with Scala Futures
422(4)
28.6 Asynchronous Implementation with CompletableFuture
426(1)
28.7 Caching Results from Strategies
427(4)
28.8 Summary
431(2)
Appendix A Features of Java and Kotlin
433(30)
A.1 Functions in Java and Kotlin
433(3)
A.2 Immutability
436(1)
A.3 Pattern Matching and Algebraic Data Types
437(2)
A.4 Recursive Programming
439(1)
A.5 Higher-Order Functions
440(6)
A.6 Lazy Evaluation
446(3)
A.7 Handling Failures
449(2)
A.8 Types
451(2)
A.9 Threads
453(1)
A.10 Atomicity and Locking
454(1)
A.11 Thread-Safe Objects
455(2)
A.12 Thread Pools
457(2)
A.13 Synchronization
459(1)
A.14 Futures and Functional-Concurrent Programming
460(1)
A.15 Minimizing Thread Blocking
461(2)
Glossary 463(6)
Index 469
Michel Charpentier is an associate professor with the Computer Science department at the University of New Hampshire (UNH). His interests over the years have ranged from distributed systems to formal verification and mobile sensor networks. He has been with UNH since 1999 and currently teaches courses in programming languages, concurrency, formal verification, and model-checking.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97801374665802e.html
Märksõnad: