When you develop a lot of different Haskell packages that work together, managing all these packages and their versions can be difficult. In this talk, I'll explain how we deal with this at Silk. I will show how to use Hackage 2.0 to build your own internal package repository, how to use cabal-dev to manage installed packages, and show a tool for bumping package versions. Together, this makes working on large amounts of packages with multiple people much easier.

When you develop a lot of different Haskell packages that work together, managing all these packages and their versions can be difficult. In this talk, I'll explain how we deal with this at Silk. I will show how to use Hackage 2.0 to build your own internal package repository, how to use cabal-dev to manage installed packages, and show a tool for bumping package versions. Together, this makes working on large amounts of packages with multiple people much easier.

Model checking turned out to be a useful tool for the analysis of programs. Usually one transforms abstract syntax trees to control flow graphs, which offer a abstract representation of program behavior. Whenever one is not focused on program behavior but on structural properties of the program (e.g. semantic analysis of a compiler), model checking the abstract syntax tree comes in handy. My talk introduces a problem, which can be solved using model checking abstract syntax trees. Additionally, different approaches for a implementation will be discussed.

Model checking turned out to be a useful tool for the analysis of programs. Usually one transforms abstract syntax trees to control flow graphs, which offer a abstract representation of program behavior. Whenever one is not focused on program behavior but on structural properties of the program (e.g. semantic analysis of a compiler), model checking the abstract syntax tree comes in handy. My talk introduces a problem, which can be solved using model checking abstract syntax trees. Additionally, different approaches for a implementation will be discussed.

Everyone who has more than one account on Linux/Unix/OS X systems knows how hard is can be to keep track of all the different config files in your home directory. <tt>.vimrc</tt>, <tt>.muttrc</tt>, <tt>.hgrc</tt>, <tt>.screenrc</tt>, <tt>.bashrc</tt>, and <tt>.xinitrc</tt> are just a few, but we're sure you can come up with many more yourself. Imagine how wonderful your life could be if you just had an easy tool to keep track of different versions of all these files on all your machines. We argue that traditional version control systems on their own are not up the task and we provide an alternative.

Everyone who has more than one account on Linux/Unix/OS X systems knows how hard is can be to keep track of all the different config files in your home directory. <tt>.vimrc</tt>, <tt>.muttrc</tt>, <tt>.hgrc</tt>, <tt>.screenrc</tt>, <tt>.bashrc</tt>, and <tt>.xinitrc</tt> are just a few, but we're sure you can come up with many more yourself. Imagine how wonderful your life could be if you just had an easy tool to keep track of different versions of all these files on all your machines. We argue that traditional version control systems on their own are not up the task and we provide an alternative.

−

