Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Book Overview & Buying Haskell High Performance Programming
  • Table Of Contents Toc
Haskell High Performance Programming

Haskell High Performance Programming

By : Thomasson
3 (2)
Buy this Book
close
close
Haskell High Performance Programming

Haskell High Performance Programming

3 (2)
By: Thomasson
Buy this Book

Overview of this book

Haskell, with its power to optimize the code and its high performance, is a natural candidate for high performance programming. It is especially well suited to stacking abstractions high with a relatively low performance cost. This book addresses the challenges of writing efficient code with lazy evaluation and techniques often used to optimize the performance of Haskell programs. We open with an in-depth look at the evaluation of Haskell expressions and discuss optimization and benchmarking. You will learn to use parallelism and we'll explore the concept of streaming. We’ll demonstrate the benefits of running multithreaded and concurrent applications. Next we’ll guide you through various profiling tools that will help you identify performance issues in your program. We’ll end our journey by looking at GPGPU, Cloud and Functional Reactive Programming in Haskell. At the very end there is a catalogue of robust library recommendations with code samples. By the end of the book, you will be able to boost the performance of any app and prepare it to stand up to real-world punishment.
Table of Contents (16 chapters)
close
close
close
Preface
Icon
Preface
Icon
What this book covers
Icon
What you need for this book
Icon
Who this book is for
Icon
Conventions
Icon
Reader feedback
Icon
Customer support
Lock Free Chapter
1
1. Identifying Bottlenecks
Icon
1. Identifying Bottlenecks
Icon
Meeting lazy evaluation
Icon
Memoization and CAFs
Icon
Recursion and accumulators
Icon
Inspecting time and space usage
Icon
Compiler code optimizations
Icon
Summary
2
2. Choosing the Correct Data Structures
Icon
2. Choosing the Correct Data Structures
Icon
Annotating strictness and unpacking datatype fields
Icon
Handling numerical data
Icon
Handling binary and textual data
Icon
Handling sequential data
Icon
Handling tabular data
Icon
Handling sparse data
Icon
Ephemeral data structures
Icon
Working with monads and monad stacks
Icon
Summary
3
3. Profile and Benchmark to Your Heart's Content
Icon
3. Profile and Benchmark to Your Heart's Content
Icon
Profiling time and allocations
Icon
Heap profiling
Icon
Benchmarking using the criterion library
Icon
Profile and monitor in real time
Icon
Summary
4
4. The Devil's in the Detail
chevron up
Icon
4. The Devil's in the Detail
Icon
The anatomy of a Haskell project
Icon
Erroring and handling exceptions
Icon
Writing tests for Haskell
Icon
Trivia at term-level
Icon
Trivia at type-level
Icon
Useful GHC extensions
Icon
Summary
5
5. Parallelize for Performance
Icon
5. Parallelize for Performance
Icon
Primitive parallelism and the Runtime System
Icon
The Eval monad and strategies
Icon
The Par monad and schedules
Icon
Diagnosing parallelism – ThreadScope
Icon
Data parallel programming – Repa
Icon
Summary
6
6. I/O and Streaming
Icon
6. I/O and Streaming
Icon
Reading, writing, and handling resources
Icon
Streaming with side-effects
Icon
Logging in Haskell
Icon
Summary
7
7. Concurrency and Performance
Icon
7. Concurrency and Performance
Icon
Threads and concurrency primitives
Icon
Software Transactional Memory
Icon
Runtime System and threads
Icon
Asynchronous processing
Icon
Lifting up from I/O
Icon
Summary
8
8. Tweaking the Compiler and Runtime System (GHC)
Icon
8. Tweaking the Compiler and Runtime System (GHC)
Icon
Using GHC like a pro
Icon
Tuning GHC's Runtime System
Icon
Summary of useful GHC options
Icon
Summary of useful RTS options
Icon
Summary
9
9. GHC Internals and Code Generation
Icon
9. GHC Internals and Code Generation
Icon
Interpreting GHC's internal representations
Icon
Primitive GHC-specific features
Icon
Datatype generic programming
Icon
Generating Haskell with Haskell
Icon
Summary
10
10. Foreign Function Interface
Icon
10. Foreign Function Interface
Icon
From Haskell to C and C to Haskell
Icon
Data marshal and stable pointers
Icon
Summary
11
11. Programming for the GPU with Accelerate
Icon
11. Programming for the GPU with Accelerate
Icon
Writing Accelerate programs
Icon
Running with the CUDA backend
Icon
More Accelerate concepts
Icon
Summary
12
12. Scaling to the Cloud with Cloud Haskell
Icon
12. Scaling to the Cloud with Cloud Haskell
Icon
Processes and message-passing
Icon
Handling failure
Icon
Nodes and networking
Icon
Summary
13
13. Functional Reactive Programming
Icon
13. Functional Reactive Programming
Icon
The tiny discrete-time Elerea
Icon
Events and signal functions with Yampa
Icon
Reactive-banana – Safe and simple semantics
Icon
Combining events and behaviors
Icon
Summary
14
14. Library Recommendations
Icon
14. Library Recommendations
Icon
Representing data
Icon
Functional graphs
Icon
Numeric data for special use
Icon
Encoding and serialization
Icon
Persistent storage, SQL, and NoSQL
Icon
Networking and HTTP
Icon
Cryptography
Icon
Web technologies
Icon
Parsing and pretty-printing
Icon
Pretty-printing and text formatting
Icon
Control and utility libraries
Icon
Working with monads and transformers
Icon
Handling exceptions
Icon
Random number generators
Icon
Parallel and concurrent programming
Icon
Functional Reactive Programming
Icon
Mathematics, statistics, and science
Icon
Tools for research and sketching
Icon
The HaskellR project
Icon
Creating charts and diagrams
Icon
Scripting and CLI applications
Icon
Testing and benchmarking
Icon
Summary
15
Index
Icon
Index

Writing tests for Haskell

There are many libraries for testing Haskell code. Besides classic unit tests with HUnit and spec testing in Ruby-style with Hspec, we can verify properties using SmallCheck and QuickCheck with exhaustive and randomized test cases, respectively.

Property checks

With QuickCheck we can test properties in a randomized fashion. We don't need to generate the test cases ourselves, as QuickCheck takes care of that. Here's a quick example of testing a simple arithmetic property:

stack ghci --package QuickCheck
> import Test.QuickCheck as QC
> QC.quickCheck $ \x y -> x > 0 ==> x + y >= y

All testable properties in QuickCheck are given as instances of the Testable class. As a quick reference, the core interface looks like this:

quickCheck :: Testable prop => prop → IO ()

class Testable prop where […]

instance Testable Property
instance Testable Bool
instance (Arbitrary a, Show a, Testable prop) => Testable (a → prop)

The...

Visually different images
CONTINUE READING
83
Tech Concepts
36
Programming languages
73
Tech Tools
Icon Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.
Icon Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.
Icon 50+ new titles added per month and exclusive early access to books as they are being written.
Haskell High Performance Programming
End of Section 4
Next Section
notes
bookmark Notes and Bookmarks search Search in title playlist Add to playlist download Download options
font-size Font size

Change the font size

margin-width Margin width

Change margin width

day-mode Day/Sepia/Night Modes

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY

Submit Your Feedback

Modal Close icon
Modal Close icon
Modal Close icon