Divine Programmer

Dart, CoffeScript and Amber

2011-10-17T06:16:00.000-07:00

I have really been looking forward to learning about Dart, Google's new "JavaScript replacement" language. Recently the Dart web site went on-line, and on this page you can find some sample code: http://www.dartlang.org/articles/idiomatic-dart/

It goes without saying that Dart takes the fun out of JavaScript and potentially ruins your programming experience by introducing templates and other nonproductive constructs. Last thing the programming world needs is yet another language bogged down by type declarations. To me, Dart feels more like a replacement for Java than for JavaScript. I would, however, prefer Dart over Java any day ;-) Dart looks like dynamic language bliss by comparison.

Anyway, if you wish to read a balanced analysis of Dart, here is a blog post I found interesting: http://alanknightsblog.blogspot.com/2011/10/dart.html I wonder if you can dynamically compile Dart to JavaScript? So that you can do live coding in a web browser. Need to read up on this.

If you you wish to look beyond JavaScript, there are several alternatives to Dart. One of them is the wonderfully simplified language CoffeeScript. This is what Google language designers should have aimed for. It is quite a paradox, and also quite typical, that an individual, Jeremy Ashkenas, goes to design a language vastly more beautiful than the one produced by Google, one of the world's leading web technology companies.

Another JavaScript alternative is Amber Smalltalk by Nicolas Petton. Formerly known as Jtalk, Amber is a Smalltalk implementation that compiles to JavaScript. In the tradition of for example Squeak, Amber is written in itself, a very powerful and elegant way to implement a language.

I am looking forward to try out Amber for programming mobile devices. By making a client run a WebView with Amber, connect over a socket to a remote editor, you can interactively live code the program running on device, in Smalltalk :-) This would be very similar to the LuaLive Editor in the MobileLua project I am working on.

Upcoming talk on MoSync at GTUG Stockholm

2011-01-24T09:13:00.000-08:00

I have been working at MoSync for eight months now, and I really love it. Today I had a very creative lunch with Peter Svensson, organizer of Dyncon 2011 a very cool conference on Dynamic Languages in Stockholm, March 12-13. Peter is also the organizer of GTUG Stockholm (the Google Technology User Group meetings). We started talking about MoSync, which is a cross platform mobile development toolkit, and came up with the idea of doing a presentation of MoSync at the next GTUG meeting, coming up in Stockholm on February 10.

So how does MoSync relate to Google technologies? With MoSync you build mobile applications in a platform independent way, for Android, iOS, JavaME, Symbian, and other platforms. If you specifically want to target Android, is there any point in using MoSync? Yes, for various reasons, this can be the case.

First, Android is itself becoming a multi-target ("fragmented") platform, and using MoSync can help with such things as handling differences between different Android versions. MoSync is tested on a variety of devices, which means that it is tested on different brands of the Android OS. Platforms have subtle differences, and these are handled by MoSync. This can take away some of the problems an Android developer may encounter.

Second, MoSync is based on C/C++. This means that porting applications and games written in C/C++ to Android is feasable. You do not have to install the Android NDK (Native Development Kit) or even the Android SDK. The MoSync Eclipse IDE supports Android out of the box. For example, Another World (Out of this World) has been ported to MoSync, as has the libraries Box2D and SDL.

Third, if you think C/C++ is too low level, or if you think Java is cumbersome, other languages can run on top of MoSync. So far, there are MoSync ports of Lua and Python, and they run with satisfactory performance (MoSync recompiles to machine code on the fly). In the upcoming NativeUI support for MoSync, one component is a WebView, which implements a WebKit browser running JavaScript. From JavaScript you can call MoSync code, and the other way around.

Finally, if you are an Android developer who plans to target also iPhone/iPad, you can do so with one code base.

Personally, I see a bright future for using dynamic languages for mobile development. Lua has quickly became one of my favourite languages, and I am very happy to see also Python coming to MoSync. I hope that this can contribute to new groups of people developing applications for their mobile devices, such as teenagers and hobbyist programmers. Today's application market is much too focused on users as consumers, rather than users as innovators. Developing and publishing a simple app should be as easy as publishing a blog post.

No Censorship

2010-12-08T12:34:00.001-08:00

Wikileaks

2010-12-06T13:42:00.000-08:00

I strongly feel that now is the time when it happens. Governments call for actions outside of law to stop the free word from spreading. But the Internet community is strong, people who have lived and grown up with a free Internet will resist and fight back, I am certain of that.

For many people this must be the first time to experience what it is like to live under censorship and dictatorship. It is for me, at least. The past days, I have seen the naked faces of representatives for world governments attacking and threatening Free Speech. It is not a pretty sight.

Visit http://wlcentral.org/. Google for Niels Harrit. Take action by making choices. Get synchronised. You can vote. In Sweden the Pirate Party got less that a percent of the votes in the recent election. Now look at what we have! Freedom is more important than money, and money is on its way to lose its value. Freedom will soon prove be what is truly valuable.

Arrest Senator Joe Lieberman

2010-12-05T11:18:00.000-08:00

As a citizen of the free world, I call for the immediate prosecution of Senator Joe Lieberman, who illegally censors web content by means of threat.

http://wlcentral.org/node/459

Mobile Lua

2010-10-04T09:00:00.000-07:00

MobileLua is a port of Lua to MoSync, a cross-platform mobile development tool. One goal with MobileLua is to make it really easy to write mobile applications for hobbyist programmers.

MobileLua features a browser application that downloads and runs Lua apps over the Internet. Lua apps are published as text files, and to make it easy to publish applications on any web page, like on this blog, MobileLua recognises a begin and end tag. This is an example of a simple painting app published using these tags:

MOBILELUA_BEGIN
-- Paint example
function OnInit()
  SetColor(255, 0, 0)
  FillRect(0, 0, ScreenWidth(), ScreenHeight())
  UpdateScreen()
end

function OnTouchDown(x, y)
  SetColor(0, 0, 0)
  FillRect(x - 5, y - 5, 10, 10)
  UpdateScreen()
end

function OnTouchDrag(x, y)
  OnTouchDown(x, y)
end
MOBILELUA_END

If you download and build MobileLua, you can enter the address of this page into the browser application, and the above app is launched.

Dynamic Languages on Android - Talk at AndroidOnly 2010

2010-09-28T13:41:00.000-07:00

The following are notes from my talk at Android Only, Stockholm September 29-30, 2010.

Dynamic Languages on Android

Mikael Kindborg
MoSync AB
mikael.kindborg@mosync.com
http://divineprogrammer.se

Early bound vs. Late bound

When you
                                learn this...
----------------------------------------!------>
            ^
Can you go back
and change this?

The answer is "Yes", if you late bind...

Outline of talk

Dynamic languages on Android
JavaScript in Rhino
DroidScript
JavaScript in WebKit
MobileLua and MoSync
Hobbyist programming - making app development easy & fun

Why use dynamic Languages?

Incremental development - no build process
Less code, less syntactic noise
Dynamic typing and polymorphism - refactoring friendly
Higher level programming constructs

Dynamic languages on Android

Scripting Layer for Android (SL4A) - Python, Lua, JavaScript, Ruby, Perl, BeanShell, ...
Interpreter embedded in a native Java app - JavaScript (Rhino), JRuby, BeanShell, Kawa, Clojure, ...
JavaScript running in WebKit
Stand-alone authoring tool/engine - Flash, Corona, AppInventor, Squeak, MobileLua, ...

Mozilla Rhino

JavaScript system written in Java
Has both interpreter/runtime engine and bytecode compiler
Mature project
Moderate footprint (DroidScript is around 360KB)
Good performance

DroidScript

JavaScript on Android
Micke's project for learning Android
Experimental open-source project (MIT)
Based on Mozilla Rhino JavaScript engine
Full access to the Android API (minus subclassing)
Remote browser-based editor built with CodeMirror
Goal: Interactive programming, developing Android applications without a heavyweight IDE

Code example - display a Toast

var Toast = Packages.android.widget.Toast;
Toast.makeText(
    Activity,
    "Hello World!", 
    Toast.LENGTH_SHORT).show();

Ways DroidScript can be used

Write code in the on-device editor (works crappy).
Load/Run JavaScript files from the SD card or over the Internet.
Load/Run JavaScript code embedded on a web page within DROIDSCRIPT_BEGIN and DROIDSCRIPT_END tags - this means that programs can be published on a blog page, for example.
Do remote programming via the built-in web server that accepts PUT requests with JavaScript code.
Build a native app that embeds JavaScript files as assets.

JavaScript advantages

Late binding
Reduced syntactic noise
High-level language constructs
Closures
Compact event callback functions
Flexible object model (prototypes)
More of a language for everyone compared to Java
JavaScript is the new 'machine language'; old and new languages compile to JavaScript, e.g. CoffeeScript

JavaScript drawbacks

Poor tool support (editor, debugger)
Almost no static code checking - lots of runtime errors
No dynamic byte code generation

Scripting Java from Rhino - what works and what doesn't

Can use Java packages
Can instantiate Java classes
Can call methods and access instance variables
Data types are automatically converted between Java and JavaScript
Can instantiate interfaces that have one method (similar to an anonymous inner class in Java, but shorther syntax)
Must code a bit to implement multi-method interfaces
Cannot generate Dalvik byte code on the fly
Cannot subclass
Must run in interpreted mode
Android resource XML is early bound; some classes need resource ids, e.g. ArrayAdapter, means you cannot dynamically specify views as list items.

Code example - making a clickable button

// Short names for packages.
var widget = Packages.android.widget;
var graphics = Packages.android.graphics;

// onCreate is called when the script has been loaded.
function onCreate(bundle)
{
    var font = graphics.Typeface.create(
        graphics.Typeface.SANS_SERIF, 
        graphics.Typeface.BOLD);

    // Activity is a global variable that refers
    // to the Android activity.
    var button = new widget.Button(Activity);
    button.setText("Hello World!");
    button.setTypeface(font);
    button.setTextSize(26);
    button.setBackgroundColor(graphics.Color.rgb(0, 0, 64));
    button.setTextColor(graphics.Color.rgb(255, 255, 255));
    
    // One method interface implemented as a function.
    button.setOnClickListener(function() { 
        button.setText("You Clicked Me!"); });
        
    Activity.setContentView(button);
}

Refering to packages and classes

// Packages is a global variable that contains
// all packages and classes."),

// Write out full package path.
var button = new Packages.android.widget.Button(Activity);"),

// Use variable to refer to a package.
var widget = Packages.android.widget;
var button = new widget.Button(Activity);

