Re: Is Lua the next big thing?

[David Given <dg@...>]

Sam Roberts wrote:
[...]
> - erlang allows data structures (+code/objects, I think) to be
>   transparently serialized into messages.  So, even though it enforces
>   separation of states, it also allows easy transport of data between
>   states. The lua implementation I've seen of this don't involve sending
>   code, and usually allow only a few primitive types to be marshalled.

This is CSP, the 'other' way of writing multithreaded applications --- most
systems call it message passing, but that's really overly simplistic. CSP is
more a way of life than an algorithm... it's thought highly of in academic
circles because it's much easier to reason about than shared memory
concurrency; it's simpler to prove CSP algorithms correct. Another well-known
language that's based around CSP is Occam, which practically invented concurrency.

CSP typically has two primitives: send() and recv(). In Lua terms, they'd work
like this:

function adderthread(in, out)
	while true do
		local i = recv(in)
		send(out, i+1)
	end
end

function main()
	local slavein, slaveout = CreateThread(adderthread)
	for i = 1, 10 do
		send(slaveout, i)
		local j = recv(slavein, i)
		print(i.."+1 = "..j)
	end
end

Other typical features include type checking (so that if you send an int where
the thing on the other end wanted a pixmap, you get a clean exception rather
than a crash), variadic messages (so that the thing on other end can detect
whether you sent an int or a pixmap and do the right thing), parallel recv()s
(so you can monitor several input channels simultaneously), buffered sends (so
that you can send() without waiting for the other end to respond)...

Pure CSP forbids threads to touch objects belonging to another thread. This
has obvious disadvantages, but also some advantages: it means that you can run
threads in different address spaces. Or different machines. It lends itself
beautifully to clustering.

(There's also other cool stuff you can do with CSP, such as Linda.)

You could do CSP on Lua with fork(), pipe(), and a fast marshalling algorithm.
Not a lot of code.

[...]
> Lua is scheme-minimalist in many ways, but one thing the lisps have
> usually provided (always?) is data marshalling. You can write and
> read recursive data structures natively. I know, there are dozens of
> implementations of this out there for lua... but maybe thats a bad
> thing.

Fast marshalling is dead handy. I'd even argue that it was so handy that it
belonged in the core language...

-- 
┌── ｄｇ＠ｃｏｗｌａｒｋ．ｃｏｍ ─── http://www.cowlark.com ───────────────────
│ "I have always wished for my computer to be as easy to use as my
│ telephone; my wish has come true because I can no longer figure out how to
│ use my telephone." --- Bjarne Stroustrup

Attachment: signature.asc
Description: OpenPGP digital signature