Software Simply

What's in a name? A lot.

2011-12-06T11:20:00.001-05:00

One letter identifier names have been getting bad press recently. The other day a post entitled Name Your Type Variables! got some discussion on the Haskell reddit. I agree with the author's value of good names, but I disagree with the specific examples he uses as well as his sweeping condemnation of one letter names. Since I am the primary author of one of his examples and have contributed code

Patterns in Chess Square Enumerations

2011-04-20T06:52:00.000-04:00

In my bit manipulation post awhile back I posed a problem involving "closed form" calculation of chess endgame table indices. Back when I originally solved the problem, it was a big help to create some visualizations of some of the patterns embedded in the square numbering scheme. I had mentioned that I thought the patterns were interesting, so I thought I'd come back and elaborate on that

Splice Subtleties

2011-04-18T10:18:00.014-04:00

In the recent release of Heist 0.5.1, there was performance bug in my implementation of head merging. I turned off the head merging, and then fixed the bug but did not reenable head merging. If you want to turn it back on, you need to bind the html tag to the htmlImpl function from the Text.Templating.Heist.Splices.Html module. I think I'll continue to leave it off by default because it does

Heist Template Abstractions in a Nutshell

2011-04-15T15:10:00.000-04:00

In the last post I discussed how logic and control flow can (and I argue should) be done in splices where types, higher order functions, and the full power of Haskell can be applied to the problem. In this post I want to take some time to think about the raw materials that are available in templates. At the lowest level, we have just Text (...which is certainly /= Nothing). The templates are

Looping and Control Flow in Heist

2011-04-14T08:20:00.003-04:00

One of the most frequent questions I get about Heist is how to do loops or control flow in Heist templates. I usually respond that we've tried to avoid introducing these constructs into templates to encourage a better separation between view and model/controller. In this post I want to discuss the issue in more detail so that my thoughts are stored and I can refer people here in the future.

Views, Controllers, and Heist

2011-04-13T08:55:00.010-04:00

A very common question when using Heist is how to specify views in a splice. There are three different approaches one can take: 1. Specify a splice's view in the Haskell code implementing the splice. 2. Get a splice's view from a template. 3. Pass the desired view to the splice as the spliced tag's child nodes. Aproach #1 tends to be ugly and violates the principle of separating logic and view

Heist in 60 Seconds

2011-04-11T09:04:00.088-04:00

A template system is a bridge between static data (templates) and dynamic data. Heist is a template system bridging HTML templates and Haskell code. A splice is code that Heist binds to an HTML tag. Every time the tag appears in a template, Heist runs the splice bound to that tag and passes the tag (including its attributes and its children) as input to the splice. A splice's output is a list

Heist Gets Blaze Syntax

2010-12-26T10:36:00.004-05:00

Update: Heist has switched from using hexpat to using xmlhtml as of version 0.5. You can still use blaze syntax as described in this post, but you have to import Text.Blaze.Renderer.XmlHtml instead. Users of Heist, my Haskell templating system, got a very nice surprise for Christmas this year when Jasper Van der Jeugt uploaded a new package blaze-html-hexpat to Hackage. If you're not familiar

Numerical Sequence Puzzle

2010-11-21T13:49:00.002-05:00

What's the next number in this sequence, and how is it determined? 1, 3, 5, 9, 15, 31, 61, 125, 251, 503, 1015, 2035, 4081, 8177, 16367, 32747, 65511, ? Years ago I spent some time playing around with integer sequence puzzles. I ended up constructing a few puzzles based on ideas I had never seen used before. Sometime between 1995 and 1998 I published four of them in my user profile on the

Log Analysis Commentary

2010-06-10T06:21:00.005-04:00

I've hade some requests to explain some of the less common functions used in my log analysis screencast. I think the most straightforward approach is to examine each of the lines in a literate Haskell style. This is going to be a long-winded description of exactly what's going on. If you understood everything in the screencast, this post will probably bore you. But if you found yourself

Heist 0.2 Released

2010-06-08T15:37:00.012-04:00

Yesterday I released version 0.2 of the Heist XML templating library. This release makes some significant API changes, so it may break existing applications. But if you're only using Heist for basic templating, then you probably won't have to change anything. However, http://snapframework.com uses Heist extensively; and it did not require any code changes to upgrade. Here is a summary of what

Haskell Scripting: Log Analysis

2010-06-07T08:50:00.004-04:00

The other day I wanted to analyze some of my website log files to get a better idea of how many active users I have. I've been meaning to do this for quite some time, but have kept putting it off. I decided to see what I could accomplish by just doing some experimenting in GHCI. It was so easy and convenient that I decided to do a screencast demonstrating what I did and how easy it was. The

Standardizing Go

2009-11-11T11:59:00.017-05:00

