Pushed wrong button, rebooted the Internet ...

Getting started with WebGL 3D magic

2009-10-17T16:59:00.000-07:00

Firefox trunk build and webkit nightly builds both support WebGL, the upcoming Standard for hardware accelerated web browser 3D graphics. So I wanted to get my feet wet with this new technology and after short analysis, I did the following steps as possibly fastest solution to get a working demo (in my case on a mac):

updated my nightly build of webkit
in a terminal, issued the following command:
defaults write com.apple.Safari WebKitWebGLEnabled -bool YES
opened one of the currently popular demos / showcases.

and then you get a smooth rotating object, all coded in Javascript !

Back on business

2009-10-02T01:38:00.000-07:00

After some longer absence from the blogosphere and open source communities in general due to some personal disruptions, I am back, this time with focus on serverside Javascript, webkit-specific client-side stuff (for iPhone web apps, of course) and more. Right now I have just learned that super slick Cappuccino web framework is starting its Atlas-Web-IDE beta program on November 15. Exciting times ahead.

Develop native iPhone apps in Javascript

2009-04-15T16:06:00.000-07:00

With phonegap you can today write iPhone webapps which run on an embedded browser and with a bit of clever CSS styling and JS trickery you can makes those apps smell and feel like native apps. Why not just writing normal browser based web apps for the iPhone ? Well, first you can't sell web apps on the app store and second, phonegap exposes many additional APIs to Javascript based apps.

Soon there will be a new flavor of JS / phonegap iPhone apps: Mike Nachbaur is working on a phonagap branch, which allows (or hopefully soon will allow, I haven't tested yet) to create in JS native Cocoa UI widgets such as tabbars and toolbars. Apple often just follows with Apple-branded versions of what smart developers do ahead of time, so if this will happen in this case as well, I would expect many of the iPhone developers to switch from Objective-C to JS.

CodeMirror browser editor got a Lua parser

2009-04-14T08:55:00.000-07:00

Try it out. Unfortunately it might take a little while until it will find its way into bespin, because right now, CodeMirror based syntax highlighting in bespin tip is disabled due to some one restructuring of the canvas paint function.

Helma NG serverside Javascript framework on appengine

2009-04-11T06:45:00.000-07:00

Helma is one of the few Javascript server-side web frameworks, and it's next generation version runs right out-of-the-box on Google appengine. I followed the tutorial and easily got my own Helma NG demo running on appengine. Because Helma NG is a complete rewrite of standard Helma (which doesn't run on appengine), it is very simple, no persistence yet, mostly just request wrapping and routing and a simple template engine (no template inheritance and other fancy feature you find e.g. in django). If this is all one needs then Helma NG on appengine is now probably the easiest way to run javascript at client and server side. So let's hope that those who need a bit more, will contribute to Helma NG development to make it competitive with PHP, django and RubyOnRails, or come up with a new framework (RhinoOnRails ???).

And for those who need less than Helma NG, this article might be helpful.

Update: I was wrong about template inheritance, Helma NG does support it, via the "extends" tag. And the development branch has now also appengine persistence support (demo).

Javascript on appengine

2009-04-08T06:46:00.000-07:00

Was offline yesterday, therefore missed to be among the first 10K to try it out, but a bit of web research revealed that it should work right out of the box:

Update: already got my invitation, now just need time to experiment with it !

Experimenting with lexical auto-indentation for bespin

2009-04-05T17:49:00.001-07:00

While the basic features of the codemirror syntaxengine now are part of bespin (and that is just syntax highlighting), I started today to experiment to add an advanced feature: Auto indenting of current line or a selection based on lexical analysis. The user just has to press CTRL + TAB (but could be any other key binding of course). The information about what codemirror thinks is the correct indentation is already internally stored for each line of the source document, all I had to do was to add some code which inserts or deletes some whitespace at the begin of those lines the user marked for auto-indentation. That is at least what I thought. Unfortunately it doesn't work yet reliable (and that is my fault, because the original codemirror editor does perfectly auto-indent) and also is not yet integrated into bespins undo/redo system, so it needs another iteration, before I can submit a patch, but if anybody wants to help working on it, take a look at the auto-indent code I added.

Adding python syntax highlighting to bespin

2009-04-02T01:45:00.000-07:00

Support for Python got recently added to Codemirror, thanks to Timothy Farrell. So I grabbed those sources and ported them to bespin.

It doesn't work yet perfect in every case one can think of, but it does highlight Python.

The current features are (summarized from original demo page):

Token-based syntax highlighting - currently very little lexical analysis happens. Few lexical errors will be detected.
Use the normal indentation mode to enforce regular indentation, otherwise the "shift" indentation mode will give you more flexibility (not used yet in bespin).
Parser Options: Python version, error display

The patch with python support is now applied at my repo at bitbucket.

Javascript based parser generator system

2009-03-31T12:14:00.000-07:00

I hope this is real (because April 1 is approaching, see my previous post): The first ever LALR(1) parser generator system written in and for Javascript. Would be interesting to add this to bespin, declarative grammars (as used in flex/yacc) are relatively easy to define, compared to codemirror which I used for the new, alternative bespin syntax engine and which is an interruptible-resumable continuation-passing style parser and needs to be written programatically for each language.

Similar to the narcissus parser implemented by Malte, such LALR(1) based parsers could be used for generating outline views and syntax checks running in a background worker thread. What it can't be used for is syntax highlighting, because LALR(1) based parsers need to reparse the whole file for every change to a document and that makes them too slow for syntax highlighting in realtime.

Internet Explorer Eightpril.1 with Webkit/Gecko rendering option !

2009-03-31T11:54:00.000-07:00

I guess this is an April 1 joke leaked out too early and with perfectly photoshopped screenshots. If it is not a hoax, then, according to this article, the new Internet Explorer 8.1 will also allow to use Firefox extensions ! Ha ha !

iBespin

2009-03-29T00:03:00.000-07:00

Now that my bespin syntax engine is more or less working and got added to the main repo, I experimented again with inline previews, but this time I think the result is a bit more in line with what one actually needs:

I added a preview setting. Using previews is the same as always, either click on the icon, or type the command: preview.

Below are the new settings:

set preview window - default, an external window, as we have now.
set preview inline - instead of editor canvas we have an iframe containing the preview
set preview iphone - a non-modal popup containing an iframe with dimensions of the iPhone screen. Of course you should use Safari for this.

With ESC key the previews get closed / toggled off.

Now this just needs to be cleaned up a bit and turned into a patch or pushed to my repo at bitbucket.

Update: Bugzilla ticket

Java on AppEngine (or serverside JavaScript for the masses) !!!

2009-03-26T12:41:00.000-07:00

But let's wait first for confirmation of the rumor.

Update: Following the first comment on this post ("Java != JavaScript"), it might look like I am confusing things, so let me clarify for those who can't remote read my mind (hopefully most) and are not familiar with Rhino, which is a JavaScript implementation written in Java, and allows serverside scripts to be written in JavaScript. And maybe just coincidentally, a few days ago a new release of Rhino has been pushed out. And for those who don't know, Norris Boyd, the main developer of Rhino is a Google engineer. So for me at least it makes sense to assume, JavaScript is part of Google's Java App Engine plans. But let's not forget, this is all based on speculation, and the only difference between now and the very same rumors "leaked out" by a Google engineer a few months ago, is that Michael Arrington has a lot of readers.

Cross-browser offlining

2009-03-23T00:37:00.000-07:00

