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
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
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
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
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
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.
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
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
See this Bump case
study, for why teams are choosing Haskell over Python, and
the comparison against Ruby of a similar nature: Haskell yields
fewer errors and bugs.
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
Summary and further
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
- Haskell aids in reproducibility which helps teams work
together, expand, and deploy.
- Haskell's speed and easy concurrency reduce the cost of
- 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
Subscribe to our blog via email
Email subscriptions come from our Atom feed and are handled by Blogtrottr. You will only receive notifications of blog posts, and can unsubscribe any time.
Do you like this blog post and need help with DevOps, Rust or functional programming? Contact us.