CUFP 2013 Erlang Web Tutorial

September 12th, 2013  |  Published in conferences, erlang, web  |  Bookmark on

On Monday Sep. 23, 2013, I’ll be giving a tutorial on Erlang web development at the Commercial Users of Functional Programming (CUFP) conference in Boston. Please plan to attend if you’re interested in how various Erlang web servers and frameworks work. And don’t be afraid if you don’t know Erlang — I’ll also provide a brief Erlang introduction, so you’ll be able to follow along even if you don’t yet know the language. Or better yet, attend Francesco Cesarini’s and Simon Thompson’s Erlang tutorial that morning and get a great introduction to the language and its frameworks.

In fact, check out the whole CUFP schedule — in general there are a number of interesting talks at the conference part on Sep. 22, including my old friend Dave Thomas’s keynote, and a bunch of nice tutorials on the two following days. I’m greatly looking forward to attending Yaron Minsky’s and Anil Madhavapeddy’s OCaml tutorial and Dean Wampler’s Scala tutorial, since I don’t know either language (yet).

Hope to see you there!

Implementation of “Don’t Lose Your ets Tables”

May 8th, 2013  |  Published in erlang, reliability  |  Bookmark on

A couple years ago I wrote about how to avoid losing your ets tables if the Erlang processes that own those tables crash. The original post resulted from accidentally losing an ets table full of video subscriber data during a debug session on a live customer production site. Oops.

If you’re looking for some code that implements what that post describes, look no further than DeadZen‘s etsgive repository. DeadZen is a very experienced Erlang developer, so it’s no surprise that his example code is straightforward and clean.

Just as described in my post, DeadZen’s supervisor code starts two workers, one that manages the table and one that uses it. The table manager process takes the following steps:

  1. traps exits
  2. links to the table user worker process (the supervisor starts the table user worker first)
  3. creates the ets table
  4. sets itself as the table heir process
  5. gives ownership of the table away to the table user worker process

The table user worker process first handles the transfer message resulting from the manager giving it ownership of the table. Once it becomes the owner, it can handle a call to increment a counter in the table and a call to check the table contents. It can also handle a call to die, which you would issue interactively from an Erlang shell to exercise the code. This causes the worker process to die, which means the table manager regains ownership of the table because it’s the table’s heir. The table manager then waits for the supervisor to start a a new table user worker process, and once it’s up and running, the manager links to it and then transfers table ownership to it.

This written description might be difficult to work through, but fear not, DeadZen also supplies an example Erlang shell session showing how it all works. Clone his repository and try it out for yourself!

2013 Erlang Workshop Call For Papers

February 20th, 2013  |  Published in call for papers, conferences, erlang, functional programming  |  Bookmark on

The Twelfth ACM SIGPLAN Erlang Workshop will take place on September 28, 2013, in Boston, Massachusetts, USA. See the call for papers for more details.

It’s a satellite event of the 18th ACM SIGPLAN International Conference on Functional Programming (ICFP), September 25–27, 2013.

The PC is chaired by Laura M. Castro, and I’m serving as the workshop chair and as part of the program committee. We’re looking forward to receiving many excellent paper submissions from the ever-growing Erlang community.

Final “Functional Web” Column: the Nitrogen Web Framework

December 20th, 2012  |  Published in column, erlang, framework, HTTP, web  |  Bookmark on

The November/December 2012 issue of IEEE Internet Computing magazine contains my final “Functional Web” column covering the Nitrogen web framework. As with all my previous columns, this column is available here in PDF form.

My first column for IC appeared in March 2002, nearly 11 years ago. Back then my column, called “Toward Integration,” focused around enterprise middleware. My old friend Doug Lea, who was on the IC editorial board at the time, suggested that I write it, and who in their right mind would turn down Doug Lea? In March 2009 I stopped that column and began writing the “Functional Web” column, focusing on the use of functional programming languages and techniques for web development. Prior to writing for IC, I was a columnist for the C++ Report magazine, starting in January 1995, and then later continuing that column over in the C/C++ Users Journal. That column focused on distributed object computing, and I stopped writing it in 2005.

That’s a total of 18 years as a columnist, which is a lengthy duration for a side gig done on my own time (and for IC, done on a purely volunteer basis). My common goal for all the columns was to write for practitioners like me — to try to cover topics, approaches, and ideas that other software developers could immediately apply in their own work. I also saw column writing as a way to try to pay back all the authors from whom I had learned so much over the years.

But 18 years is enough, for now anyway. While I might return to publishing in the future, for now I just want to focus on technology and software development.

Thanks to all my readers for your feedback and encouragement over the years. You definitely made it all worthwhile.

Concurrency and Message Passing in Erlang

November 5th, 2012  |  Published in concurrency, erlang, languages, message passing, performance  |  Bookmark on

In July 2011 I received an email asking if I would write an article about Erlang for the IEEE Computers in Science and Engineering (CiSE) magazine. The email said they had first invited Joe Armstrong but Joe had recommended me instead — how could I refuse a request like that? :)

It took awhile, but my resulting article “Concurrency and Message Passing in Erlang” is now published in the Nov/Dec 2012 issue of CiSE. Here’s the abstract:

Developers use the open source Erlang programming language in domains such as telecommunications, database systems, and the Web due to its superior support for concurrency and reliability. Erlang applications comprise numerous processes—lightweight user-space threads—that communicate via message passing. This article focuses on Erlang’s concurrency support and details an example 1D Poisson solver program.

Due to IEEE copyright rules I’m allowed to post only the final draft (PDF) sent to the magazine’s layout folks, but that’s OK since its text and figures are identical to the final published version. I haven’t yet received my hard copy of the magazine, but it looks like an interesting issue; it’s a special one covering concurrency in modern programming languages, and it also contains articles about Haskell and Clojure. The guest editors’ introduction explains the issue in more detail.

If you’re interested, you can purchase the full final article from the IEEE here. And now for some obligatory legalese: My article linked above is © 2012 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works. This material is presented to ensure timely dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All persons copying this information are expected to adhere to the terms and constraints invoked by each author’s copyright. In most cases, these works may not be reposted without the explicit permission of the copyright holder.