Mastering Time-to-Market with Haskell

For bringing your product to market, there isn't just one metric for success. That depends on your business needs. Haskell is the pure functional

programming language that brings tangible benefits over its

competitors for a variety of TTM priorities. Let's explore four of

them.

Speed to market

You may want to bring your product to market as quickly as

possible, because you have direct competitors; you have to produce

a functioning demo for your investors; or your success in the

market is time sensitive. Haskell speeds up this process in various

ways.

Constuct things correctly the first time: Haskell is

statically typed, which is a form of program verification that

guarantees correctness of certain properties, like in Java or C#.

Unlike Java or C#, Haskell is a pure functional language, leading to verification of far more portions of the program

source code. With feedback from the compiler while developing, your

developers are guaranteed a certain level of correctness and this

allows them to concentrate on your domain business logic. As

written elsewhere, worst practices should be hard. Also, a case study on Haskell vs C# for contract writing.

Reduce testing time: Haskell emphasizes the correct by construction approach, which is to use the type system to

verify that program parts are combined in only the ways that will

not crash and that make sense. Examples range from the simple to

advanced. For example, Haskell web frameworks like Yesod prevent XSS and accidental broken links statically. The more surface area of your problem

covered by static analysis, the less time and effort is needed by

your developers for writing unit and integration tests, and the

tests blow up less often in continuous integration.

Make builds reproducible: Haskell projects that are built with the Stack build tool, are guaranteed reproducible builds using a stable set of packages,

with Stack also providing docker support out of the box, adding an

additional layer of reproducibility. If a reproducible build is

created on one developer's machine, it will work on any. This

significantly reduces ramp up time for your developers, and makes

continuous integration trivial for your devops people.

Use the concurrency: Many problems are solved more easily

with concurrency (networking, file I/O, video/image/document

processing, database access, etc.) simply because the programming

model is easier to understand. Haskell has some of the best

concurrency support of any popular language, it has a breadth of

tools, efficiency, stability, and it is trivial to use, out of the

box. Let your developers use it. See Beautiful concurrency for more about concurrency in Haskell.

Additionally, the code doesn't have to be rewritten in an arcane

style like in NodeJS to gain concurrency.

Shipping on schedule

You may not need to ship as soon as possible, but to ship on schedule, for a demo, a conference or as promised to your

investors or customers. For this, there is another mitigating

feature of Haskell.

Types shed light on scope: Using the type system of

Haskell to model your domain logic helps to expand the "fog of war"

that we experience with project scope: there are many unknowns, and

we need to enumerate all the cases and kinds of things. Armed with

this UML-without-the-UML, you can have confidence in how much scope

you can cover now for the current shipping schedule, and what needs

to come in version 2. This gives confidence in time estimates made

by your developers. See Haskell-Providing

Peace of Mind for a case-study. See Using Haskell at SQream Technologies for a technical demonstration.

Avoid build system detours: Reproducible builds help to

avoid the inevitable build system detours that happen on large

projects, where developers are wasting time getting the build

system to work on eachother's machines and debugging failures.

Stack is reproducible out of the box.

Minimizing resources

You might want or need to be cost-effective in your development

cycle, using as few developers or machines as possible. Haskell

also reduces development costs.

Less testing is required: Haskell software requires less testing. Your developers always write tests, but with

Haskell they can write fewer, and spend less time on it.

Furthermore, fewer developers are needed to achieve a stable

system, because a type system helps limit scope of possibilities,

and lets your developers manage complexity.

Use Haskell's raw performance: Additionally, Haskell is a

fast language on a single core. It is compiled to native machine

code, and is competitive with C# and Java. At times it is

competitive with C, see Haskell from C: Where are the for

loops? for a technical demonstration. This means that you need

fewer machine resources, and fewer machines. Haskell is also easy

to write concurrent code for, which means you can make use of those

additional cores on your machines.

Flexbility to make changes

Most developments put a high priority in flexibility to change,

or should. But you may have particularly pronounced need for

flexibility in changes to requirements without disruption. This is

perhaps Haskell's strongest, most desirable advantage.

Correct by construction extends to reconstruction: Making

a change to a well-typed system in Haskell is far more stable and

reliable than its competitors because correctness invariants are

maintained with any change of the code. See also this case study by

Silk.

Less maintenance of the test suite under change: This

requires less maintenance of the test suite, because static

analysis gives your developers immediate feedback at a granular

level, whereas a test suite typically does not guide them through

the change process, it only tells them what their out-of-date

specification expects. Once the change process is complete,

updating the test suite becomes easier.

Types are rarely buggy: It's very rare to design a data

type that has bugs in it, because they are so simple. Meanwhile a

unit test or integration test suite presents additional developer

overhead because it itself is a program that requires maintenance

too.

See this Bump case

study, for why teams are choosing Haskell over Python, and

here for

the comparison against Ruby of a similar nature: Haskell yields

fewer errors and bugs.

Expanding development effort

You may find that your project requires hiring new developers

and building a team. Now is the perfect time to hire Haskell

developers. Like Python developers 10 years ago, Haskell developers are self-selecting;

they learn it because it's a better language, not because it will

guarantee them employment. At the same time, at this stage in

Haskell's development, the wealth of practical, stable packages

available indicate an infusion of pragmatic, experienced

programmers.

Summary and further reading

In summary we've seen that:

• Haskell decreases development time by narrowing the scope of development to your domain.

• Haskell decreases the need and dependency on unit testing alone.

• Haskell aids in reproducibility which helps teams work together, expand, and deploy.

• Haskell's speed and easy concurrency reduce the cost of development substantially.

• Haskell helps your developers evolve a system over time safely and with confidence, yielding more reliable time estimates.

You can learn more about using Haskell as a business at FP Complete's home page, in particular the Consulting page, or go and contact us straight away and we'll be in touch.