September 12th, 2013 |
conferences, erlang, web | Bookmark on Pinboard.in
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!
May 8th, 2013 |
erlang, reliability | Bookmark on Pinboard.in
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:
- traps exits
- links to the table user worker process (the supervisor starts the table user worker first)
- creates the
- sets itself as the table heir process
- 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!
March 11th, 2013 |
call for proposals, conferences, functional programming | Bookmark on Pinboard.in
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.
February 20th, 2013 |
call for papers, conferences, erlang, functional programming | Bookmark on Pinboard.in
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.
December 20th, 2012 |
column, erlang, framework, HTTP, web | Bookmark on Pinboard.in
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.