ptalk > Work

That thing Tucker hasn't been able to tell you about all year…

A thermostat.

“Huh?”

I told you you’d say that. But that’s what my new company, Nest, is making, and what I’ve been unable to tell you about until today. It’s a smart thermostat. It learns when you are home and what temperatures you like, and it saves energy and money by managing your heating and cooling more efficiently. Today, we’re introducing it.

I’ve got two at my house, if you want to see one in person. Or you can save yourself the trip by visiting our web site:

Nest | The Learning Thermostat

Hope you’ll give it a look.

Hot Date?

Laszlo is previewing a Calendar module for its webtop. My first take: it works in the usual “Laszlo-rific” way you expect. I plugged in a couple of my .Mac calendars, and they “just worked”!

Our Webtop family has grown to include a personal Calendar, a perfect complement to Laszlo Mail and Contacts. As we said earlier, Calendar is the most requested application and, while we’ve taken a lot of time to get this right, we have decided to release it a little early, as a Preview, because we want to know what you think.

Introducing Laszlo Calendar

Pizza, Beer and OpenLaszlo [Part Deux]

Please join Laszlo Systems in San Francisco, CA for an evening of pizza, beer and OpenLaszlo development on Thursday, May 31st from 7:00-9:00 pm. In addition to meeting and mingling with other OpenLaszlo advocates, you will also be able to share your own OpenLaszlo success stories and learn the latest Laszlo community news and product advancements.

WE’RE LOOKING FOR PRESENTERS!
OpenLaszlo Developers: We’d love to catch a glimpse at your latest applications and projects. Each presentation should be technical in nature with a demo included. 10 minute slots will be available from 7:30 pm - onwards, and there will be a projector on site.

COST
Free. Pizza, beer and non-alcoholic drinks will be provided by Laszlo Systems.

TO SIGN UP
Please register at the following link

Free as in beer, Open as in source

Please join Laszlo Systems in Chicago, IL for an evening of pizza, beer and OpenLaszlo AJAX development on Thursday, October 19th.

Laszlo - Pizza, Beer and AJAX (Chicago)

It's Fresh!

So it must be Legal. We’ve released the first snapshot of our multi-target runtime (code named Legal’s, because the initial outline of the project came over a lunch meeting there).

Read all about it here: Introducing Legals.

You had me at "Hello".

We had the BOS "Pizza, Beer, and AJAX" meet up last night at Optaros [Thanks, for hosting, guys!].

The format was a little different than the SFO event. (Aside from the local pizza and beer.) Lots more informal chats. David gave a great presentation, showing some of the amazing things that have been already done with OpenLaszlo, such as LaszloMail, Gliffy, and Pandora. He gave a glimpse of Laszlo in 10 Minutes, which of course starts out with the usual "Hello World!" example. He finished up with a demo of LZPIX, showing it running identically on the Flash runtime and on the AJAX runtime.

An audience member raised his hand with a question: I just wanted to say, "You had me at 'Hello'".

Thank you Henry for the pictures, and Amy for transcribing the quote of the night.

Typekey, XHTML and Firefox

Several people have complained that they could not make comments on my blog. I eventually tracked this down to Firefox’s strict XHTML interpretation disabling the (somewhat sloppy) Javascript that tries to dynamically generate the comment form. Cleaning up that Javascript was all that it took, although it took me more than an hour to find the bits that needed cleaning.

Circles and Arrows

Henry asked me the other day if I could draw a picture of how my Classy Javascript works. Here’s what I came up with:

Pizza, Beer, and AJAX 16 March 2006

We had a meetup at Cell Space in San Francisco on 16 March (see the pictures on www.flickr.com, right). Lots of free (as in beer) beer and pizza. And lots of participation. Max gave a demo of our new DHTML delivery (Look Ma, No Flash). Antun showed rapid development in LZX, and six developers showed how they are using OpenLaszlo in their products: Pandora, Gliffy, Homebase, SimFaux, FireTrust, and Mazarin.

The highlight of the night for me was, after Max showed the LZPIX demo — same source running identically in both Flash and DHTML, a member of the audience commented: “Thank you Max, for saving the world.”

We hope so!

Classy Javascript

The Treaty of Orlando notwithstanding, inheritance has become more popular than delegation as a mechanism for doing object-oriented programming.

