Blog articles

Many areas of Haskell have been explored in the form of blog posts. This page collects the best of those articles from across the web.

Introductions to Haskell

• Haskell Study Plan
• On Haskell, Intuition And Expressive Power
• Haskell: Raising the bar
• Learning the Haskell programming language
• On learning Haskell
• My evolution as a Haskell programmer
• Why its hard for imperative programmers to learn Haskell
• Flirting with Functional Programming
• Building a Firewall Against Complexity
• Haskell, bondage-and-discipline and separation-of-concerns programming
• Type systems as safety belts
• Haskell introduction for beginners
• Haskell Basics
• Haskell Preliminaries: Implementations and Tools
• Simple Functions in Haskell
• Reconsidering my approach to learning Haskell
• A Haskell study plan
• Haskell Eye for the Ruby Guy

First impressions

• Haskell First Impressions
• One month in Haskell
• Thoughts on one week in Haskell
• Haskell, first impressions (with sexy results)
• The beauty of Haskell
• Monad wrangling, and the joy of #haskell
• Learning Haskell
• I like Haskell a lot

Comparisons to other languages

Ruby

• Ruby vs Haskell: choose what works
• Haskell: open secret in Ruby land
• Haskell Eye for the Ruby Guy
• Monads in Ruby
  • Part 1: Identity
  • Part 1.5: Identity
• RushCheck, a lightweight random testing tool for Ruby similar to QuickCheck
• part 1
• zip and transpose
• Pattern matching in Ruby

Ada

• Describing Haskell to an Ada programmer

Java

• More Haskell in Java 7 or 8?
• Type classes in Java
• Closures and bottom for Java
• An infinite list in Java
• Maybe monad in Java

Eiffel

• The type system of ECMA Eiffel (modelled in Haskell)

Javascript

• foldr and foldl in JavaScript

C

• The functional C programmer

C#

• The New Lambda Expressions Feature in C# 3.0
• Immutability, Purity, and Referential Transparency in C#
• Haskell for C# 3 Programmers

Scala

• Haskell, CAL and Scala

CAL

• Haskell code/Java UI

Python

• Haskell versus Python
• Using Haskell in Python: haskellembed
• Understanding Monads Via Python List Comprehensions

Scheme

• Haskell versus Scheme

Forth

• Forth as a Haskell DSL

Factor

• Haskell-style parser combinators in Factor: s-expression reader

Lisp

• Writing lisp in Haskell
• Haskell like data structures in Common Lisp

Lua

• Lazy streams for Lua

Functional programming

• A fold-like procedure in C
• What's wrong with for loops
• More on what's wrong with for loops
• Liberating Myself from the von Neumann Style
• Programming Productivity and Programming Languages
• Haskell - A valuable language
• On Functional Programming
• Functional programming is a silver bullet
• Silver Bullets Incoming!
• Computers were invented to keep track of boring things
• Functional programming for the rest of us
• What is so cool about Functional Programming?
• Zen and the Art of Functional Programming
• Thinking in types

Programming exercises

• Diff in Haskell
• Introductory Haskell: Solving the Sorting-It-Out Kata
• Fibonacci series one-liner in Haskell
• A Simple RPN Calculator in Haskell
• Eratosthenes sieve
• Software Cipher
• Secret Santas in Haskell I: Preliminaries
• Secret Santas in Haskell II: Orbits and Lists
• Secret Santas in Haskell III: Lather, Rinse, Repeat 1
• The Dot-Matrix Printhead: a Haskell Toy
• The Revised Dot-Matrix Printhead
• Run length encoding:
  • part 1
  • part 2
  • part 3
• Overlap function in Haskell for rectangles
• Tying Knots Generically
• A quick and dirty theorem prover in Haskell
• Brainf*k interpreter in Haskell
• FourFours in Haskell
• Using Bayesian filtering instead of 'if' in Haskell
• Prime sieves in Haskell
• Bowling in Haskell
  • Haskell Bowling
  • Bowling in Haskell Response

