How to stand out digitally

I was asked by Adam Jolly to give some advice about the web and its value to small businesses for his forthcoming book The Growing Business Handbook. I'm very happy to acknowledge help from colleagues in the KITC, and particularly Vishal Soni and Jason Marshall 

The article

If you are searching for growth, look online. In the UK, the web economy now accounts for 8.5% of all activity, which is a higher figure than any of the world’s other main markets.

To give you a sense of scale of the change that is happening, consider online groceries. They already account for 4.5% to 5% of the market. If they continue growing at their current rate of 15% a year, their share will be 10% to 12% by 2020.

So how can you as a small enterprise start capturing this potential? Here are a series of relatively easy steps that you can take that might end up transforming your business without saddling yourself with too many extra costs.

Phase 1: web presence

First, change your mindset. It is no longer a matter of thinking whether you should be online, but about how you must build your presence.

At a minimum, whether you are florist in Canterbury, a curry house in Margate or anyone else, you have to create a basic web page. It is how your customers now find you. Many brands represent themselves through their “domain name” like google.com, or amazon.co.uk, so it’s worth finding which domain name you can purchase for yourself, such as floratheflorist.co.uk. This name will then be a key part of your overall brand, and you can then publicise it through local online directories, many of which are free.

At this web site, as well as saying who you are and where you are, you can start adding details that your customers will find useful, such as what you have on the menu or what bouquets you might recommend for different occasions.

Alongside your own activities, it will be worth placing yourself within a wider picture. As a florist, you might point customers towards your preferred maker of vases and carry a link to an online ordering service like Interflora.

Similarly, at the restaurant, you might plug yourself into a national infrastructure for making bookings. Any visitors are likely to go through one of these networks in planning their trip. Like most of us, they are likely to rely on recommendations from other customers on sites such as Trip Advisor. These reviews can be highly influential in how anyone unfamiliar with your area makes their spending choices.

Phase 2: social media

So far, you are still taking a relatively passive digital approach. On the web, you generally rely on customers to come to you. On social media, or Web2.0 as it’s sometimes called, you can connect them with more directly.

If you build your own page on Facebook, you can start sending out messages to those who choose to like you, highlighting any special offers you might be running.

On Twitter, you can create an account for yourself by finding a name that no-one else is using and put a @ in front of it, like @floratheflorist. Anyone who follows you will then receive your tweets. It is a powerful way of starting to build a relationship.

When you tweet, you can highlight any words or phrases, such as flowers for Easter, with a hash tag #flowersforeaster. Anyone who is searching for that hash tag will then find you.

You need to find followers, of course. People may give you all sorts of different advice, but probably the simplest way is to follow people: if you follow them they are more likely to follow you. Then, once anyone comments on you and you respond, all their followers will see what you have to say. Another way of attracting followers is to forward (or “retweet”) others’ tweets.

Advertising on the web has completely changed how advertising works. Instead of placing an ad in a newspaper, and hoping that some of the readers will respond, it’s now possible to target your advertisements. You can choose to advertise to people who search for particular words, and you only pay when someone has clicked on the link to read more. The cost will depend on the level of demand for any combination of words. ‘Cheap booze’ is likely to command a premium. ‘Curries in Margate’ or ‘flowers in Canterbury’ are likely to much more affordable.

Phase 3: e-commerce

Once you have worked through these options, you will have created your online presence. The next stage is to start making sales directly through e-commerce. Again, you can go a long way without incurring too many upfront costs, or too much technical effort.

You can create your own shop on e-Bay, who, as well as running auctions, let you sell direct through their ‘buy it now’ option. Or you can become a partner on Amazon and appear on its listings when customers search for your type of product. For services, like hotels and restaurants, sites like Trip Advisor are now moving beyond its origins in customer advice into linking directly to hotel booking sites like hotels.com. If you want to sell through your site, companies like PayPal will process payments for you, saving you the complications of managing credit cards.

Potentially, such activities will transform the nature of your business. Think about second-hand books. We used to travel the country, dropping into shops in the hope of finding a title. Now you can essentially see a whole country’s stock of second-hand books on a site like abebooks.com in an instant.