// Use variable to refer to a class.
var Button = Packages.android.widget.Button;
var button = new Button(Activity);

Interfaces, closures, and polymorphism

// You implement a single method interface as a function.
// Example interface: View.OnClickListener.onClick(View v)

// Variable button is contained in the function closure.
// Method parameters need not to be spelled out.
button.setOnClickListener(function() { 
    button.setText("You Clicked Me!"); });

// Using the supplied parameter, note the use of
// dynamic typing and polymorphism.
button.setOnClickListener(function(view) { 
    view.setText("You Clicked Me!"); });

// First example in Java, variable button must be final.
button.setOnClickListener(new View.OnClickListener() {
    public void onClick(View view) {
        button.setText("You Clicked Me!"); } });

// Second example in Java, you must type cast.
button.setOnClickListener(new View.OnClickListener() {
    public void onClick(View view) {
        ((Button)view).setText("You Clicked Me!"); } });

Code example - a counting button

var widget = Packages.android.widget;
var graphics = Packages.android.graphics;

function onCreate(bundle)
{
    var font = graphics.Typeface.create(
        graphics.Typeface.SANS_SERIF, 
        graphics.Typeface.BOLD);
    var button = new widget.Button(Activity);
    button.setText("Hello World!");
    button.setTypeface(font);
    button.setTextSize(26);
    button.setBackgroundColor(graphics.Color.rgb(0, 0, 64));
    button.setTextColor(graphics.Color.rgb(255, 255, 255));

    var counter = 0;
    button.setOnClickListener(function() {
        counter++;
        button.setText("Click count: " + counter); });
    
    Activity.setContentView(button);
}

How to implement multi-method interfaces

// Program that displays images from the camera.

var Camera = Packages.android.hardware.Camera;
var SurfaceHolder = Packages.android.view.SurfaceHolder;
var SurfaceView = Packages.android.view.SurfaceView;
var Window = Packages.android.view.Window;

function onCreate(bundle)
{
    Activity.requestWindowFeature(Window.FEATURE_NO_TITLE);
    var preview = createPreviewSurface();
    Activity.setContentView(preview.getSurfaceView());
}