* [https://github.com/toothbrush/dotfs On GitHub]

+

* [http://prezi.com/-acujvowpciq/dotfs Slides] on prezi.com

+

* [http://hackage.haskell.org/package/dotfs dotfs] on Hackage

+

* [https://github.com/toothbrush/dotfs dotfs] on GitHub

+

* [https://vimeo.com/42304273 video] on Vimeo

=== <span id="gruze"></span>Snap and Gruze ===

=== <span id="gruze"></span>Snap and Gruze ===

Line 121:

Line 137:

Developing an astronomy application using Snap and an experimental entity-attribute-value store for Haskell.

Developing an astronomy application using Snap and an experimental entity-attribute-value store for Haskell.

=== <span id="fclabels"></span>fclabels: First Class Record Labels for Haskell ===

=== <span id="fclabels"></span>fclabels: First Class Record Labels for Haskell ===

Line 155:

Line 179:

Haskell's record system for algebraic datatypes uses labels as accessors for fields within constructors. Record labels can be used for both selection and modification of individual fields within value, but only selection can be composed in a natural way. The special syntax for updates makes composing modifications very cumbersome. The fclabels package tries to solve this problem by implementing field accessors as first class Haskell values instead of special syntax. Labels are implemented as lenses and can easily be composed for both selection and modification. To avoid boilerplate labels can be derived using Template Haskell. This talk will give a brief introduction into the usage of the library and will show a bit of the inner workings as a bridge to future

Haskell's record system for algebraic datatypes uses labels as accessors for fields within constructors. Record labels can be used for both selection and modification of individual fields within value, but only selection can be composed in a natural way. The special syntax for updates makes composing modifications very cumbersome. The fclabels package tries to solve this problem by implementing field accessors as first class Haskell values instead of special syntax. Labels are implemented as lenses and can easily be composed for both selection and modification. To avoid boilerplate labels can be derived using Template Haskell. This talk will give a brief introduction into the usage of the library and will show a bit of the inner workings as a bridge to future

The Haskell websockets library allows you to write WebSocket-enabled
servers in Haskell, bidirectional communication with the browser.
However, browsers and their related specifications change fast, and
there are different versions of the WebSockets protocol. This talk
discusses a type-safe technique which disallows the programmer from
using primitives not available in the chosen version, while still
allowing the latest features.

When you develop a lot of different Haskell packages that work together, managing all these packages and their versions can be difficult. In this talk, I'll explain how we deal with this at Silk. I will show how to use Hackage 2.0 to build your own internal package repository, how to use cabal-dev to manage installed packages, and show a tool for bumping package versions. Together, this makes working on large amounts of packages with multiple people much easier.

Model checking turned out to be a useful tool for the analysis of programs. Usually one transforms abstract syntax trees to control flow graphs, which offer a abstract representation of program behavior. Whenever one is not focused on program behavior but on structural properties of the program (e.g. semantic analysis of a compiler), model checking the abstract syntax tree comes in handy. My talk introduces a problem, which can be solved using model checking abstract syntax trees. Additionally, different approaches for a implementation will be discussed.

Everyone who has more than one account on Linux/Unix/OS X systems knows how hard is can be to keep track of all the different config files in your home directory. .vimrc, .muttrc, .hgrc, .screenrc, .bashrc, and .xinitrc are just a few, but we're sure you can come up with many more yourself. Imagine how wonderful your life could be if you just had an easy tool to keep track of different versions of all these files on all your machines. We argue that traditional version control systems on their own are not up the task and we provide an alternative.

[edit]1.6 Invitation to Participate in a Functional Programming Case Study

Jurriaan Hage (UU)

I want to invite you to participate in an experiment in Haskell.
In this experiment we are going to pit HaRe (the Haskell Refactorer)
against Holmes (my plagiarism detector). The goal is to find out how much
time somebody needs to refactor a Haskell program into something that
is not recognizable by Holmes as plagiarism. We shall be looking at
two groups of study: experienced programmers (we shall pretend they
are paid for by newbies to make their assignments for them, and to do
so without starting from scratch), and the newbies themselves.
This experiment is a collaboration with Simon Thompson of Kent.
He will take charge of the newbies, my task is to perform the experiment
with experienced Haskell programmers, which is why I am now seeking for
participants.

Haskell's record system for algebraic datatypes uses labels as accessors for fields within constructors. Record labels can be used for both selection and modification of individual fields within value, but only selection can be composed in a natural way. The special syntax for updates makes composing modifications very cumbersome. The fclabels package tries to solve this problem by implementing field accessors as first class Haskell values instead of special syntax. Labels are implemented as lenses and can easily be composed for both selection and modification. To avoid boilerplate labels can be derived using Template Haskell. This talk will give a brief introduction into the usage of the library and will show a bit of the inner workings as a bridge to future
extensions.

With each new version, GHC brings new and exciting type-level features to the
Haskell language. In this talk we look at some upcoming features for GHC 7.6:
data kinds, kind polymorphism, type-level literals, and deferred type errors.
We show through some example programs how to take advantage of the new features,
and what possibilities they open for Haskell programmers.