The web is abuzz with the recent announcement of the Go Programming Language. I've put a decent bit of thought into similar issues over the years, so I thought I'd chime in on the discussion. To start with, Go is targeting a niche which I think has been need of filling for a long time. The Go home page bills it as "a systems programming language", but I don't think that name completely

Dynamic List Formlets in Haskell

2009-08-11T15:33:00.009-04:00

The Haskell Formlets library (described here) provides an elegant abstraction that takes the tedium out of HTML form generation, validation, and processing (not to mention make it less error prone). This abstraction allows you to develop HTML form UIs while still thinking in and working with haskell's type system and data structures. It also fits very naturally with Happstack's ideas about

Bit Manipulation Problem

2009-05-14T16:21:00.010-04:00

This post is a bit different from my usual content. It's not about Haskell or functional programming, and not strictly about software. But I think it's a nice little brain teaser that may be of interest. Some may view it as too much tedium (congruent to 3 or 4 mod 5 in Knuth's scoring system), but I found the multitude of beautiful patterns in this problem interesting enough that I didn't

Adding Authentication to the Blog App

2009-04-08T09:00:00.000-04:00

In the last post, we developed a very basic blog application using Happstack. Now that we have a simple application without an authentication mechanism, let's see how much effort it takes to add authentication using the Happstack-Auth module mentioned here. First let's make an outline of what needs to be done. We need the following pieces of functionality: Pages for login/registration

Basic Happstack Blog App

2009-04-07T11:00:00.010-04:00

Happstack is improving, and my old blog posts on HAppS are now out of date. So we're in need of a bare-bones app to demonstrate functionality. I also wanted a simple app without authentication capability to demonstrate how to integrate Happstack-Auth into a project. Blog apps seem to be one of the canonical beginner's examples in the web framework world, so I thought that would be a good

A Standalone Auth Framework for Happstack

2009-04-06T19:01:00.003-04:00

It's been awhile since my series of posts outlining some of the basic ideas behind the HAppS Haskell web framework (which is since been renamed Happstack). Ever since I started developing it I envisioned a standalone library, perhaps shipped as a part of happstack, that would make it trivial for anyone to add robust authentication to their application. After doing some more work on Happs(tack)

Happstack: An Interview with Matthew Elder

2009-01-28T13:07:00.014-05:00

HAppS development has been all but stopped for almost a year (as have my posts about it). Recently Matthew Elder took up the flag with a new project called Happstack. I thought this would be a good time to catch up with Matthew and find out why he is doing this and where he is going with it. So without further ado, here is Matthew Elder on Happstack. Is Happstack a fork or a rename? Happstack

To Template Or Not To Template

2008-03-06T20:53:00.002-05:00

Since developing the tutorial in the last few posts, I have been working on developing a real web app in Haskell with HAppS. Now that I know my way around the basics of HAppS, I need to move on to generating actual HTML (as opposed to the plaint text messages that the tutorial used). Before starting, I had to decide what methodology I would use to generate the HTML. I'm new to web development

HAppS Demo

2008-03-02T21:08:00.002-05:00

Several people requested that I post a link to a running instance of the HAppS code that I developed here over several posts. One person was nice enough to actually offer me the use of a server. So the demo is now up and running. It's not at all meant to be user friendly, since it's just a demo of the basic HAppS capabilities. So here are a list of links that are useful. http://

How I Learned to Stop Worrying And Love Haskell's Type Inference

2008-02-29T11:32:00.002-05:00

In developing the HAppS example that I have been posting here, I came upon a problem that gave me new insight to Haskell. I don't think it was a particularly deep insight, but it is significant to me as someone new to the language, and new to type inference. Consider a user authentication function that retrieves a map from the reader monad, looks up a username, and compares the password

Transactional Integrity Problem

2008-02-28T11:48:00.001-05:00

An astute reader pointed out that there is a transactional integrity problem with the HAppS application built over the last 4 posts. The function checkAndAdd in Finished HAppS Application contains a call to "query $ IsUser" as well as a call to "update $ AddUser". This violates that ACID guarantee that was desired from the checkAndAdd function. If two people simultaneously try to create the

Finished HAppS Application

2008-02-26T21:36:00.007-05:00

Update: Due to popular demand, I put the plain haskell code for this app on hpaste.org. Here are links for Session.hs, Main.hs, and login.html. The past three posts have laid the groundwork for a full HAppS web app. We have built the infrastructure for an authentication system that can store usernames and passwords as well as the session IDs for active sessions. Here we will tie everything

Using HAppS-State

2008-02-25T17:41:00.002-05:00

Update: A demo of the finished application is now available. See this post for more information. In the last post, I outlined the requirements for making a data type an instance of Component. This is great, but not very useful without a mechanism for accessing the state data. HAppS persists its state by storing functions that operate on the state. This requires a way to serialize the