Erlang: What the Cool Kids Are Doing

For instance, what follows is the code to the Scala address book example:

object addressbook {

  case class Person(name: String, age: Int)

  /** An AddressBook takes a variable number of arguments
   *  which are accessed as a Sequence
   */
  class AddressBook(a: Person*) {
    private val people: List[Person] = a.toList

    /** Serialize to XHTML. Scala supports XML literals
     *  which may contain Scala expressions between braces, 
     *  which are replaced by their evaluation
     */
    def toXHTML =
      <table cellpadding="2" cellspacing="0">
        <tr>
          <th>Last Name</th>
          <th>First Name</th>
        </tr>
        { for (val p <- people) yield
            <tr>
              <td> { p.name } </td>
              <td> { p.age.toString() } </td>
            </tr> 
        }
      </table>;
  }

  /** We introduce CSS using raw strings (between triple
   *  quotes). Raw strings may contain newlines and special 
   *  characters (like \) are not interpreted.
   */
  val header =
    <head>
      <title>
        { "My Address Book" }
      </title>
      <style type="text/css"> {
     """table { border-right: 1px solid #cccccc; }
        th { background-color: #cccccc; }
        td { border-left: 1px solid #acacac; }
        td { border-bottom: 1px solid #acacac;"""}
      </style>
    </head>;

  val people = new AddressBook(
    Person("Tom", 20),
    Person("Bob", 22),
    Person("James", 19));

  val page =
    <html>
      { header }
      <body>
       { people.toXHTML }
      </body>
    </html>;

  def main(args: Array[String]) {
    println(page)
  }

This is so much less scary to people than the Erlang equivalent. EQUALLY complicated, just less scary! So if there are kids out there looking at implementing something new really fast, they will be drawn to Scala.

Remember PERL, it was lightning fast . . . and really scary. Java was less scary. PHP was friendlier still. And, I suspect, the frameworks built using Scala will be downright promiscuous.

It's too bad, I'm an old fart, 36, but I like Erlang.

Maybe the kids will let their religion get the best of them. They are really anti-Java, and Scala is built on Java.

Of course, they love JRuby.

Quel dommage.

See Virding's First Rule of Programming (http://www.nabble.com/Erlang-concurrency-to14747956.html):

"Any sufficiently complicated concurrent program in another language contains an ad hoc informally-specified bug-ridden slow implementation of half of Erlang."

Here's an introduction if you've got an imperative/OO background: http://www.defmacro.org/ramblings/fp.html