function createPreviewSurface()
{
    var camera = null;
    var surface = new SurfaceView(Activity);

    // JavaScript object that implements the interface
    // android.view.SurfaceHolder.Callback
    var object = {
        getSurfaceView: function() {
            return surface; },
        surfaceCreated: function(holder) {
            camera = Camera.open();
            try {
                camera.setPreviewDisplay(holder); }
            catch (exception) {
                camera.release();
                camera = null; } },
        surfaceDestroyed: function(holder) {
            camera.stopPreview();
            camera.release();
            camera = null; },
        surfaceChanged: function(holder, format, w, h) {
            var parameters = camera.getParameters();
            parameters.setPreviewSize(w, h);
            // Causes camera to fail on Nexus One
            //camera.setParameters(parameters);
            camera.startPreview(); }
    };

    // Create the instance of the interface.
    var callback = createInstance(
        // Must use full package name for some reason...
        Packages.android.view.SurfaceHolder.Callback, 
        object);
    
    // Set the callback for the surface.
    surface.getHolder().addCallback(callback);
    surface.getHolder().setType(
        SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    return object;
}

// Create an instance of a Java interface.
//   javaInterface - the interface type
//   object - JS object that will receive messages
//     sent to the instance
function createInstance(javaInterface, object)
{
    // Local function to convert a Java array to
    // a JavaScript array
    function javaArrayToJsArray(javaArray) {
        var jsArray = [];
        for (var i = 0; i < javaArray.length; ++i) {
            jsArray[i] = javaArray[i]; }
        return jsArray; }

    // Short name for lang package.
    var lang = Packages.java.lang;

    // Interface we implement.
    var interfaces = 
        lang.reflect.Array.newInstance(lang.Class, 1);
    interfaces[0] = javaInterface;

    // Create proxy object.
    var obj = lang.reflect.Proxy.newProxyInstance(
        lang.ClassLoader.getSystemClassLoader(),
        interfaces,
        // This function is called on method invocation.
        // Note that args is a Java array.
        function(proxy, method, args) {
            // Apply JavaScript function to arguments.
            return object[method.getName()].apply(
                null,
                javaArrayToJsArray(args)); });
    return obj;
}

DroidScript architecture

DroidScriptActivity.java - basic Android activity that embeds the Rhino engine
DroidScriptApp.java - extends DroidScriptActivity, provides the starting point of the application
DroidScriptApp.js - The actual code for the DroidScript application, all of the user interface and application logic is here
DroidScriptServer.java - tiny web server that can be used from JavaScript
DroidScriptServer.js - The user interface and logic for the server activity
Limitation: require is currently not implemented, but you can load JavaScript code into the global scope

Event handling functions (called from DroidScriptActivity.java)

onCreate
onStart
onRestart
onResume
onPause
onStop
onDestroy
onCreateContextMenu
onContextItemSelected
onCreateContextMenu
onCreateOptionsMenu
onPrepareOptionsMenu
onOptionsItemSelected

Evaluating JavaScript (methods in DroidScriptActivity.java)

eval(String code)
evalFileOrUrl(String fileNameOrUrl)
evalAssetFile(String fileName)

// These can be called from JavScript, for example:
Activity.evalFileOrUrl("http://www.mydomain.se/MyCode.js");

Or use eval in JavaScript

How to build a native JavaScript app

DroidScriptActivity.java - use as is
MyApp.java - extend DroidScriptActivity, and load your JavaScript code from asset files, or download over the Internet and optionally cache files on the device
MyApp.js - the JavaScript code of the application, place in the assets folder in the Eclipse project

// MyApp.java - example of a stand alone DroidScript app.
package mydomain.myapp;

import android.content.Intent;
import android.os.Bundle;

public class MyApp extends comikit.droidscript.DroidScriptActivity
{
    @Override
    public void onCreate(Bundle bubble)
    {
        Intent intent = getIntent();
        intent.putExtra("ScriptAsset", "MyApp.js");
        super.onCreate(bubble);
    }
}

As a starting point, check out DroidZine (project by Jonas Beckman and Mikael Kindborg): http://github.com/kamidev/droidzine/

JavaScript in WebKit

This example shows how to access Java from JavaScript in WebKit, via DroidScript.

function onCreate(bundle)
{
    var WebView = Packages.android.webkit.WebView;

    var webview = new WebView(Activity);
    webview.getSettings().setJavaScriptEnabled(true);
    webview.addJavascriptInterface(Activity, "activity");
    Activity.setContentView(webview);   
    
    var content =
    """<html>
        <body>
            <script>
            function showToast(message) {
                activity.eval(
                    "var Toast = Packages.android.widget.Toast;" +
                    "Toast.makeText(Activity, '" + message + "', " +
                    "Toast.LENGTH_SHORT).show();"); }
            </script>
            <h1>Take the pill</h1>
            <input 
                type="button" 
                value="Take pill" 
                onclick="showToast('You have taken the red pill!')">
        </body>
    </html>""";
    
    webview.loadData(content, "text/html", "utf-8");
}

MobileLua - An easy way to create Android apps (developed with MoSync)

Minimal painting app in Lua:

function OnInit()
  SetColor(255, 255, 255)
  FillRect(0, 0, ScreenWidth(), ScreenHeight())
  UpdateScreen()
end

function OnTouchDown(x, y)
  SetColor(0, 0, 0)
  FillRect(x - 5, y - 5, 10, 10)
  UpdateScreen()
end

function OnTouchDrag(x, y)
  OnTouchDown(x, y)
end

http://code.google.com/p/mobilelua/

Notes from Talk at SWDC2010

2010-06-02T13:58:00.000-07:00

These are notes from my talk at SWDC2010, April 3, 2010.

The New Mobile Web

Mikael Kindborg
MoSync AB

Introduction
My Favourite languages are Lisp, Smalltalk, and C

I also like JavaScript, and CoffeeScript looks very promising!

JavaScript:

function square(x) {
return x * x;
}

CoffeeScript:

square: (x) ->
x * x

Early Bound vs. Late Bound
The theme of this talk is Early Bound vs. Late Bound Thinking & Technologies.

Ready made toys like model cars are early bound, that is, the design is set ("in stone") early on in the design/production process and cannot easily be altered when manufactured, neither by the designer nor by the end user.

Going Late Bound means that the design/product can be altered at "run time".

For example, a model car kit is a bit less early bound than a ready made car model, but once assembled an painted, it is not as straightforward to alter and experiment with.

By contrast. LEGO is a truely late bound type of toy. Children can assemble, alter and disassemble LEGO designs in endless ways.

Nathan Sawaya is an example of an artist that has taken LEGO-designs to new heights of creativity, see http://brickartist.com/

Going late bound enables both Dynamic Development and Dynamic Deployment.

Dynamic Development
Characteristics of dynamic development:

Incremental coding
No Build
Edit/Run cycle blurred
Edit the running program
Edit code during debugging
Dynamic languages enable incremental evaluation

Examples of Dynamic/Late Bound Tools

Spreadsheets
Smalltalk
Seaside
Live JavaScript
Greasemonkey and Extensions
The work at http://vpri.org
DroidScript
Magic Words (interactive toy)

Smalltalk/Seaside:

Squeak: http://squeak.org/
Pharo: http://pharo-project.org/
Clamato: http://clamato.net/
Seaside - Web application framework: http://seaside.st/
VisualWorks/WebVelocity: http://cincomsmalltalk.com

Live JavaScript:

Influence of Self and Strongtalk:

To: self-interest@self.smli.com
Subject: Sun buys Java compiler technology based upon Self!!!
From: keith@uniteq.com (Keith Hankin)
Date: Tue, 18 Feb 1997 17:38:17 -0800

Sun has just announced that they are buying Animorphic
Systems, which for the last 2+ years has been developing
JIT compiler technology for Java and Smalltalk.
And, guess what? It's based upon the Self project!!!

http://www.merlintec.com/old-self-interest/msg01011.html

Strongtalk and Google V8:

From: Dave Griswold
Date: Tue, 2 Sep 2008 12:14:32 -0700 (PDT)
Local: Tues, Sep 2 2008 9:14 pm
Subject: Chrome and V8

Hi everyone,

It's been a while, but now that Google has announced
Chrome and V8, I can finally make a little clearer a
major reason why I haven't been pushing Strongtalk
development for quite a while: Chrome's new JavaScript
engine V8.

The V8 development team has multiple members of the
original Animorphic team; it is headed by Lars Bak,
who was the technical lead for both Strongtalk and the
HotSpot Java VM (as well as a huge contributor to the
original Self VM). I think that you will find that V8
has a lot of the creamy goodness of the Strongtalk and
Self VMs, with many big architectural improvements

http://groups.google.com/group/strongtalk-general/browse_thread/thread/40eb8f405fbd3041/0abb010f0eac18e9

Strongtalk type system:

Type System: It contains the first fully developed
strong, static type system for Smalltalk (hence the
name Strongtalk). The type system is both optional
and incremental, and operates completely independently
of the compiler technology (which means that normal
untyped Smalltalk code runs just as fast as typed code).
http://www.strongtalk.org/

Dynamic Deployment:

Update application at any point - even while it is running
User modifiable applications
Networked/linked/browsable apps (web of applications)
Security! (*x*)

Mobile Apps compared to Web Apps
Mobile Apps:

Early bound
Manual install
Manual updates
Isolated
Developed in static languages (Java, Objective C/C++)
Native access

Web Apps:

A bit more late bound
Automatic install
Automatic updates
Networked
Developed in dynamic language (JavaScript)
Restricted native access

DroidScript
What it is:

JavaScript on Android
Experimental open-source project
Based on Mozilla Rhino
Full access to the Android API (minus subclassing)
http://droidscript.se/
http://droidscript.blogspot.com

DroidScript Development:

Edit on computer, copy files to device, run on device
Edit on device, run on device
Edit on device, run incrementally on device (like a REPL)
Edit in browser, run incrementally on device

DroidScript Deployment:

Copy files to device
Publish JavaScript files and open on device
Publish inlined JavaScript on any web page and open on device
Open JavaScript from an application (web of applications)
Distribute as native application (with or without dynamic updates)
Security! (*x*)

The Future

HTML5 and other web-based techniques will become increasingly powerful
Dynamic languages enable dynamic development and dynamic distribution of mobile applications
Going late bound boosts creativity and user participation (LEGO)
A mobile web browser based on a dynamic programming language (NoHTML) would be cool

Contact

mikael.kindborg (at) mobilesorcery.com
http://mosync.com

Hört

2010-05-30T11:39:00.000-07:00

Hört på tunnelbanan av tjejer i övre tonåren:

"Man får inte vara med sina pojkvänner, det är förbjudet. Man får inte ha pojkvänner."

"Helt underbart att mina vänner ger mig flyktvägar!"

"Vissa dagar ser man saker som man inte borde se under en hel livstid."

Samtal med äldre man:

Mannen: Det är inte alla som dör.
Jag: Vilka?
Mannen: De som väljer att inte födas.

Jorden

2010-05-02T13:44:00.001-07:00

Tack jorden för att jag får gå på dig. Jag ska vara så varsam som möjligt.

Slides from seminar on Dynamic Languages

2010-04-27T15:02:00.000-07:00

The following are slides from a seminar on Dynamic programming langauges, given at MSC Konsult, Stockholm, April 28, 2010.

Better Software with Dynamic Languages

Mikael Kindborg

2010-04-28

License: Creative Commons Attribution-Noncommercial-Share Alike 2.5 Sweden License

Programming background

Programming languages I have used:

ASTA 1982
Cobol 1982
Simula 1983-1984
CS4 1983
Lisp 1983-1990, 2000-2003 *
Logo 1983-1984 *
Prolog 1984-1985
Pascal 1985-1986 *
C 1985-1999 *
Scheme 1987-1988
Smalltalk 1985-1989, 2003-2010 *
HyperTalk/SuperTalk 1997-1991 *
Lingo 1990-1994, 1997 *
C++ 1993-1999, 2006-2008 *
PowerBuilder 1995-1996 *
Visual Basic 1996 *
Java 1995-2010 *
JavaScript 1995-1999, 2009-2010 *
ToonTalk 1999-2006
PHP 2001-2010 *
Erlang 2002, 2004, 2008
Oz 2003-2005
Python 2003-2010 *
Ruby 2005, 2008
(* = paid work)

Children's programming tools I have developed:

Concurrent Comics
Magic Words

Favourite languages:

C
Lisp
Smalltalk
Python
JavaScript (CoffeScript)

Language I would like to learn:

Factor

Habits, conciousness, awareness

Who has decided which language you are using in your project?
Why is it used?
What are the alternatives?

World's most popular programming environment

Dynamic typing
Strong typing
Incremental
Modeless (no build cycle)
Visual/spatial
Image-based
Functional

This happens to be the spreadsheet!

Resolver - Spreadsheet in Python

This is an advanced spreadsheet that uses Python:

http://code.google.com/p/resolver/

http://www.resolversystems.com/

Prototyping vs Production

Dynamic languages are good for prototyping because they are fast to develop in.

Static languages are good for production because they are slow to develop in?

Myths

Dynamic languages are slow (Scheme/Lisp, Erlang, Node.js (JavaScript) are fast)
Dynamic languages cannot scale (Erlang, Smalltalk, GemStone/S scale)
Dynamic languages are not safe (Erlang is for real-time systems)
Dynamic languages are harder to code in, inexperienced programmers can screw up too easily
Dynamic languages are a new trend. (Dynamic languages were big in 1980,
boosted by AI-research, Lisp, Smalltalk, Prolog, Concurrent Logic Programming, Logo)

Benchmarks: http://shootout.alioth.debian.org/

History

Modern languages and user interfaces have one big influence, Smalltalk and Alan Kay's team at Xerox PARC 1970-1980

DynaBook
Object-oriented programming
Overlapping windows
Bitmapped graphics
Mouse interaction
Networking (Ethernet)
Font technology
Printing technology
Desktop publishing

http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html

Alan Kay Quotes

"Actually I made up the term 'object-oriented', and I can tell you I did not have C++ in mind."

"I'm not against types, but I don't know of any type systems that aren't a complete pain, so I still like dynamic typing."

"Java is the most distressing thing to hit computing since MS-DOS."

http://c2.com/cgi-bin/wiki?AlanKayQuotes

http://en.wikiquote.org/wiki/Alan_Kay

Demo of Squeak/Pharo

http://www.squeak.org

http://www.pharo-project.org/home

Code example:

Morph subclass: #Drawing
 instanceVariableNames: ''
 classVariableNames: ''
 poolDictionaries: ''
 category: 'MyClasses'

initialize
    super initialize.
    self color: Color white.
    self borderColor: Color black.
    self borderWidth: 2.
    self extent: 600@400.
    self position: 50@50.
    self clipSubmorphs: true.
    self on: #mouseDown send: #createCircle: to: self.

createCircle: event
    | circle |
    circle := EllipseMorph new.
    circle color: Color red.
    circle borderColor: Color black.
    circle borderWidth: 2.
    circle extent: 100@100.
    circle center: event position.
    self addMorphFront: circle.

StrongTalk and the history of the Java Jitter

To: self-interest@self.smli.com
Subject: Sun buys Java compiler technology based upon Self!!!
From: keith@uniteq.com (Keith Hankin)
Date: Tue, 18 Feb 1997 17:38:17 -0800

Sun has just announced that they are buying Animorphic Systems, which for the 
last 2+ years has been developing JIT compiler technology for Java and 
Smalltalk.  And, guess what?  It's based upon the Self project!!!
---
Source: http://www.merlintec.com/old-self-interest/msg01011.html

From: Dave Griswold <David.Griswold....@gmail.com>
Date: Tue, 2 Sep 2008 12:14:32 -0700 (PDT)
Local: Tues, Sep 2 2008 9:14 pm
Subject: Chrome and V8

Hi everyone,

It's been a while, but now that Google has announced Chrome and V8, I
can finally make a little clearer a major reason why I haven't been
pushing Strongtalk development for quite a while: Chrome's new
JavaScript engine V8.

The V8 development team has multiple members of the original
Animorphic team; it is headed by Lars Bak, who was the technical lead
for both Strongtalk and the HotSpot Java VM (as well as a huge
contributor to the original Self VM).   I think that you will find
that V8 has a lot of the creamy goodness of the Strongtalk and Self
VMs, with many big architectural improvements
---
Source: http://groups.google.com/group/strongtalk-general/browse_thread/thread/40eb8f405fbd3041/0abb010f0eac18e9

http://www.strongtalk.org/history.html

On the StrongTalk Type System: It contains the first fully developed strong, static type system for Smalltalk (hence the name Strongtalk).
The type system is both optional and incremental, and operates completely independently of the compiler
technology (which means that normal untyped Smalltalk code runs just as fast as typed code).

http://www.strongtalk.org/

Readability

Shorter code is easier to read and to maintain and refactor
Need balance between cryptic and expressive

Smalltalk:

square
    ^self * self

JavaScript:

function square(x) {
    return x * x;
}

CoffeeScript:

square: (x) -> 
    x * x

Java:

public int square(int x) {
    return x * x;
}

CoffeeScript: http://jashkenas.github.com/coffee-script/

More examples

Smalltalk:

self on: #mouseDown send: #createCircle: to: self.

button on: #mouseDown send: #value to: [Object inform: 'You clicked me'].

JavaScript:

button.setOnClickListener(function (view) {
    view.setText("You Clicked Me!"); 
});

CoffeeScript:

button.setOnClickListener((view) -> view.setText("You Clicked Me!"))

Java:

button.setOnClickListener(new View.OnClickListener() {
    public void onClick(View view) {
        (Button) view).setText(""You Clicked Me!")
    }
});

More CoffeeScript

CoffeeScript:

mood: greatly_improved if singing

if happy and knows_it
  claps_hands()
  cha_cha_cha()

date: if friday then sue else jill

expensive: or do_the_math()

Compiles to JavaScript:

var date, expensive, mood;
if (singing) {
  mood = greatly_improved;
}
if (happy && knows_it) {
  claps_hands();
  cha_cha_cha();
}

date = friday ? sue : jill;
expensive = expensive || do_the_math();

Things that make life difficult

Source code analysis is clearly helpful, and optional type
declarations can add value, but in static languages that is not all you get.
You also get some less desirable things:

Static inheritance relation - cannot be changed at runtime
Type hierarchy lock in, not true polymorphism
Interfaces are not protocol specifications, they are hierarchical types
Primitive types
Modifiers
Generics
Extreme line noise
Things change, and static types, as the name implies, are not friendly to change

This:

public static final synchronized 
List<Map<String, Product>> getProductList() {
    List<Map<String, Product>> productList = 
        new ArrayList<Map<String, Product>>();
    ...
}

Can be:

def getProductList():
    productList = []
    ...

Strong points of dynamically typed languages

Fast to develop
Late binding
Incremental development (no build cycles)
Shorter code
Easier to read code
Easier to maintain/refactor code
Aggressive Jitting possible with late binding
Polymorphism/Duck typing
High-level constructs, e.g. first-class functions and closures
Syntax for data structures (tuples, lists)
DSL-friendly

As one participant at the seminar pointed out, many of these points are also true of functional languages based on type inference, like Haskell and Ocaml.

Duck typing: "If it walks like a duck and talks like a duck, it must be a duck"

http://c2.com/cgi/wiki?DuckTyping

http://en.wikipedia.org/wiki/Duck_typing

What makes Smalltalk special?

Truly incremental development
Late binding taken to the extreme
Source code at your fingertips
Innovative keyword syntax
Succinct closure syntax
Rich programming environment (doit, debugger, inspector, senders/implementors, refactoring browser...)

Weak points

Type declarations serves as documentation
Type declarations make refactoring tools more reliable
Weak typing is a source of mistakes
Implicit variable declarations are error prone

Demo of JavaScript on Android

http://droidscript.se

http://droidscript.blogspot.com

Y Combinator explained

2010-04-06T13:38:00.000-07:00

I have spent some time to look into the Y Combinator, a function for defining recursive functions without using conventional recursion support.

The Y Combinator is quite legendary in functional programming, and appears in "The Little Schemer", by Daniel P. Friedman and Matthias Felleisen. The idea is to show how recursion can be expressed in a language that does not support recursion (but has support for higher-order functions). As implementation language I will use JavaScript, and I will also show how Y can be expressed in Smalltalk and in Erlang.

A good article on Y written by James Coglan can be found here: http://blog.jcoglan.com/2008/01/10/deriving-the-y-combinator/. Like James Coglan, I write this blog article to better understand Y, and I use a somewhat different approach to explain it. A tool you can use to interactively experiment with the functions below, is this live browser-based JavaScript editor: http://droidscript.se/jsedit.html

Typically a recursive function is said to "call itself", like this recursive definition of the factorial function in JavaScript:

function factorial(n) {
    if (n == 0) { return 1; }
    else { return n * factorial(n - 1); }
}

The trick to understand recursion, and the Y Combinator, is that a recursive function actually does not "call itself", it calls an instance of a function that has the same function body, but with its own values for the actual parameters. Thus, recursion is not iterative, but consists of a chain of function calls lined up waiting for each other to return (unless you have optimised tail recursion, but that is another story). When the recursion has reached the end and returns, the function calls that wait return one by one, each using their local variable values to compute their result in the call chain.

If I could draw a diagram of this (not easily done with primitive blog tools!), it would become more clear than using plain words. But we can picture the call chain like this:

factorial(3)

is the same as:

3 * (2 * (1 * (1)))

This is what we get if we substitute the calls with the actual variable values in each function instance. The innermost 1 is the number returned by the factorial function when the value of n is zero.

The point of Y Combinator is to show that recursion can be expressed without referring to the name of the recursive function. Of little practical relevance, but an interesting exploration of recursive functional structures.

Lets start by this recursive JavaScript function:

function repeat() {
    if (confirm("Continue?")) { repeat(); }
}

How can this be written without referring to the name of the function? To do this, we will use an anonymous function that takes another anonymous function as a parameter.

Anonymous functions are functions that do not have a name, here is a quick example before we continue.

This:

function twice(n) { return n * 2; }
alert(twice(22));

Can be written as:

fun = function(n) { return n * 2 };
alert(fun(22));

Or, if we substitute the variable fun with the expression it refers to:

result = (function(n) { return n * 2 }) (22);
alert(result);

Now back to the version of repeat written with anonymous functions:

(function(fun) { fun(fun); }) 
(function(fun) { 
    if (confirm("Continue?")) { fun(fun); });

What happens here is that the function (function(fun) { fun(fun); }) gets called and "kick-starts" the recursion. This is an anonymous function that takes another function as a parameter. It then calls that function with the very same function as the argument. The actual function being called is the other anonymous function, which is a variation of our continue function. Inside that function, the function is again called, with the very same function as its argument! This means that we will get an endless chain of function calls until the user chooses not to continue, in which case the recursive function application is not called, and the call stack unwinds and the function call chain terminates.

Another way to write the same thing:

repeat = (function(fun) { 
    if (confirm("Continue?")) { fun(fun); });
repeat(repeat);

Here we use a variable to refer to the anonymous function, and apply it to itself. Note that this is not cheating, it is not a named recursive function call, and we could just as well have replaced the occurrences of repeat in the call on the second line with the function expression it refers to.

This "trick" of calling a function with another function as a parameter (which happens to be the same function), is at the heart of the Y Combinator.

Before showing Y, we will use one more intermediate step. The above example does not take a parameter, and does not return anything useful. To recursively compute something, say the factorial of a number, we need to be able to supply parameters to and return values from the recursive function applications.

Here is factorial written as a "kick-started" anonymous recursive function; then we call the function using the variable factorial, which refers to the expression that starts the computation:

factorial = (function(fun) { return fun(fun); })
    (function(fun) {
        return function(n) {
            return n == 0 ? 1 : n * fun(fun)(n - 1); } } );
alter(factorial(9));

Tadam! Here we have proper recursion without using named functions. But what does the variable factorial in the above piece of code refer to? It refers to an instance of the anonymous function that starts on line 3, with the local variable fun referring to the anonymous function that starts on line 2. The function returned on line 3 is an example of a closure; a function instance that has some of its local variables initialised, but has not yet started to execute. On line 5, that function gets called with the argument value 9. And on line 4 the same process continues and drives the recursion.

It is still a bit cumbersome and non-general to have to apply fun to itself inside factorial. It would be nicer to have something that looks like a proper recursive function call, and this is what Y accomplishes.

Finally, here is the definition of Y Combinator, using a style similar to the one we have used above:

Y = function(fun) {
    return (function(recurse) { return recurse(recurse); })
       (function(recurse) { return function(x) { 
           return fun(recurse(recurse))(x); }; });
};

Y neatly packages the recursive function application into one single closure; the function that is returned on line 3 above. The difference from the previous example is that we have separated the function fun that does the specific computation (factorial in our example below) from the function that does the recursive application (recurse). It should also be noted that this definition of Y is limited to recursive functions that take one argument.

Y is used with functions that have this form:

factorial = function(recurse) {
    return function(n) {
        return n == 0 ? 1 : n * recurse(n - 1); } };
};

And here is how to call it:

alert(Y(factorial)(9));

Y can (as far as I know) be written in any language that supports higher-order functions and closures. Here is a version in Smalltalk that uses block closures:

y := [:fun | [:recurse | recurse value: recurse] value:
    [:recurse | [:x | (fun value: 
        (recurse value: recurse)) value: x]]].

Example on use (produces a pretty big number):

factorial := [:recurse | [:n | n = 0 
    ifTrue: [1] 
    ifFalse: [n * (recurse value: n - 1)]]].
   
(y value: factorial) value: 5000.

Erlang is a cool functional language, and here goes two variations of Y:

Y = fun(Function) -> 
    (fun(Recurse) -> Recurse(Recurse) end)
    (fun(Recurse) -> fun(X) -> 
        (Function(Recurse(Recurse)))(X) end end) end.

Somewhat simplified with a variable that refers to the recursive function:

Y = fun(Function) -> 
    Go = fun(Recurse) -> fun(X) -> 
        (Function(Recurse(Recurse)))(X) end end,
    Go(Go) end.

And how to use (Erlang too can handle big numbers):

Factorial = fun(Recurse) -> 
    fun(0) -> 1; 
       (N) -> N * Recurse(N - 1) end end.

(Y(Factorial))(5000).

A good way to understand how the above code examples work is to draw diagrams on paper of how the anonymous functions are instantiated and called.

Y Combinator is also the name of a start-up venture firm funded by Paul Graham.

New version of DroidScript - JavaScript on Android

2010-04-05T11:20:00.001-07:00

There is a new version of DroidScript available, see the DroidScript blog:
http://droidscript.blogspot.com/2010/04/version-4-of-droidscript.html

Sikuli - Python source code with pictures

2010-03-26T15:06:00.000-07:00

I love Sikuli! What I like most is that the source code contains pictures! Since I have a background in visual programming and programming languages based on comic strips, one might have guessed that I would fall for Sikuli :-) Even better, the programming language is Python (Jython), which makes for really clean code.

Now, what is Sikuli? It is a tool for scripting user interfaces, and it is based on matching images (for example an image of a button in the ui). I introduced Sikuli to a client the other day, and now they are using it to create automated ui tests for a web application.

I have one hint, importing modules with Python's standard import statement does not work, instead use execfile to load your Python modules (see link below).

Links:
http://groups.csail.mit.edu/uid/sikuli/
https://answers.launchpad.net/sikuli/+question/102003

Talk on dynamic Android apps at SWDC2010

2010-03-24T09:00:00.000-07:00

I will be giving a talk on dynamic languages on Android at the Scandinavian Web Developer Conference 2010. It goes without saying that I am proud of being invited to speak at this high-profile conference. I am looking forward to Marcus Ahnve talking about TDD and Android, and to Nikolai Onken's talk on accessing hardware from the browser, to name a few.

It is interesting to note that after years of having a trend towards browser based applications, the popularity of iPhone and Android has shifted focus back to "fat clients" in the form of mobile apps. Obviously, native apps have the potential for a richer user interface experience than what is possible with today's browser based apps.

But mobile apps tend to be a bit heavy going. In the case of iPhone, this is especially noteworthy. Not only is there a substantial development cycle (edit, compile, run) for native apps, Apple's notorious process for accepting apps to the app store stretches the deployment cycle to the magnitude of weeks.

Android development and deployment is quite smooth, thanks to the Eclipse plugin for Android, and to the fact that one can easily and legally deploy the app on any web site (you are not restricted to Android Market). Still there is some effort involved in deploying and installing new versions of an app. And the development process is still based on the build centric edit-compile-run cycle.

When it comes to web development, there is no need to rebuild and redeploy the application on every edit-run cycle. Thanks to JavaScript being a dynamic language, you can edit and reload only the part that has been updated. A web application is also trivial to deploy and upgrade (ahem, well in theory that is ;-).

In my talk at SWDC2010, I will discuss how dynamic languages like JavaScript can be used as a basis for a platform where applications can be deployed and updated with the same ease as for browser based applications. Furthermore, I will discuss how to take advantage of the dynamic nature of JavaScript for incremental development of applications, and demo the interactive editor in DroidScript, which is a simplistic but illustrative example of a Smalltalk inspired programming tool for Android.

More DroidScript

2010-03-21T14:36:00.000-07:00

I have written a couple of code examples that illustrate how to create ListViews in JavaScript on Android. See the DroidScript blog: http://droidscript.blogspot.com

Google Closure

2010-03-03T14:34:00.000-08:00

These are notes for a talk on Google Closure I will give tomorrow at GTUG Stockholm.

Note that Google Closure is a JavaScript library and toolkit, not to be confused with the Lisp dialect Clojure (which happens to be pronounced as "closure").

Overview
The Closure toolkit consists of the following parts:

Closure Compiler - JS to JS compiler; optimises and checks your JavaScript code.
Closure Library - very comprehensive; UI widgets, graphics, modules, packaging, DOM manipulation, communication, test framework, and much more.
Closure Templates - dynamic generation of HTML using a template language; "small components that you compose to form your user interface"; for both client side (JavaScript) and server side (Java).
Closure is used by large-scale web applications; it is the foundation for Gmail, Calendar, Docs, Blogger, and other Google products.

Closure Compiler
The compiler is an optimising JavaScript to JavaScript compiler. There is an interactive compiler tool available that is very cool, just paste in your JavaScript and optimise it. There is also Service API for calling the compiler from a program. One feature of the compiler is the optional use of doc tags annotations and type expressions for providing type hints etc.

As an experiment I ran the jQuery library through the compiler. Here are the numbers:

Compiling http://code.jquery.com/jquery-1.4.2.js
Original Size: 160.01KB (45.04KB gzipped)
Compiled Size: 63.86KB (22.75KB gzipped)
Saved 60.09% off the original size (49.49% off the gzipped size)

Compiling http://code.jquery.com/jquery-1.4.2.min.js
Original Size: 70.48KB (24.03KB gzipped)
Compiled Size: 63.84KB (22.75KB gzipped)
Saved 9.42% off the original size (5.33% off the gzipped size)

The Google optimiser generates a bit more compact code than the minimised jQuery library. I have not done any performance tests, so I cannot say how the Google version performs compared to the original jQuery code.

Personally, I think it is a bit sad with the tendency to deliver optimised JavaScript code, because one of the truly great things with the web was to be able to view the source of any web page. That boosted knowledge about HTML and web design, and I would prefer if the JavaScript engine would take care of the optimisation. To always have the source code available is a huge advantage. This is one of the things that makes Smalltalk so productive; the code for the whole library and even the compiler is available to study and learn from.

Closure Templates
Closure includes a template language. It provides a common language for both JavaScript (client-side) and Java (server-side), and the idea is to write small, composable units that are used to build web applications. The syntax is based on curly-bracket tags, not as painful for the eye as XML, but it goes without saying that it is a freaky syntax, and one might indeed ask what motivates template languages in general. I have never understood the benefits of having a half-done semi-markup and semi-programing language when you can have the full power of a dynamic language with internal DSLs if needed. A strong point of XML and other markup languages is that they describe structure and content in a declarative way. But you have always had this for free in Lisp, and with proper DSL-design and other language extensions, the same can be done in Python, Ruby, JavaScript, Smalltalk, et. al.

Closure Library
The JavaScript library is the heart of Closure, and it is a massive library that covers most aspects you could ask for when developing advanced web applications. There is a module system, with proper namespaces, and it is easy do define your own namespaces and modules.

A hint; as an alternative to download the entire library from Google's Subversion repository, you can refer to the base file in a script tag, using this url: http://closure-library.googlecode.com/svn/trunk/closure/goog/base.js

JavaScript Live Editor
To get started and dive into the Closure library, I decided to create a web-based JavaScript editor that could interactively evaluate Closure code. I would also use Closure itself when writing the editor. I already had the DroidScript live editor for programming JavaScript on Android, which is implemented using jQuery and CodeMirror. So I took that editor and rewrote it using Google Closure. It is a very small project, just one web page with some embedded JavaScript that evaluates code, but it was an useful experience. The editor, which contains a number of Closure code examples, is here: http://droidscript.se/jseditor

The editor works like a Smalltalk workspace; select a piece of code and evaluate it. This proved to be a useful tool for experimenting with the Closure library, and it should be equally usable for interactive exploration of jQuery, or any JavaScript library, or JavaScript programming in general. I have never understood why most REPLs are command-line oriented. Long time since we used paper-based teletype terminals ;-)

