The best way today to write robust, maintainable, and efficient software
Haskell is an advanced, purely-functional programming language. Haskell's combination of static and strong typing, declarative style, user-friendly syntax, wide collection of real-world libraries, top-notch tooling, and great educational and support resources, make it a great choice for creating robust, high-performance applications with quick time-to-market.
FP Complete is ready to help you take advantage of this wonderful technology with our consulting offerings and custom training, as well as many online learning resources.
FP Complete's CEO, Aaron Contorer, explains Haskell's strengths
There are many case studies from companies that have successfully used Haskell for scientific software, distributed computing, and user-facing web applications.
The Haskell Language website contains more information, including getting start guides, tooling links, tutorials, and community information.
At FP Complete, we've chosen Haskell as the cornerstone of most of our technology decisions…
because it works
… and it works better than other software out there. While there are many benefits to this language, we believe that it is a great choice for commercial development for primarily three reasons:
Regardless of your industry, odds are pretty good that the faster you can deliver results, the better. Haskell delivers on this by providing a high level, expressive language. Leveraging the extensive set of libraries available, you can quickly build a working prototype application.
Typical Haskell applications are about the same number of lines of code as equivalent Python or Ruby applications. But unlike those other languages, Haskell prototypes are typically easily converted to production applications due to their higher maintainability and better performance.
In contrast to other languages like C++, Java, and C#, Haskell applications are typically much shorter. You can avoid much of the boilerplate necessary in these languages to get basic functionality, and express your programs declaratively thanks to the combination of functional programming and Haskell's type-first approach.
And while Haskell gives you the option to have fine-grained, low level control, by default you can write at the high level you'd like to in order to elegantly express your solution.
Like most modern languages, Haskell has a strong ecosystem and culture around tested software. It features common paradigms like unit, functional, and integration testing, together with comprehensive test suite libraries. However, Haskell takes this a step further with a few types-first features:
Many people experienced with languages like Java and C++ are used to the worst of a type system: a weakly typed system that forces the developer to do a lot of busywork. Haskell features type inference, letting the developer avoid explicit work around typing, while using its stronger type system to give you better guarantees.
Besides typing features, Haskell uses well thought out solutions to complicated problems:
All this put together gives you the ability to produce code with less bugs, and evolve that code for new features and changing requirements with more confidence.
Idiomatic, high-level Haskell code is typically quite fast, on average about half the speed of highly tuned C++ code. This is due to highly optimized libraries like vector and techniques like stream fusion, as well as mature native code generation. Sophisticated profiling techniques like us zero in on performance hot spots, and easy access to low-level techniques and an elegant Foreign Function Interface let us speed up those hot spots quickly.
Beyond this unique mixture of elegance and speed, Haskell also offers a best-in-class multicore experience. Haskell's purity makes many parallelism problems trivial. And for non-trivial problems, well designed libraries like async and concurrency primitives like STM can knock down problems from complicated and error prone to easily verified as correct.
Finally, Haskell's green thread based runtime makes it simple to implement highly concurrent network services. Green threads are significantly faster than system threads due to their avoidance of kernel context switches. And unlike callback-based systems found in other languages, code remains simple and avoids accidental blocking of the entire system due to long-running computations.
FP Complete is the world’s #1 provider of Haskell expertise, consulting, and commercial-grade tools. Our team contributes prolifically to the open source Haskell world, and FP Complete has developed and continues to maintain many important aspects of the Haskell ecosystem, including:
Learn more about FP Complete consulting
We've created a world-class devops platform to host our Haskell code. Learn more about our devops platform and what it can do for you.