Equally, in your own business, you might start expanding into areas you never thought possible before. Our florist in Canterbury, for instance, could look at selling animated cards to send with bouquets.

Phase 4: brand dialogue

By inviting your users to start conducting a conversation with your brand, you are moving from a static presence online to a more dynamic two-way flow. But how do you keep yourself fresh and ready to engage? 

Right at the start, you want to make sure that you retain the option to manage your content. Many of the companies we see at the University of Kent tend to create a striking first site, which they struggle to adapt as the nature of their business changes and expands. One way of keeping your site up to date is to use a Content Management System (or CMS); your web site developer can advise you about this.

Later, as you move into social media, you have to be ready for the eccentric and unexpected comments that you might attract. So it is worth thinking in advance about the tone you might adopt. If a slip-up happens, rather than being defensive, it is generally better to be graceful. Your relationship with your customers and clients has changed: now you are in a conversation with them, and keeping track of what’s happening on your social media is something that you need to keep on top of. That way, you can keep building your audience.

Once you have taken the steps here, your business will be more sustainable, because you’re visible in the media that people – particularly young people – are increasingly turning to. As well as this, you’ll have found new business directions and hopefully you’ll be interacting with new groups of customers in different ways.

You’ve seen how quickly things have changed in the last five years with the advent of twitter … one thing for sure is that there will be the same number of surprises in the next five years, so keeping up with what’s going on on the web is a real priority for all small businesses.

Social media policy 

• Define: What type of company you want to be seen as - informal, formal etc. Remember your target audience.
• Time: Online promotions and monitor the response
• Monitor: What is the sentiment toward your business and topics related to you
• Respond: To the key topics that are related to your business and to your target market

The Kent IT Consultancy

The Kent IT Consultancy is an IT consultancy based in the School of Computing at the University of Kent. Its mission is to support the community by solving business problems with technology, as well as providing its students consultants with the skills to make them more employable. Its motto is “the graduates of tomorrow supporting the businesses of today”.

Transformed by You (updated)

I spent Saturday in Tunbridge Wells Town Hall with three of our first year students and a whole lot of other participants at the Transformed by You event. The idea of the event was to bring together people interested in building computer systems - often apps - that will have a positive effect on the community. Specifically they should do on of three things

• encourage people to help each other out - e.g. by doing some gardening for someone;
• encourage people to get healthier, by eating better, or exercising more;
• encouraging artistic and cultural activity.

  

So, what was it like? Our students – Ed Wellbrook, Viorel Tudose and Panayiotis Christofides – had gone along with ideas for

• a recipe app for students,
• a "treasure hunt" app for local area events, and
• an app to help encourage use of the gym.