Games

• Haskell chess
• My first Haskell adventure game!
• Hangman AI in Haskell
• Haskell as a puzzle solver

Laziness

• Haskell laziness
• Laziness and fizzbuzz in Haskell
• Lazy lists as iterators

Records

• Haskell records considered grungy

IO

• Haskell I/O for imperative programmers
• Directory tree printing:
  • Part 1
  • Part 2
• Introductory console IO in Haskell
• Listing files in Haskell
• separating IO from logic -- example
• Programming Haskell
  • Programming Haskell: part 1
  • Programming Haskell: part 2
  • Programming Haskell: part 3
• Design Patterns in Haskell: bracket
• 7 Rules for IO in Haskell

Command line arguments

• Command line arguments in Haskell

Unix

• Simple Unix Tools in Elegant Haskell
• Introductory Haskell Programming in the UNIX Environment
• HSH: a Haskell scripting environment
• Function composition and unix pipes
• Practical Haskell: shell scripting with error handling and privilege separation
• A simple file filter

Network

TCP

• Simple STM TCP server
• Haskell's 'interact' with TCP sockets
• Port Scanner in Haskell
• Simple socket programming:
  • Part 1
  • Part 2
• On haskell: writing a packet sniffer

IRC

• An IRC client/server in Haskell
• Roll your own Haskell IRC bot

Parallelism and Concurrency

• Threads
• STM and IO
  • STM, IO, and a Simple Persistence Model
  • STM and IO Redux
• Synchronised threads:
  • part1
  • part2
• More Haskell parallelism

Performance

• High performance Haskell
• Reading GHC Core and tuning assembly output

Parsing

• Parser combinators
• Monadic parsing
• Adventures in Haskell: the Parsec magic weapon
• Adventures in Haskell: parsing the game world
• Combinator parsing
• Parser with Writer monad
• Simple Parsec Example: HTMangL
• Parsers, Parsec and Haskell
• Interesting parsers in Haskell
• Explicit Typing, Trail Blazing, and Packrat Parsing
• Playing fast and loose with Parsec for parsing in Haskell
• Config file parsing

Monads

• The monad laws
• Quick interpreters with the Reader monad
• Monads
• More on Haskell, Side Effects and Code Reuse
• A First Step Into Monads
• More Monads: Stateful Programming
• The theory of monads
• Monads: a field guide
• Variable substitution gives a ... monad
• The monad behind every zipper
• Monads for vector spaces, probability and quantum mechanics pt. I
• Monads, Vector Spaces and Quantum Mechanics pt. II
• A newbie in Haskell land or another monad tutorial
• A newbie in Haskell land : The (->) monad
• Smart classification using Bayesian monads
• 3 open problems with monads
• Monads in 15 minutes: Backtracking and Maybe
• How to make Data.Set a monad
• Monads work because they have a tight interface
• Haskell: bootstrapping into a clue about monads
• Why monads matter
• Monads through Pictures
• Monads as universe helpers
• The Trivial Monad

Monad transformers

• A twisted history of monad transformers
• How To Use Monad Transformers
• Local and global side effects with monad transformers
• Grok monad transformers
• A Simple Game with StateT

Arrows

• Concatenative programming in Haskell's Arrows
• Arrows and security

Comonads

• Comonads and reading from the future
• Evaluating cellular automata is co-monadic
• Reading and co-reading
• Understanding comonads

Error handling and exceptions

• Error handling in Haskell
• Some Very Basic Haskell and Thoughts on Error Diagnosis
• 8 ways to report errors in Haskell

Types

• A type-based solution to the 'strings problem'
• Generalised Algebraic Data Types, Phantom Types, and Dependent Types
• Functions, Types, Function Types, and Type Inference
• Building Datatypes in Haskell (part 1)
• Rank-2 polymorphism is a strange thing

Type classes

• Type Classes: Not Quite Overloading"
• Haskell: the Basics of Type Classes

Data structures

