The Joy of Kotlin

Name: The Joy of Kotlin
Brand: Manning
Price: 39.71 EUR
Availability: OnlineOnly

Pierre-Yves Saumont(Autor*in)

Manning (Verlag)

1. Auflage

Erschienen am 21. April 2019

480 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-63835-012-5 (ISBN)

39,71 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Summary

Maintaining poor legacy code, interpreting cryptic comments, and writing the same boilerplate over and over can suck the joy out of your life as a Java developer. Fear not! There's hope! Kotlin is an elegant JVM language with modern features and easy integration with Java. The Joy of Kotlin teaches you practical techniques to improve abstraction and design, to write comprehensible code, and to build maintainable bug-free applications.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology

Your programming language should be expressive, safe, flexible, and intuitive, and Kotlin checks all the boxes! This elegant JVM language integrates seamlessly with Java, and makes it a breeze to switch between OO and functional styles of programming. It's also fully supported by Google as a first-class Android language. Master the powerful techniques in this unique book, and you'll be able to take on new challenges with increased confidence and skill.

About the Book

The Joy of Kotlin teaches you to write comprehensible, easy-to-maintain, safe programs with Kotlin. In this expert guide, seasoned engineer Pierre-Yves Saumont teaches you to approach common programming challenges with a fresh, FP-inspired perspective. As you work through the many examples, you'll dive deep into handling errors and data properly, managing state, and taking advantage of laziness. The author's down-to-earth examples and experience-driven insights will make you a better?and more joyful?developer!

What's inside

Programming with functions
Dealing with optional data
Safe handling of errors and exceptions
Handling and sharing state mutation

About the Reader

Written for intermediate Java or Kotlin developers.

About the Author

Pierre-Yves Saumont is a senior software engineer at Alcatel-Submarine Networks. He's the author of Functional Programming in Java (Manning, 2017).

Table of Contents

Making programs safer
Functional programming in Kotlin: An overview
Programming with functions
Recursion, corecursion, and memoization
Data handling with lists
Dealing with optional data
Handling errors and exceptions
Advanced list handling
Working with laziness
More data handling with trees
Solving problems with advanced trees
Functional input/output
Sharing mutable states with actors
Solving common problems functionally

Weitere Details

Weitere Ausgaben

Person

Inhalt

