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
  • Feedback & Rating feedback
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 (21 chapters)
close
close
close
Haskell High Performance Programming
Icon
Haskell High Performance Programming
Credits
Icon
Credits
About the Author
Icon
About the Author
About the Reviewer
Icon
About the Reviewer
www.PacktPub.com
Icon
www.PacktPub.com
Preface
Icon
Preface
Free Chapter
1
Identifying Bottlenecks
Icon
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
Choosing the Correct Data Structures
Icon
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
Profile and Benchmark to Your Heart's Content
Icon
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
The Devil's in the Detail
chevron up
Icon
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
Parallelize for Performance
Icon
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
I/O and Streaming
Icon
I/O and Streaming
Icon
Reading, writing, and handling resources
Icon
Streaming with side-effects
Icon
Logging in Haskell
Icon
Summary
7
Concurrency and Performance
Icon
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
Tweaking the Compiler and Runtime System (GHC)
Icon
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
GHC Internals and Code Generation
Icon
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
Foreign Function Interface
Icon
Foreign Function Interface
Icon
From Haskell to C and C to Haskell
Icon
Data marshal and stable pointers
Icon
Summary
11
Programming for the GPU with Accelerate
Icon
Programming for the GPU with Accelerate
Icon
Writing Accelerate programs
Icon
Running with the CUDA backend
Icon
More Accelerate concepts
Icon
Summary
12
Scaling to the Cloud with Cloud Haskell
Icon
Scaling to the Cloud with Cloud Haskell
Icon
Processes and message-passing
Icon
Handling failure
Icon
Nodes and networking
Icon
Summary
13
Functional Reactive Programming
Icon
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
Library Recommendations
Icon
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
Index
Icon
Index

Trivia at term-level

In this section, we look at lazy patterns, using the magic hash, controlling inlining and using rewrite rules. These are small things used rarely in applications, but nevertheless are very convenient where applicable.

We'll start with lazy patterns. Where strict pattern annotations use bangs and mean "Evaluate this argument to WHNF immediately," lazy pattern annotations use tildes and imply "Don't even bother pattern-matching unless a binding is really requested." So this errors:

> let f (a,b) = 5
> f undefined
*** Exception: Prelude.undefined

But with a lazy pattern match, we are all okay:

> let f ~(a,b) = 5
> f undefined
5

A more realistic use case for lazy patterns is the classic server-client setting. The client makes requests sequentially and can change the request based on previous responses. We can express this in Haskell elegantly with just linked lists. The server is slightly simpler than the client: it just applies a computation on every request...

Limited Time Offer

$10p/m for 3 months

Get online access to our library of over 7000 practical eBooks and videos, constantly updated with the latest in tech and supported with AI assistants
Claim Now Or Sign In
End of Section 5
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

Create a Note

Modal Close icon
You need to login to use this feature.

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete

Delete Note

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete

Edit Note

Modal Close icon
Write a note (max 255 characters)
Cancel
Update Note