Concerning “inconsistent” capitalization, Erlang is 100% consistent with capitalization. It is *enforced*. In Erlang, variables are *always* capitalized, whereas “atoms” are *always* lower-case. An atom (like anything in the world that is *truly* an atom) is something that is meant to be indivisible: you can’t reduce it. An atom is like a variable name where you use the name itself, there is no value associated with the name.

Concerning “L” versus “L2″, Erlang is a single-assignment language. These are variables, since they are capitalized, but the naming is used to show versioning of variables (e.g. making change explicit). Within the same *scope*, once a value is bound to a variable, the variable cannot be reassigned. This design philosophy is meant to eliminate whole categories of programming errors, which is important since *reliability* is Erlang’s primary goal. With multiple-assignment that most languages use, it’s almost as if you have to track the state of variables in addition to the state of objects, because the same name can be bound to different values at different times within the same scope. Erlang’s need for distributed programming in order to allow fail-over and similar features requires reliable concurrency. Reliable concurrency can’t happen if you have to track a lot of messy state. Therefore, at every opportunity, Erlang tries to be as stateless as possible. Only each process as a whole has state by continuously passing its variables back to itself via a recursive function that acts as a main loop (it doesn’t run out of stack/memory due to tail-call optimization being required).

Concerning “A”, “B”, “C”, and “D”, it looks like the author is pattern-matching in order to assign values to these, so that if you pass into the function an IP address of “127.0.0.1″, the result is: A=127, B=0, C=0, D=1. Since you didn’t include the entire function code, I don’t see where these variables are used unless I dig into the source myself.

Regarding the SLOCcount for the LAN plugin, i adjusted the C++ linecount down when collecting these stats because I didn’t implement the PING/PONG stuff in the Erlang code. (ie, i removed that code from C++ then counted the lines). So I still think it’s a reasonable comparison.

I’ll admit the style/newline proliferation in some of the C++ code will have inflated the line-count a little, and it could certainly be written with less newlines (and less readability, some would say), but we’re still in the right ballpark.

Playdar is often network/IO bound, but it also does a lot concurrently with plugins doing things in parallel then notifying the main resolver when they find something. Erlang style concurrency is perfect for this.

handle_info({udp, _Sock, {A,B,C,D}=Ip, _InPortNo, Packet}, State) ->
?LOG(debug, “received msg: ~s”, [Packet]),
{struct, L} = mochijson2:decode(Packet),
case proplists:get_value(<>,L) of
<> ->
Qid = proplists:get_value(<>, L),
case resolver:qid2pid(Qid) of
Qpid when is_pid(Qpid) ->
{struct, L2} = proplists:get_value(<>, L),

What is all this A,B,C,D, Qid, L, L2, etc.? And why is your C++ code so vertically spaced out in some places?

unsigned short port = DEFAULT_LAN_PORT;
string ip;
if( v.type() == str_type )
{
ip = v.get_str();
}
else if( v.type() != array_type )
{
continue;
}
else
{

This could as easily and as (more?) readably be written

unsigned short port = DEFAULT_LAN_PORT;
string ip;
if( v.type() == str_type ) { ip = v.get_str(); }
else if( v.type() != array_type ) { continue; }
else {

Voila! 50% savings, C++ versus . . . C++.

By the way, I’m not trying to knock your choice in language by any means. From everything I’ve heard, Erlang is a great language. And there may very well be a difference between it and C++ in terms of conciseness. But when I see all these line count comparisons sometimes I get a sense that it’s less that one language offers more conciseness than another and more that the author _wants_ it to, and thus codes differently such that the conclusion they wish to draw is supported.

./server < myfifo | script.py > myfifo

I was curious to see if erlang had some kind of support for binding to c libraries, for how you got taglib on erlang, but you’re just spawning a process and talking on stdio! That’s cheating! :p

That’s about the biggest nit I can find to pick. And I have a C++ server that’s using python right now by running ./server myfifo so I can’t really say anything :)

Pretty awesome. I guess I’m with Norman, a big pain in the ass VM was my last excuse. I’m out of excuses!