During the day they worked on presentations of their ideas, in collaboration and comments from other attendees. This gave them useful feedback on their ideas, and helped to focus what they were aiming to do; they also gained experience of building quick prototypes (result: it's not as quick as you would hope … ).

I was also able to spend some time with one of the other projects, ThinkHealth from Gravesham NHS Trust, which was one of the winners of the day. Interesting there to see how an internal NHS project for promoting health among staff might well be rolled out to companies as part of their occupational health schemes.

Finally, we had the archetypical hacker lunch, coke and Pizza from Dominio's – a first for me: I didn't really take to the barbecue sauce instead of tomato on some of the bases :-S

Updated …

On the following Thursday, Noel visited Kent to watch the one minute videos made by our students. Here are our CO334 tutors – Keith, Dan and Minas – watching them too, complete with popcorn:

He also revealed winners among the students, who took all three prizes in the ideas section of the competition organised by public sector organisation Kent Connects.

Their ideas included two mobile phone apps to help motivate people to exercise. One - Exercise Escape, developed by computing students Ruhul Amin and Jacob Fox - involved a game which would encourage users to run from virtual enemies. The other - Motivated by Fiction, developed by computing student Matthew Aldridge - would encourage people to exercise by drip feeding them parts of a story each time they used the app when running or walking. Fault Finders was the third winner in the ideas categories; an app developed by computing student Christina O'Docherty to help businesses find ways they can help their local community.

Carol Patrick, Kent Connects' Head of ICT Partnerships, said: "We were really impressed by the quantity and quality of ideas sent in by people wanting to find ways to improve their local community and we're now looking forward to these ideas and prototypes becoming a reality."

These are a few of our favourite things …

I have the pleasure of convening the module on “Developing as a Researcher in Higher Education” that is part of Kent's qualification for new staff. In the first session participants each gave a one minute presentation – excellent timekeeping, incidentally – on their research. It's fantastic to hear all these diverse topics, and the enthusiasm of the people working on them. Here's a selection

• how does stand-up comedy work?
• how to make a performance of taste (of wine)?
• how is performance affected by place 
• architecture (practitioner)
• how to capture what clients of software houses really want?
• how to improve the efficiency of wireless networks … adaptively
• what is the role of language in social work?
• micro-meteorites (≦2mm) … not least, how on earth do you find them?
• theoretical physics
• Bayesian decisions in mathematics
• theoretical syntax, and the disappearance of if/whether in Icelandic
• a new theoretical / jurisprudential platform for critical legal studies
• torture and the state, aboriginal art and constitutionalism
• use of cool materials (in architecture)
• what makes an action successful?
• Lea Valley Drift: bringing the immediately available city back into prominence
• Gender in International Cooperation
• Is there a pool of talented people being lost [to HE]?
• Sustainability Research in Business Practice and CSR
• Modelling faking in high stakes self-assessments and biases in assessments of others
• Napoleon, The Cardinal and the Prostitute
• Sociology of the Professions - particular focus is on equality, diversity and inclusion
• Political psychology, specifically: self-esteem and narcissism
• the brain basis of remembering

The only disappointing thing is that we don't really have time to talk about them in the sessions for the course.

REF Factory

Writing the REF submission for Computing at Kent is drawing to a close, agonisingly slowly, but there we are … Now is the time to capture any insights about how it might have been done, and how it could be done next time (I'm not volunteering!). I'll write this now, and then finish revising my first publication for REF 2020: final copy is due to be with the ACM in a couple of days' time.

Kent made the decision to hold a full-scale pilot in 2012, so that we had been through the process of writing all the narrative sections, the impact case studies, and – in the case of computing and a few others – the 100 words accompanying each output, about 120 for us. This had some strong points, and it was particularly good in giving us a deadline by which we had to have written a first draft of everything, so that the last year has been a process of refining those drafts.

On reflection, though, it has – at least for me – meant that we (or I) have conflated two quite different processes:

• the process of marshalling the arguments, information and data, and 
• the process of writing that within the constraints of the 100 word limit, or the various templates.

I did have long drafts – essentially compilations of data and info – prior to the pilot, but since then, we've been working on drafts in the form of the final submission. What I'd do if we were doing this again is to keep the separation between the two until much later in the process, and work on the raw information and data until a much later point. Doing that means that we're able to get an overall view of all that might be pertinent, rather than selecting, and then re-selecting, which is what we've done. For example, I had included data on staff study leave in a draft of REF 5 in May, but that was removed in June, only to be re-introduced in November. 

The same applies to the 100 words, I think; a subject I discussed with another REF coordinator recently. Aiming to get all the pertinent information collected for each potential paper (with a few prompts about different kinds of info), and to keep that up to date and reviewed, would allow the final 100 words to be generated close to the deadline, rather than evolving over two years in many cases.

I realise that this may week be a case of the other person's grass always being greener, and that we would most likely find problems with this approach, but this is what I would try were I to do it again. In the case of the pilot submission, if we had to write it in that format, we should see it as a throw-away draft, and keep on marshalling until we write a new final draft from scratch.

Finally, the more I think about this, the more I think that this is very like a problem we come across in writing successful research grant applications. The most useful feedback on an application is at the stage where the ideas begin to be articulated clearly. One way of expressing this is as a “one pager” that summarises the essence of the ideas, the work packages, the methodology and the impact, all on one side of A4. As a reviewer it's possible to engage with this, and say “yes, but it would be so much better if you were to push it in this direction” – it's almost impossible to do this once it has been set in concrete in a complete application. In a roundabout way, that explains why I called this post “REF Factory” – Kent's well-regarded grant application training is called “Grants Factory”, a name coined by Andrew Derrington.

Is it viable or not? An exercise in estimation.

In the first year course at Kent, we're involving students in the Transformed by You competition set up by Kent Connects. The aim of this is to collect ideas for technology that can have a transformative effect on lives of people in Kent. Our students are working on a design exercise, but we've also used examples of this to talk about ethics: for example, what are the ethical questions raised by parents monitoring their children's movements, or employers keeping track of their employees?

Another theme of the course is to encourage students to estimate quantities: we started off trying to estimate the size of the lecture theatre, but concluded the session by trying to estimate the viability of three of the suggested projects:

• Live streaming of lectures onto the internet.
• An app to track buses in real time.
• An app to find the closest taxi for hire.

In thinking about this, we worked with a short set of prompts:

• Scope: University of Kent? Canterbury? Size? Coverage?
• What is needed (for it to operate)?
• Cost (above the software itself): capital / running? Income?
• Decision, with reasons.

The best solutions were definite: they fixed on a particular scenario, e.g. streaming lectures from the Canterbury campus at Kent, or the UniBus system of buses. Given that, making an assessment of what was needed - servers, webcams, GPS systems - followed, as did an estimate of costs, and then a justified decision: most of the well-documented solutions come in at about £10,000 capital costs, and perhaps £1,000 ongoing, leading to the decision that it is a viable proposal. Not all the solutions were as good as this.

One variation between solutions was scope: what can we take for granted, and what has to be supported explicitly? In the streaming example, do we have to pay for storage? for bandwidth? In the same example, would there be any income? [I think not!] We do record lectures, in fact, using Panopto, which gives us most of this functionality, but not in real time.

The bus example shows much more variability: fair enough, it's further away from people's experience. Even more so, the taxi example. The conclusion is that the bus app is viable, because the cost per GPS is small, and the number of buses constrained too; it clearly has a benefit, too. The taxi app is less clear: taxis belong to a number of companies, and without comprehensive sign up, it's less clear about the value. Is income going to be paid by taxi companies? Again, not clear.

The exercise was deliberately open-ended: perhaps too much so? The intended outcome is to give participants a mechanism for making rule of thumb estimates, when a reasoned estimate is better than a guess or a shrug of the shoulders. All part of being a professional. 

2001, 1968 and 2013 - reheating a blog post

I went to see 2001: A Space Odyssey one Saturday afternoon a few months ago, and drafted some notes: just found them again, so here goes …

First, all those childhood memories from when I first saw it. Was it really 1968, or a bit later? Whatever the case, I was a teenager coming to the end of a sci-fi infatuation. Despite moving on, we took for granted that by 2001 there would be moon bases, expeditions to Mars, and that space would be normalised.

Clarke and Kubrick tried so hard to make it as accurate as possible, and the wonderful HAL's legacy has a whole lot of stories about that. The most remarkable is of the two of them visiting Bell Labs and seeing hearing state-of-the-art speech synthesis: a computer sings "Daisy, Daisy" – just what HAL sings as he's being deconstructed by Dave. It's hard not to be moved by that.

The late 60s and 70s were a golden age for American film: 2001, Nashville, One Flew Over the Cuckoo's Nest, the Deer Hunter, and it's impossible to imagine that something like 2001 could be made now. Why?

First the speed of the thing: it's slow – with little dialogue – but the sound is so carefully done. Heavy breathing when Dave is in the spacesuit, some isolated conversations … and the music is only played on its own: you hear the music, and see how it works with the visuals: it's emphatically not used simply to pump up the adrenaline.

Then the visuals: remember then no one had even seen the earth from the moon (“earth rise”) when the film was made: it is mattes and models, but even though it's not photorealistic, it works. Way before CGI, but just as good!

HAL, as Stork suggests, is the real star of the film … one big brain, of course, and no PCs, but less anachronistic now (“internet of things”) than it was in 2001 itself.

And the actors? No famous lead players, but good old British character actors: Leonard Rossiter – Reggie Perrin – and Margaret Tyzack – Forsyte Saga – who also appears in A Clockwork Orange.

Of course, some things are “wrong”: there are no PCs, for instance, but the most noticeable is the prominent PAN AM logo on the space shuttle: Kubrick and Clarke were good on the science, but less on the economics …

From imperative to functional in Java 8: paper review

I have been writing functional programs for thirty years, first in KRC, then in Miranda, and more recently in Haskell and Erlang. In the past few years, though, something rather remarkable has been happening: the essentials of functional programming have been popping up in more “serious” mainstream languages: JavaScript, C#, C++ and now, with the advent of the 8th version of the standard, Java. What is this functional core that’s coming into these languages: the ability to compute functions as a part of the work of a program, and to pass these around as parameters or return values of other functions: closures as “first-class citizens” in Strachey’s words.

But why is this happening? As the authors of this fine paper explain, it is to exploit the parallelism that is now a feature of some many computing platforms, from smartphones and tablets, through laptops and desktops to servers and supercomputers. To give one example: mapping a function across a collection data structure is one of the key parallel patterns, providing the data analogue of a linear (control) pipeline.

Given the opportunity, how can we program using these new features? One possibility is to start from scratch with these new constructs, but a more attractive option is to refactor existing code to exploit these features: that is precisely the topic of this paper. The authors show how refactoring opportunities are identified, and what transformations need to be performed. Moreover, they anatomise some of the attendant difficulties: how are side-effects to be handled? how to deal with different scoping regimes between anonymous inner classes and closures? Their work is validated through a set of substantial case studies, and made available through the standard Net Beans distribution.

I would recommend this paper to anyone interested in exploiting the parallelism inherent in many standard programs, as well as anyone who would like to see a justification for machine-supported refactoring. Finally it is a remarkable vindication of getting students involved in research: two of the four authors took part as undergraduate summer interns.

This is a draft review for Computing Reviews of Crossing the Gap from Imperative to Functional Programming through Refactoring.

Computing trending at Kent

I was lucky enough to go to two quite different events at Kent today that would have been inconceivable just two years ago. This morning I spent time at the #kenthack and this afternoon at a Digital Humanities event … quite different, but both lots of fun.

The #kenthack was the brainchild of some computer science students, getting together collectively to hack out some new ideas, sustained by a heady mixture of sugar, saturated fats and salt (OK, sweets and doritos).

Nice ideas going around included a version of the old "helicopters" game, with a motion sensitive interface. Sorry I don't remember the name of the particular piece of kit, which is able to sense all 10 fingers and thumbs, up to about 50cm away, based on 3 IR sensors and an ARM chip. More info about the outcomes at www.kenthack.com. Great atmosphere, and refreshing to see people getting together to have fun coding.

This afternoon to the new "crit space" in the school of architecture for a digital humanities event, bringing together academics from architecture, history, english, archaeology, film studies, linguistics to talk about their research and teaching activities informed and and mediated by digital technologies.

Exciting to hear about what's going on. Highlights included

• using network visualisation of word counts and proximities to understand documents;
• how software has revolutionised the practice of linguistic analysis of real speech, and the repercussions for speech therapy;
• understanding the mental mapping and conceptualisation of space, time and software behaviour in game development software.

The talks were good, but as always, discussions over coffee were more fruitful. I hope we'll be able to build some links with the last project … exciting things to do with new APIs, and also with data mining of "big data" from programmers of different kinds. Also able to catch up with learning support staff from UELT to share our enthusiasm for panopto, but at the same time to bemoan the fact that we're unable to share any of our exciting teaching and learning initiatives and materials outside the university. Grr.

Commercial users of functional programming: call for tutorials

Commercial Users of Functional Programming (CUFP) is an annual meeting co-located with the International Conference on Functional Programming which this year will take place in Boston, MA, USA on 22-24 September 2013. CUFP aims to bridge the gap between academia and users applying functional programming in practice. CUFP provides high-quality practical tutorials covering state-of-the-art techniques and tools for functional programming.

We are seeking proposals for half-day tutorials to be presented during the first two days of the meeting, 22 and 23 September, with the main CUFP session on 24 September.

Among the suggested topics for tutorials are:

- Introductions to functional programming languages: in the past we have had introductions to Clojure, Erlang, F#, Haskell, ML, OCaml, Scala, Scheme and others.

- Applying functional programming in particular areas, including the web, high-performance computing, finance.

- Tools and techniques supporting state of the art functional programming.

Tutorial proposals should address the following points

- Title
- Abstract (about 100 words)
- Goals: by the end of this tutorial you will be able to …
- Intended audience: e.g. beginners, those with a working knowledge of X, …
- Infrastructure required: For example,
    - will participants need access to a particular system?
    - can they be expected to have this on a laptop, or does it need to be provided by the meeting?

and should be sent by email to

- Francesco Cesarini: francesco@erlang-solutions.com
- Simon Thompson: S.J.Thompson@kent.ac.uk

by 31 March 2013.

Evaluating, compiling and running arithmetical expressions.

Partly reminded to do this by recent FB posts by Graham Hutton and Andy Gill, I used foils and OHP pens to deliver my last lecture in the functional programming course "live". I like the sense of tension you get from writing stuff "out there" and interacting with the class in a more thoroughgoing way than seems to happen with pre-prepared slides.

What did I cover? The aim was to hammer home the message about the data driving the programming, and I took the example of processing arithmetical expressions, writing an evaluator, a virtual machine and a compiler … I didn't cover parsing, but that can come in the second half of the course: Stefan?

So, we started with a data type for expressions, with literals, +, - and *.

data Exp = Lit Int 
         | Add Exp Exp
         | Sub Exp Exp
         | Mul Exp Exp
          deriving (Show)

with the expression 2+((3-(-3))*3) represented by

(Lit 2) `Add` (((Lit 3) `Sub` (Lit (-3))) `Mul` (Lit 3))

The first thing to define is the evaluator, which has a straightforward data-directed definition:


eval :: Exp -> Int

eval (Lit n)       = n
eval (Add ex1 ex2) = eval ex1 + eval ex2
eval (Sub ex1 ex2) = eval ex1 - eval ex2
eval (Mul ex1 ex2) = eval ex1 * eval ex2

What sort of machine should we use to evaluate the expressions? The simplest approach is to build a stack machine, which can either push literals, or apply an operation to the top elements on the stack (from my slides):

Here's the type of code.

data Code = PushLit Int

          | DoAdd

          | DoSub

          | DoMul

            deriving (Show)

We can describe this machine by giving the function that runs a program, when we represent the stack by a list of integers, and the program by a list of code.

type Program = [Code]

type Stack = [Int]

run :: Program -> Stack -> Stack

run [] stack 

        = stack

run (PushLit int : program) stack 

        = run program (int : stack)

run (DoAdd : program) (v1:v2:stack)

        = run program (v1 + v2 : stack)

run (DoSub : program) (v1:v2:stack)

        = run program (v1 - v2 : stack)

run (DoMul : program) (v1:v2:stack)

        = run program (v1 * v2 : stack)

run _ _ = []

An alternative here would be to give the oneStep function, and then to define run in terms of that: that's an exercise for the reader.

The final piece of the puzzle is to define the compiler:


compile :: Exp -> Program

compile (Lit n) 
        = [PushLit n]
compile (Add ex1 ex2)
        = compile ex2 ++ compile ex1 ++ [DoAdd]
compile (Sub ex1 ex2)
        = compile ex2 ++ compile ex1 ++ [DoSub]
compile (Mul ex1 ex2)
        = compile ex2 ++ compile ex1 ++ [DoMul]

Voilà!

Why do I like this example so much?

• It shows Haskell's strengths: I think my students get fed up of me comparing Haskell with Java, but this is a case where it really shines. The types make it very clear what's going on; the algebraic types guide the definitions, and we can even prove it correct …
• What is the statement of correctness? That evaluation is the same as compiling and running:
  run (compile exp) [] = [eval exp]
  but there's a bit of work to do to get the right induction hypothesis (exercise).
• There are lots of nice generalisations: we can introduce local definitions with a let construct, or indeed allow (updatable) variables within expressions. All these can be added in a nice type-directed way.
• There are lots of related exercises too: e.g. generate truth tables for Boolean expressions, and using these write tautology checkers.

So, a very enjoyable last lecture on Haskell.

Teaching Haskell … but for the last time for a while.

For one reason or another, I haven't been teaching functional programming at Kent for a few years, so it's interesting to be back doing it, and to reflect on that.

The last time I was involved was when we were teaching Haskell in the first year, starting in the second term, and following up on Java which had been taught from the start. We came to the conclusion that this wasn't ideal: instead of reinforcing each other, it seemed perverse to start with a second paradigm before the first one was properly internalised. This time I'm teaching in the second term of the second year … just like we did twenty years ago, in fact … and it seems to be going much better.

One thing that's really helpful is to be able to discuss features of Haskell using Java as a reference point.   For example, what does it mean to belong to a class? Well, you have to implement the interface that's given by the class declaration. Seems to demystify the idea.

Sometimes Haskell is so much better: data types with multiple constructors (e.g simple geometric shapes such as circles and rectangles) just work in Haskell. No ugly abstract base classes and subtyping, no problem with binary methods, the joys of pattern matching … great stuff.

Types play an important role: the first and most important piece of documentation for any function, but also a way of discovering things in the library thanks to hoogle. If you've not tried this out, give it a go: it works for monotypes, such as Char -> Bool, just as much as for complicated polymorphic examples. Really useful, and appreciated by the students.

On the other hand, some things are difficult for the beginner. It's too easy to overlook concrete syntax when you understand it well - indeed the whole point is that the syntax almost disappears, and you perceive the intention, or the semantics immediately - but that's just not the case for beginners, and the novelty of the Haskell syntax can be a problem. Just function application looks unfamiliar, and the layout sensitivity can trip people up too. Other little irritations: length (of a list) returns a fixed size Int, as does replicate: we should probably use the generic versions from scratch and ignore Int altogether?

Funny things you wouldn't think of. A colleague sitting in on the lectures noted that the (x:xs) notation could be a problem: sometimes it wasn't clear when I was saying "x is" and when I was saying "exes". Perhaps I need to say "excess" instead, or maybe ditch that notation altogether?

I've been lucky enough to have inherited Olaf Chitil's slides (though I think some of my DNA is in there from a number of generations back) which are great. The problem is I'm never happy with using someone else's slides - or indeed my own from a previous year - so start rewriting them. Even when this is the last time they will be used, because next year we're trying something different …

As a root and branch curriculum review we looked at what we taught in the second year of our programmes as core material, and found that we wanted to include about 180 credits worth of material in a 120 credit year. Together with all the other material we saw as core, we wanted to carry on teaching functional programming, and also to teach concurrency (which we currently do in occam-pi, optionally to second and final years), but we didn't have enough time to teach two separate languages. So, we decided to use a language with both: that could be Clojure, we could look at Haskell's various concurrency extensions, but we'll be working with Erlang next year.

Not everyone was happy with this … indeed I'm not 100% sure … but it will be really interesting to look at Erlang as a practical functional/concurrent language, and use it as a base for exercises and projects, as well as a comparison point for other approaches like Haskell, occam-pi. I'll report back in a year's time …

Back on track in the blogosphere

Back again to my blog after about 6 weeks off. What was the problem? It wasn't that I didn't have anything to say, because lots of things were going on: teaching a functional programming (Haskell) undergrad course for the first time in ages, convening a module for new lecturers at Kent on developing as a researcher, doing project work on both Release and PROWESS, as well as getting to some films, concerts and so on. I'll be blogging about some of these in the next few days, I hope.

No, I think the problem was that I didn't have enough train journeys to go on. Somehow the ambiance and length of a train journey is just right for getting thoughts marshalled and into blogger. As you might guess, I'm writing this on the train: en route to Swindon for a two day grant review panel at EPSRC. There certainly should be another post in a couple of day's time, on my way home, if not before …