Well-Typed Hires Two Additional Consultants
Mon, 06 Sep 2010 13:34:35 GMT, by ian.
Filed under well-typed.
We are please to announce that, following our recent hiring process, we have taken on two additional consultants in order to meet our upcoming commitments.
Andres Löh
Andres started using Haskell in 1997. Since then, he has used Haskell for most of his programming projects. He has participated in the ICFP programming contest multiple times, and won it in a team together with Duncan Coutts, Ian Lynagh and Ganesh Sittampalam in 2004, with an all-Haskell entry.
Andres is a well-known member of the Haskell community. He maintains several tools and libraries on Hackage. He has also packaged Haskell compilers and libraries for the Gentoo and NixOS Linux distributions.
Andres obtained a PhD in Computer Science from Utrecht University in 2004. Since 2004, he has worked as a lecturer and researcher at the Institute of Cybernetics in Tallin, and at the universities of Freiburg, Bonn, and Utrecht. Andres' research is focused on improving abstraction and reuse in functional programs, by using or enhancing the underlying type system. His interests also include embedded domain specific languages, version control and typesetting.
Andres was the program chair of the 2006 ACM SIGPLAN Workshop on Haskell. He has served as a program committee member for several other academic conferences and has published regularly at conferences and journals. He also has extensive experience in teaching Haskell to undergraduate and graduate students, as well as people with an industrial background.
Andres will begin working for Well-Typed in November.
Dmitry Astapov
Dmitry has ten years of experience using Haskell for solving practical problems. He has used Haskell as a day-to-day scripting language, for large and small projects, at full-time jobs and in consulting projects. He has created several hackage packages and contributed to various Haskell projects including darcs, xmonad, bytestring, happs, HaXml and lambdabot. He has written several tutorials, written content for the Haskell wiki, and is currently editor of a Russian-language magazine on functional programming for which he writes articles on a regular basis. He has supported Haskell newcomers and mentored students as part of the Google Summer of Code programme.
He holds a bachelors degree in applied math and a specialists degree in computer science from the Taras Shevchenko National University of Kiev, Ukraine.
Dmitry has already started working for Well-Typed.
Visiting Utrecht and IFL
Fri, 03 Sep 2010 23:57:43 GMT, by duncan.
Filed under community.
I've been in Utrecht all week. As per usual I've spent most my time talking about Haskell and plotting world domination with friends and colleagues.
Andres Löh invited Don Stewart and me to give guest talks on the last day of the Utrecht summer school on applied functional programming. The idea was to give the summer school participants some perspective from people who make a living working with Haskell. Don talked about how Galois have been using Haskell for the last 10 years; what features, tools and techniques they have found to be important. I gave a semi-technical talk entitled "Monoids monoids everywhere!" about functional design patterns. The point was that identifying, capturing and abstracting over patterns is useful in real programs. I used monoids as the running example partly because they're nice and simple but also because it's somewhat surprising how far you can go with such a simple concept.
Several people have asked for the slides from the talk and I've promised to post them soon. In the live talk I drew some diagrams on the whiteboard and I'd like to add the diagrams to the slides so that the slides will make some sense on their own.
Over the weekend we had a mini-hackathon. Ian caught the ferry over and Johan Tibell flew in to join us. Johan and Don worked on optimising the Data.Map implementation. I spent much of my time reviewing Cabal patches. In particular I spent quite a while reviewing a big pile of patches from Thomas Tuegel which implement the new "cabal test" feature that he's been working for his GSoC project. He'll be presenting it at the Haskell Implementors' Workshop next month.
The latter half of the week Don, Andres and I have been at IFL. There's been lots of interesting talks on a fairly wide range of FP topics. There's been plenty of talks on parallelism and concurrency. I've been slightly surprised by the number of talks on low-level, hardware and embedded topics.
Don and I had several interesting chats with Kevin Hammond and his colleagues from the University of St Andrews about their continuing work on parallel and distributed Haskell. I think I've finally sorted out the confusion in my mind about the relationship between "GpH", "GdH", "GUM" and "Eden". For reference:
- GpH (Glasgow parallel Haskell): A language specification; this is ordinary Haskell plus the 'par' and 'pseq' primitives. GHC is an implementation of GpH for shared memory systems.
- GUM: an implementation of GpH for distributed memory systems. That is, you can write ordinary parallel Haskell programs using 'par', 'pseq' and strategies and then run it on a cluster.
- GdH (Glasgow distributed Haskell): A language plus an implementation; roughly speaking it takes parallel + concurrent Haskell (ie par, pseq, forkIO) and adds extra support for things like explicit placing of threads on nodes and node-private resources. Like the distributed implementation of GpH, it uses a global graph.
- Eden: another language plus implementation. It is like parallel Haskell but with an explicit notion of processes. Processes send values to each other but they do not share any global graph.
Oh and I finally gave in and signed Well-Typed up to twitter.
On Hiring Haskell People
Tue, 24 Aug 2010 16:53:42 GMT, by duncan.
Filed under well-typed.
A couple of months ago we announced that Well-Typed were hiring Haskell people. This is a brief report on how we went about the process of hiring and what we found. The purpose is partly to give some feedback to the many people who applied and hopefully also to provide information to other people who may be looking to hire Haskell experts in future.
The background to our decision to hire was simply that we have found we have more work to do than we have time available and that we expected this to continue. So while last year we had two people help us for short term projects, we decided that it makes the most sense to expand the size of our permanent team. Both people who worked with us last year had moved on to other exciting Haskell jobs.
Applications
We posted the job notice on our company blog (which is syndicated to Planet Haskell) and also to the haskell and haskell-cafe mailing lists. We probably should have also posted it on the CUFP jobs page.
We were pleased to get a total of 42 applications, of which 19 merited serious consideration, and we eventually settled on a shortlist of 7 to interview. We also received a couple expressions of interest from people looking for part-time work.
Advertising openly was certainly the right decision, though it does entail a fair amount of work. We received applications from well-known members of the community plus many excellent applications from people we did not know or who we were only peripherally aware of. In the end, we made two offers to people we would not have asked directly: one person we did not previously know and another person we do know but who we would not have thought to ask.
The main features of our job posting were that it was not geographically limited, the work is, we think, interesting but the rate of pay we were able to guarantee was not especially high. All of these affected the kind of applications we received. We are in the lucky position that we do not need to sit in the same physical office as our co-workers, which gives us access to a big international pool of talent. The people who applied were quite dispersed geographically, covering 21 countries. There were 18 people from the EU, 8 from the US and 16 from elsewhere including several from Australia, Russia and Ukraine.
We know that we cannot compete with large companies in terms of pay, but on the other hand we are able to offer a great deal of flexibility and work that involves using Haskell and interacting with the Haskell community. Many people wrote about their love of Haskell and functional programming and how they would like to make more use of it professionally.
Decision process
When it came to the decision making process, a key issue was that we had decided that we would need two people rather than one. Hiring two people gave us the opportunity to increase the range of skills in our team by picking people with different skills and background experience. We decided that we should aim to select one person with a mainly academic background and one person with more business and consulting experience.
Ian and I both read all the cover letters and résumés. We didn't want to influence each others initial assessments so we read everything independently and compared notes at the end. There was a wide variety in style of résumés, from 1 page bullet lists of education and experience, through to 9 pages including descriptive paragraphs. I don't think one style is a particular advantage over another; those with short résumés tended to come with longer more descriptive cover letters. A few résumés made it quite difficult to guess how much Haskell experience the applicant really has.
We decided to make an initial "longlist" by restricting our attention to people with three or more years of Haskell experience. That combined with a little more discussion and comparing notes between Ian and myself gave us a longlist of 19 people. This was quite a spectacularly talented group of people, everyone with some mixture of Haskell programming and other commercial experience. It included 5 people with 10 or more years professional programming experience, 7 people with masters degrees, 3 people with PhDs and 7 people who have used Haskell in a commercial context.
The next step of picking an interview shortlist was of course very difficult. Our aim was to interview only a handful of people. We reread and discussed letters and résumés.
It became obvious that we had a clear first choice on the academic side. In a sense we had a shortlist of one. We were thus in the slightly odd position of not shortlisting several people with excellent academic qualifications, but relatively little commercial experience.
On the commercial side, the deciding factor was (our perception of) the combination of Haskell programming skill and business experience, the latter especially in a client-facing role. Of course you cannot really assess programming skill on paper, but before the interview stage one has to go by what people say about themselves and their achievements.
We eventually picked an interview shortlist of six people on the commercial side, plus the one person on the academic side. We sent out notifications to everyone who had applied. Five of the six people had experience of either running their own company or otherwise acting in a client consulting role.
Interviews
For the interviews we decided to use IRC rather than phone or Skype. Ian devised a technical problem to use in the interviews. We had candidates log in to our server so that they could view, edit and run code during the interview. We used a shared console session so we could all see. We scheduled two hours for each interview and ended up using more or less the full time. The technical part ended up taking around 40-60 minutes and we spent the rest of each interview chatting about past experience and future plans.
The purpose of the technical problem was to assess more directly candidates ability to write Haskell programs that can be used to solve real world problems, where memory usage and performance are important. The problem was all about evaluation order and memory behaviour. We started by asking candidates to look at a short program and say what shape they would expect the heap profile to be. That would then lead on to a discussion of what things are evaluated at what stage and how much memory they are taking in the meantime. For the final step we asked candidates to rewrite the program to run in constant space. We felt overall that the technical problem was quite useful and we allowed it to become a significant factor in our final decision making process.
The choice of problem is based on our belief that a good understanding of evaluation order is very important for writing practical Haskell programs. People learning Haskell often have the idea that evaluation order is not important because it does not affect the calculated result. It is no coincidence that beginners end up floundering around with space leaks that they do not understand.
We had about a week of interviews following which we made two offers. With our shortlist of one on the academic side, the outcome was a foregone conclusion. On the commercial side we based our decision both on our prior reading of résumés etc and also on how things went in the interview. Again, the key factor was the combination of Haskell programming skill and consulting experience.
Reflection
I think all in all, given that we have never run a hiring process before, that we did OK. We could however have done better with keeping candidates informed about the process and expected timeline. The period for applications was perhaps unnecessarily long. I would welcome any feedback from people who found the process painful.
Ian and I would again like to thank everyone who applied. We appreciate the thought and effort people put in and that so many people are interested in working with us.
World map originally by John Harvey and others, CC-BY-SA.
Haskell Platform download stats
Sat, 07 Aug 2010 22:25:04 GMT, by ian.
Filed under community.
It's been just over two weeks since the Haskell Platform 2010.2.0.0 was released. The Windows and Mac installers were hosted on our new server, destined to replace haskell.org. As the server isn't yet doing anything else, this gives us some clear data for the traffic associated with the release.
Shortly after the release, the daily bandwidth graph peaked just short of 3MB/s:
Over 24 hours the rate dropped steadily, and then levelled off at 200-300kB/s:
and it isn't showing any signs of falling off yet:
So far, there have been 9613 downloads of the Windows installer, from 3947 unique IPs, and 1068 downloads of the Mac installer, from 959 unique IPs.
You can see how this compares to the previous series of releases here.
Community Server Stats
Thu, 17 Jun 2010 15:34:44 GMT, by ian.
Filed under community.
It's been just over 3 years since the Haskell community server was started, and since then 372 projects have been created. While work goes on behind the scenes to move community to a more powerful server, with a recently enlarged sysadmin team running it, here are some stats for what it's being used for.
Almost all projects use community for hosting source code, but many also use it for a trac bug tracker, a web page, and a mailing list:
Working out what licence projects use, without a lot of manual effort, is tricky, but hopefully this is a good approximation:
This data is based on licence files, and licence fields in Cabal files,
within project's /srv/code directories. The total is more than 100%
as soem projects contain files under multiple licences, and it is likely
that there are further licences that have been missed. In particular,
licences for document such as RFCs and academic papers will likely have
been missed.
Unsurprisingly, BSD3 is the most common license, with GPL and LGPL next. The "Haskell" licence is the licence used for the Haskell98 report.
Interestingly, the picture is a little different if we look at the number of bytes under each licence:
The "Haskell" licence is much higher now, as it includes any project containing a GHC tree (which is large). GHC trees also get marked as using the GPL (due to a Cabal file in Cabal's testsuite, although some of the Windows tarballs contain GPLed programs anyway) and there are also some large projects using the GPL; the combination puts GPL ahead of BSD3.
Looking at the number of users per project, most have a single developer, and the number tails of as one would expect:
Most projects have seen activity (defined as "a file in the
/srv/code directory has been modified) within the last 6 months, and
more than two thirds within the last year. Inevitably, there are some
that appear dormant:
Finally, here's a breakdown of the disk usage on community:
Interestingly, home directories account for more disk usage than
projects. This ls largely due bindists, builds and darcs
checkouts of large projects - mostly GHC. There's now a more recent GHC
in /srv/local/ghc/ghc-6.12.2/bin, but when community moves to its
new home we'll try to keep an up-to-date GHC in the default path.
Well-Typed are hiring
Fri, 07 May 2010 22:34:50 GMT, by duncan.
Filed under well-typed.
We are looking to hire a Haskell expert to work with us at Well-Typed as a Haskell consultant. We are seeing an increasing demand for our services, and are thus seeking to expand our capacity.
This is an exciting opportunity for someone who is passionate about Haskell and who is keen to improve and promote Haskell in a professional context.
The role is quite general and could cover any of the projects and activities that we are involved in as a company. The tasks may involve:
- working on the Haskell compilers, libraries and tools;
- Haskell application development;
- working directly with clients to solve their problems.
Well-Typed has a variety of clients. For some we do proprietary Haskell development and consulting. For others, much of the work involves open-source development and cooperating with the rest of the Haskell community: the commercial, open-source and academic users.
The position is initially as a contractor for one year with a salary from 150 GBP per day, plus a profit-dependent bonus. We offer flexible hours and work from home. Living in England is not required.
In the longer term there is the opportunity to become a member of the partnership with a full stake in the business: being involved in business decisions, and fully sharing the risks and rewards.
If you are interested, please apply via info@well-typed.com. Send us your CV, and tell us why you are interested and why you would be a good fit for the job. We are more than happy to answer informal enquiries. Contact Duncan Coutts or Ian Lynagh for further information, either by email or IRC.
The deadline for applications is Friday 11 June 2010.
Well-Typed delivers air traffic analysis tool for NATS
Wed, 05 May 2010 11:04:35 GMT, by duncan.
Filed under well-typed.
Well-Typed have successfully delivered an application in Haskell to meet NATS requirements in order to analyse air traffic in UK airspace. Since the beginning of the year UK airline operators have been using the software to fine-tune aspects of their future schedules.
Sid Mohangee, project manager at NATS, said:
"At the beginning of the project I set our suppliers a challenging schedule. Well-Typed's use of Haskell and a small expert team worked out well. They worked closely with me and my team and together we were able to adjust quickly to changing customer requirements. We delivered the project on schedule."
The use of Haskell allowed the software to be developed rapidly, while at the same time giving confidence in its correctness. Well-Typed used the standard suite of Haskell techniques, libraries and tools, including testing with QuickCheck and code coverage with HPC.
In light of the success in this project, NATS is considering further use of Haskell as part of its technology strategy.
About Well-Typed
Well-Typed LLP is a Haskell services company, providing Haskell consultancy services and writing bespoke Haskell applications.
About NATS
NATS is the UK's leading air traffic services provider. It provides air traffic control to all en-route aircraft in UK airspace, and to aircraft at 15 of the UK's biggest airports.
Parallel Haskell: 2-year project to push real world use
Thu, 29 Apr 2010 14:41:09 GMT, by duncan.
Filed under well-typed.
GHC HQ and Well-Typed are very pleased to announce a 2-year project funded by Microsoft Research to push the real-world adoption and practical development of parallel Haskell with GHC. We are seeking organisations to take part: read on for details.
In the last few years GHC has gained impressive support for parallel programming on commodity multi-core systems. In addition to traditional threads and shared variables, it supports pure parallelism, software transactional memory (STM), and data parallelism. With much of this research and development complete, and more on the way, the next stage is to get the technology into more widespread use.
This project aims to do the engineering work to solve whatever remaining practical problems are blocking organisations from making serious use of parallelism with GHC. The driving force will be the applications rather than the technology.
We will work in partnership with a small number of commercial or scientific users who are keen to make use of parallel Haskell. We will work with these partners to identify the issues, major or minor, that are hindering progress. The project is prepared to handle system issues, covering everything from compiler and runtime system through to more mundane platform and tool problems. Meanwhile our partners will contribute their domain-specific expertise to use parallel Haskell to address their application.
We are now seeking organisations to take part in this project. Organisations do not need to contribute financially but should be prepared to make a significant commitment of their own time. We expect to get final confirmation of the project funding in June and to start work shortly thereafter.
Well-Typed will coordinate the project, working directly with both the participating organisations and the Simons at GHC HQ. If you think your organisation may be interested then get in touch with me, Duncan Coutts, via info@well-typed.com.
To the Hackathon!
Wed, 17 Mar 2010 14:15:09 GMT, by duncan.
Filed under community.
I'm off tomorrow morning to the Haskell Hackathon in Zurich. I'm looking forward to seeing people.
I don't have particular plans yet for what I will be working on, though undoubtedly it'll be related to the Cabal/Hackage/Platform projects. Of course the point of a hackathon is to get people together to share ideas and enthusiasm, so it's usually best not to have too fixed ideas about how to spend one's time.
By the way, in case anyone has been wondering why I've been so quiet since the beginning of the year; I've been in hiding (i.e. mostly offline) doing the final push on my DPhil thesis. It's getting pretty close now; I sent my long-suffering supervisor a 180-page draft the other day. I'm really looking forward now to getting it over with and moving on to new commercial and academic projects.
Talk at the Functional Programming eXchange
Wed, 09 Dec 2009 19:18:18 GMT, by duncan.
Filed under community.
I gave a talk a couple days ago at the Functional Programming eXchange event organised by Skills Matter in London.
Strong Types and Pure Functions
It was an interesting event. We had about 50 people attend, mostly professional programmers with day jobs doing development on the JVM and .NET platforms. Sadek Drobi gave the opening talk about computational abstraction, by which he meant monadic glue code. He explained why we want it and showed examples in C#, Scala and F#. I hadn't realised that the C# LINQ stuff is actually general monad syntax. It was fun to see Sadek telling all these professional programmers that what they really want are functors, applicative functors and monads.
I gave a talk in the afternoon about some of the things you can do if you go all the way with FP and use a purely functional language (rather than a hybrid). I explained a technique for making interfaces where you use types to enforce which side effects are allowed. Of course this means making custom monads so it was good that Sadek had introduced that topic in the morning. The feedback I got was that this was one of the more technically advanced talks, but I think that was ok since it wasn't essential to understand every last detail to get the point.
Overall I think it went quite well, especially given it was the first time the event has been put on. I expect that other members of the Haskell community might like to take part in future (Ganesh Sittampalam and Matthew Sackman also spoke this time). Also, Skills Matter are planning to do an FP journal/magazine aimed at mainstream professional programmers. Hopefully that'll be another good way to get our message out. Get in touch with me or Robert Pickering if you're interested in either the conference or the journal.