I just tried to find out what needs to be done to make a web application (let's take bespin as example) work offline. Unfortunately a google search for cross browser offlining did not point to any magic solution. So let's start with what I knew already about this:

offlining the static resources is the easy part and modern browsers and google gears provide all kind of support for that.
offlining the dynamic requests is extremely difficult. The server logic needs to be modeled on clientside and the risk of getting data inconsistencies is big. So let's leave that part for another day.

Unfortunately all the popular browsers (I tested with the newest betas) and google gears provide different ways of how to handle the offlining of static resources:

Firefox 3.1beta

Supports the HTML 5 offline API and has a menu option to simulate the offline mode. The static resources need to be listed in a manifest file:


CACHE MANIFEST

/index.html
/default.css
/images/logo.png

and that manifest file name becomes an attribute of the html tag of the app start page:

<html manifest="/tests/th/cache-manifest">
<head><title>test</title></head>
<body>test</body>
</html>

Safari 4beta

Also supports the HTML 5 offline API, therefore everything the same as with Firefox, except there is no easy way to simulate the offline mode. Just turning off the internet connection does not help if you use a server on localhost for development.

Google gears for all the other browsers

Now it's getting a bit more complicated. First you need to find out whether gears is installed, and if yes, load the cache manifest file, which unfortunately has a different format (JSON) than the HTML 5 version:

// cache-manifest.gears
{
  "betaManifestVersion": 1,
"version": "site_version_string",
"entries": [
    { "url": "/index.html" },
{ "url": "/default.css" },
{ "url": "/images/logo.png" }
  ]
}

And the loading of the manifest has to be done in Javascript:

if (google && google.gears) {
var localServer = google.gears.factory.create('beta.localserver');
var store = localServer.createManagedStore('test-dev');
store.manifestUrl = '/cache-manifest.gears';
store.checkForUpdate();
}

Because the HTML 5 / gears manifest files have a different format and easily grow beyond manually manageable size, a tool (or a custom build step) is necessary to create and update the cache manifest file for complex apps.

Finally ported CodeMirror syntax engine to bespin

2009-03-21T00:04:00.000-07:00

I have written before about my attempt to port the CodeMirror syntax highlight engine to bespin. I got it mostly working now (for Javascript, HTML, CSS, PHP and even all these languags mixed together as in PHP) and have submitted an initial patch for review.

The port required quite a few structural changes of the code because, on bespin the syntax engine is running in a background thread if webworkers are available (FF 3.1beta, Safari 4beta, Webkit nightly) or gears is installed, otherwise it is still running asynchronous, triggered by a Javascript setTimeout() with value 0. This all has only been possible thanks to the groundbreaking work of Malte Ubl.

So if you wanna try that patch out today, you need of course a local installation of bespin, then apply the patch and use the command-line to enable / disable the syntax engine:


set syntax2 on / set syntax2 off

And don't expect it to be not even near as fast as the default engine. It is just an initial port, caching and other tricks to make it fast are not enabled or implemented yet.

Bespin, Mercurial and keeping your patch up-todate

2009-03-15T15:58:00.000-07:00

While hacking on bespin I experimented some of the possible ways to keep a patch in sync with tip (this is how they call "trunk" in hg land).

Just cloning the repo for developing the patch

this is the easiest, and seems quite popular. Unfortunately you are switching physical directories when you switch between clones, and in the case of bespin, where running server-instances are tied to a physical directory, it requires either a smart approach for running the instances in parallel or easily shutting down one and starting up he other. And if you are working on different unrelated patches, it can get quite messy to do manual merges when tip changes. To sum up, easy to get started with, but lots of disadvantages.

Using branches

Branches are easy to create and easy to switch between them and they have one big advantage compared to cloning: You stay on the same physical directory if you switch branches. However, the pain of manual merges when tip changes seemed to me even worse than with cloning.

Using queues extension

this is currently my preferred way. With queues extension you have always a clean tip, can develop patches, apply them, remove them, apply /remove patch-sets and easily change the order of the patches in the set. Updating tip is as easy as:


hg qrefresh    # update current patch with local changes
hg qpop -a      # remove all patches
hg pull
hg update
hg qpush -a    # apply all patches

What I haven't figured out yet is how to use bundles with queues extensions.

Update:
By enabling rebase extension, rebasing with tip got even easier. The lines above got reduced now to:


hg qrefresh    # update current patch with local changes
hg pull --rebase

Update II:
Lately I just push my local repo with applied MQ patches to my personal public repo at bitbucket, with the purpose of facilitating the pull of my patches.

More on the new syntax engine for bespin

2009-03-08T09:24:00.000-07:00

And so here continues my journey in porting the CodeMirror parser / tokenizer to the bespin syntax engine. While at my first iteration I basically just merged the codebase and managed some initial nicely-colorized rendering, I bypassed the mechanism which actually makes CodeMirror parser / tokenizer an interesting choice for bespin: the interruptable / resumable parsing. Now this is halfway working so let me explain it in detail:
The default bespin syntax highlighter works on a per line base and is extremely fast (magnitudes faster than any approach involving real parsing) and its performance is independent from the document size. But if we wanna have real syntax analysis in real-time, there is a price to pay for it and this price is a slower syntax engine. But with some real computer science (many dissertations have been written about parsers) and a lot of tricks, the user hopefully won't perceive any loss in responsiveness.

The streaming tokenizer / parser approach

While most parsers need to read the full document to parse it then all at once, CodeMirror is more like a streaming pipeline engine: it can start at any line in the document, after processing that line, the engine spits out immediately the tokens containing the syntax coloring information and in the near future callbacks for indentation and maybe even code-completion. So how does this engine work ? The main trick is that the parser stores its state at each line, so it can resume its operation at any line. Of course with all the details, it is a bit more complicated:

First we have our document, bespin internally represents it as an array of lines of text. Then there is a StringStream wrapper, which allows us to treat the document like a stream. Then there is a stream traverser which goes forward through the stream, passing the stream content to the tokenizer, which splits the stream into tokens and the last element in the pipeline, the parser does the main job of further analyzing those tokens. For every line the parser attaches a copy of itself (or better: its internal state) to he line. So once the document is initially parsed up to a certain line Y and the the user changes something at a previous line X, the engine retrieves the stream starting at line X, grabs the parser which has been attached to line X and continues its job there.

Of course there are a lot of things which can go wrong. For example the engine loosing sync between the stream representing the actual text lines, the document itself and the stored parsers. If this happens the document needs to be fully reparsed, which is a performance disaster. And this happens right now, because a few parts are not implemented yet, but I am working on it.

I am very excited about integrating the engine with Malte Ubi's work: offloading the engine to webworkers / gears for async background syntax analysis and merging it with the upcoming thunderhead editor component, which is optimized for calling the syntax engine only when really necessary. Right now I am messing with caching (otherwise the parser would block the UI, arrghh !!!), I try to detect whether calling the syntax engine is necessary, if not I provide cached results if available.

So the next week will be very interesting, to see how these things rapidly evolve.

Porting CodeMirror syntax parser to Bespin

2009-03-04T09:09:00.000-08:00

The first screenshot (or the second, if the images are in a row) shows the current bespin syntax highlighting engine. It applies on a per-line base regular expressions to highlight the different parts. This approach is very fast, and new language color definitions can easily be added, but the engine is not aware of the internal structure of the code the user is typing in, and therefore such an engine cannot be extended to show in realtime syntax errors and provide intelligent code indentation and completion. The engine splits code into the following elements for colorizing:

comments
C-style comments
keywords
strings
punctuation

The second screenshot shows an early stage of a new approach I am working on, a syntax engine which uses a real tokenizer and parser (borrowed from the CodeMirror project), fully aware of the structure of the code. So far the initial coloring is fine, but to get it work continuously and smooth and with large files, there are a lot of problems and a lot of work to solve them ahead.

The second screenshot (or first, if the images are in a row) also shows that a few more Javascript code elements got identified and colored:

atoms
variables
variable definitions
local variables
properties
operators

I have chosen Javascript as the first language to port to this new syntax engine, because it is the most important one for me and maybe for web apps in general. But JS is a dynamic language and syntax analys is tricky. The good thing about CodeMirror is that beside of JS there exist already tokenizers / parsers for:

CSS
HTML mixed (with JS, CSS)
PHP mixed (with JS, CSS, HTML)
Django mixin (my proof-of-concept, never got officially released)

This new syntax engine, if I ever get it working in an acceptable way, is not supposed to replace the existing one. If desired and enabled, it will try to provide a better user experience, but will use the original syntax engine as fail back.

Bespin - experimenting with embedded preview

2009-02-28T12:29:00.000-08:00

While a browser based text editor or web development environment has many disadvantages compared to the desktop variant, there a also some great possibilities which haven't been explored yet with bespin. Possibilities such as having direct browser DOM access for previewing and possibly manipulating content and that is not limited to text. Images (img tags and background images) can also be edited live (with a bit of canvas magic, as e.g. in pixastic) and server round trips are only required to store the edited images. Traditional editors can only dream of this and adding this possibilities to monster IDEs makes them even more complex.
So here is my proposal (including fully functional early stage prototype) for a live preview, see the screenshots above, just clicking on the eye icon at the toolbar and at the place of the editor canvas with the HML source code, a preview panel gets blended in. Unfortunately there are a few issues. Lets take a look at the style definition of the example. It has defined properties for the "body". But we don't want to change the bespin body properties. So what I am doing to prevent a visual and usability disaster is parsing (not really in the lexical sense) the HTML template, extracting styles and injecting them as filtered CSS rules into the page when rendering the preview and removing the rules when switching off the preview.

So far this is only for HTML templates. But my idea is to have a pluggable template parser system so we can expand PHP, django or other templates. While this is not easy, I have done it before (ErlyDTL, the Django template language for Erlang) and I have used a javascript template system before: dojox.dtl - dojo django rendering. So why not use dojox.dtl for bespin template rendering ? Well, first it is specific for django, second it is text and node based (for performance reasons). That is good for an app where template parts get swapped frequently, but just for preview we don't need a node based template system, at least not for now because it adds a lot of complexity.

And one more thing to consider are the edge cases in which this approach won't work. Hopefully with enough trickery the embedded preview will work good enough in most cases. The bespin toolbar and commando line will anyway prevent a full-browser preview, unless they are blended out as well, which is currently not implemented and I am not even sure whether it would be a good idea to do so.

If you wanna contribute to the technical discussion, please user the google bespin core group.

Does now web development start to move into the browser ?

2009-02-25T08:03:00.000-08:00

The browser has always been the most common tool to consume content from the internet. It also has served to create simple text based content (CMS). But now the tools start to appear for creating more complex content like web applications direclty in the browser. Let me list what I have tried out (or just heard of) recently.

bespin the super-cool and wicked-fast browser code editor (which since today contains a few lines of code I have contributed)
280atlas, just been announced yesterday, an amazingly awesome looking visual builder for cappccino web apps, not available yet, except of the screencast.
Wavemaker, they have been around for a while, very enterprisy, it did not work for my out of the box when I tried a few months ago (isn't the first impression what counts most ?).
AmyEditor. Looks like an online version of TextMate. That is good, because TextMate looks and feels great and people just love TextMate, but is bad because I believe the browser is not the right place for embedding a desktop app alike. And when resizing the browser, that app did not resize, so that was the early ending of my exploration of that otherwise probably great app.
Coghead. Was a cloudbased visual app builder. They failed, are on the deadpool now. At least they could sell some of their IP to SAP. AFAIK, Coghead was not open source, halfway flash based and had a lot of proprietary things, even a proprietary programming language. Maybe that is not the way to go, unless you have more salesmen than developers in the team.

Beside of bespin these web apps all seem to look like desktop apps. I am not sure whether this is what developers will feel most comfortable with. Look at gmail, greader and other highly successful web apps. They don't look like and feel like desktop apps.

There are also cool graphics apps from aviary, for creating artwork. They are flash based and take more time to load than Pixelmator on my laptop.

bespin now dojo-powered

2009-02-24T12:03:00.000-08:00

well, at least on my laptop, but I submitted a patch, so if the Mozilla guys like it, I hope it goes into trunk. The screenshot shows bespin running on the brand new Safari 4 beta.

There are still things to do related to the port, for example eliminating global variables outside of dojo and bespin namespace, dojo build profile and fixing the zillons of bugs I probably have introduced (but at least one I fixed, mousewheel works on Firefox as well)

Porting bespin to dojo - 90 percent done

2009-02-22T18:29:00.000-08:00

No I try to break the number one rule in software development: the last 10 percent take 90% of the total time. The dashboard works, except the command line sometimes having hiccups. The editor lets me type in text, but anything else breaks. I also replaced all third party libraries (in the external folder) with dojo equivalents. Here my experience in regard to prototype:

It's an absolutely fantastic framework if you wanna simple things get done quickly and you don't care about JS design philosophies (name spaces, native object extension).
There are a lot of utility functions for string, array and enumerable manipulation, but some of these functions are "opinionated" as all the great things from the 37systems guys. In dojo you end up cooking together your own one-line solutions for the simple stuff. It is additional work, but results in a customized and optimized solution.
The huge amount of string utilities suggests that prototype is targeted to developers who prefer not to deal too much with regular expressions.

So what else is missing once the bug fixing is done:

Name space cleanup: I used a all-lowercase namespace (e.g.: "bespin.editor"), because that is how dojo name space and file hierarchy looks like. I regret that, because it violates the bespin coding guideline and worst of all, requires a lot of slave work to update the documentation, so I will refactor to a name space mostly identical to the current one from bespin trunk (e.g.: "Bespin.Editor")
There are still some global variables (in the startup scripts), but before I even suggest how to change that I need some feedback from the bespin architects.
Testing (I introduced lots of bugs ...)
Build script to create minimized JS/CSS for production, maybe as paver task.

Update: I found a cheat sheet for conversion between dojo <->prototype

Exploring bespin - and porting it to dojo

2009-02-19T19:57:00.001-08:00

After some months absent from blogging and open source software involvement, the launch of bespin motivated me to get back to fun-hacking and blogging. Bespin is a browser based code editor which feels and smells like a real editor (vim, emacs, textmate), and not like a form on a webpage as all of the other browser based code editors (including an experimental one I hacked together myself). Internally bespin uses canvas and therefore currently only runs well on Firefox or webkit nightly. As JS lib Protoptype was choosen, but that might change in favor of dojo. So I thought I will give it a try, to port bespin to dojo and learn about the internals of bespin. And it might serve as suggestion in case bespin officially gets ported to dojo.

So where we are so far ? The screenshot at right shows that dashboard canvas rendering halfway works already, but with scaling dimensions something went wrong. Prototype makes the simple things very simple, dojo doesn't care much about the simple things, so I had to hand code a few things which had ready-to-use counterparts in prototype. But the really ugly thing about Prototype based javascript development is the global name space pollution and the extension of native objects, that is so much better handled with dojo and its class system. Of course nobody cares about those details once an app is up and running. Will finish the port and submit it to bespin bugzilla, but it might take a few days to iron out the bugs.

Javascript performance optimization with jeene

2008-09-21T13:10:00.000-07:00

Karl Krukov is working on Jeene, a Javascript library for partial evaluation, based on Douglas Crockford’s Pratt JS parser. Karl has just published some benchmarks (across all common browsers), where Jeene brings performance optimization of approximately 50%.

I want chrome !

2008-09-02T13:28:00.000-07:00

But there is no date yet when it becomes available for Mac.

Online publishing with Issuu.com

2008-08-07T10:51:00.000-07:00

Issuu has an interesting solution for online publishing of print magazines and other publications. It is partially in flash, I usually don't like Flash, but their Flash stuff is really well done. And they take interesting approaches for the surrounding stuff of a web app as well, take a look at their documentation: http://platform.issuu.com, it's all google groups pages !

Perl on Google App Engine

2008-07-22T21:56:00.000-07:00

Brad Fitzpatrick, the guy who added memchached to the Google App Engine, is starting a new project at Google: adding Perl support to the App Engine.

10gen: Cloud hosting platform offering serverside Javascript

2008-07-21T12:28:00.000-07:00

There was some speculation that Google will offer it once they open up the App Engine Platform to more languages, there were some small-scale attempts with serverside Javascript (including the mine, with http://erlyjs.googlecode.com, which is currently receiving very little attention from my side) but now 10gen (with well known Java hacker and director of the Apache Software Foundation Geir Magnusson as CoFounder) plans to offer cloud-based hosting solution with any language running on the Java VM (at least that is what I am reading between the lines of their press release) and the funny thing is they don't start with Java itself, no they offer as first Language Javascript. The guys at 10gen also seem to like django, a quick look at one of the tutorials reveals they are providing a thing called djang10, django inspired framework for creating web applications purely in Javascript.

Erlang Exchange 2008

2008-06-28T05:48:00.000-07:00

The last two days I have spent at the Erlang Exchange Conference. It was great to met other Erlang hackers in person I just knew from their blog, emails or mailing list. Below the slides from my talk:

Javascript syntax highligting for Firebug

2008-06-14T10:02:00.000-07:00

The syntax highligting capabilities of CodeMirror, my favorite Javascript based code editor (for Web IDE-type applications) found their way into Firebug, currently available as additional extension.

Google App Engine limitations and workarounds

2008-06-06T10:06:00.000-07:00

One of the current limitations of the Google App Engine is the lack of scheduled background processes. But early adapters are creative to circumnavigate this and other limitations. The most simple solution to this problem has William Vambenepe: he uses Google Reader to subscribe to a dummy RSS feed on his App Engine hosted test app, that results in some kind of regular polling with an interval of about 30 minutes. Of course this can't be used for any serious stuff, and the eight seconds maximum lifespan of a request also is not helping much to improve the situation. William concludes:

In the meantime, this was a fun exploration of the GAE environment. It makes it clear to me that this environment is still a toy. But a very interesting and promising one.

A more sophisticated but also much more complicated solution to the same problem has Peter Dolan: HTTPMR, a Map Reduce implementation in Python for running on HTTP based web clusters such as Google App Engine.

I am experimenting myself with a completely rewritten, not yet released version of ErlyComet, for adding a RESTful, highly scalable Comet layer with transactional cache in front of Google App Engine (or any other service which provides easy, cheap, reliable and scalable solution for persistence and shortlived HTTP requests)

Malicious Flash fullscreen mode

2008-06-01T19:25:00.000-07:00

Go there an try it yourself. It doesn't do any real harm, but it can scare people, especially those not really familiar with the latest capabilities of the flash player, such as full screen mode. While this example is just fun and actually the first example of this kind I have seen, I guess the same principles could also be used for real malicious stuff (e.g.: a new kind of phishing).

IETester - makes web page testing on IE less painful

2008-05-29T11:19:00.000-07:00

Previously I was switching between several virtually installed Windows XP instances on Parallels (for Mac OS X), just for testing a web page on different versions of Internet Explorer. Now I have installed IETester, a free Windows tool, which allows to run simultaneously (and switch between) the following IE versions:

IE 5.5
IE 6
IE 7
IE 8 beta 1

Notapad - the start of a dojo based WebIDE

2008-05-26T23:25:00.000-07:00

Niccola Rizzo has been working for a couple of months now on the CodeTextArea dojo widget for in-browser Javascript code editing and he has just launched a public demo and test site named notaPad.

The editor provides Javascript syntax highlighting and additional functionalities with the following key bindings:

CTRL + space - autocomplete
CTRL + l - GOTO LINE
CTRL + b - GOTO MATCHING BRACKET
CTRL + c - COPY
CTRL + x - CUT
CTRL + v - PASTE
right click on the row numbers - BOOKMARKS

blogger.com not updating homepages

2008-05-25T21:40:00.000-07:00

Shame on you, Google ! The last few posts of this blog did only update my blog homepage after about 24 hours. I guess updating the homepage is not part of the transaction when a new post gets stored somewhere on BigTable. So if you wanna see the actual homepage of this blog instead of an out-of-date cached version, type in:

http://rsaccon.com/index.html (instead of http://rsaccon.com)

Anyway, real men build their own blog engine, instead of complaining. Right now new blog engines are popping up like mushrooms, as result of some 60000 developers messing around with Google App Engine. Unfortunately those real men are facing real problems when trying to completely import old blogs into their custom blog engine, at least that is what happened to me when I tried some years ago with a custom Rails blog engine. So for now let's hope the blogger.com issues are just temporary ...

Update: It's getting worse. Right after posting, http://rsaccon.com/index.html also continued to serve the outdated cached version.

Update II: A couple of hours later, at least the .../index.html home page got updated.

js2-mode - the second most important Javascript tool

2008-05-24T13:39:00.001-07:00

I have been using js2-mode (an Emacs Javascript mode) for a couple of weeks now. I started using it out of curiosity, at the time I gave up on TextMate as all-purpose editor and turned back to Emacs, mainly because Emacs has so much better Erlang support. Now I consider js2-mode as the second most important Javascript tool (nothing can beat Firebug of course, and Firebug 1.2B1 on Firefox 3RC1 really rocks !). It fits perfectly into my work flow, you don't have to learn anything specifically to use it, it shows on-the-fly any syntax errors, global variables (which usually are unintentional), does a great job of line indenting, but because line indenting is often a question of personal style, js2-mode offers several possibilities you can cycle through via TAB. And in case you don't like how js2-mode works out-of-the-box, there are tons of customization options.

The only thing I am missing: I would like to use js2-mode as well as minor mode in HTML, but that doesn't seem to work yet.

Update: After writing this post, I just discovered another recent article about js2-mode with focus on syntax highlighting.

Dojo Widget for in-browser editor CodeMirror

2008-05-23T15:03:00.000-07:00

CodeMirror, a very impressive in-browser code editor for Javascript, XML/HTML or CSS (or any language, you just have to plug in a your own parser) made some nice progress in the last months. CodeMirror has no dependency on other frameworks or libraries. If you want to use it in a dojo environment as a dojo compatible widget, here I am gonna share here a little tutorial how to write such a thing:

First download CodeMirror and transform CodeMirror.js (the main file which loads the other files into an iframe), into something like this:


dojo.provide("mystuff.widget.CodeMirror");
dojo.require("dijit._Widget");


dojo.declare("mystuff.widget.CodeMirror", dijit._Widget, {

initialized: false,

// currently supported: 'xml' (HTML), 'js' or 'css'
type: 'xml',

options: {
stylesheet: "",
path: "/static/codemirror/js/",
parserfiles: [],
basefiles: ["codemirror_iframe.js"],
linesPerPass: 15,
passDelay: 200,
continuousScanning: false,
saveFunction: function() {
console.log('save');
},
content: " ",
undoDepth: 20,
undoDelay: 800,
disableSpellcheck: true,
textWrapping: true,
readOnly: false,
width: "100%",
height: "100%",
parserConfig: null
},

postMixInProperties: function() {
this.options.stylesheet = "/static/codemirror/css/" + this.type + "colors.css";
this.options.parserfiles = ["parse" + this.type + ".js"];
},

postCreate: function() {
this.inherited(arguments);
},

startup: function() {
if (dijit._isElementShown(this.domNode.parentNode))
this.initialize();
},

initialize: function() {
if (this.initialized)
return;

frame = document.createElement("IFRAME");
frame.style.border = "0";
frame.style.width = this.options.width;
frame.style.height = this.options.height;
// display: block occasionally suppresses some Firefox bugs, so we
// always add it, redundant as it sounds.
frame.style.display = "block";

this.domNode.appendChild(frame);

// Link back to this object, so that the editor can fetch options
// and add a reference to itself.
frame.CodeMirror = this;
this.win = frame.contentWindow;

var _this = this;
var html = ["<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"" + this.options.stylesheet + "\"/>"];
dojo.forEach(this.options.basefiles.concat(this.options.parserfiles), function(file) {
html.push("<script type=\"text/javascript\" src=\"" + _this.options.path + file + "\"></script>");
});
html.push("</head><body style=\"border-width: 0;\" class=\"editbox\" spellcheck=\"" +
    (this.options.disableSpellcheck ? "false" : "true") + "\"></body></html>");

var doc = this.win.document;
doc.open();
doc.write(html.join(""));
doc.close();

this.initialized = true;
},

getCode: function() {
return this.editor.getCode();
},

setCode: function(code) {
this.editor.importCode(code);
},

focus: function() {
this.win.focus();
},

jumpToChar: function(start, end) {
this.editor.jumpToChar(start, end);
this.focus();
},

jumpToLine: function(line) {
this.editor.jumpToLine(line);
this.focus();
},

currentLine: function() {
return this.editor.currentLine();
},

selection: function() {
return this.editor.selectedText();
},

reindent: function() {
this.editor.reindent();
},

replaceSelection: function(text, focus) {
this.editor.replaceSelection(text);
if (focus) this.focus();
},

replaceChars: function(text, start, end) {
this.editor.replaceChars(text, start, end);
},

getSearchCursor: function(string, fromCursor) {
return this.editor.getSearchCursor(string, fromCursor);
}
});

Then your should concatenate and minifiy (I use YUI compressor) all the JS files:


util.js, stringstream.js, select.js, undo.js, editor.js

=> codemirror_iframe.js

Also minify the parsers: parsejavascript.js, tokenizejavascript.js, parsecss.js, parsexml.js

At this point you can embed the widget into a test page:

<div
id="html_editor"
dojoType="mystuff.widget.CodeMirror"
type="xml"
style="height:100%;">
</div>

Now comes the tricky part: the editor does not initialize automatically at page load, because with dojo, chances are very high, you are gonna use this widget inside a container, where the editor is hidden at page load, and that would cause trouble with some browsers. So you need to subscribe to an event which triggers the visibility of the editor, so it can be lazy-initialized at first time it becomes visible. For example to use CodeMirror inside a tab container with a tab with id 'html_editor_tab' I do something like this:

dojo.declare("MyApp", null, {
main_tab_selected: function(page) {
if (page.id == 'html_editor_tab'){
dijit.byId('html_editor').initialize();
}
}
});

var myAppInstance = new MyApp();

dojo.subscribe("main_tabs-selectChild", myAppInstance, "main_tab_selected");

Update: Uhh, where was my brain when I wrote this article, I accidentally "misspelled" CodeMirror with CodePress at several places, including the title, it's corrected now ...

New Erlang web framework by Torbjorn Tornkvist

2008-05-23T11:01:00.000-07:00

Tobbe just announced the very first release of a new, very simple Erlang based web framework fully integrated into erlware. It has support for sgte templates. Tobbe also has a collection of other highly interesting web related projects in his git repositry, including domerl, a simple, yaws and JQuery based Comet lib.

Hard to find technical docs about dojo internals

2008-05-23T09:18:00.000-07:00

Of course an open source framework has no real untold secrets, but digging into the source code can be time consuming and and without in-deep documentation it's difficult to extract the authors thoughts behind it, so I was pleasantly surprised when I stumbled upon this links about dojo internals (which currently can't be found, or at least not by me, at dojo documentation):

Next flashplayer ships with speex audio codec

2008-05-14T23:19:00.000-07:00

See the release notes. Speex is one of the best codecs for VoIP, and it is patent-free and open source. Related to this is also a new UDP-based network protocol called RTMFP for faster realtime media and P2P-capable, which will be part of flashplayer 10, now let's hope Adobe will release this protocol as part of their open specification initiative, but I guess they will try to keep RTMFP proprietary (at least until it gets reverse engineered), so they can sell their overpriced Media streaming servers.

Google JS library released

2008-05-14T15:31:00.000-07:00

As part of Google's effort to better document the open web, they released today some of their Javascript libraries. I browsed a bit through the code, it is well documented and one thing grabbed my attention: the code structure looks similar to dojo, e.g. below a snippet from their DOM lib with ''provide" and "require" statements:

goog.provide('goog.dom');
goog.provide('goog.dom.DomHelper');
goog.provide('goog.dom.NodeType');

goog.require('goog.array');
goog.require('goog.math.Coordinate');
goog.require('goog.math.Size');
goog.require('goog.object');
goog.require('goog.string');
goog.require('goog.userAgent');
...

XHTML or HTML

2008-05-14T12:31:00.000-07:00

I never really understood why people were using XHTML and I usually tried to clarify by pointing to articles by respected Web experts (e.g.: Ian Hickson, Brad Neuberg).
Today I read this and collected some more links about use and misuse of XHTML:

Adobe "opening" a few more bits of Flash

2008-05-01T00:34:00.000-07:00

Their new initiative is called Open Screen Project and is dedicated to drive consistent rich Internet experiences across devices. It is not about open sourcing the flash player, just about opening some specifications, such as FlashCast protocol and the AMF protocol. But AMF for example has been reverse engineered long time ago, in 2003 when I contributed to JavaAMF, this protocol has already been implemented in numerous other languages.

What I would like to see is RTMP (the Flash Video transport protocol) as open specification, so let's hope they consider this at their next round of "opening".

Firefox extensions for JS disabling and Python integration

2008-04-30T04:25:00.000-07:00

My collection of Firefox extensions is mostly just the usual stuff you need for web development, such as Firebug, MeasureIt, ColorZilla, S3Fox, FlashSwitcher and a few more. After Firebug, for long time I didn't spot anything comparable spectacular. But recently I discovered some interesting extensions:

QuickJava: Finally an extension which makes it dead simple to disable/re-enable Javascript (I use that often to see how Ajax enriched webpages look like without Javascript). Just one click on a status bar button to enable/disable and reloading the page. Here there is even room for improvement: I would like to have enabling/disabling optionally coupled with reloading. Anyway, other extensions which provide the same functionality require a lot more GUI interaction.
Pyxpcomext: Python bindings (PyXPCOM). This extension doesn't provide any direct end user functionality, but makes it possible to write extensions in Python instead of Javascript. Just for fun I installed the Python Shell. I can think of many potential use cases, e.g. integration with the Python based App Engine SDK, so that web designers not comfortable with command line interfaces could easily interact with the local App Engine test webserver via such an extension, when testing their templates and stylesheets.

The missing feature of the Web: a DNS REST API

2008-04-25T22:59:00.000-07:00

I have been waiting for years, that a quality DNS provider will a offer a REST API for setting DNS Records, but there is still no such a thing on the market. There is a SOAP based offering from Nettica (unfortunately I have an SOAP allergy). And there are the REST APIs some service providers are exposing for updating dynamic IPs.
DNS Made Easy, one of my preferred DNS providers, told me about a year ago they were working on such an API. I am still waiting. Anyway, if anybody is aware of such a service, please let me know.

Update: Found a possible solution (but I haven't actually tested their service yet): Slicehost, a similar service as Amazon EC2, they seem to have an API which allows to manipulate DNS records. But your domain has to be hosted on slicehost.

Update II: WorldwideDNS is another option.

It's getting cloudy - Yahoo Application Platform

2008-04-24T19:26:00.000-07:00

Just read this on TechCrunch:

... Yahoo Application Platform (YAP) - which will be a direct competitor to Google App Engine. Users can host their independent applications on Yahoo’s bandwidth, storage, database and CPU resources. At first they’ll support SecurePHP applications only, but they’ll expand to additional languages over time. The model will be very similar to Google’s - free usage up to a point, metered after that. They’ll also offer various developer tools as well.

With Yahoo offering cloud based PHP app hosting, I hope Google will focus on soon adding the already announced really useful features to App Engine, and not waste engineering efforts for supporting PHP.

Cryptography API for Google Gears

2008-04-22T20:51:00.000-07:00

Gears will provide native cryptography to web applications, at least this is what Google Summer of Code student Mike Ter Louw is planning to implement in the coming months. While it is possible to implement browser side cryptography in Javascript (e.g.: dojox.encoding), only few Ajax applications use this functionality, because it is slow and for communication purposes it only adds a very thin layer of security (requiring lots of tricks) , compared to HTTPS.
But HTTPS is a bit of a problem in todays clouding computing platforms, because it requires static IPs tied to a domain name for a valid certificate. So gears maybe will become a preferred option to increase poor man's web application security.

Flash done right and on Google App Engine

2008-04-19T09:49:00.000-07:00

Often I criticize the usage of Flash for content centric pages, because often Flash is implemented in a way it causes a disastrous user experience (from arbitrarily resizing browser to sound which you can't turn off and fonts which you can't resize, just to mention the worst mistakes). Now I came across a new project, which advocates to do Flash the right way: gaeswf by Aral Balkan, a client and server side open source framework, based on a collection of best practices for using Flash on Google App Engine, in a way that Flash does NOT suck. The proof-of concept (live demo) implements techniques such as:

Embedding Flash with SwfObject
Deep linking (based on SwfAddress)
Flash content that obeys browser text-size changes

Google App Engine Team fixing issues quickly

2008-04-15T07:34:00.000-07:00

Toying around a bit today on Google App Engine, I found a minor issue (not security related, very easy to work around and only affecting Mac users) in an add-on for the actual SDK. Only 32 minutes after I reported the issue they had fixed it !

Amazon announced persistent storage for EC2

2008-04-13T21:50:00.000-07:00

If Google App Engine does not provide enough flexibility for you, then there is some good news from Amazon: one of the missing pieces, persistent storage for EC2, has just been announced.

Exploring some lesser known Ajax GUI toolkits

2008-04-13T14:39:00.000-07:00

I have only been exposed so far to Dojo and ExtJS, and I believe both are bleeding edge technology, provide a great user experience and are widely accepted. But there are about 50 more Ajax GUI toolkits out there. And some of them occasionally appear on my Google Ads, so out of curiosity I took a quick look at some randomly chosen ones:

SmartClient Ajax GUI System: Lots of widgets, but they are all table based and look desktop-like, that makes it a very Web 1.0 experience.
Icefaces: An Ajax GUI toolkit for integration into J2EE systems. Also lots of widgtes, looks a bit less desktop-like, but here as well I see tables (e.g. their tab container) where I think pure DIVs and a bit more CSS provide a better user experience (smother loading). I am not a J2EE guy (anymore), so I did not look closer at this product.
Nitobi: Their website looks nice and well organized, so I head high expectations. But I switch randomly between browsers and at the time I tried the Nitobi demos, I was using Safari 3,1. Unfortunately I could not load the demo (then I tried on Firefox and there everything worked fine and looked good). But then came the ugly part: They provide a free trial version with a 30 day evaluation period and beyond that you are expected to buy a license, prices start at $ 429 US and go up to $ 3699 for the enterprise version !!!
Telerik RadControls for ASP.NET: Even more expensive: prices start at $ 799 US. And you have to register on their site just to download the trial version. At least I could load the online demo, even on Safari. And it looks good, very good, nearly as good as ExtJS.

Lesson learned: there is a reason these Ajax GUI toolkits are lesser known !

Scaling down - the least talked about feature of GAE

2008-04-13T10:41:00.000-07:00

It launched less than a week ago and now all over the blogosphere people are discussing the Google App Engine (GAE). Most talk is about scaling up, about potential lock-ins, even if the SDK is based on open source software. Only one thing where developers seem generally to agree: with Python, Google has made a good choice (maybe those not knowing Python yet but desperately looking forward to learn it, don't know that Python dictates line indention, actually the only thing I had difficulty to get used to). That is interesting by itself, because developers usually are highly opinionated in regard to programming languages. Or is it just the early adapter mentality which is more flexible ? Anyway - in this article I want to talk about something I haven't found mentioned yet at 100 other places:

scaling down

I see a growing number of businesses reducing or eliminating their IT department by using Google Apps (gmail & Co. on custom domain) for e-mail and other standard tasks covered by the Google Apps suite. Custom built applications for streamlining their non-standard, probably also simple but business specific work-flow has been beyond the budget of small organizations. So they used the available standard tools, which are often more complex than necessary for those tasks. But now the creation and especially the maintenance of custom built web applications is getting cheaper with GAE, because problems like authentication, deployment, high availability and even data redundancy (as probably-good-enough backup-strategy) are solved already and the cost for hosting gets completely eliminated (scaling down means just few concurrent users per application, little resource usage and the app will probably stay within the quotas for free usage of GAE). So the saved money from traditional in-house or outsourced IT administration, spent on development of custom applications will allow organization to improve their efficiency. And Google of course still will make good money with this scenario, because some companies will choose Google Apps Premier Edition over free/limited edition and will pay Google 50 $ per user account / per year.

Google App Engine - Niall Kennedy's summary

2008-04-10T18:10:00.000-07:00

Great summary about the Google App engine, by Niall Kennedy. He even provides some insights about the people behind it, and according to his first hand knowledge, this is just the beginning of what Google is rolling out:

I met with the App Engine's team leads on Monday morning for an in-depth overview of the product, its features, and its limitations. Google has been working on the Google App Engine since at least March 2006 and has only just begun revealing some of its features.

Erlang R12B-2 released - with native PNG drawing

2008-04-09T08:58:00.000-07:00

It's a bugfix release and I had no big expectations when scanning through the release notes, but then I spotted this:

--- percept-0.7 ------------------------------------------------------------

OTP-7162  Percept no longer depends on external c-libraries. The
    graphical rendering is now done via erlang code.

Thats huge, if you are interested in generating PNG images and don't wanna have dependencies on c-libraries (as you would have using my cairo wrapper erlycairo). Egd won't win any speed competition and has a limited feature set, but runs out of the box on any Erlang supported platform !

Google App Engine - Quotes and thougts

2008-04-08T19:53:00.000-07:00

From the many blog posts about the Google App Engine, my favorite quote comes from Dave Winer:

Now, what Google announced is really exciting! I'm not kidding. It's even better than I hoped. Yes, it's only Python, but IBM's PC-DOS was only BASIC and Pascal when it first came out, and it didn't matter. Yeah, I preferred C, but I coded in Pascal because that's what you had to do to get an app running. What you're going to see here that you've never seen before is shrinkwrap net apps that scale that can be deployed by civillians. That's a mouthful, but that's what's coming. Why? Because here is a standardized platform that can be stamped out in the billions of units. Maybe Google can't do it, but the perception is that they can. Who is willing to stand up and say Google hasn't nailed scaling? What PCs did in the 80s, Google is doing now. PCs took the black magic out of owning a computer. Now Google is taking the black magic out of operating a scalable web app. Python is the new BASIC.

There were also lots of negative thoughts, e.g. Donna Bogatin:

Google’s latest attempt at Internet shock and awe replays the by now traditional Google routine of “giving away” Web services under the guise of disinterested benevolence while the Web cheers the supposed Googley revolutionary Internet disruption and forecasts doom for existing players, such as Amazon, for this example.
In typical Google fashion, though, “free” comes at a very high price. In fact, the Google App Engine product unveiled by the high-flying corporation is in contention for the scariest Google move to date.
Not only do startups using Google App Engine unwittingly put control of their businesses in the sole discretionary hands of Eric Schmidt and company, unwitting consumer users of Google App Engine hosted services automatically “share” all of their personal, proprietary data with Google, whether they really want to or not.

Generally people are comparing the App Engine with Amazon's AWS offerings and either seem to be interested in the one or the other. I think these two services can be combined for easy creating scalable web applications which go beyond what you can do with a limited amount of time and money, compared to the scenario where you would use just one of the services. Let me elaborate: For the simple, stateless stuff, for static and dynamic HTML pages and for persisting data, Google App Engine is perfect. For advanced stuff like Comet HTTP push, video streaming or batch processing, Amazon EC2 instances could be used on demand just for that.

Trying out Google App Engine

2008-04-08T07:03:00.000-07:00

Yesterday night Google launched App Engine, a highly scalable web application platform, which has the potential to become a game changer. I was lucky to grab a developer account, which is currently tied to several limitations:

only 10000 developer accounts available
applications have to be coded in Python
only three applications per developer
bandwidth, storage and CPU usage limitations
no road map, no info about future pricing model

On the other hand, it's free for now, you can use the Django open source web framework and template language, you can locally develop and test your app with the cross platform Google App Engine SDK (download size only 2.3 MB - on Mac OS X), you get a powerful administration interface at your Google account and most important, it is extremely easy to get started with, in no time you have a schema-less, database driven helloworld web application deployed on Google's server farm.

The internet users may start their own home business by having business deals with the global entrepreneurs. The different brands of computers have been manufacturing the latest and stylish models of different sizes and shapes for the computing clients. The main features of hosting plans of godaddy are reputable among the potential customers. You may get hosting services of high quality in affordable rates by joining powweb, reliable web host.

Skype and PostgreSQL database

2008-04-06T07:05:00.000-07:00

PostgreSQL is my favorite open source relational database. Some time ago I wrote some experimental code (currently unmaintained) for integrating it with erlyweb. The guys at Skype seem to like PostgreSQL as well. In regard to the current Google Skype takeover rumors (or was it just a 1st of April joke which went out of control ?) and to this article: Skype Plans for PostgreSQL to Scale to 1 Billion Users, I took a look at the Skype open source projects and found a few interesting ones related to PostgreSQL:

PL/Proxy: Horizontal data partitioning, based on a hashed database field (for distributing large amount of data among several physical servers).
SkyTools: DB cluster management software for replication, message queues, fail over and Python integration.
PgBouncer: connection pooling.

The most advanced features of backup software are very assistive for exclusive disaster recovery of data. The web site design services are also the main part of some hosting plans of the service providers. The benefits of affiliate marketing have been attracting a number of investors and entrepreneurs of this global business community rapidly. The webmaster is responsible for administering all web applications expertly.

Easy git on Emacs with emacs-git

2008-04-02T20:55:00.000-07:00

I have been using emacs-git for the last few days and and it proved incredible useful. It let's you do interactively most of the basic git operations such as creating, cloning or importing a repository, it inidcates graphically the git status of the current file with a colored LED-like icon at the Emacs bottom status line and it also facilitates adding / removing files to the repo, ignoring files, tagging, merging and conflict resolution.
Emacs-git works only on Emacs (and not on X Emacs) and requires a very recent version of Emacs (I am using it on a nightly build of aquamacs, which is based on Emacs from CVS).

Emacs on Ajax with Steve Yegge's new js2-mode

2008-03-31T05:57:00.000-07:00

Steve Yegge just released a new Javascript Emacs mode. I installed it and played around a bit and syntax highlighting and indention seemed to work perfectly. The feature list is impressive (copy-pasted from project page):

it offers the usual features from other Emacs modes
it supports the JavaScript language up through version 1.7
it has a real recursive-descent parser
it highlights syntax errors and underlines warnings
it supports collapsing function-body and block-comment definitions
it has some preliminary support for IMenu (to be improved soon)
it knows about jsdoc and highlights tags in jsdoc comments
it has a set of typing helpers to make editing easier

The best news comes now: according to his blog, this is just the beginning:

This is part of a larger project, in progress, to permit writing Emacs extensions in JavaScript instead of Emacs-Lisp. Lest ye judge: hey, some people swing that way. The larger project is well underway, but probably won't be out until late summer or early fall.

My new editing mode is called js2-mode, because eventually I plan to support JavaScript 2, also known as ECMAScript Edition 4. Currently, however, it only supports up through JavaScript 1.7, so the name is something of a misnomer for now.

Plenty of reason to switch back to Emacs for those like me who thought that TextMate was the future.

The Power of Javascript - by Glenn Vanderburg

2008-03-31T00:56:00.000-07:00

Wanna listen to an in-depth introduction to Javascript, not just the technical but also the historical side ? Then this talk by Glenn Vanderburg recorded at JAOO 2007 is the right choice (direct link to the media - flash .flv video).

The talk mentions Douglas Crockford's famous article: The World's Most Misunderstood Programming Language from 2001. Just for completeness, here is Crockford's recent follow-up article: The World's Most Misunderstood Programming Language Has Become the World's Most Popular Programming Language.

What sucks most about the Mac

2008-03-29T06:26:00.000-07:00

.. are those nearly weekly software updates which require a reboot. I didn't buy a Mac because I was influenced by those all-day-long digging mac fanboys, I bought it because I wanted to run some graphics and video editing software which is not available for Ubuntu Linux (my previous desktop system, from windows I stay away as far as possible) and for paying about twice the price compared to a similar Dell or noname hardware configuration capable of running Linux, I really expected a better user experience in every possible aspect, as promised in their glorified advertisement. But the requirement to reboot the machine for those nearly weekly minor updates really puts the Mac back into the stone age of computing !

Doloto - Javascript Rewriting paper by Microsoft

2008-03-28T08:48:00.000-07:00

I just read the reseach paper (pdf) about Doloto a Microsoft project for speeding up Web 2.0 applications by serverside Javascript static code analysis, AST transformations and code splitting. They claim that with this technique the loading time of monolithic (all Javascript loaded at once) Ajax applications can be significantly reduced. In my opinion, a better approach is to build right away non-monolithic apps (Javascript libraries like dojo provide support for that).

Crary - A new Erlang lightweight web server

2008-03-26T21:10:00.000-07:00

Beside of featherlight iserve and battle proved mochiweb (at MochiMedia), there is now an additional choice for lightweight Erlang HTTP servers: Crary, which shares similar design goals but provides a different interface. According to its author Scott Parish:

Crary, a HTTP server for the REST of us.

The intention is that its small enough and flexible enough to be used for most any HTTP server need. While it isn't a stand-alone system, nor does it have its own web-framework, these things can easily be built on top of crary. Crary should be easily embedded into the release of a larger application to provide a web interface or to create a web service interface.

Below a tiny little snippet illustrating how to write a hello world program with crary:

start() ->
crary:start(8080, {?MODULE, handler, []}).

handler(#crary_req{method = "GET", uri = #uri{path = "/favicon.ico"}} = Req) -> 
crary_dir_listing:write_file(Req, filename:join([my_doc_root(), "favicon.ico"]));                                                                 
handler(#crary_req{method = "GET", uri = #uri{path = "/test"}} = Req) -> 
crary:r(Req, ok, [{"content-type", "text/html"}], <<"hello world">);
handler(#crary_req{method = "GET"} = Req) -> 
crary:not_found(Req);
handler(Req) -> 
crary:not_implemented(Req).

To get your copy of crary just clone it from its git repository, or install it via erlware.

New YouTube player - Nice, but still not ready for HD screencasts

2008-03-25T11:08:00.000-07:00

Geoff Stern, the Google guy who recently rewrote the YouTube player, just posted an interesting demo, mashing up the video player with the Google maps API, demonstrating the new player's Javascript integration capabilities.

Other examples out there:

This brings new possibilities for screencasts (or video presentations / podcasts), for syncing the audio/video with text caption or any HTML content along the audio/video timeline. Now I am just waiting for YouTube not destroying anymore the HD quality of uploaded quicktime videos when they convert it to flash (requiring cumbersome hacks like this for online HD flash video), so that YouTube can eventually be used for high quality screencasts and video enabled online presentations.

Update: more chromeless players:

ExtJS-styled

Erlang processes benchmarked against threads of other languages

2008-03-23T00:51:00.000-07:00

We all know that the result of benchmarks are only significant for that specific piece of code which is getting tested, and usually the benchmark authors favorite products are tuned to outperform its competitors. Nevertheless, below a summary of a benchmark recently discussed on reddit. The benchmark itself is just a few lines of source code (at least in Erlang), spawning a bunch of processes and doing some simple message passing between those processes. Thread implementations in other languages:

C (pthread - GNU gcc): 8.5 times slower
Python: 15 x slower, 1.4 x more memory
Java: 20 x slower, 5.8 x more memory
Ruby: 282 x slower, 3.4 x more memory

More numbers, details and the benchmark source code in all the different languages at the language shootout site.

The gBrowser is coming - disguised as Google Gears

2008-03-17T00:11:00.000-07:00

At least this is the impression I get when I take a look at the Google Gears developer documentation , especially the wiki pages with label DesignDoc and the discussions in the contributor mailing list. Here a few examples to illustrate what I am talking about and what will hopefully soon come to any browser near you:

AudioAPI: Playback, Recording, Mixing and Editing of WAV, OGG and MP3 audio.
LocationAPI: Provides geolocation.
ImageManipulationAPI: mentioned in the BlobApi description.
OpenGL vector drawing: discussed in this thread.

Upgrading existing browsers with Javascript APIs providing HTML5-compliant functionality is much better for a healthy, accessible, easy indexable and open standards oriented near future of the web, than relying on proprietary plugins such as the flashplayer for specific functions which can' t be provided by HTML/CSS/Javascript of todays browsers.

Podcast: Joe Armstrong on Erlang

2008-03-12T09:00:00.000-07:00

I am currently listening to this Podcast by Joe Armstrong, creator of Erlang. It's a great overview and has lots of historic and other background information.
In case you are new to Erlang, and need something more entertaining and haven't seen yet the classic, "Monty Python" Erlang video, you must see it !

ErlyDTL now has date and time formating

2008-03-08T12:29:00.000-08:00

ErlyDTL, the Erlang version of the Django Template Language is progressing nicely. Most of the common tags and filters are implemented. Recently Colm Dougan joined the development team and added date and time formating.

Let's take a look at some examples with fictive dates:

Template: {% var1|date "r" %}
Rendered Output: Thu, 21 Dec 2000 16:01:07 +0200

Template: {% var2|date "jS F Y H:i" %}
Rendered Output: 27th February 2008 01:24

Template: It is the {% var3|date "jS o\f F Y" %}
Rendered Output: It is the 4th of September 2007

Diving into Core Erlang

2008-03-07T16:09:00.000-08:00

Inspired by Robert Virding's LFE - Lisp flavored Erlang, I recently started to evaluate Core Erlang as base for ErlyJS, the Erlang Javascript compiler I am working on. The current approach is based on Erlang Abstract Syntax trees. Erlang Core is more low level and looks more like a LISP dialect than Erlang. Following a short summary about Core Erlang's design goals (copy pasted from the spec):

Core Erlang should be as regular as possible, to facilitate the development of code-walking tools.
Core Erlang should have a clear and simple semantics.
Core Erlang should be straight-forward to translate to every intermediate code used in any Erlang implementation; similarly, it should be straightforward to translate from Erlang programs to equivalent Core Erlang programs.
There should exist a well deﬁned textual representation of Core Erlang, with a simple and preferably unambiguous grammar, making it easy to construct tools for printing and reading programs. This representation should be possible to use for communication between tools using diﬀerent internal representations of Core Erlang.
The textual representation should be easy for humans to read and edit, in case the developer wants to check what the Erlang source looks like in Core Erlang form, inspect – or modify – the results of code transformations, or maybe write some Core Erlang code by hand.

You wanna see how Core Erlang looks like ? Take any Erlang source code and compile it as binary and with the to_core compiling option and with core_pp:format/1 you can pretty-print the output. Core Erlang is an intermediate step between Erlang AST representation and VM internal representation. So far I see the following advantages by using Core Erlang for ErlyJS:

It is less tied to Erlang the language and therefore just a more natural choice.
There exist `let` expressions which seem to provide a cleaner way to handle Javascript variable reassignments (you can't directly reassign variables in Erlang).
And last and least, Ecmascript 4 Reference implementation is written in Standard ML, which is more similar to Core Erlang than to normal Erlang. Maybe this point will have relevance one day in the future.

Unless I will discover a show stopper, there will be soon a complete rewrite of ErlyJS to Erlang Core (but I am using git now and only pushing to googlecode SVN major changes in bulk).

Erlang and Fuse

2008-03-06T18:28:00.000-08:00

The Dukes of Erl guys have created an Erlang implementation of FUSE called fuserl. From reading their blog, it seems they need it for interacting with RRDtool, a open source software for realtime data logging and the ultimate goal for fuserl is a distributed filesystem based on mnesia: walkenfs (the idea is not new, Ulf Wiger has something similar as part of erlhive). Now I just read about another possible use case for fuserl:

Benjamin Nortier is blogging about Apache + Erlang for dynamic web content: Using Apache (I would use Lighty or nginx instead) to serve static files (static at least from the point of view of the webserver), but they are dynamically created by a distributed Erlang system and fuserl. Benjamin did recently some extensive benchmarking comparing LAMP with LYME (Linux + YAWS + Mnesia + Erlang) and now I hope he will do performance measurements on fuserl based systems as well !

I am trying to get a clue whether fuserl would bring any benefit in combining it with git. The scenario would be distributed Erlang nodes running a collaborative editing app, everything in Erlang except of git (but git plays a central role for document storage) and lots of git repos.

The advanced strategies of internet marketing are employed by the different internet marketers to promote E-businesses. The web site design and web development programs are organized by the different IT companies. The cheapest domain name registration services are very useful for the medium kind of entrepreneurs who can’t afford expensive rates. The cheap hosting services of various web hosts are available to facilitate the individuals who run small businesses.

When to use Ruby and when not

2008-03-01T20:50:00.000-08:00

Just read this interesting article by Zed Shaw about Ruby, Ruby in the enterprise, Ruby on virtual machines and more ...

ErlyJS - translating Javascript to Erlang

2008-02-23T11:33:00.000-08:00

I have lately invested many hours of coding in ErlyJS, my open source attempt of writing a Javascript compiler for the Erlang virtual machine and crossed today the barrier of 100, for the number of commits and also for the number of test cases. There is still a long way to go, because nobody (including myself) will actually use the compiler in a real project, unless it is 100% Javascript compliant. But at least, most of the basic stuff is now halfway implemented:

Literals
Global / local variable handling
Operators (except of dot operator, for objects)
Functions
Built-in global functions

The next big task will be object handling (and implementing the built-in objects and their functions)

I am not targeting the Erlang VM directly (beside of the Erlang compiler source code, there doesen't exist any formal specification or at least documentation about the Erlang VM internals in general and specifically the VM opcodes). What I do is transforming the Javascript source code AST to an Erlang AST. This involves a lot of trickery, because Erlang doesn't allow variable re-assignments (this is good and also necessary in the context of Erlang concurrency), but most Javascript code is just a bunch of variable re-assignments, so I have to model it somehow and I have choosen to model it differently for global Javascript variables (Erlang process dictionary) and local variables (normal Erlang variables). One interesting thing about having an Erlang AST of Javascript source code is the possibility of pretty-printing Erlang source code. Let's take a look at a Javascript example from the test cases:

function test() {
var a=0, b="Bananas";

switch (b) {
case "Oranges":
a = 1;
break;
case "Apples":
a = 2;
break;
case "Papayas":
case "Bananas":
a = 2.5;
a = 3;
break;
default:
a = 4;
}

return a;
}

If I pretty print the AST (just before compiling it, and this is even done automatically at verbose ErlyJS compiling settings) I get the following Erlang source code:

js_test() ->
V78 = 0,
V80 = "Bananas",
{V152} = case V80 of
         "Oranges" -> V170 = 1, {V170};
         "Apples" -> V88 = 2, {V88};
         X when X == "Papayas"; X == "Bananas" ->
             V270 = 2.5, V288 = 3, {V288};
         _ -> V32 = 4, {V32}
       end,
V152.

This kind of source code translation is extremely useful while developing and debugging the ErlyJS compiler and analyzing test cases.

Dojo theming tutorial and more at dojocampus

2008-02-22T18:24:00.000-08:00

Ever wanted to know how to create flexible-size background images for rounded corners or other CSS effects specifically for custom-theming Dojo widgets ? Unless you have already intimate knowledge of the Sliding Doors technique and CSS sprites, you should checkout the "Rounded tabs" tutorial on the recently started DojoCampus site. There is also other great stuff there such as a video about the dojo grid and Firebug tips.

Discontinuing ErlyMate

2008-02-19T15:17:00.000-08:00

My attempt of better integrating Erlang with TextMate has been an interesting trip into foreign territory (Objective C and Desktop applications), but I never considered it as a serious project, it was more a kind of overreaction to my inability of mastering all Emacs key bindings even at sleep. And I also don't like to put lots of time into an open source project to erlangify a proprietary, Mac-only software from a one-man-company. Anyway, if this are non-issues for anybody who wants to resurrect the project, I will be available to answer initial questions. Ok, this was probably my last post about ErlyMate here.

Erlang – The CEO’s View - by Gordon Guthrie

2008-02-19T15:11:00.000-08:00

An interesting article about Erlang from the business point of view, by Gordon Guthrie the CEO/CTO of hypernumbers.net.

Interfacing Erlang with C - explained by Joel Reymont

2008-02-16T07:34:00.000-08:00

Great tutorial on how speeding up Erlang with linkedin C code. But hopefully you won't have to do it because it makes your software hard to maintain and the C part might crash your program. But if you have to interface with C, then first check whether a C-node (as for example done in ErlyCairo) has enough performance, a C-node uses it's own memory space and doesn't crash your Erlang program, in case things go wrong. But if your C code is very robust, and you really need the performance, Joel's tutorial is a great introduction to that topic.

Django Template Language - the dojo implementation

2008-02-14T03:28:00.000-08:00

Beside of Erlang based ErlyDTL (by Evan Miller and myself) there exists (at least) one other non-Python project which implements the Django Template Language: the dojo Javascript version: dojox DTL (documentation) for creating dynamically and template-based HTML layouts inside the Web browser (opposed to traditional approaches of creating HTML layouts at server-side). Today dojox DTL reached feature completeness, implementing all original Django tags and filters, at least that is what I guess from reading the SVN changes for the README:

--- This aims to be a 1:1 match with the Django Template Language as outlined in
+++ This is a 1:1 match with the Django Template Language as outlined in

While dojox DTL is a very interesting concept and brings new possibilities to separate client-side logic and presentation, I haven't seen yet a killer example. Maybe I just haven't looked far enough. But one thing is sure: if you use a template language at server side and at Javascript client side, and it can be the same template language, that's a huge benefit.

Erlang Style Concurrency - explained by Ulf Wiger

2008-02-06T16:05:00.000-08:00

That is probably all you ever wanted to know about Erlang style concurrency, put into a great summary by Ulf Wiger, who has been using Erlang since 1992.

New book "Mastering Dojo" - beta PDF now available

2008-02-01T09:05:00.000-08:00

For those who prefer to learn new Javascript stuff by reading a real book, Mastering Dojo (500 pages) has been announced today. It will be relesed in June, but the beta PDF is already available. Alex Russell, one of the initial developers of dojo, is a co-author of that book.

Update: I ordered the PDF version, right after writing this post, but haven't received the e-mail with the download-link yet, so all what is really available right now, are the two example chapters at the publisher's site.

More on serverside Javascript - Rhino on Rails

2008-01-29T14:06:00.000-08:00

Dion Almaer has recently interviewed Steve Yegge about his project of porting Rails to Javascript, you can listen to it right here:

Serverside Javascript with Jaxer

2008-01-22T15:55:00.000-08:00

Today Aptana (mostly known for their eclipse based Ajax IDE) launched Jaxer, an open source based Ajax server for using Javascript as server side scripting language. It is built on top of the Apache Web server and and the Spidermonkey Javascript engine and has an API which covers most developers needs: File and database access, logging, email and all kind of other utility functions.

So what are Jaxers major selling points ?

Write entire applications or presentation layers in Ajax.
Share code between browser and server.
Database and file access from JavaScript.
Integration with Aptana Studio (their Ajax IDE).

The most important question for me of course is how it compares to erlyjs, my Javascript-to-Erlang compiler project with main purpose of running Javascript at the serverside for Ajax web applications. Obviously Jaxer is available today and now and erlyjs is work-in-progress far from being ready to use yet. Both share the same vision and both use Spidermonkey. But while on Jaxr the Javascripts really run within the Spidermonkey engine, erlyjs uses Spidermonkey only for parsing the Javascript, then compiles the parsed Javascript to Erlang beam files, for running on the Erlang virtual machine. I believe my approach gives significant performance and scalability advantages (and integrates better with the rest, in those rare cases where the rest is written in Erlang as well ...)

Hypernumbers whitepapepr: comparing Erlang and LAMP web stacks

2008-01-17T09:11:00.000-08:00

Using Erlang In A Web Start-Up is a whitepaper (PDF) by Gordon Guthrie, pointing to advantages from the business point of view when choosing Erlang.

ErlyDTL - the Django template language in Erlang

2008-01-15T22:40:00.000-08:00

I have been working on a new template language called ErlyDTL. Let's compare it first with the other, established players in the Erlang open source template languages field:

ErlTL by Yariv Sadan. ErlTL is used in ErlyWeb and therefore probably the most popular Erlang template language. It exposes the full Erlang language to the template author, that is good, if the template author is an experienced Erlang developer, but bad, if the template author does not know Erlang. ErlTL compiles templates to beam files.
sgte by Filippo Pacini. An Erlang implementation of StringTemplate. Enforces separation between model and view. Templates get evaluated at runtime. Used at erlware (if you install the erlware launcher, sgte is one of the core packages used internally for the various erlware templates)
ErlyDTL by Evan Miller and myself: based on the Django template language. It does not expose Erlang to the template author, it compiles templates to beam files, pre-renders as much as possible at compilation time and supports a lot of features such as template inheritance, presetting variables at compilation time, automatic HTML escaping and lots of Django tags and filters. But it is not feature complete yet, just the more important tags and about half of the django filters are currently implemented.

If you wanna learn more about ErlyDTL, check out the code or take a look at the examples, there are a bunch of ErlyDTL demo and test templates at he googlecode project and also the resulting, rendered output files.

Update: There are more Erlang template engines out there: seethrough which is specifically for XML/XHTML and internally uses xmerl to do its magic. It is rather simple compared to the others, but depending on the use case that can be an advantage.

The search engine optimizers are very much expert to manage ppc productivity in an efficient manner. The main function of web hosting service provider is to help the individualistic web sites to have direct accessibility to worldwide immediately. The website design templates are designed by the professional web designers which can be downloaded from different web directories free of charges. The internet service providers offer their latest services of dsl which are reliable and affordable for internet users.

CodeMirror - an AST aware in-browser code editor

2008-01-13T23:11:00.000-08:00

I have been following for a while now the development of Javascript based code editors and web IDEs (see here and here), I even started to build one myself, because I thought there is no such AST aware editor out there, at least until I discovered codemirror, which comes with support for Javascript and HTML, and with support I mean it has a real parser (and a CSS file for syntax highlighting) for those languages. Marijn Haverbeke, the author of this masterpiece of functional Javascript programming has released today a new version, which makes it easy to integrate it with a different Javascript libraries (codemirror itself uses MochiKit).

Codemirror has the following features:

syntax highlighting
automatic code indentation of current line on pressing TAB or RETURN
if some code it selected, automatic indentation of current selection on pressing TAB
works with all common modern browsers
highly configurable: additional languages, performance settings, etc.

Zed Shaw on Rails (Ghetto)

2008-01-06T11:49:00.000-08:00

The new year started with an explosion in the Rails community: Zed Shaw's Rails rant, where he points to some well known Ruby/Rails-people, explains why they are "assholes" and brings up some "general thoughts" such as:

This is exactly what makes Rails a ghetto. A bunch of half-trained former PHP morons who never bother to sit down and really learn the computer science they were too good to study in college.

Zed is the author of Mongrel, that made him well known and highly respected within the Rails community. But now I see people from the whole software industry blogging about him and his famous rant. Zed got mentioned on techcrunch and today I saw even a post from Rickard Oeberg about Ted's rant. A few years ago, Rickard was blogging in a very similar style, highly informative but also entertaining about the nasty things around the JBoss community (Rickard was the most important initial developer of the JBoss application server).

Erlang on Javascript

2007-12-28T08:56:00.000-08:00

While I am working on a Javascript to Erlang compiler for running Javascript code on the Erlang virtual machine, others do the opposite: Alex Graveley has written Er.js, a Javascript library for using Erlang-style concurrency with JavaScript, even with an Erlang like syntax !

Javascript does not support natively any kind of threads, therefore a lot of tricks (like using the asynchronous timer callback) went into this and other narrative Javascript based threading libraries to make it look and feel like real multithreading.

Gmail insecurity - check your filters - you may have been hacked

2007-12-26T06:07:00.000-08:00

David Dairey's .com domain name got stolen by an online criminal, exploiting a gmail security vulnerability (now fixed). The scary thing about this is that the exploit added a filter to gmail, so even after Google fixed the security whole, any malicious inserted filter continues to do its evil actions. Read the entire story and check your filters !

How to put HD video on the web with latest flashplayer

2007-12-15T20:34:00.000-08:00

First I want to make it clear that I am all for open web standards and requiring the latest flashplayer for showing some video on your site always degrades the user experience, no matter how much effort you put into avoiding that. So if you wanna depend on latest flashplayer, there must be a strong reason for it. Flashplayer 9.0.125 (released about a week ago) offering high quality codecs (h264/HE-AAC) might be such as strong reason, the audio/video quality is excellent and filesize of the videofiles is relatively small. Here the required steps to produce such a video and how to put it on a webpage without degrading the user experience too much.

Let's assume you already have your original video file in high quality and large file size, either form a HD video camera, a screen recording application or most probably as a result of post processing with a video editing software.

First you must transcode your media to h264 video / HE-AAC audio and put it in a mp4 fileformat. I assume there exists some software from Adobe which does that for you, but I am not familiar with their current commercial offerings. In my case I put together an open source toolchain to perform the transcoding.

Now you have the video as a *.mp4 file. Next you need to prepare your website to embed the video with a flash videoplayer (there are others which work equally well, just the code below probably neds to be slightly modified). The tricky part is that you require the latest flashplayer, so I suggest embedding via Javascript and with SwfObject, that allows to upgrade to the latest flashplayer via Adobe ExpressInstall, if Javascript is enabled. And what if Javascript is not enabled or not available at all ? There is a solution for that: "Extended" markup, which results in either the video or an alternative content (bur no easy upgrade via flashplayer ExpressInstall). Here the embedding steps in detail:

Load swfobject.js (Javascript library):

<script type="text/javascript" src="{{ path }}/swfobject.js"></script>

<script type="text/javascript">
 swfobject.registerObject("{{ video-DOM-ID }}", "9.0.115", "{{ path
}}/expressInstall.swf");
</script>

Extended HTML markup for embedding video:

<object id="{{ video-DOM-ID }}"
classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="800"
height="620">
 <param name="movie" value="{{ path }}/mediaplayer.swf">
 <param name="allowfullscreen" value="true">
 <param name="menu" value="false">
 <param name="flashvars" value="file={{ path_to_video }}&image={{
path_to_preview_image}}">
 <!--[if !IE]>-->
 <object type="application/x-shockwave-flash" data="{{ path
}}/mediaplayer.swf" width="800" height="620">
 <param name="allowfullscreen" value="true">
 <param name="menu" value="false">
 <param name="flashvars" value="file={{ path_to_video }}&image={{
path_to_preview_image}}">
 <!--<![endif]-->
 <h2>To view the video:</h2>
 <p>
   <a href="http://www.adobe.com/go/getflashplayer">
           <img src="http://www.adobe.com/images/shared/download_buttons/get_flash_player.gif"
alt="Get Adobe Flash player">
         </a>
 </p>
 <!--[if !IE]>-->
 </object>
 <!--<![endif]-->
</object>

Remarks:

all {{ path }} variables need to be replaced with the actual path or URL where you have your static content.
{{ path_to_video }} : the path or URL of the actual video file
{{ path_to_preview_image }} : path or URL of a preview image

Example:

as explained above, and inside this blog (requires editing the blogger template, if you wanna try that out yourself)

ErlyComet article and screencast

2007-12-14T09:00:00.000-08:00

Today my article "Getting started with Comet on Erlang" got published at CometDaily, there is also a screencast there (scroll down there, to the ErlyComet section) if you prefer to watch and listen ...

Update: Some users could not load the screencast / did not like to get asked for upgrading the flashplayer. I halfway expected this. It's not that I haven't put in efforts to avoid that kind of bad user experience, but my efforts apparently failed. Let me explain in detail: the video is encoded in h264/HE-AAC and that only works on flashplayer 9.0.125. If the flashplayer is not the very latest one, a dialog should inform the user (and provide direct link) to upgrade the flashplayer, if he wishes to watch the video. Uploading the original QuicktTime screencast to youtube or google video results in bad, mostly unreadable text quality, similar to all those RubyOnRails screencasts which have been originally recorded in QuickTime.
Nevertheless, here is the google video version (bad quality).

The web hosting services of different hosting companies include the most additional features of domain registration free of charge. The web site design of varied websites is developed by the professional web designers who have artistic touch of Excellency. If you want to have direct and fast internet access, you should subscribe reliable broadband service providers. The website development services are offered by the different IT companies to boost up the significance of web site into the main search engine.

Erlang TextMate integration - Documentation lookup

2007-12-13T22:35:00.000-08:00

I have made some progress with ErlyMate, my pet project for adding first class Erlang support to TextMate. Based on a new architecture with an Erlang background server (starts and stops together with TextMate, wrote a Cocoa plugin for that) I implemented a very first and highly experimental approach of edoc lookup. More technical details can be found at the googlecode project page.

And here a screencast to show you how it looks and feels like (requires latest flashplayer, and asks you to upgrade to it, if you don't have it, because video is h264/HE-AAC encoded):

To view the ErlyMate screencast:

Rubinius - the next generation Ruby virtual machine

2007-12-10T12:26:00.000-08:00

The guys at Engine Yard, a RubyOnRails application hosting company are serious about solving the Ruby performance issues (Ruby is interpreted) and they are developing a virtual machine. Straight from the Rubinius homepage:

Rubinius draws on the best virtual machine research and technology of the past 30 years and incorporates the newest research in dynamic language implementations. Rubinius implements the core libraries in Ruby, providing a system that is much more accessible, easier to develop and to extend.

And what's in the bag for an Ex-Ruby-developer (Ruby it is a great language, but since I am comfortable with Erlang, I don't have any use for Ruby anymore ...) ? Well, TextMate, my preferred editor has a lot of its functionality implemented as Ruby scripts, and if they run faster with Rubinius, that's fine for me.

Benchmark - ErlyWeb vs. RubyOnRails

2007-12-09T23:15:00.000-08:00

Yariv Sadan, the author of ErlyWeb, has benchmarked his Erlang MVC web framework against RubyOnRails 2.0 and according to his results, ErlyWeb is outperforming RubyOnRails by factor 47. [Corrected: it's 6 now, see Update]

If Ruby is on Rails, than ErlyWeb is on rocket engines !

Update: This number is far too good to be true ! In fact, Yariv had Mongrel running in non-production mode, in his corrected version the ErlyWeb outperforming factor went down to 6.

Erlang R12B-0 on Leopard

2007-12-06T09:45:00.000-08:00

Yesterday Erlang R12B-0 was released. Compilation on Leopard (with XCode development tools installed) was straight forward, except for one Erlang application: the new profiling tool percept, which got disabled because of missing libgd library at the ./configure step.

So I installed it via macports:

sudo port install gd2

unfortunately ./configure continued to complain. Finally today a solution for how to run ./configure was posted on the Erlang mailing list:

./configure --with-gd=/opt/local

and everything went without further problems ...

There a lots of new features and improvements, and I look forward to explore them one by one in the next weeks and months. Just the troublemaker percept I had to inspect immediately. It seems to be a powerful tool for performance analysis and it ships with a module called edg which wraps libgd and serves for creating 2D vector graphics (to visualize the percept profiling results), similar to my own erlycairo, but it produces*.gif files (erlycairo only outputs *.png files).

Updated ErlyCairo

2007-11-30T11:00:00.000-08:00

Did some housekeeping on my growing inventory of Erlang open source projects targeted to web development. I completely rewrote the Erlang part of ErlyCairo, the Erlang bindings for the Cairo 2D graphics library. Previously it had a hard coded node name for the C-node, now it is based on a much more flexible gen-server approach.

Below see how to use this software to create a simple, purple, 100px * 100px PNG image:

start() -> 
 erlycairo:start_link().

%% if you run multiple C-Nodes, to avoid nodename conflicts 
start(CNodeNumber) -> 
  erlycairo:start_link(CNodeNumber).
    
stop() -> 
  erlycairo:stop().        

create_images()->
  rect("rect.png", 100, 100, {1.0, 0.2, 0.7, 1.0}).

rect(File, Width, Height, {Red, Green, Blue, Alpha}) ->
  case erlycairo:new_image_blank(Width, Height) of
      ok ->
          erlycairo:set_source_rgba(Red, Green, Blue, Alpha),
          erlycairo:rectangle(0, 0, Width, Height),
          erlycairo:fill(),
          erlycairo:write_to_png(File),
          erlycairo:close_image(),
          ok;
      {error, Reason} ->
          exit(Reason)
  end.

Amazon EC2 / S3 Network Performance

2007-11-28T20:27:00.000-08:00

Thorsten von Eicken (CTO at RightScale) did some bandwidth measurements, here an overview of his analysis:

EC2 <-> EC2 (large instances):

one connection: totally 75 MB/s
three connections: totally 96 MB/s

S3 <- EC2 (large instance, HTTPS, download):

one connection: totally 12.6 MB/s
eight connections: totally 49.8 MB/s

the results for non-SSL (HTTP) are about the same.

S3 -> EC2 (large instance, HTTPS, upload):

one connection: totally 6.9 MB/s
twelve connections: totally 53.8 MB/s

TextMate is the most popular Rails development environment

2007-11-27T17:32:00.000-08:00

So I am hopefully on the right track with my attempt to improve Erlang support for TextMate !
Tim Bray asked 1000 Ruby / RubyOnRails about their preferred development environment, below just the most popular ones, for the complete table go to Tim Bray's Ruby survey.

	All	%	Ruby	%	Rails	%
TextMate	478	30.35	216	24.24	262	38.30
Vi family	345	21.90	217	24.35	128	18.71
NetBeans	184	11.68	93	10.44	91	13.30
Eclipse	175	11.11	101	11.34	74	10.82
Emacs family	198	12.57	132	14.81	66	9.65

Disaster recovery nightmare with mozy.com

2007-11-27T16:08:00.000-08:00

Shit happens and usually when you don't expect it, in my case I lost some personal data on my mac (iTunes and iPhoto library). I had signed up with Mozy for automatically backing up my data and easily restoring it, so I thought it just needs a few mouse clicks and everything is fine again. Unfortunately that was not the case. The pictures above show how both restore methods they offer (online restore and download-file-and-restore) failed (even after multiple retries).

Mozy support staff seems to responsive and friendly, but that's all. The copy-pasted text below is from an email they sent me 21 hours ago:

I will continue to do more research on this, and tomorrow our mac specialist will be in the building and from there we can work on a more permanent solution.

Lessons learned:

Don't trust your data to a fast growing startup company. In my case it was Mozy. But I believe this can happen with any other of these over-hyped cheap-service companies.
Don't test the backup service by just restoring a simple file. Take the time to do a test restore of your real valuable data at its full size.
Choose at least two totally independent backup solutions.

Faster interaction between Erlang and TextMate

2007-11-26T06:22:00.000-08:00

My first attempt of combining TextMate key bindings to Erlang scripts was fully based on escripts. Unfortunatley starting an escript costs some time (because of the startup of an Erlang VM), on my mac it is about 0.15 seconds. Not much, but enough to be perceived as short delay by the user. So I was looking for a faster way of interaction and Erlang core developer Bengt Kleberg pointed me to erlaunch, a kind of erlang scripting environment where the VM runs in the background and dosent need to be restarted for each script. So I guess something along that lines is the way to go for TextMate Erlang integration, probably a TextMate plugin written in C which takes care of the Erlang background VM during TextMate uptime. Need to learn now how to write a TextMate plugin ...

s3fox - a great Amazon S3 explorer and backup tool

2007-11-24T18:28:00.000-08:00

I recently had to do some disaster recovery on my mac and made the painful experience that mozy sucks in every way one can imagine. After several failed attempts I managed to restore most of my stuff. Ok, mozy mac version is still in beta, and it is dirty cheap but it is also completly useless for the less experienced user, because it was not straight forward for me to restore large sets of files and it is useless for the more technical user, because it gives you little control of what it is doing and you can't even backup hidden files (e.g. a git repository) and when I asked them about that, I just received a non-answer from somebody who did not understand what I asked. This is my personal experience. I am sure there are plenty of happy mozy users out there.
So I had to reevaluate my options for personal backups. Because I was already a heavy user of Amazon S3 in relation with various web projects, I tried out some of the common S3 desktop tools:

JungleDisk (commercial, cheap) - sucks because what you store with JungleDisk you can only retrieve with JungleDisk (with additional effort you can do anything of course).
S3 Browser (free) - sucks because there is only a mac version and it has very limited functionality.
BucketExplorer (commercial, free while in beta) - sucks because it is written in Java and therefore looks ugly and just feels strange on the mac.

It's a crowded market and there are a lot of other S3 explorer and backup tools out there. I actually had been using one heavily and with great success when it came out: s3fox. It's a slick Firefox extension and it was the only one which exactly worked the way I actually expected it to work. But there was one problem: after initial release, the author did not maintain it, and Firefox evolved, the S3 protocol itself evolved and when I switched to a mac half a year ago, I couldn't use it anymore (I don't remember for what particular reason). Now I checked again and - nice surprise - there is a new version (0.4), which solved all the problems and even got drag & drop and some functionality for synchronizing local and remote folders. Easy to install, easy to use, free. I didn't have to look any further.

MochiWeb got a HTML parser

2007-11-20T17:17:00.000-08:00

Since MochiWeb went open source I have been working with Tait Larson on a Comet server (HTTP push) built on top of MochiWeb. We are not there yet, but it has been a very pleasant experience so far, especially considering an earlier (failed) attempt of mine to build such a thing on top of yaws, where I had to patch yaws and deal with all kind of annoyances (don't get me wrong, yaws is great for 99% of all possible use cases, just HTTP Push belongs to the other 1%).

So today I was just doing some online housekeeping and I noticed that MochiWeb got a HTML parser. Thats great ! So far, it has been asked many times on the Erlang mailing list how to parse HTML. And sooner or later somebody points to the yaws HTML parser, which works reasonably well. One time it was me asking that question and when I got the answer, I started to play with that yaws HTML parser and some simple XHTML (if I remember properly) examples and everything looked fine. But things turned nasty when I tested the yaws parser with real world HTML.

Now I hope people are starting testing and crashing (I just did) the MochiWeb parser with real world HTML and provide feedback to the developers so they can further improve it !

Rounded corners with canvas tag graphics

2007-11-20T08:50:00.000-08:00

There exist many different approaches for creating rounded corners on HTML pages, and each of these approach has its problems. Javascript based solutions consume too much CPU cycles (and even more if doing anti aliasing), background-image based solutions are complicated (and even more, if done properly, e.g. sliding-doors based) and involve additional HTTP requests and solutions based on a bunch of DIVs (with border and varying margin to emulate the corner radius) turn any page into a horrible tag soup. The slickest solution, with the cleanest HTML and Javascript code I have seen so far is Greg Houston's mocha. It uses the canvas HTML tag, which is supported by Firefox, Safari and Opera 9. The ugly part of this solution is the heavy work-around required for Internet Explorer.