OpenLaszlo’s LZX language is an attempt to blend the best of both class-based and prototype-based object-oriented programming to provide a powerful interface description language. It has classes, as traditional inheritance-based languages do, but it adds an interesting feature from delegation-based languages: the ability to extend the behavior of a single instance of a class. While it does not permit using an instance as a prototype for another instance, it does make it very easy to turn an extended instance into a class so more instances can be created, or the class further extended.

But, OpenLaszlo is built on Javascript. Which doesn’t (in the currently accepted standard) have classes. It is a prototype-based language.

So, Adam and I spent some time thinking about how to really do class-style inheritance right in Javascript. As he pointed out in his blog entry, the methods that are out there leave a lot to be desired. We know that class- and prototype-based inheritance are equivalent, so it shouldn’t be that hard.

Here’s what we came up with:

Abject expression

Henry and I were looking at the debugger and wondering why:

lzx> function foo () { return 'Fu'; }
«Function#0| foo»
lzx> foo
WARNING: interactive-eval-2:-1: reference to undefined variable 'foo'
lzx> function foo () { return 'Fu'; };
lzx> foo
«Function#2| foo»

In the first case, a function named ‘foo’ is created, but it is not the value of the global foo. Instead the Debug evaluator returns a value which is that function object. In the second case, the evaluator does not return a value, and the global foo is defined to be the function. What gives?

It turns out the debugger evaluator will first try to evaluate what you type as an expression, and if that fails, it will try to evaluate it as a statement. The second form is clearly not an expression (think of what you type as having parens around it — the semi-colon forces the second form to be a statement list, with an empty second statement). It turns out that this is correct ECMA semantics. It is not whether you name a function or not that determines when a global definition will be made; two things must be true: 1) the function must be named, and 2) the function declaration must occur in a statement context. If the function declaration occurs in an expression context, all you have done is to create a named function object as the value of that expression, you have not defined that name as the function… Subtle.

There is a bug in the current debugger, though, because:

lzx> a = 3
3
lzx> a
WARNING: interactive-eval-7:-1: reference to undefined variable 'a'
lzx> a = 3;
lzx> a
3

In the case of =, it should not matter whether you are in an expression or statement context. = should cause the side-effect of assignment. Henry and I are looking into fixing that bug.

But in the mean time, if you ever wonder why when you define a function in the debugger it does not take, take a clue from what the evaluator prints out: if it prints out a function object, all you did was create a function, not define a function. Add the semi-colon after your definition and you will define the function (and not see a value printed).

Fourth and Bitz

Well, after beating on ASSetPropFlags for sometime, I finally came to the conclusion that the flag table that everyone has been referencing is wrong

BLITZ Labs » Blog Archive » ASSetPropFlags - The correct flag table

Well, there must be something else missing from all the tables on the web: the real meaning of that fourth argument. Is it really just a boolean? If it is just a boolean, then setting the flags to 0 should make a property writable and deletable too. Clearly that is not the case:

lzx> foo.test = 'bar' 
"bar" 
lzx> ASSetPropFlags(foo, null, 6) 
lzx> delete foo.test 
false 
lzx> ASSetPropFlags(foo, null, 0, true) 
lzx> delete foo.test 
false

It’s pretty clear to me that the fourth argument is also a bitmask, and it is the mask of the bits to clear (before you set the bits in the third argument). That is why so many people are confused. If you pass true as the fourth argument, it is coerced to a number, 1, so only the enumerability bit is cleared. Here’s the proof:

lzx> ASSetPropFlags(foo, null, 0, 2) 
lzx> delete foo.test 
true

AJAX and Netflix

Well, here’s one disadvantage to using AJAX over LZX. Your source is ‘open’ whether you like it or not. And your comments can be embarrassing:

// This function is fragile. Tinker with it at your own peril. "Optimizations" will cause you pain. - BK
function updateQueueDisplay(item) {

http://www.netflix.com/layout/jscript/miniqueue.js

Nonetheless, I am pleased that I can just drag and drop items in my queue to reorder them now.

Don't assume undefined is undefined

Sarah has a bug where she knows that:

typeof(foo) == 'undefined'

is true, but when she tested:

foo == undefined

it is false. How can this be? This is because undefined is not a literal in ECMAscript. Lots of people use undefined expecting it to be undefined, but it doesn’t have to be, at least not according to the spec. (null on the other hand, is a literal, defined to be the sole member of the Null type, just as the literals true and false are the only members of the Boolean type and cannot be redefined, and 1, 2, … Infinity are Number literals.)

If you try this in the debugger:

global[undefined] = 42

you will get a warning from the compiler, but now when you type:

undefined

you will find that it is indeed 42!

What’s the right way to test for undefined? It depends. Do you really need to know if a variable is undefined? If so, the typeof test is one valid way. The other valid way would be:

foo === void 0

void will cast any value to undefined — 0 is just a convenient (literal) value to use. Note the use of === to test for identical to undefined, if you really are testing for undefined, because:

null == void 0

is also true, so if you used == you would only know that foo was either null or undefined.

If all you need to know is that foo is not undefined, null, false, , or "" (an empty string), then you can use:

Boolean(foo)

or:

!!foo

or:

if (foo) { ... }

because all of undefined, null, false, and "" coerce to false in a boolean context.

The moral of the story is: Don’t assume undefined is undefined. If you really need the undefined value, use void 0, or test for typeof(...) == 'undefined'.

What is the type of a prototype?

I’m trying to beef up the Laszlo debugger to help myself with the SOLO data reimplementation. I have gotten confused a couple of times because the debugger isn’t careful enough.

The goal of the Debug.__String routine (which is used by Debug.write and Debug.inspect to present objects), is to compactly and unambiguously display objects. For primitive types, it displays a representation that, if evaluated, would give you back an === object. (In Lisp this is called print/read consistency). It can’t do that for objects without giving up its compact goal. So, for instances of Object, what it displays is:

« type # uid ( length ) | name »

The double-angle-quotes are just there to be distinguish this representation from primitive types (In Lisp, there is a reserved reader macro #< that is used to distinguish ‘unreadable’ objects).

type is meant to be the most specific class where object instanceof class is true.

uid is a unique id assigned by the debugger to distinguish objects whose representation is otherwise the same (e.g., 2 empty objects)

length will be displayed if the object has a property length with a numeric value. This is mostly for arrays, but means that objects that are used as arrays will be displayed usefully too.

name is meant to be some informative information about the object. Users can define a _dbg_name method on their classes to provide this. For LzNode, name will be either '#' + this.id or '.' + this.name. If an object has a toString method, other than the default one, that will be used. Otherwise an abbreviated listing of the objects properties will be used.

Here’s my plan:

• Verify that type is correct.

  The constructor property of an object should be its type. If that is not the case the type will be annotated '(' + type + '?)', to indicate that something is fishy about this object. This will address the case where an object was showing up as being an object in the old debugger, but it had a null __proto__ and hence compared === null, mystifying more than one of us.

• Verify that the __proto__ property of the object is normal.

  Normally the __proto__ property of an object should be === the object’s constructor’s prototype. If this is not the case, the object can have non-standard behavior. If the __proto__ is not as expected, the debugger will add a second uid that is the uid of the non-standard prototype object (which can be inspected by using Debug.inspect with Debug.showInternalProperties = true). This will address the case where the __proto__ chain is being (ab)used to implement defaults in parameter lists, for instance.

My question is:

What is the type of a prototype? For a class foo, foo.prototype.constructor === foo, but foo.prototype.__proto__ === Object.prototype (typically, it can be some other classes prototype if the class extends another class). Under my plan, a prototype will always show up as having a broken type. Technically this is correct, because the prototype of a class is not an instance of the class, but I don’t want the user to think all prototypes are broken. What would be the most useful thing to display for the type of a prototype? The class of its __proto__ is what I am thinking.

Now Appearing Nightly

Nightly builds of the Laszlo development branch are now available. Get yours while it’s hot.

About that serverless app...

In Now We Are Three, I pointed out that Laszlo apps could now be ‘serverless’, meaning they can be compiled to a standalone .swf that can be delivered by any web server (no J2EE servlet required) and that they can fetch XML data directly from any http: data source. I pointed out that I should rewrite my little ptunes app (in the left column) to be serverless, and that I would report on how hard it was. Well, here’s the report:

It should have been simple. I should have been able to just put in the <canvas> tag proxied="false" and recompile. It would have been that simple if my app code were not nearly two years old. The <tabslider> component that I used in my app has evolved a lot in that time, so I had to spend a bunch of time ripping out kludges that I had in my code to work around some of the limitations of the old implementation.

In the end, it was a great improvement. I eliminated a lot of excess baggage. I was able to use the new <style> component to give my app a uniform style. I was able to use the new resizable canvas feature to let my app take its size from the <object> tag that embeds it, rather than having a static size. I was able to eliminate a lot of nested views because I just understand LZX better now.

I did have to change the code that calculates the source URL for my ‘Show Source’ button. It has to change the file suffix from .swf to .lzx. I was fooled for a second on why my tooltips faded in and out in such a funky fashion, then I remembered that <text> now defaults to device fonts and I guessed that device fonts don’t respond to opacity changes any more than they respond to rotation. I changed my tooltip font back to an embedded font and all was well.

The one thing that stumped me the longest was figuring out how to get the ‘Now playing’ track to be the tab that is open on loading. I poked around in the documentation and on the web for a while and found a whole bunch of techniques for dealing with the fact that because replication happens lazily, nearly anything you try is going to set the selected ‘too soon’. Setting defaultselected in the tabslider doesn’t work. Setting it in and ondata clause in the tabslider doesn’t work. Setting it in an onclones in the datapath doesn’t work. Aha. You can’t set it until the tab that you want to set to has been inited. I finally hit upon it: in the <tabelement> I put:

oninit="this.setAttribute('selected', this.tip == 'Now playing')"

Phew. The tough part is that sometimes it seemed to work, when I was debugging locally — presumably because the data arrives fast enough — but when I would install the app on my server, it stopped working.

The last step to getting my SOLO app to work was simply to upload it (and the source!) to my server (Just used Interarchy to do that) and then adjust my <object> tag to fetch the app locally (instead of through mylaszlo). Oh, I could shorten the opml address to a relative address. You see the result to the left.

I’m still using Kung-Tunes to upload my XML, but that is obsolete. So the next effort will be to, hm, can I use DynDNS to make my laptop visible and have ptunes query my iTunes directly for what’s playing? Hm…

The Laszlo or the Tiger

I installed Tiger over the weekend. So far, so good. LZX development and browsing seems to work just fine.

I did an “archive and install” because I like a clean start. This meant that my /usr/local was moved to Previous Systems. I had to move back /usr/local/bin/p4, and that is also where I kept my flasm, javacc, jython, and tomcat. I just moved them back and they work fine.

I had my _xmlplus stored in the python Framework, so that was not there in the new install. I grabbed it out of Previous Systems and decided to use a new strategy in the future (so I would not waste so much time trying to figure out why the python version check failed — it was because _xmplus was missing). I added the following to my .bashrc:

# we use _xmlplus, which I put here to stay out of the /System dir
export PYTHONPATH=/usr/local/lib/python2.3/site-packages

and moved _xmlplus there.

Tiger comes with Flash 7.0r24 installed by default. I thought I recalled some reason I didn’t want that (I had 7.0r14 on Panther), but it seems to work just fine.

I installed Java 1.5 and tried building, but there are a bunch of errors that will need to be looked into.

Now We Are Three

OpenLaszlo 3.0 is out. Drawing API. Dynamic Libraries. Unicode. Serverless.

Serverless? Yup. You can write a standalone app that talks directly to data sources. Hm. Guess that would mean that app in the left column there. Gotta try it. More on that in a minute…

Laszlo in Business

Laszlo Systems (which designed the Earthlink mail program)

So Long to Clunky Web E-Mail

Laszlo gets an IDE

IDE for Laszlo is a technology preview of an Eclipse-based development environment for creating, editing, debugging, and testing applications based on the LZX declarative mark-up language.

alphaWorks : Integrated Development Environment for Laszlo

So, it seems that this little company named IBM has picked up on Laszlo going open source. They’ve developed a plug-in for their Eclipse open source IDE to support developing Laszlo apps. Should make things interesting…

Particularly cute is the demo, written in LZX using Eclipse. The demo demos demoing the demo ;)

Laszlopen!

Laszlo is now Open Source. The Laszlo Platform, which is the LZX language and the Laszlo Presentation Server, are now open source. You can download and install the Laszlo Platform for free, and you can develop and deploy Laszlo applications for free.

How do we make money doing that? The same way lots of companies are now: by providing service, support, and commercial development on top of that platform.

The ptunes widget to the left, that shows what I am listening to in iTunes is an example of a simple Laszlo application. For examples of commercial applications using Laszlo, visit Laszlo Systems, Inc.

For more information on Laszlo’s open source platform visit Open Laszlo.

Laszlo is more 'flex'-able

Concise comparison of Laszlo and Flex: Laszlo - Laszlo's Price??

Wild Codie

Laszlo has been nominated in two categories for a Codie.

New England clam fryer adopts laszlo blogbox series

Guess we'll need to have a Laszlo luncheon soon at Charlie's Too!

Try one, get one free

The latest Laszlo Release, LPS 2.0p DE, is freely downloadable and serves up to two simultaneous client connections.

Laszlo - Downloads

My Back Pages

Stumbling around in the blogosphere I came across an article about Dylan, the programming language. Brought back fond memories. I still think it’s the coolest O-O language, but I have to program in the language that will pay the bills…

I have one quibble with the author: Dylan did not invent multi-methods. They have been around since Flavors and LOOPS.

My personal favorite feature that Dylan did invent is sealing, or perhaps more appropriately, opening. Dylan’s sealed and open declarations are the key to its balance of flexibility and efficiency. They let the developer of a module declare which classes and methods are permitted to be extended. This declaration allows the compiler to generate much more efficient code for the case where extensibility is not allowed (outside the module), without burdening the programmer with an excess of type and visibility declarations.

Quoting from Dylan Programming:

A C++ compiler could optimize out the dispatching of a virtual function by analyzing the entire scope of the argument on which the virtual function dispatches, proving that argument’s exact class. Unfortunately, that scope is often the entire program, so this optimization often can be performed only by a linker. Even a linker cannot make this optimization when a library is compiled, because the classes of a library can be subclassed by a client. The complexity is compounded for dynamic-link libraries, where there may be multiple clients at once. As a result, this optimization is rarely achieved in C++.

In Dylan, sealed classes, sealed generic functions, and sealed domains explicitly state which generic functions and classes may be extended, and more important, which cannot. The library designer plans in advance exactly what extensibility the library will have. The Dylan compiler can then optimize dispatching on sealed generic functions and classes and within sealed domains with the assurance that no client will violate the assumptions of the optimization. The sealing restrictions against subclassing or changing method applicability are automatically enforced on each client of a Dylan library.

Fink Panther

Panther is out with X11, but they forgot to X-enable the emacs. Follow the instructions at Tales of the Racoon Fink to get yourself a working emacs.

The ubiquitous blogging widget

Following Sarah and Mark’s lead, I had to make my own version of the ‘ubiquitous blog widget’.

ptunes

I’d been looking for a way to display what I'm playing in iTunes on my blog, and I stumbled across Kung-Tunes, a cute little AppleScript that queries iTunes and formats your recently played list as XML (or OPML, if you take the time to teach it the right template), and then uploads it to your web server. It was simple enough to hook the blogging widget on to the OPML file, but I wasn't satisfied with the ‘skinning’ of the widget. It clashed with the look of my blog. I spent a few hours fiddling with Photoshop to create some new art, then adjusted the layout to handle my slightly different requirements. I tried to make the interface cleaner, and in the process lost some of the Laszlo promotional material. So I stole my prototype cyberlogo from my Site Toc demo and implemented some crude tool tips.

I hope people don't get too upset at the Apple-centricity of my implementation. Clicking on the song links will tell iTunes to search its Music Store. Sorry Windows users.¹

Come out and play!

Christophe Coenraets has created a really neat Laszlo application for learning about Laszlo, the LZXplorer.

LZXplorer

The explorer shows three panels that display simultaneously example code, comments on the code, and the results of running the code. It is is self-paced tutorial that lets you explore the basics of Laszlo programming, but you can also use it to prototype Laszlo code of your own.

If you are intrigued by what you see, you can download the free developer edition of the Laszlo Presentation Server for quick turn-around development.

When you have an idea that you want to share, you can upload it to MyLaszlo.com, a free service provided by Laszlo for sharing LZX demos.

Yahoo for Laszlo

Yahoo! has released a new personalization interface for their customers using Laszlo technology.

[Press release at Yahoo! Media Relations - Press Release.]

Read more about the Laszlo-based personalization tool in Sarah Allen’s web log.

Flash Hash

The new Flash 7 beta demonstrates a significant performance improvement.

Presumably some of that improvement comes from improving an algorithm that must be central to any Javascript virtual machine: looking up Object members. Objects in Javascript can have members with any Javascript string as the member name. Most implementations will use a hash table to implement Objects, where the hash key is the member name and the hash value is the value corresponding to that member.

Arrays in Javascript are really just Objects that happen to have members with names like '0', '1', '2', etc., and a special length property that is always 1 more than the member with the highest numeric index.

Implementing Array’s efficiently must be tricky, because programs will typically ask for array members using numeric indices, but Javascript semantics state that they must behave as if the numeric index was converted to a string first and then used to look up the member. Furthermore, you are allowed to add members to an array with non-numeric indices, so you can’t specialize your hash table to only support numeric indices.

Clearly, you’d like to avoid the overhead of converting to a string if you can. One way I can think of doing that would be to have a clever hash algorithm that hashes numbers and the string representation of a number to the same value, then you can delay the number-to-string conversion until you have a key to compare to.

I’m thinking that Macromedia may have an optimization something like that in the Flash 7 player, because of the following bug that I have found. If I set any array to have an element at '-', it seems to corrupt all the other arrays in my application that have an element at 0 — they all behave as if their 0 element moved to '-'.

If you have Flash 7 beta installed, you can see for yourself: Flash 7 Bug

Here’s the source code for this demonstration:

mylist.addItem("Create an empty array: var crud = new Array;");
var crud = new Array;
mylist.addItem("Store a value at '-':  crud['-'] = 'foo'");
crud['-'] = 'foo';
mylist.addItem("Create an array of one element: var ary = [ 'one' ];");
var ary = [ 'one' ];
mylist.addItem("What is at ary[0] now?");
var j = '0';
mylist.addItem('ary[' + j + '] => [' + typeof(ary[j]) + ' ' + ary[j] + ']');
mylist.addItem("What is at ary['-'] now?");
j = '-';
mylist.addItem('ary[' + j + '] => [' + typeof(ary[j]) + ' ' + ary[j] + ']');
mylist.addItem("What are all the elements of ary?");
for (var i in ary) {
	mylist.addItem('ary[' + i + '] => [' + typeof(ary[i]) + ' ' + ary[i] + ']');
}

... so many to choose from

What if you gave a standard and nobody came?

Standards are a good thing, and open standards are even better, but do I really have a standard just because I say so? Some of the most successful standards are de facto standards — standards that have become so because a product has been accepted by the market and become the paragon against which others are judged. Linux could not exist without Unix having first established a de facto standard.

On the other hand, proprietary standards can fail to take hold because the market does not accept them. The classic example here is Beta vs. VHS — it is widely accepted that despite Beta being a better quality format, Sony's refusal to open (even license) its standard, let VHS dominate in the marketplace.

Postscript and Java are interesting standards to compare. Adobe has retained control of the Postscript standard, but because Postscript has to have an interface to page layout programs that is well-specified, third parties have been able to create Postscript emulators, competing with Adobe's proprietary implementation. Adobe has retained market share by continuing to provide value — Adobe's engine remains the touchstone against which all other emulators are judged.

Sun has waffled on whether to relinquish control of Java to ECMA in an attempt to gain greater acceptance while preventing the divergence that plagued Lisp and Unix in the early 70's. Sun has had less success than Adobe in licensing "true" Java, perhaps because the value is less clear.

The question is: when developing a new product, at what point do I want to standardize it?

Safar-as-I's concerned

Safari bugs that are impeding me:

Setting location.href on a frame won't update the frame. In some cases, it will update it once, but not again. In other cases, it won't update it at all.

Here is a simple example that works as expected in Camino (Mozilla).

Web Ring is an actual application that I am working on that demonstrates the 'only loads once' effect.

Royale FUD¹

Macromedia's Royale promises to be, someday, everything that Laszlo Systems² is today.

LZX is an object-oriented programming language expressed in XML and Javascript. Application source files are text-based, meaning they can be managed by any IDE and source control system, and projects can easily be developed by teams.

The Laszlo foundation classes are a suite of UI objects and behaviors providing a substrate for rich internet apps, including back-end database connectivity.

The Laszlo presentation server is a JRE servlet that is deployed on a J2EE application server. The presentation server compiles your LZX source to SWF so your application can be delivered to any platform where the Flash player is present (5.0 player or better).

Laszlo lets you build desktop-level power into applications that can run in any web browser.

Is it a sign?

Walking to my train today, stopped to drop my spare change in a coffee cup. The holder is wearing a Macromedia polo shirt. What does it mean?

Garbology

"noun, social science: the investigation of the refuse discarded by a society as part of the study of that society. c 1970s: from GARBAGE"
Chambers 21st Century Dictionary