Finally, I wish to give massive amounts of cred. to Marijn Haverbeke, the author of CodeMirror, a syntax highlighting code editor written in JavaScript (note that it is *not* part of the Closure library). It is the best web-based code editor I have seen, with a clean API that is very easy to use.

To sum up on Closure, it is definitely seems like a very capable library. Heavier and more complex than for example jQuery, but for large applications it provides much more support and features. It feels like GWT without Java, and using JavaScript rather than Java is by definition a good thing ;-)

DroidScript - JavaScript for Android

2010-02-20T14:54:00.000-08:00

I have published a post at my DroidScript blog that describes a tool for programming Android devices interactively in a web browser using JavaScript.

Utvecklingen av tunnelbananedramat

2010-02-20T14:51:00.000-08:00

Historien om Jesper Nilsson som blev utsatt för tveksamma metoder från två civilpoliser i tunnelbanan fortsätter. Jesper har uppdaterat sin blogg med vad som hänt efter händelsen. Jag hoppas att inte media och andra inblandade tappar intresset. Tvärtom ser det ut som att både jurister och media följer fallet med intresse. Hoppas Jesper fortsätter skriva om fallet på sin blogg. Händelsen känns som toppen på ett isberg, och det känns viktigt att den följs upp.

Villkor för fotografering i Stockholms tunnelbana (in Swedish)