• Queues without pointers
• A Tree Grows Up in Haskell: Building a Dictionary Type
• Haskell Stacks : Two Different Ways
• A counter datatype with constant-time update
• Map fusion: Making Haskell 225% faster

Strings

• Splitting a string in Haskell

Algorithms and techniques

Folds

• Second order folds
• Folds and functional programming
• Fold diagrams
• foldr, foldl

Dynamic programming

• Dynamic Programming in Haskell

Mutable data

• Haskell: an Imperative Language with Mutable State

Sections and Currying

• Currying
• Playing with sections in Haskell

GUIs

• Developing Gnome Apps with Glade
• Haskell in the real, mundane world
• Haskell GUI Programing

Graphics

• IFS In Haskell
• Raytracing on a grid in Haskell
• Fractals with Haskell-GD

Web and XML

• Haskell and Web Applications
• Ruby and Haskell: write your Rails backend code in Haskell instead of C
• Writing a Simple Search Engine in Haskell
  • Part 0 Introduction
  • Part 1 Maybe and List
• Haskell and the web: some ideas in progress
• A search engine (core) written in Haskell
• Haskell Transactional Cache

HTML

• Use of Text.XHtml.Strict for Outputting XHTML

XML, Atom, RSS

• Really simple Atom syndication
• A simple RSS aggregator in 50 lines of Haskell using HXT
• Using the Haskell XML Toolbox

Maths

Haskell for mathematics

• Learn Maths with Haskell
• Practical Synthetic Differential Geometry
• More Low Cost Geometric Algebra
• Algebraic Topology in Haskell
• Infinitesimal Types
• Geometric Algebra for Free!
• Eleven Reasons to use Haskell as a Mathematician
• Laws of Form: An Opinion
• A-algebras and group cohomology
• Prototyping thought
• Computational Group Theory in Haskell
• Carry bits and group cohomology
• Polynomials as numbers
• Non-standard analysis, automatic differentiation, Haskell
• Haskell for Maths: commutative algebra, combinatorics, number theory, and group theory
• Two-dimensional spatial hashing with space-filling curves
• Arithmetic coding in Haskell
• Countable Ordinals in Haskell
• Polynomials as numbers
• The Division Bell
  • Part One
  • Part Two
  • Part Three
  • Part Four (Conclusion)
  • The Divisive Aftermath
• Haskell, PDF and penrose tilings
• Overloading Haskell numbers
  • Part 1: symbolic expressions
  • Part 2: Forward Automatic Differentiation
  • Part 3: Fixed Precision

Theorem proving

• Quick and Dirty Theorem Prover

Quantum computing

• The Essence of Quantum Computing
• Monads for vector spaces, probability and quantum mechanics pt. I
• Monads, Vector Spaces and Quantum Mechanics pt. II
• Independence, entanglement and decoherence with the quantum monad
• The Shor Quantum Error Correcting Code (and a Monad for Heat)
• The Frame Of Reference Monad

Mathematics of Haskell

• Why isn't ListT list a monad?
• Reverse Engineering Machines with the Yoneda Lemma
• Variable substitution gives a...
• From Lb's Theorem to Spreadsheet Evaluation
• Games, Strategies and the Self-Composition of the List Monad.
• Programs are Proofs: Models and Types in Lambda Calculus
• Why Haskell?
• Don't need the Y combinator

Testing

• Introduction to QuickCheck
• QuickChecking a window manager
• On Unit Testing and Type Safety
• Testing ... testing
• Robustness and QuickCheck

Regular expressions

• A regular expression tutorial
• Using the new regex packages

The foreign function interface

• Simple demonstration of Haskell FFI

Tips and tricks

• Using Haskell from the command line

Cabal and libraries

• Cabal and rpms
• Getting started with installing third-party Haskell packages
• The lambda revolution: how you can help
• The lambda revolution, Episode V, the deb strikes back
• Questions on Haskell Style (and Polynomials redux)
• Using the Haskell package system

Hardware description languages

• Haskell and HDL's