Steve Vinoski's Blog

As an editorial board member for Internet Computing magazine one of my duties is to occasionally write the “From the Editors” column, so for the March/April 2014 issue I contributed the article “Rediscovering Distributed Systems” (PDF). The idea behind the article is that many production systems today are distributed systems, and so more developers are taking a look back at all the distributed systems research from the past few decades so they can try to avoid reinventing the wheel. The brief article goes through a few important distributed systems papers, and also includes references to other sites and resources for learning more about distributed systems.

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!

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!

The 2013 Commercial Users of Functional Programming (CUFP) call for presentations is open. If you’re a practitioner using functional programming languages to build novel or interesting systems, please consider submitting a talk proposal.

The CUFP workshop is part of ICFP 2013, and the CUFP talks will be held in Boston on Sep. 24, 2013.

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. http://www.icfpconference.org/icfp2013/.

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.