2010-02-13T01:48:00.000-08:00

Dagens stora samhällsrättsliga nyhet är det förmodade polisövergreppet mot Jesper Nilsson som fotograferade och filmade två civilpoliser i Stockholms tunnelbana (se bland annart artikel i DN).

Efter att ha sett en hänvisning till en uppseendeväckande formulering i de villkor för fotografering i tunnelbanan som MTR (företaget som driver Stockholms tunnelbana) har ställt ut, letade jag upp texten med villkoren på MTRs hemsida. Här är de intressanta avsnitten (markeringen med kursiv stil är min egen):

"För privat bruk
Privatpersoner som vill fotografera eller filma i SLs miljöer för enskilt bruk behöver inte söka tillstånd. Detta förutsatt att de inte på något sätt påverkar eller stör den dagliga verksamheten.

I kommersiellt syfte
När syftet med filmning eller fotografering i SL-trafiken är kommersiellt skall gällande lagar och förordningar följas. Generellt tillämpas Internationella handelskammarens (ICC) regler.
Detta innebär att SLs miljöer inte får förekomma i sammanhang som gör reklam för tobak, alkoholhaltiga drycker, reklam som kan uppfattas som stötande, sedlighetssårande eller sårande mot folkgrupp, reklam riktad mot kollektivtrafiken och reklam som kan anses strida mot god marknadsföringssed.
Det är heller inte tillåtet att filma eller fotografera vandalisering eller graffiti, så kallad plankning, våld mot resenärer eller personal, rökning eller användande av illegala droger eller personer som vistas i SL-trafiken utan giltig biljett. Allmänt gäller att SL och SLs miljöer inte ska figurera i sammanhang som uppfattas som störande eller stötande."

Min tolkning av ovanstående är att för privat bruk är det i princip fritt fram att fotografera i tunnelbanan utan restriktioner, men för kommersiellt bruk är det inte tillåtet att fotografera till exempel polisövergrepp eller misshandel (då denna forumlering faller under rubriken "I kommersiellt syfte"). Om det inte skulle vara tillåtet (åtalbart) för en privatperson att dokumentera brott innebär det att bevisläget vid t.ex. polisövergrepp och andra misshandelsbrott kraftigt försämras till den drabbades nackdel.

Dessa villkor öppnar för många frågor beträffande vad lagen egentligen säger, och vilken rätt ett företag har att ställa upp egna villkor inom detta område. Intressant är också frågor kring relationen mellan SL och MTR. Vem äger SL? På SLs hemsida står att "Stockholms läns landsting äger aktiebolaget SL". Går skattemedel till att finsanisera verksamheten? (Ja via landstingsskatten.) Kan MTR som privat, ej landstingsägt företag utfärda sina egna villkor utan att SL (och ägaren landstinget) godkänner dessa?

Utvecklingen av rättsläget i Sverige känns inte lovande. Intrång i den personliga integriteten, lobbyingorganisationer som påverkar lagstiftningen på området, polisövergrepp, och andra tveksamma händelser ger en mörk bild av vart vårt samhälle är på väg. Jag är tacksam för att det än så länge finns ett fritt internet där fria människor kan rapportera, exponera och diskutera rättsläget i vår demokrati. Att en demokrati förblir en demokrati är inte alls självklart, vilket bland andra Naomi Wolf kan berätta om.

Book Review: "Beginning Android"

2010-02-11T12:36:00.000-08:00

Book Review: "Beginning Android"
Mark L. Murphy
Apress, 2009
ISBN: 978-1-4302-2419-8

I got a review copy of this book from Apress. Here is the review.

This is a book for programmers who have a basic knowledge of Java and want to get an introduction to the elements of Android programming. The book should be useful for both professionals and hobbyists. It is easy to read and well structured, and not too extensive, which makes it comprehensible. The 350 pages do a good job at covering a fair amount of the Android API. One area that is not covered is development tools, here the book refers to the Android web site (www.android.com). Setting up a development environment for Android can be tricky if you are new to programming, so this is an area where less experienced readers are left on their own.

The book covers Android 1.5, which is an old version by now. I however found the text and the code examples useful also for Android 2.1 development. The back inside cover mentions that there is a companion eBook available. An updated eBook would be of great added value, but it should be provided for free to customers who have purchased the book, not at additional cost as seems to currently be the case.

The style of writing is clear and the text is easy to read. The book is structured into several short chapters, where each chapter covers an aspect of Android development and the related parts of the API. Each chapter begins with an introduction that explains the topics covered in the chapter. Then follows a complete, runnable, and often short and concise code example that illustrates the chapter topic. This makes the book useful as a cookbook.

