Some graphical examples

The following are two graphical applications written in LuaGravity with respective videos and source codes.

---

The first example shows some flying rectangles whose size and speed increase as they get closer to the screen base.

Here's the source code:

for i=1, 15
do
 local r = root:_add(
     Rect()
         ._fill {r=255,g=200,b=100}
         .x { pc=0, dim=true }
         .y { p2=0, dim=true }()
     )

 r.x.pc = root.x.pc + INT(math.random(-15,15))

 local y2 = r.y.p2

 local v = 1 + y2^1.3/root.y.p2
 r.y.p2 = INT(math.random(1,15)*v)

 local dim = 1 + y2/5
 r.x.dim = dim
 r.y.dim = dim
end

---

The second example shows the mouse cursor surrounded by orbiting rectangles.
The orbit radius may be changed explicitly.
It's based on an example found in the FrTime distribution.

Here's the source code:

local secs = INT(1)
local sin  = L(math.sin)
local cos  = L(math.cos)
local C    = 2/3 * math.pi

radius = 50

for i=1, 3
do
 root:_add(
     Rect()
         ._fill {r=255,g=0,b=0}
         .x { dim=20, pc=(mouse.x + radius * sin(secs+C*i)) }
         .y { dim=20, pc=(mouse.y + radius * cos(secs+C*i)) }()
     )
end

A first glance at LuaGravity

As a pragmatic programmer, I'll try to mix the academic bla,bla,bla with practice, so...

LuaGravity is the name of my toy language that implements the synchronous approach for concurrency (I'll dig into it sometime).
(Actually, it's a *serious* toy language as a I'm very concerned to it and keep adding features and tweaking it all the time.)

When running it without a filename, you'll see a prompt just like in the Lua Language [1].
As you type the statements and expressions you'll attest that it's just normal Lua...

Except, it's reactive!

The video above shows that the variables a and b reacts to the current time, a - b to a and to b, and so on.

The INT function integrates its argument over dt (remember it from Calculus?).
It's used here only to create a time reference for the application.
The L function states to its arguments that they should behave reactively (the name comes from "function Lifting").

The result of the expression a - b shows the perfect synchronism between its arguments: no need for locks, no milliseconds difference, no text blinking, just zero as it is expected.

LuaGravity is roughly based on Esterel [2] and FrTime [3], two synchronous languages, the former having an imperative style, the latter being functional.
The example above shows only some functional features.

Here are some LuaGravity Implementation Facts:

• It's implemented over the Lua language runtime (there's no need to parse source code).
• The engine running the system is "just" an event handler.
• The elapsed time during an event handling determines the dt value used by INT and varies over the time.
  
• The prompt you see is a collection of graphical objects (no, it's not a magical raw terminal).
• It's single threaded, of course.
• The engine's whole source has about 300 lines of Lua code.
• Chuck Norris wrote a version in assembly in 2 hours.

In the next examples we'll escape from the dry command line and see a lot of graphics, where LuaGravity really rocks.

[1] http://www.lua.org
[2] http://www-sop.inria.fr/meije/esterel/esterel-eng.html
[3] http://www.cs.brown.edu/research/pubs/techreports/reports/CS-03-20.html