サクサク読めて、アプリ限定の機能も多数!
トップへ戻る
iPhone 16
www.fpcomplete.com
Applied Haskell is a commercial training program focusing on teaching intermediate Haskell. The goal is to help someone move from knowing Haskell basics to being able to write commercial software, with enough knowledge to pick up any new skills needed on demand. If you’re new to Haskell, please check out our learning page for introductory material. The content below is freely available. If you’re
Many common programming languages today eschew manual memory management in preference to garbage collection. While the former certainly has its place in certain use cases, I believe the majority of application development today occurs in garbage collected languages, and for good reason. Garbage collection moves responsibility for many memory issues from the developer into the language’s runtime, m
Example code can be found here. When Node.JS first came onto the scene it successfully popularized the event-loop. Ryan Dahl correctly identified a serious problem with the way that I/O is generally handled in concurrent environments. Many web servers, for example achieve concurrency by creating a new thread for every connection. In most platforms, this comes at a substantial cost. The default sta
The language Scala promises a smooth migration path from Object-oriented Java to functional programming. It runs on the JVM, has concepts both from OOP and FP, and an emphasis on interoperability with Java. As a multi-paradigm language, Scala can flatten the learning curve for those already familiar with OOP, at the price of making some compromises in language design that can make functional progr
Scripting in Haskell Writing scripts in Haskell using Stack is straight-forward and reliable. We’ve made a screencast to demonstrate this: Summary Slides in the screencast cover: What Haskell is What Stack is We make a case for reproducible scripting We cover the following example cases: Hello, World! as a Haskell script Generating a histogram of lines of a file Using FSNotify to watch a directory
Last week, I was at DevConTLV X and attended a workshop by Aaron Cruz. While the title was a bit of a lie (it wasn’t four hours, and we didn’t do a chat app), it was a great way to see some basics of concurrency in different languages. Of course, that made me all the more curious to add Haskell to the mix. I’ve provided multiple different implementations of this program in Haskell, focusing on dif
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
Typeclasses such as Bifunctor are often expressed in terms of whether they are covariant or contravariant. While these terms may appear intimidating to the unfamiliar, they are a precise language for discussing these concepts, and once explained are relatively easy to understand. Furthermore, the related topics of positive and negative position can greatly simplify how you think about complex data
The content below is still correct, but has been absorbed into the more comprehensive safe exception handling tutorial document instead. I recommend reading that, which provides more information and more up-to-date library references. Over the years, I’ve written a number of different documents, tutorials, comments, and libraries on how to do proper exception handling in Haskell. Most of this has
In our last blog post we showed you the new docker init executable pid1. What if we wanted to use our shiny new pid1 binary on a CentOS Docker image but we compiled it on Ubuntu? The answer is that it wouldn’t likely work. All Linux flavors package things up a little differently and with different versions and flags. If we were to compile pid1 completely static it could be portable (within a given
The other day I threw together a quick program to solve an annoyance some people on our team were expressing. We sometimes do our development on remote machines, but would still like to use local file editors. There are plenty of solutions for this (SSHFS, inotify+rsync), but none of us ever found a prebaked solution that was low-latency and robust enough to use regularly. The program I put togeth
Working with data in Haskell In data mining or general exploration, it’s common to need to easily access data efficiently and without ceremony. Typically, a programming language will be designed for this case specifically, like R, or a library will be written for it, like Python with the pandas library. Implementing this in Haskell, we improve upon this area with all the benefits that come with us
We have set up a new public Jenkins CI server for use with our open source projects. This server currently runs the Stack integration tests, and deploys to ci.haskell-lang.org and ci.stackage.org every time a commit is pushed to the master branch of their respective repositories. In the future, we also intend to set up Jenkins to run the Stack integration tests on all supported platforms (rather t
This blog post is an initial announcement of a new package, safe-exceptions (and Github repo). This is a follow up to a number of comments I made in last week’s blog post. To quote the README: Safe, consistent, and easy exception handling Runtime exceptions – as exposed in base by the Control.Exception module – have long been an intimidating part of the Haskell ecosystem. This package, and this RE
For a change of pace, I wanted to cover a simple topic: asynchronous exceptions, and how they interact with Software Transactional Memory and MVars, as well as the GHC runtime system’s deadlock detection. As fate would have it, the topics in question occurred twice in the past month, once in a bug report against the yaml package, and once in a major refactoring of FP Complete’s distributed computa
Work motivation While working for various clients that needed fast binary serialization, we had discovered that the binary and cereal packages are both inefficient and so we created the store package. In the high-frequency trading sector, we had to decode and encode a binary protocol into Haskell data structures for analysis. During this process it was made apparent to us that while we had been at
A couple months ago, Michael Snoyman wrote a blogpost describing an experiment in an efficient implementation of binary serialization. Since then, we’ve developed this approach into a new package for efficient serialization of Haskell datatypes. I’m happy to announce that today we are putting out the initial release of our new new store package! The store package takes a different approach than mo
We do a lot of work at FP Complete in the realm of multi-machine computing for our customers. One of the things we need to do efficiently to get good speedups from adding more machines is optimizing serialization. Since our multi-machine work often revolves around scientific and mathematical computing, we primarily need to make sure that there is efficient serialization of primitive data types (li
Using Stack for build of Haskell code on Travis CI has number of benefits. For those unfamiliar with it, Travis is a cloud-base continuous integration system, which will build and test your code automatically. It integrates with Github and is free for open-source projects (but also has paid plans for private projects). Stack’s use of cached packages built from Stackage snapshots means builds will
You can use Stack and the Stackage snapshots with GHC 7.10.3 right now! By default (since v0.1.4), Stack insists that the minor version of GHC matches the version that was used to build the Stackage snapshot. This means that using the current LTS 3.x and nightly snapshots will require GHC 7.10.2, even if GHC 7.10.3 is installed (as this is the safest option for reproducability). However, this beha
www.schoolofhaskell.com
Interactive code snippets not yet available for SoH 2.0, see our Status of of School of Haskell 2.0 blog post This outline provides a wide array of content, focused on practical lessons towards writing real-world applications. It presumes a basic knowledge of Haskell, as would be gained from books such as Real World Haskell and Learn You a Haskell. Much of the content described below does not yet
Kubernetes (AKA “k8s”) From kubernetes.io: Kubernetes is an open source orchestration system for Docker containers. It handles scheduling onto nodes in a compute cluster and actively manages workloads to ensure that their state matches the users declared intentions. Using the concepts of “labels” and “pods”, it groups the containers which make up an application into logical units for easy manageme
The stack build tool is a cross-platform program for developing Haskell projects. It is aimed at Haskellers both new and experienced. I recently put together an in-depth guide to using stack for Haskell development. EDIT The content below is now significantly outdated. We strongly recommend reading the guide on the Stack website. The official home for this document is in the stack repository. Belo
Interactive code snippets not yet available for SoH 2.0, see our Status of of School of Haskell 2.0 blog post An ArrayArray# is just an Array# with a modified invariant. It points directly to other unlifted ArrayArray#'s or ByteArray#'s. While those live in #, they are garbage collected objects, so this all lives on the heap. They were added to make some of the Data Parallel Haskell stuff fast whe
I’ve spent some time over the past few weeks working on problems stack users have run into on Windows, and I’d like to share the outcome. To summarize, here are the major problems I’ve seen encountered: When linking a project with a large number of libraries, GHC hits the 32k command length limit of Windows, causing linking to fail with a mysterious “gcc: command not found.” On Windows, paths (at
TL;DR: if you just want to get started use stack‘s Docker support, see the Docker page on the stack wiki. The rest of this post gives background on the benefits, implementation, and reasons for our choices. A brief history Using LXC for containerization is an integral component of the FP Complete Haskell Center and School of Haskell, so lightweight virtualization was not new to us. We started tent
Interactive code snippets not yet available for SoH 2.0, see our Status of of School of Haskell 2.0 blog post perf and low-level Haskell programsTL;DR: perf can be particularly helpful when profiling performance critical sections of your programs. We show how through an example. The perf_events framework in the linux kernel, together with the perf userland tools, can be used to profile application
This blog post is intended to answer two very frequest questions about stack: how is it different from Cabal? And: Why was it developed as a separate project instead of being worked on with Cabal? Before we delve into the details, let’s first deconstruct the premises of the questions. There are really three things that people talk about when they say “Cabal”: a package metadata format (.cabal file
A few weeks ago, we announced the first public beta of stack, a new build tool for Haskell. Since then we’ve seen a huge amount of work on stack: code contributions, feature requests, bug reports, and design discussions. In other words, the response we’ve had from the community has been amazing. Thank you for helping us push forward with improved Haskell tooling. Today we’re announcing a new miles
次のページ
このページを最初にブックマークしてみませんか?
『Home Page - FP Complete』の新着エントリーを見る
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く