One not-so-nice aspect of the text is the use of supposedly funny section titles. I find titles like “Mother, May I”, “Halt! Who Goes There?”, ”When IPC Attacks!”, and “Seeing Pestering in Action”, to be quite irritating and distracting. The subject is interesting on its own merits, and the silly section titles actually make it harder to find what you are looking for in the book. There may, however, be readers who will find the titles entertaining. Another less good aspect of the book is the code style used, with no blanks between the parts of an expression. The first chapters use the correctly spaced Java-code style, but the majority of the chapters do not, and this is bad since it can establish bad coding practices among readers (especially beginners).

It is quite common for programming books to list classes and methods in the APIs covered, something which I find superfluous since the most current API documentation is available online. This book does not provide API listings, which is positive because it makes the text more coherent and flowing. It also saves pages, and makes room for more code examples and explanatory texts, which are added values compared to the online API documentation, and a reason for buying a book.

For me, the major value of the book has been as a cookbook of code examples. The examples in the book are often short, clear, useful, and on the spot on what you want to do.

Talk on Rosenmetoden in Stockholm

2010-02-09T21:48:00.000-08:00

This Saturday (Feb 13) there will be a talk and demo of Rosenmetoden in Stockholm: http://jeanette.nu/

I'm studying to become a Rosen Method practitioner, hence my interest in the subject. When I first met Marion Rosen, the physical therapist who has developed the method (and given it its name), I was quite taken. The first thing she said was, "Protection is not necessary". At that point it became clear to me that many problems and conflicts in the world, both on a personal and global level (they interrelate, people's actions shape the world), spring from our habits of protecting ourselves from people, emotions, and future misfortune (however unlikely to happen). I realized that my default attitude was that strangers can mean problems, better be on guard. And I think that attitude is draining you on energy.

Then I discovered the Rosen Method Movements, a truly lovely and relaxing way of moving. I'm completely hooked on it, and take classes every week now.

Read more at:
http://www.rosenmethod.org/
http://jeanette.nu/rosenmetoden.html (Swedish text)

Rosen Movement videos (with Theresa Garcia, a great instructor and teacher; Marion Rosen is also participating in the class, sitting on a chair):
http://www.youtube.com/watch?v=oKkBUfblww4
http://www.youtube.com/watch?v=jkZP1beeFHE
http://www.youtube.com/watch?v=H540bw1ERBU
http://www.youtube.com/watch?v=U108U3wVgyY

Twitter and refactoring (totally unrelated!)

2010-01-19T13:21:00.000-08:00

I am now on Twitter @divineprog - but don't expect frequent updates, I am not the Twitter type really ;-) But perhaps I will grow fond of it once I learn how to use the Twitter infrastructure.

A couple of days ago, when renaming a bunch of methods in Eclipse using the refactoring function, it struck me, why not make changing the name of something do an automatic refactoring by default? It seems reasoable that if I change the name of en existing object, I would like everyone using the name of that object to update their references, right? It would make sense to ditch source text files and go all the way and manage the source code in an presistent in-memory database (I guess Eclipse maintains some kind of database-like view of the source code). Smalltalk has of course had this since the 70:ies ;-)

Things that make me happy

2010-01-06T04:07:00.000-08:00

Seven true wonders of the world

Les Negresses Vertes

Jussi Marttinen Mikkeli playing Säkkijärven Polkka

Ukulele Orchestra of Great Britain

Identify 100 things that make me happy

Interactive development with Clojure

2009-12-29T13:28:00.000-08:00

Here is a very nice video demo that illustrates interactive servlet development with Clojure. Same thing could be done on Android using the techniques referred to in the previous post.

Clojure REPL on Android

2009-12-28T08:39:00.000-08:00

Found this thread where George Jahad explains how he implemented dynamic evaluation of Clojure on Android. Very cool how he dexed the dexer!

Interactive development and experimentation using a Read-Eval-Print-Loop is a great feature of dynamic languages. Really nice to see that Clojure attracts attention, it would be sad if Lisp would be forgotten. Lisp is one of the most productive languages I have ever worked with, and actually the first programming languages I was paid to program in.

Speaking of REPL, the way you can evaluate text in any window in Smalltalk is truly cool - just select an expression and "doit". I take this feature so for granted that I forget that this is not widely known outside the Smalltalk community. It would be nice to see a programming environment on Android that supports such a style of development, and RhinoDroid is one step on the way. I am working on a web based development tool for interactive programming on Android using JavaScript, hope to have that up and running soon.

Domain Specific Languages

2009-12-09T13:07:00.000-08:00

Today, I made a presentation on Domain Specific Languages at the MSC Office in Stockholm. The slides are here: http://www.comikit.se/dsl/dsl_talk_20091209/DSLSlides.html Press S to enter slide show mode, use N for next slide and P for previous slide. Or just scroll the document!

The presentation is written in a Python Slide Show DSL I made for the presentation, here is the source for the slides: http://www.comikit.se/dsl/dsl_talk_20091209/DSLSlides.py

The source code for the DSL is here: http://www.comikit.se/dsl/dsl_talk_20091209/SlideShow.py

My next DSL-related project is an interactive Game Development DSL in JavaScript for Android.

RhinoDroid - JavaScript for Android

2009-12-03T04:36:00.000-08:00

RhinoDroid is an experimental JavaScript app that runs on Android. The app contains a tiny HTTP server that accepts PUT requests with JavaScript as content. The app is based on the Mozilla Rhino Engine and the Android port by Brice Lambson.

Update: RhinoDroid is now called DroidScript. Get it at GitHub: http://github.com/divineprog/droidscript

Check ut the browser-based editor for DroidScript: http://droidscript.se

Interactive JavaScript on Android

2009-11-30T14:25:00.000-08:00

I now have working version of a remote JavaScript scripting app running on Android. The app runs a HTTP server that accepts incoming PUT requests with JavaScript code as content. The code is evaluated on the Android, and the result is sent back to the client. Also have a workspace in Squeak/Pharo that I use to evaluate JavaScript on the Android. It is kind of neat to be able to interactively create views, buttons and so on. Will demo this on the upcoming GTUG meeting in Stockholm on Thursday December 3.

JavaScript (Rhino) on Android

2009-11-20T15:02:00.000-08:00

Finally I have found a great dynamic language for writing Android apps - Rhino, a JavaScript implementation in Java. Rhino can run in interpreted mode, which makes it suitable for running on Dalvik (since on-the-fly byte code generation on Dalvik isn't implemented by dynamic languages, yet).

I used the work by Brice Lambson as a starting point. He has created a version of Rhino for the Android Scripting Environment (ASE). With the new release of the ASE you can now write scripts using JavaScript.

Since I want to write applications for Android in a dynamic language, I decided to experiment with embedding Rhino in an Android app. I created a new Android Java project, grabbed the Rhino jar-file from the ASE web site and dropped it in the libs directory. By browsing the documentation at the Rhino web site, it was quite straightforward to write a working demo.

Here is the code:

package miki.jsapp;

import android.app.Activity;
import android.os.Bundle;

import org.mozilla.javascript.*;

public class JSApp extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        doit(
             "var widgets = Packages.android.widget;\n" +
             "var view = new widgets.TextView(TheActivity);\n" +
             "TheActivity.setContentView(view);\n" +
             "var text = 'Hello Android!\\nThis is JavaScript in action!';\n" +
             "view.append(text);"
             );
    }

    void doit(String code)
    {
        // Create an execution environment.
        Context cx = Context.enter();

        // Turn compilation off.
        cx.setOptimizationLevel(-1);

        try
        {
            // Initialize a variable scope with bindnings for
            // standard objects (Object, Function, etc.)
            Scriptable scope = cx.initStandardObjects();

            // Set a global variable that holds the activity instance.
            ScriptableObject.putProperty(
                scope, "TheActivity", Context.javaToJS(this, scope));

            // Evaluate the script.
            cx.evaluateString(scope, code, "doit:", 1, null);
        }
        finally
        {
            Context.exit();
        }
    }
}

Various links

2009-11-05T07:56:00.000-08:00

Discussion of concurrency and message passing in Erlang and Clojure:
http://www.tbray.org/ongoing/When/200x/2009/10/26/Messaging

DSL links:
http://dsl09.blogspot.com/
http://lambda-the-ultimate.org/node/3601

Atomic install:
http://gbracha.blogspot.com/2009/10/atomic-install.html

Evaluate JRuby from Java:
http://jruby-embed.kenai.com/docs

Discussion of characteristics of dynamic languages:
http://lambda-the-ultimate.org/node/1012

PyConcordion - Writing Concordion tests in Python

2009-11-04T07:28:00.000-08:00

Concordion is an open source test framework that encourages writing tests in a specification driven style. A key aspect is that tests are integrated into the textual specification of the system. This makes it possible to write requirements and tests simultaneously, and from a maintainability point of view, it is a great advantage to have requirements and tests tightly integrated.

PyConcordion allows you to write tests in Python, rather than Java (a very nice feature from the perspective of this blog!).

Each PyConcordion test has two parts, and HTML-file and a Python file. Specifications and declarative definitions of the tests are written in HTML. The scripting parts of the test that connects to the system being tested and implements services for the declarative tests are written in Python. Note that the Python code can be written in a declarative DSL-driven fashion, see the discussion on this page. The principle is to write a specification of a scenario, rather than coding a test script.

To try out PyConcordion, I downloaded PyConcordion and made an example based on this tutorial.

The example defined a very simplictic bank account object, called Account. Here goes the HTML-part of the specification.

File: Account.html
<html xmlns:concordion="http://www.concordion.org/2007/concordion">
<body>

    <h1>Account</h1>

    <h2>Overview</h2>

    <p>The Account object supports the following operations:
        <ul>
            <li>Ask for the account balance</li>
            <li>Deposit an amount</li>
            <li>Withdraw an amount</li>
        </ul>
    </p>

    <h2>Examples</h2>

    <p>
        A new account object has a balance of
        <span concordion:assertEquals="getBalance()">0</span>.
    </p>

    <p>
        If I open a new account and deposit
        <span concordion:execute="deposit(#TEXT)">1200</span>,
        the balance is
        <span concordion:assertEquals="getBalance()">1200</span>.
    </p>

    <p>
        If I deposit another
        <span concordion:execute="deposit(#TEXT)">600</span>,
        the new balance is
        <span concordion:assertEquals="getBalance()">1800</span>.
    </p>

    <p>
        If I withdraw
        <span concordion:execute="withdraw(#TEXT)">100</span>,
        the balance is
        <span concordion:assertEquals="getBalance()">1700</span>.
    </p>

</body>
</html>

And here is the Python code that defined the Account class.

