Records

Records are a way of providing a names for elements of tuples.

Record declarations are created in .hrl files with a syntax like:


-record(events, {day=monday,name=hangover}).


This gives us the ability to create a new event record with attributes of day and name. Like this:


X1 = #event{day=monday,name=hangover}).


Remember, its really just a tuple, but because we make it a record, it gets to have names for its variables. We can pattern match to get the variables out of the record. To get the values out of X1 above for example:


#event{day=D,name=N} = X1.
D.
monday


Guards

As far as I understand, guards provide an enhancement to pattern matching, allowing us to enhance our pattern matching abilities by testing the values of variables. I’m not quite sure exactly where guards can be used: No limitations on where are mentioned yet, so I’m going to assume that you can use them anywhere you are using pattern matching, although it seems a bit odd to use them on the RHS of an expression.

The simplest example of a guard is probably something like:


sqrt(X) when X < 0 -> exit(dumbValue).


In this case when we call sqrt with a value less than 0 we’ll exit. Pretty straight forward.

Guard sequences

We can also combine guard clauses to give us more complex checks:


sqrt(X) when X < 0, X < 20 -> exit(notInValue).


Guard sequences are simply separate guard clauses conjoined in some way. They typical way they are conjoined is simply by a comma as above, in which case the comma represents an ‘and’ statement. They can also be combined by short-circuit boolean operators andalso or orelse, or by the normal boolean operators or or and.

These cases function much as you would expect, with short-circuit boolean expressions functioning as in other languages.

List comprehensions

I first encountered List Comprehensions in Python, and they were one of the things I loved, and missed as I started working in Ruby more. In principle, they are a simple way to define a mapping from one list to another. Here’s the notation in Erlang:

This concise piece of code says something like: take each of the elements from the list L, and map them as element X into a new list defined by the function 2 times X.

Of course, the function you apply to the elements of the list could be a good deal more complex, and probably would be in real life.

There are some quite interesting isolated examples of list comprehension in Joe Armstrong’s book, including a terse quicksort implementation, but I don’t think there’s much more to say about them here, out of the context of a real application

This is hands down the best talk I have ever seen at a conference.

I don’t know if the feeling comes across on the video, but I have never seen the kind of reaction to a talk that Giles got to this talk at RubyFringe. The room was totally electric and he had a minute long standing ovation at the end of the talk. The hair was standing up on the back of my neck.

People left the room for lunch afterwards with stunned looks on their faces. Even Giles seemed to be amazed by the response he got, judging by the look on his face.

Absolutely recommended.

Higher order functions

A higher order function is any function which does one or more of the following:

• Takes one or more functions as its input
• Returns a function as its output

Functions that take functions as an argument

We already saw some examples of this in the last section. Remember this code:

1> List = [2,4,6,8,10].
[2,4,6,8,10]
2> Triple = fun(X) -> 3 * X end.
#Fun
3> lists:map(Triple, List).
[6,12,18,24,30]


In this code, lists:map takes a function as an argument and applies the function to each member of the passed in list. A map function is a very common example of this pattern. I would expect that its fairly fundamental to any language that allows functions to be passed around as first class entities.

Functions that return functions

Functions that return functions are somewhat less common, but they can be useful to help us write generic code that can be parameterized at runtime to do different things. Here’s some imaginary, untested, code to help get the point across:

1> % Imagine some readings of various types exist…
1>MakeReadingFinder = fun(Type) -> (fun(DateRange) -> readings:find(Type, Date) end end.
#Fun
2>BeforeBreakfastReadingFinder = MakeReadingFinder(before_breakfast).
#Fun
3>BeforeBreakfastReadingFinder(now()).
% Readings are magically returned!

Although the example isn’t perfectly clear (there’s a better one on pg. 45 of Programming Erlang) you can see that what we’re doing is using the ability to return a function as a way to fill in some of the returned functions parameters before we use it.

This allows us to parameterize the function, and is probably going to be ideal for implementing Factory patterns etc. very simply.

Anonymous functions

Anonymous functions in erlang are known as funs.

Funs work mostly like regular functions - they can take any number of arguments, the arguments can be of any type, and the function can have multiple clauses. The thing that makes anonymous functions useful is that they can be bound to a variable. For example:

1> Half = fun(X) -> X / 2 end.
#Fun
2> Half(3).
1.5

Or, with multiple clauses:

1> DistanceConvert = fun({miles, M}) -> {kilometers, 1.609344 * M};
1> ({kilometers, K}) -> {miles, 0.6213 * K}
1> end.
#Fun
2> DistanceConvert({miles, 10}).
{kilometers,16.09344}
3> DistanceConvert({kilometers, 15}).
{miles,9.3195}

Many other languages allow anonymous functions bound to variables. Think of Ruby or Python’s lambdas or, as an even closer analogy, of Javascript’s assignment of methods to variables.

Anonymous functions as arguments

Much like Javascript or Ruby, you can use these anonymous functions as arguments to other functions. This enables us to perform list wide operations using internal iterators, and to perform operations such as map and filter. For example:

1> List = [2,4,6,8,10].
[2,4,6,8,10]
2> Triple = fun(X) -> 3 * X end.
#Fun
3> lists:map(Triple, List).
[6,12,18,24,30]


As you can imagine, this opens up a lot of power. As far as I can tell the syntax for passing in funs allows you to pass them in as any parameter, and to call them inside a function clause body just by using the () call syntax.

It would also be interesting to know if funs are full closures. That is, do they keep their bindings with them when they’re passed around? As far as I know, I think they lose it, so they’re not.

Obviously this is a very cursory glance at things. It’s really just notes to help me remember things. If you’re looking for something in more detail you can take a look at the erlang reference manual.

Functions

Functions in erlang are consist of multiple clauses. Each clause is separated by a semicolon and the final clause is terminated by a dot-whitespace. For example:

utter(dog) -> “woof”;
utter(cat) -> “meow”;
utter(cow) -> “moo”.

In the case above we have a function utter with three clauses. Each of the clauses has a head and a body.

The head

• The head is a function name then a pattern
  in parens, such as:
  
  utter(cow)

• The pattern in the head is pattern matched based on the parameters passed when the function is called. So to execute the clause with the head defined above we would write:
  
  utter(cow).

• If there are multiple clauses with heads that match the call, then the first one that matches will be used.

The body

• The body consists of a series of expressions.
• An expression is anything that can be evaluated to produce a value
• You can have a series of expressions, separated by commas to produce an expression sequence. The value of the expression sequence is the value of the last expression that was evaluated.

Putting it all together

So we have:

utter(dog) -> “woof”;
utter(cat) -> “meow”;
utter(cow) -> “moo”.

Tweaking an example from the great Programming Erlang, we can do:

-module(perimiter).
-compile(export_all).

Where you can see that having multiple clauses for a function, combined with tuples allows us to implement a sort of polymorphism.

Another thing to note about functions is that functions with the same name and a different arity are completely different functions.

That is, area(Radius) is a totally different function from area(Length * Width) as far as the runtime system is concerned.

Joe Armstrong says that erlang programmers often use this feature to provide helper functions for a main function, but that makes me throw up in my mouth a little.

Obviously this is a very cursory glance at things. It’s really just notes to help me remember things. If you’re looking for something in more detail you can take a look at the erlang reference manual.

Variables

• Literals starting with an upper case character, such as Pizza are variables
• Variables are single assignment only, meaning that once they are bound to a value, that value cannot be changed. That’s different from a lot of languages, obviously, where we can change the values of variables during the run of the program. For example:
  
1> % Lets assign X to be 6
1> X = 6.
6
2> X = 7.
** exception error: no match of right hand side value 7


  When trying to re-assign a new value to a variable, we get an error message. The error message complains about bad matching, which leads us into the next issue.

Assignment

Assignment is slightly different from traditional languages. It is done by pattern matching the RHS against the LHS of an expression, rather than the more traditional manner of simply plugging the value of the RHS into the LHS.

Numbers

Pattern matching a number is simple. If the number or expression on the RHS evaluates to the same number as on the LHS, then there is a match. For example:

1> X = 6.
6
2> Y = 2.
2
3> X = 7.
** exception error: no match of right hand side value 7
4> X = Y.
** exception error: no match of right hand side value 2
5> X = Y + 4.
6


Tuples

Matching tuples is a little more complicated. Of course, you can have a direct match between two tuples, but more commonly, you can extract values from tuples by pattern matching. Lets say we have a tuple structure that represents an employee and we want to extract the employee name

2> % First we’ll define a tuple
2> Employee = {employee, {name, grant}}.
{employee,{name,grant}}
3> % Now we’ll pattern match on the tuple to extract the
3> % particular element we want from the tuple
3> {employee, {name, EmployeeName}} = Employee.
{employee,{name,grant}}
4> % So we expect that the EmployeeName variable
4> % will have the value grant now.
4> EmployeeName.
grant


Interestingly, this seems to reverse the common pattern of accessing elements deeply nested in structures in more conventional languages. In ruby, for instance, we might have an example like this:

person = {:employee => {:name => ‘grant’}}
employee_name = person[:employee][:name]

In this case we have a naked variable name on the LHS and do some silly walking on the structure on the RHS to get at the value we want. Erlang reverses this so that we have a naked structure (meaning no function calls or other manipulation) on the RHS and we pattern match our way to the value that we want on the LHS of the expression.

Lists

Pattern matching Lists seems to be a little more simple. In general, a list can be pattern matched by the form [A, B, C… | T] where A, B and C are variables substituted by the first, second and third elements of the list respectively, and T is substituted by the remaining elements of the list. For example:

1> L = [1,2,3,4,5].
[1,2,3,4,5]
2> [A,B,C | T] = L.
[1,2,3,4,5]
3> A.
1
4> B.
2
5> C.
3
6> T.
[4,5]
7> [A, B, C, D, E, F, G] = L.
** exception error: no match of right hand side value [1,2,3,4,5]

Note that if we run out of elements on the RHS of the expression we’ll get a bad match type message. Also, the most common operation with this type of matching is more than likely to remove the head of the list into a variable so that we can work with it, and store the tail of the list for future work.

Obviously this is a very cursory glance at things. It’s really just notes to help me remember things. If you’re looking for something in more detail you can take a look at the erlang reference manual.

Basic Data Types

Integers

• Integer arithmetic is arbitrary sized. Yay for no overflows
• Base 16 and 32 can be represented by 16#1a and 32#1a respectively. In fact, that
  works for arbitrary bases up to 36, I think. Base 2 is 2#1101

Floating-Point Numbers

• Floating point numbers must have a decimal point followed by at least one decimal digit
• As far as I can tell floats are also aribrarily sized.
• Not sure yet how to specify precision, or if you can.
• Cooercion from integer to float seems to be automatic, if one of the terms is a float

Atoms

• Atoms usually start with lowercase letters. They can start with uppercase letters or non-alphanumerics if they are enclosed in
  quotes though.
• foo, ‘Foo’, ‘@Foo’, dave@smith are all valid atoms
• Atoms are used to represent symbolic constants, similar to Symbols in Ruby, or the #define FOO 1 construct in C

Tuples

• A group of things enclosed in curly braces, {Foo, bar, 1, “22″} is a tuple
• Tuples group a fixed number of things together. It performs the same function as a Struct in C or some other type of Record type of data structure
• Tuples seem to be commonly used as a way of differentiating between functions that need to have different behaviours, but keep their arity the same. One example from Joe Armstrong’s book:

  
area({rectangle, W, H}) -> W*H;
area({circle, R}) -> 3.14 * R * R.


  By passing a tuple we are able to keep the arity the same, but cheat on the type of behaviour the function is implementing

Lists

• A group of things enclosed in square brackets, [foo, X, 23, “toad”] is a list
• Lists are useful for storing variable length numbers of things.
• The first element of a list is called the head and the remainder is called the tail We can talk about these two elements using the general form [Head|Tail]. This is a common operation, especially when using recursive implementations of algorithms.

Strings

• Strings are enclosed in double quotation marks. “My big ass” is a string.
• Remember that things enclosed in single quotation marks are atoms - don’t confuse the two
• Strings in erlang are really just lists of integers.
• The shell will print a list of integers as a string if all the integers in the list represent printable characters under iso 8809 encoding

Given that their customer service is notoriously bad, I haven’t even tried phoning in to see what condition their condition is in. But, if you reboot the cable modem, router and ATA in that order it re-registers, so I’m guessing the ATA only gets a window to register after their dhcp server has assigned a lease, and if the ATA drops the registration it’s not able to re-register until something asks for a new lease. (Btw, I”m using a linksys WRT 54G with DD-WRT firmware on the router, and the ATA is behind the router, so that I can do QOS routing on the SIP packets).

Anyhow….

I’m just writing this as a quick note to anyone else who might want to hack this setup. The ATA can be reset following Cyberweb’s instructions by dialing 1111 then RESET then # then 1 into your phone. This puts it in a factory default state where you can log into its admin web page and futz around - it’s at http://192.168.0.1 and the username is admin, password is also admin.

Then Cyberweb then instructs you to download a file from them through the modem to provision it. Once you download this file, the admin interface of the modem becomes locked, so it’s no longer possible to edit its setup parameters. Fortunately the file they ask you to download contains the admin password in clear text, so it’s trivial to get back in to the ATA.

Having said this though, I’ve no reason to believe that getting into it is useful. Unless you know what parameters their sip server is using at the other end, I doubt that changing anything will get you a better service. More than likely it’ll still suck. But its nice to know it’s doable even for the hack value. It’s also probably handy if you want to bring your own ATA or set up an asterisk box at home.

If anyone finds some params to frob that will make the whole thing more reliable though, let me know.