Intro
The Joy of Kotlin
Copyright
Brief contents
contents
Front matter
preface
acknowledgments
about this book
Who should read this book
What you'll learn
Pushing abstraction further
Immutability
Referential transparency
Encapsulated state mutation sharing
Abstracting control flow and control structures
Using the right types
Laziness
Audience
How this book is organized: A roadmap
Completing the exercises
Learning the techniques in this book
About the code
liveBook discussion
about the author
about the cover illustration
1 Making programs safer
1.1 Programming traps
1.1.1 Safely handling effects
1.1.2 Making programs safer with referential transparency
1.2 The benefits of safe programming
1.2.1 Using the substitution model to reason about programs
1.2.2 Applying safe principles to a simple example
1.2.3 Pushing abstraction to the limit
Summary
2 Functional programming in Kotlin: An overview
2.1 Fields and variables in Kotlin
2.1.1 Omitting the type to simplify
2.1.2 Using mutable fields
2.1.3 Understanding lazy initialization
2.2 Classes and interfaces in Kotlin
2.2.1 Making the code even more concise
2.2.2 Implementing an interface or extending a class
2.2.3 Instantiating a class
2.2.4 Overloading property constructors
2.2.5 Creating equals and hashCode methods
2.2.6 Destructuring data objects
2.2.7 Implementing static members in Kotlin
2.2.8 Using singletons
2.2.9 Preventing utility class instantiation
2.3 Kotlin doesn't have primitives
2.4 Kotlin's two types of collections
2.5 Kotlin's packages
2.6 Visibility in Kotlin
2.7 Functions in Kotlin
2.7.1 Declaring functions
2.7.2 Using local functions
2.7.3 Overriding functions
2.7.4 Using extension functions
2.7.5 Using lambdas
2.8 Nulls in Kotlin
2.8.1 Dealing with nullable types
2.8.2 Elvis and the default value
2.9 Program flow and control structures
2.9.1 Using conditional selectors
2.9.2 Using multi-conditional selectors
2.9.3 Using loops
Kotlin's unchecked exceptions
Automatic resource closure
Kotlin's smart casts
Equality versus identity
String interpolation
Multi-line strings
Variance: parameterized types and subtyping
2.16.1 Why is variance a potential problem?
2.16.2 When to use covariance and when to use contravariance
2.16.3 Declaration-site variance versus use-site variance
Summary
3 Programming with functions
3.1 What's a function?
3.1.1 Understanding the relationship between two function sets
3.1.2 An overview of inverse functions in Kotlin
3.1.3 Working with partial functions
3.1.4 Understanding function composition
3.1.5 Using functions of several arguments
3.1.6 Currying functions
3.1.7 Using partially-applied functions
3.1.8 Functions have no effects
3.2 Functions in Kotlin
3.2.1 Understanding functions as data
3.2.2 Understanding data as functions
3.2.3 Using object constructors as functions
3.2.4 Using Kotlin's fun functions
Exactness
3.2.5 Using object notation versus functional notation
3.2.6 Using value functions
3.2.7 Using function references
3.2.8 Composing functions
3.2.9 Reusing functions
3.3 Advanced function features
3.3.1 What about functions of several arguments?
3.3.2 Applying curried functions
3.3.3 Implementing higher-order functions
3.3.4 Creating polymorphic HOFs
Testing function parameters
3.3.5 Using anonymous functions
3.3.6 Defining local functions
3.3.7 Implementing closures
3.3.8 Applying functions partially and automatic currying
3.3.9 Switching arguments of partially-applied functions
Declaring the identity function
Using the right types
Summary
4 Recursion, corecursion, and memoization
4.1 Corecursion and recursion
4.1.1 Implementing corecursion
4.1.2 Implementing recursion
4.1.3 Differentiating recursive and corecursive functions
4.1.4 Choosing recursion or corecursion
4.2 Tail Call Elimination
4.2.1 Using Tail Call Elimination
4.2.2 Switching from loops to corecursion
4.2.3 Using recursive value functions
4.3 Recursive functions and lists
4.3.1 Using doubly recursive functions
4.3.2 Abstracting recursion on lists
4.3.3 Reversing a list
4.3.4 Building corecursive lists
4.3.5 The danger of strictness
4.4 Memoization
4.4.1 Using memoization in loop-based programming
4.4.2 Using memoization in recursive functions
4.4.3 Using implicit memoization
4.4.4 Using automatic memoization
4.4.5 Implementing memoization of multi-argument functions
4.5 Are memoized functions pure?
Summary
5 Data handling with lists
5.1 How to classify data collections
5.2 Different types of lists
5.3 Relative expected list performance
5.3.1 Trading time against memory space and complexity
5.3.2 Avoiding in-place mutation
Update in place
5.4 What kinds of lists are available in Kotlin?
5.4.1 Using persistent data structures
5.4.2 Implementing immutable, persistent, singly linked lists
5.5 Data sharing in list operations
5.6 More list operations
5.6.1 Benefiting from object notation
5.6.2 Concatenating lists
5.6.3 Dropping from the end of a list
5.6.4 Using recursion to fold lists with higher-order functions (HOFs)
5.6.5 Using variance
5.6.6 Creating a stack-safe recursive version of foldRight
5.6.7 Mapping and filtering lists
Summary
6 Dealing with optional data
6.1 Problems with the null pointer
6.2 How Kotlin handles null references
6.3 Alternatives to null references
6.4 Using the Option type
6.4.1 Getting a value from an Option
6.4.2 Applying functions to optional values
6.4.3 Dealing with Option composition
6.4.4 Option use cases
6.4.5 Other ways to combine options
6.4.6 Composing List with Option
6.4.7 Using Option and when to do so
Summary
7 Handling errors and exceptions
7.1 The problems with missing data
7.2 The Either type
7.3 The Result type
7.4 Result patterns
7.5 Advanced Result handling
7.5.1 Applying predicates
7.6 Mapping failures
7.7 Adding factory functions
7.8 Applying effects
7.9 Advanced result composition
Summary
8 Advanced list handling
8.1 The problem with length
8.2 The performance problem
8.3 The benefits of memoization
8.3.1 Handling memoization drawbacks
8.3.2 Evaluating performance improvements
8.4 List and Result composition
8.4.1 Handling lists returning Result
8.4.2 Converting from List&Result& to Result&List&
8.5 Common List abstractions
8.5.1 Zipping and unzipping lists
8.5.2 Accessing elements by their index
The zero element
8.5.3 Splitting lists
When not to use folds
8.5.4 Searching for sublists
8.5.5 Miscellaneous functions for working with lists
8.6 Automatic parallel processing of lists
8.6.1 Not all computations can be parallelized
8.6.2 Breaking the list into sublists
8.6.3 Processing sublists in parallel
Summary
9 Working with laziness
9.7 Strictness versus laziness
9.8 Kotlin and strictness
9.9 Kotlin and laziness
Laziness implementations
9.10.1 Composing lazy values
9.10.2 Lifting functions
9.10.3 Mapping and flatMapping Lazy
9.10.4 Composing Lazy with List
9.10.5 Dealing with exceptions
Further lazy compositions
9.11.1 Lazily applying effects
9.11.2 Things you can't do without laziness
9.11.3 Creating a lazy list data structure
Handling streams
9.12.1 Folding streams
9.12.2 Tracing evaluation and function application
9.12.3 Applying streams to concrete problems
Summary
10 More data handling with trees
10.1 The binary tree
10.2 Understanding balanced and unbalanced trees
10.3 Looking at size, height, and depth in trees
10.4 Empty trees and the recursive definition
10.5 Leafy trees
10.6 Ordered binary trees or binary search trees
10.7 Insertion order and the structure of trees
10.8 Recursive and non-recursive tree traversal order
10.8.1 Traversing recursive trees
10.8.2 Non-recursive traversal orders
10.9 Binary search tree implementation
10.9.1 Understanding variance and trees
10.9.2 What about an abstract function in the Tree class?
10.9.3 Overloading operators
10.9.4 Recursion in trees
10.9.5 Removing elements from trees
10.9.6 Merging arbitrary trees
About folding trees
10.10.1 Folding with two functions
10.10.2 Folding with a single function
10.10.3 Choosing a fold implementation
About mapping trees
About balancing trees
10.12.1 Rotating trees
10.12.2 Using the Day-Stout-Warren algorithm
10.12.3 Automatically balancing trees
Summary
11 Solving problems with advanced trees
11.1 Better performance and stack safety with self-balancing trees
11.1.1 Understanding the basic red-black tree structure
11.1.2 Adding an element to the red-black tree
11.1.3 Removing elements from the red-black tree
11.2 A use case for the red-black tree: Maps
11.2.1 Implementing Map
11.2.2 Extending maps
11.2.3 Using Map with noncomparable keys
11.3 Implementing a functional priority queue
11.3.1 Looking at the priority queue access protocol
11.3.2 Exploring priority queue use cases
11.3.3 Looking at implementation requirements
11.3.4 The leftist heap data structure
11.3.5 Implementing the leftist heap
11.3.6 Implementing the queue-like interface
11.4 Elements and sorted lists
11.5 A priority queue for noncomparable elements
Summary
12 Functional input/output
12.1 What does effects in context mean?
12.1.1 Handling effects
12.1.2 Implementing effects
12.2 Reading data
12.2.1 Reading data from the console
12.2.2 Reading from a file
12.3 Testing with input
12.4 Fully functional input/output
12.4.1 Making input/output fully functional
12.4.2 Implementing purely functional I/O
12.4.3 Combining I/O
12.4.4 Handling input with IO
12.4.5 Extending the IO type
12.4.6 Making the IO type stack-safe
Summary
13 Sharing mutable states with actors
13.1 The actor model
13.1.1 Understanding asynchronous messaging
13.1.2 Handling parallelization
13.1.3 Handling actor state mutation
13.2 An actor framework implementation
13.2.1 Understanding the limitations
13.2.2 Designing the actor framework interfaces
13.3 The AbstractActor implementation
13.4 Putting actors to work
13.4.1 Implementing the Ping Pong example
13.4.2 Running a computation in parallel
13.4.3 Reordering the results
13.4.4 Optimizing performance
Summary
14 Solving common problems functionally
14.1 Assertions and data validation
14.2 Retries for functions and effects
14.3 Reading properties from a file
14.3.1 Loading the property file
14.3.2 Reading properties as strings
14.3.3 Producing better error messages
14.3.4 Reading properties as lists
14.3.5 Reading enum values
14.3.6 Reading properties of arbitrary types
14.4 Converting an imperative program: The XML reader
14.4.1 Step 1: The imperative solution
14.4.2 Step 2: Making an imperative program more functional
14.4.3 Step 3: Making the program even more functional
14.4.4 Step 4: Fixing the argument type problem
14.4.5 Step 5: Making the element-processing function a parameter
14.4.6 Step 6: Handling errors on element names
14.4.7 Step 7: Additional improvements to the formerly imperative code
Summary
Appendix A. Mixing Kotlin with Java
Creating and managing mixed projects
Creating a simple project with Gradle
Importing your Gradle project into IntelliJ
Adding dependencies to your project
Creating multi-module projects
Adding dependencies to a multiple module project
Java library methods and Kotlin code
Using Java primitives
Using Java numerical object types
Failing fast on null values
Using Kotlin and Java string types
Implementing other type conversions
Using Java varargs
Specifying nullability in Java
Calling getters and setters
Accessing Java properties with reserved names
Calling checked exceptions
SAM interfaces
Kotlin functions and Java code
Converting Kotlin properties
Using Kotlin public fields
Static fields
Calling Kotlin functions as Java methods
Converting types from Kotlin to Java
Function types
Specific problems with mixed Kotlin/Java projects
Summary
Appendix B. Property-based testing in Kotlin
Why property-based testing?
Writing the interface
Writing the tests
What is property-based testing?
Abstraction and property-based tests
Dependencies for property-based unit testing
Writing property based tests
Creating your own custom generators
Using custom generators
Simplifying the code through further abstraction
Summary
Index
Lists of Figures, Tables and Listings
List of Illustrations
List of Tables
List of Listings

Systemvoraussetzungen

Als PDF speichern Als Link merken