File: AccountTest.py
#! /usr/bin/python

class AccountTest:

    def __init__(self):
        self.balance = 0

    def getBalance(self):
        return str(self.balance)

    def deposit(self, amount):
        self.balance = self.balance + int(amount)

    def withdraw(self, amount):
        self.balance = self.balance - int(amount)

To run the test, go to the folder that contains these two files, and run the command:
concordion_folder_runner ./

There are straightforward instructions on the PyConcordion web site on how to install the system under Linux.

When writing Python methods, remember to use self rather than this, especially if you are new to Python, and come from languages like C++, C#, or Java rather than Python. (Actually you can name the self-parameter anything, as it is explictly declared, but the convention is to use self.)

Android development in Scheme - How to build Kawa for Android SDK 2.0

2009-11-01T10:27:00.000-08:00

If you are into languages like Lisp and Scheme, you will appreciate Kawa, a Scheme implementation written in Java. Thanks to the work of Per Bothner, Kawa is available for Android.

The following is a how-to for installing Kawa for Android SDK 2.0 and getting started to write Scheme programs for Android. The how-to is based on a blog entry by Per Bothner. Note that you need to install Android SDK 2.0 before you proceed.

First build Kawa:

1) Go to the directory where you want Kawa to be installed. On my machine, this is:
cd /home/miki/android

Then download the sources from the Kava svn-repository with the command:
svn -q checkout svn://sourceware.org/svn/kawa/trunk kawa

2) Configure and build Kawa for Android. Go to the kawa directory and run configure, then make. You need to supply the location of the android.jar file in the Android 2.0 SDK. On my machine, the command sequence is:
cd /home/miki/android/kawa
./configure --with-android=/home/miki/android/android-sdk-linux/platforms/android-2.0/android.jar --disable-xquery
make

Next, create a Scheme project:

3) We will start by creating a standard Android Java project, and then modify it.
This is how you create a project template:

android create project \
--target 1 \
--name HelloScheme \
--path /home/miki/android/projects/HelloScheme \
--activity HelloScheme \
--package miki.helloscheme

4) Now, we will modify the project so that it can compile Scheme files. First of all, delete the generated Java source file (I'm using the full path in these examples, for clarity):
rm /home/miki/android/projects/HelloScheme/src/miki/helloscheme/HelloScheme.java

Copy the Kawa jar-file to your project's lib-folder (this is where external libs are stored; alternatively you can create a soft link to the kawa-1.9.90.jar):
cp /home/miki/android/kawa/kawa-1.9.90.jar /home/miki/android/projects/HelloScheme/libs/kawa.jar

Then replace /home/miki/android/projects/HelloScheme/build.xml with this customised version of build.xml.

The project is now configured to build Scheme programs.

Finally, write the Scheme version of Hello World:

5) Open a text editor and create the file: /home/miki/android/projects/HelloScheme/src/miki/helloscheme/HelloScheme.scm

Enter the following code into the file:

(module-extends android.app.Activity)
(module-name miki.helloscheme.HelloScheme)
(define (onCreate (savedInstanceState :: android.os.Bundle)) :: void
   (invoke-special android.app.Activity (this) 'onCreate savedInstanceState)
   (let ((textview :: android.widget.TextView (make android.widget.TextView (this))))
     (textview:setText "Hello, Android from Kawa Scheme!")
     ((this):setContentView textview)))

There is a more compact version of this program on Per Bothner's blog, but I didn't get it to work at the time of writing this.

Build and install on the emulator with:
ant install

Note that eval does not seem to be supported yet. Hopefully the ability to dynamically compile to Dalvik bytecode will be included into Kawa in the future.

How to install Android SDK 2.0

2009-11-01T05:54:00.000-08:00

The following is the procedure I used to install the Android SDK 2.0. It applies to Mac OS X and Linux (in my case Ubuntu). Note that Java SDK 1.6 (1.5 should also work?) must to be installed, before installing the Android SDK.

First download the SDK (SDK = Software Development Kit):

1) Download the SDK for your platform at: http://developer.android.com/sdk/

2) Unzip the SDK and move it to the directory where you want it installed. On my Ubuntu machine, I installed it in my home folder:
/home/miki/android/android-sdk-linux/

3) Add the SDK tools directory to the path by adding the following line to .bashrc. On my machine, it is:
export PATH=${PATH}:/home/miki/android/android-sdk-linux/tools

Next download additional SDK components using the Android SDK and AVD Manager:

4) Open the terminal and start the Android SDK and AVD Manager with the command:
android

5) Now a window opens where you can configure the SDK and create virtual devices. I had to force the manager to use http: rather that https: by selecting "Force..." under Settings, to be able to download the SDK components.

6) Select and install SDK packages under Available Packages. I installed:

SDK Platform Android 2.0, API 5, revision 1
Google APIs by Google Inc., Android 2.0, API 5, revision 1

Then exit the Manager.

Now we need to create an AVD (AVD = Android Virtual Device):

7) I find this to be most convenient to do using the command line, rather than the Manager. This creates a virtual device called myavd:
android create avd -t 2 -n myavd

8) Start the device on the emulator with this command:
emulator -avd myavd &

Note that it takes a while for the device to boot (one minute or so). If successful you are presented with the Android desktop (or is it called phonetop? ;-).

Finally, create the Hello World application:

9) Create a template project with this command:
android create project \
--target 1 \
--name HelloWord \
--path /home/miki/android/projects/HelloWorld \
--activity HelloWorld \
--package miki.hello

The --target switch specifies the id of the target platform. This command lists available targets:
android list targets

The reason we specify target 2 for the virtual device and target 1 for the project is that we want to emulate the most advanced device, but we want the project to run on all devices (this is, at least, how I understand it).

10) The template project created actually is a compilable and runnable application.
Go to the project folder, in my case:
cd /home/miki/android/projects/HelloWorld

Then compile and install the application on the emulator with the command:
ant install

Switch to the emulator window, click the tab at the bottom of the screen, and then click on your application, called HelloWorld.

When you have recovered from the avesome experience of running your app, lets change the text it displays to something more appropriate.

Go back to your project, open the file res/layout/main.xml in a text editor, and change the content of the android:text attribute (this is the text shown in the window of the application), to something you feel you want to tell the world, for example:
android:text="Oh I wish I could program this is Scheme!"

That is it! Now you are ready to explore the world of Android development! Google's site http://developer.android.com has lots of useful information on the Java API, and there are already a number of other sites on the web devoted to Android development.

Taking the Red Pill

2009-10-31T07:05:00.000-07:00

http://www.prisonplanet.com/fall-of-the-republic-millions-of-people-worldwide-take-the-red-pill.html

Why Android will be a big hit

2009-10-30T02:45:00.001-07:00

The more I research the Android market and look into Android technologies, the more convinced I am that Android will be the next major computing platform. I view the situation as somewhat similar to 1984, when we had Mac and PC. Mac was a work of art, but a bit closed, and PC was open but rough, and MS-DOS and Windows 1.0 were primitive.

Today we have iPhone, exclusive and masterfully designed, but closed in several ways (much more closed than the Mac ever was). And we have Android, open and available for everyone, with lots of new devices on the way, in different formats and price categories. The big difference compared to 1984 is that Android is not MS-DOS. It is the complete opposite; carefully designed, fun, and open source. People who speculate when Linux will take over the desktop may now have the answer - Android Linux will take over the mobile device market.

Android will be the platform of choice, because it is open for developers. The SDK is free, and serveral new languages and tools are on their way. Simple is a Basic for the Android, developed by Google. The languge seems similar to Visual Basic, and this of course sucks, but I can see the logic here. There are many many Visual Basic programmers, and attracting them to Android is a smart move. There will likely be lots of apps developed, both in-house development at companies and hobby projects. To hobbyists, publising an application on Android Market, might be less of a hazzle compared to hosting and providing support for a web app. Plus, some apps and games a better implemeted as native programs.

Languages like Python, Lua and Perl are running on the Android Scripting Environment. This is a very promising and exiting opportunity for developing mini-applications using small script hacks. There are lots of other efforts going on to port popular languages to Android. Kawa Scheme seems to be a nice choise if you (like me) are fond of the Lisp-family of languages. Scala is also available on Android (some people say Scala is the next big language on the Java platform). Here is a tutorial. Another interesting initiative is App Inventor, a visual programming language for Android developed in Kawa Scheme.

Best of all, my collegue Göran Krampe is looking into porting the Smalltalk dialect Squeak to Android ;-)

My first Android project

2009-10-19T07:23:00.001-07:00

I have stared to develop on the Android and my the first project is now on GitHub:
http://github.com/mikaelkindborg/ComiCard

This is the starting point of what might become something similar to HyperCard. It would be really cool to have an easy-to-use autoring tool on Android. I hope Squeak will be ported to Android, then MagicWords would be easy to port.

Meanwhile I experiment with making Java-programming more enjoyable by exploring the design of an internal DSL based on declarative functional Lisp-like style.

PhoneGap

2009-10-06T12:28:00.001-07:00

Just found PhoneGap, a JavaScript library for programming Android and iPhone apps in JavaScript. Looks really cool! I'm working on a book about JavaScript game development for children and teenagers (and curious grown-ups!), and PhoneGap could be a good library to use for games on Android and iPhone.

Gwt Smalltalk and Clamato

2009-10-06T12:00:00.000-07:00

Gwt Smalltalk runs in the web browser and interacts with the Google Wave protocol. It is a great thing that Smalltalk is avaliable in the browser! Clamato is another Smalltalk that runs in a web browser. And here is an article that discusses languages that compile to JavaScript.

The Duct Tape Programmer

2009-09-30T01:55:00.000-07:00

Just read this article from Joel Spolsky.

Memorable quote:
"Duct tape programmers don’t give a shit what you think about them. They stick to simple basic and easy to use tools and use the extra brainpower that these tools leave them to write more useful features for their customers."

Scheme on Android

2009-09-30T01:30:00.000-07:00

Using Kawa you can author Android apps in Scheme. This looks promising:

(require 'android-defs)
(activity hello
 (on-create-view
  (let ((view (android.widget.TextView (this))))
    (view:setText "Hello World!")
    view)))

I found this example at Per Bothner's blog.

Ruby hash map arguments

2009-09-18T11:10:00.000-07:00

Ruby is a language with divine qualities, and why the lucky stiff has shown that Ruby programming is a beatiful art.

In Ruby you can pass a hash map to a method using a simplified syntax. The cool GUI-framework Shoes is an example of how this programming technique can be used.

Plain parameter passing

def foo(a, b)
 puts a, b
end

foo(1, 2)

Variable number of arguments
Here the arguments are passed as an array:

def foo(*args)
 puts args[0], args[1]
end

foo(1, 2)

A mix of the above

def foo(a, b, *args)
 puts a, b, args[0], args[1]
end

foo(1, 2, 3, 4)

Hash map arguments
A hash can be passed as parameter (this is somewhat similar to a variable length parameter list, note that the * is not used):

def foo(values)
 puts values[:a], values[:b]
end

foo(:a => 1, :b => 2)

This also works:

def foo(a, b, values)
 puts a, b, values[:a], values[:b]
end

foo(1, 2,  :a => 1, :b => 2)

However, this does NOT work (the hash map parameter must be the last one):

def foo(values, a, b)
 puts a, b, values[:a], values[:b]
end

But you can always pass the hash map as normal parameter using the proper syntax:

def foo(values, a, b)
 puts a, b, values[:a], values[:b]
end

foo({:a => 1, :b => 2}, 1, 2)

Also check out the remarkable book Nobody Knows Shoes by why the lucky stiff.

Tiny Erlang web server - parallel version

2009-09-16T14:09:00.000-07:00

Here is a version of the tiny web server that spawns a new process for each request. This is where Erlang shines. Processes are very lightweight and efficient in Erlang.

% Filename: mserver3.erl
% Tiny webserver that restarts on error.
% Requests are processed in parallel.
% Author: mikael.kindborg@gmail.com
% Date: September 2008

-module(mserver3).
-export([start/0, stop/0, supervisor/0, start_server/0, server/1, process_client_request/2]).

% How to benchmark:
% apache benchmark ab -n 100 -c 10 http://1.1.1.84:4042/hello.html

start() ->
   spawn(?MODULE, supervisor, []).
  
supervisor() ->
   io:format("Starting server.~n"),
   Pid = spawn(?MODULE, start_server, []),
   link(Pid),
   process_flag(trap_exit, true),
   receive
       {'EXIT', Pid, normal} ->
           io:format("Server exited normally.~n");
       {'EXIT', Pid, stopped} ->
           io:format("Server stopped.~n");
       {'EXIT', Pid, Reason} ->
           io:format("Server exited with code: ~w~n", [Reason]),
           timer:sleep(1000),
           supervisor();
       stop ->
           io:format("Stoppning supervisor.~n");
       Unknown ->
           io:format("Supervisor got an unknown message: ~w~n", [Unknown]),
           supervisor()
   end.

start_server() ->
   {ok, ServerSocket} = gen_tcp:listen(
       4042, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]),
   on_exit(
       self(),
       fun (Why) ->
           gen_tcp:close(ServerSocket),
           io:format("Exiting server, closing ServerSocket, Why = ~w~n", [Why])
       end),
   server(ServerSocket).

stop() ->
   ServerAddress = "localhost",
   {ok, Socket} = gen_tcp:connect(ServerAddress, 4042, [binary, {packet, 0}]),
   ok = gen_tcp:send(Socket, <<"stop">>),
   ok = gen_tcp:close(Socket).

server(ServerSocket) ->
   {ok, Socket} = gen_tcp:accept(ServerSocket),
   spawn(?MODULE, process_client_request, [Socket, self()]),
   server(ServerSocket).

process_client_request(Socket, ServerPid) ->
   on_exit(
       self(),
       fun (Why) ->
           gen_tcp:close(Socket)
           % io:format("Exiting client request process, closing Socket, Why = ~w~n", [Why])
       end),
   {ok, BinaryData} = gen_tcp:recv(Socket, 0),   
   case BinaryData of
       <<"stop">> ->
           exit(ServerPid, stopped),
           io:format("Server stopped~n"),
           ok;
       <<"GET /stop", _/binary>> ->
           ok = gen_tcp:send(Socket, http_reply("Server stopped")),
           exit(ServerPid, stopped),
           io:format("Server stopped~n"),
           ok;
       <<"GET /echo", _/binary>> ->
           ok = gen_tcp:send(
               Socket,
               http_reply(binary_to_list(BinaryData)));
       <<"GET /", Request/binary>> ->
           ok = gen_tcp:send(
               Socket,
               http_reply(
                   readfile(
                       parse_filename(Request))));
       _Unknown ->
           ok = gen_tcp:send(Socket, http_reply("Unknown request")),
           io:format("Unknown request, BinaryData = ~s~n", [BinaryData])
   end.

parse_filename(Request) ->
   RequestString = binary_to_list(Request),
   StopIndex = string:str(RequestString, " HTTP"),
   Filename = string:substr(RequestString, 1, StopIndex-1),
   Filename.
  
readfile(Filename) ->
       {ok, Binary} = file:read_file(Filename),
       binary_to_list(Binary).

http_reply(Data) ->
   DataLength = string:len(Data),
   list_to_binary(
       "HTTP/1.1 200 OK\r\n" ++
       "Date: " ++ mdate:date_now_string() ++ "\r\n" ++
       "Server: MServer/0.1\r\n" ++
       "Last-Modified: " ++ mdate:date_now_string() ++ "\r\n" ++
       % Accept-Ranges: bytes
       "Content-Length: " ++ integer_to_list(DataLength) ++ "\r\n" ++
       "Connection: close\r\n" ++
       "Content-Type: text/html; charset=UTF-8\r\n\r\n" ++
       Data).

% Create an exit handler, a process that traps exit messages
% from another process. This can be used for a try/catch style
% error handling between processes.   
on_exit(Pid, ExitFun) ->
   spawn(
       fun() ->
           process_flag(trap_exit, true),
           link(Pid),
           receive
               {'EXIT', Pid, Why} -> ExitFun(Why)
           end
       end
   ).

Tiny Erlang web server - sequential version

2009-09-16T13:59:00.000-07:00

This is a tiny web server written in Erlang. Requests are processed sequentially.

% Filename: mserver2.erl
% Tiny webserver that restarts on error.
% Requests are processed sequentially.
% Author: mikael.kindborg@gmail.com
% Date: September 2008

-module(mserver2).
-export([start/0, stop/0, supervisor/0, start_server/0, server/1]).

% How to benchmark:
% apache benchmark ab -n 100 -c 10 http://1.1.1.84:4042/hello.html

start() ->
   spawn(?MODULE, supervisor, []).
  
supervisor() ->
   io:format("Starting server.~n"),
   Pid = spawn(?MODULE, start_server, []),
   link(Pid),
   process_flag(trap_exit, true),
   receive
       {'EXIT', Pid, normal} ->
           io:format("Server exited normally.~n"),
           timer:sleep(1000);
       {'EXIT', Pid, Reason} ->
           io:format("Server exited with code: ~w~n", [Reason]),
           timer:sleep(1000),
           supervisor();
       stop ->
           io:format("Stoppning supervisor.~n");
       Unknown ->
           io:format("Supervisor got an unknown message: ~w~n", [Unknown]),
           supervisor()
   end.

start_server() ->
   {ok, ServerSocket} = gen_tcp:listen(
       4042, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]),
   on_exit(
       self(),
       fun (Why) ->
           gen_tcp:close(ServerSocket),
           io:format("Exiting server, closing ServerSocket, Why = ~w~n", [Why])
       end),
   server(ServerSocket).

stop() ->
   ServerAddress = "localhost",
   {ok, Socket} = gen_tcp:connect(ServerAddress, 4042, [binary, {packet, 0}]),
   ok = gen_tcp:send(Socket, <<"stop">>),
   ok = gen_tcp:close(Socket).

server(ServerSocket) ->
   {ok, Socket} = gen_tcp:accept(ServerSocket),
   {ok, BinaryData} = gen_tcp:recv(Socket, 0),   
   case BinaryData of
       <<"stop">> ->
           ok = gen_tcp:close(Socket),
           io:format("Server stopped~n"),
           ok;
       <<"GET /stop", _/binary>> ->
           ok = gen_tcp:send(Socket, http_reply("Server stopped")),
           ok = gen_tcp:close(Socket),
           io:format("Server stopped~n"),
           ok;
       <<"GET /echo", _/binary>> ->
           ok = gen_tcp:send(
               Socket,
               http_reply(binary_to_list(BinaryData))),
           ok = gen_tcp:close(Socket),
           server(ServerSocket);
       <<"GET /", Request/binary>> ->
           ok = gen_tcp:send(
               Socket,
               http_reply(
                   readfile(
                       parse_filename(Request)))),
           ok = gen_tcp:close(Socket),
           server(ServerSocket);
       _Unknown ->
           ok = gen_tcp:send(Socket, http_reply("Unknown request")),
           ok = gen_tcp:close(Socket),
           io:format("BinaryData = ~s~n", [BinaryData]),
           server(ServerSocket)
   end.

parse_filename(Request) ->
   RequestString = binary_to_list(Request),
   StopIndex = string:str(RequestString, " HTTP"),
   Filename = string:substr(RequestString, 1, StopIndex-1),
   Filename.
  
readfile(Filename) ->
       {ok, Binary} = file:read_file(Filename),
       binary_to_list(Binary).

http_reply(Data) ->
   DataLength = string:len(Data),
   list_to_binary(
       "HTTP/1.1 200 OK\r\n" ++
       "Date: " ++ mdate:date_now_string() ++ "\r\n" ++
       "Server: MServer/0.1\r\n" ++
       "Last-Modified: " ++ mdate:date_now_string() ++ "\r\n" ++
       % Accept-Ranges: bytes
       "Content-Length: " ++ integer_to_list(DataLength) ++ "\r\n" ++
       "Connection: close\r\n" ++
       "Content-Type: text/html; charset=UTF-8\r\n\r\n" ++
       Data).

% Create an exit handler, a process that traps exit messages
% from another process. This can be used for a try/catch style
% error handling between processes.   
on_exit(Pid, ExitFun) ->
   spawn(
       fun() ->
           process_flag(trap_exit, true),
           link(Pid),
           receive
               {'EXIT', Pid, Why} -> ExitFun(Why)
           end
       end
   ).

Scheme and App Inventor for Android

2009-09-16T07:04:00.000-07:00

Just came across this blog entry detaling the use of Scheme for an easy-to-use Android programming tool.

Dynamic Languages

2009-09-16T06:57:00.000-07:00

This blog is about dynamic programming languages. Classic lanugages like Lisp, Scheme, and Smalltalk indeed have a divine touch, and more recent languages such as Erlang, Python, and Ruby also have a distinctive beauty and dynamism that feels enlightning.