Ernest Micklei's Blog

MCP Server

Fri, 09 May 2025 19:53:58 +0100

melrose-mcp is a tool that uses the MCP protocol to receive melrōse expressions to play. You install this tool locally on your machine and connect it from an MCP client such as Claude Desktop, Goose, VSC etc.

example

Prompt:

play a tune from Claude Debussy

AI:

I'll create a small segment inspired by Claude Debussy's impressionist style using the Melrose language.

MCP server:

{
    `expression`: `sequence('(F4 A4 D5) 4(F4 A4 D5) (G4 B4 E5) 4(G4 B4 E5) (A4 C5 F5) 4(A4 C5 F5) (G4 B4 E5) 4(G4 B4 E5) (F4 A4 D5) 8= 8(E4 G4 C5) 4(F4 A4 D5)')`
}

See melrose-mcp for details how to install and use it.

Introducing 'map'

Tue, 10 Sep 2024 09:58:42 +0200

The function map is used to create a composition by applying a transformation on each sequence in a collection.

a1 = sequence('G_3 D_ G_ A D_5 G_5')
a2 = sequence('D_3 A_3 D_ E A_ D_5')
a3 = sequence('E3 B3 E A_ B E5 ')
a4 = sequence('B2 G_3 B3 E_ G_ B')

c = map( join(a1,a3,a4,a2), fraction(8,resequence('1 4 2 4 3 6 5 4', _ )) )
loop(c)

line 1..4

Four sequences are created that play a nice combination of arpeggios.

More Drum Patterns

Fri, 26 Nov 2021 16:53:58 +0100

Using the notemap function with dots . and bangs ! you can write a pattern for an instrument. In this example, multiple instruments are choosen from the General MIDI set. The note C2 is typically assigned to a Kick drum. The loop plays the 16 beats in a bar and for each bang ! it will shortly (16th) play the note. You can start and stop each loop individually.

Once you have a MIDI capable sound program (such as a DAW) opened then tryout this example with the online Melrōse Playground yourself.

Drum Pattern

Sat, 06 Mar 2021 16:53:58 +0100

This script is an example that uses the Melrōse language to create your own drum beats. Line by line, I will explain how it is composed.

bpm(85)

// https://usermanuals.finalemusic.com/SongWriter2012Win/Content/PercussionMaps.htm

open = midi(16,46,60)
close = midi(16,42,60)
clap = midi(16,39,60)
kick = midi(16,36,80)

d1 = notemap(' 3 10 11',open)
d2 = notemap('4 12',close)
d3 = notemap('5 13',clap)
d4 = notemap('1 2 4 7 9 10 12 15',kick)
d5 = notemap('16',note('16=')) // 1/16 rest at the end to make 16 notes in the set
set = merge(d1,d2,d3,d4,d5)
lp_set = loop(channel(10, set)) // channel 10 is the general midi for a drumkit

🎶 Play

Iterating over patterns

Fri, 05 Mar 2021 17:28:49 +0100

bpm(90)
s = sequence('c e g b')
i = iterator(
    '(1 2) (3 4)',
    '(1 3) (2 4)', 
    '1 (2 3) 4', 
    '(1 4) (2 3)')
m = resequence(i,s)
l = loop(m,next(i))

🎶 Play

Using resequence you can compose a new sequence with index-based entries. The first compostion played by the loop is (C E) (G B).

DAW - Apple Logic Pro X

Wed, 06 May 2020 16:53:58 +0100

Logic Pro is a product of Apple Inc.

Goal

Logic Pro is a professional Digital Audio Workstation (DAW) available for Apple Mac OSX. Melrōse can communicate with Logic Pro by sending MIDI messages. Logic Pro has a rich set of sounds and instruments to play MIDI notes. In addition, Logic Pro is able to play multiple MIDI channels simultaneously which can be programmed individualy by melrōse.

This article describes the steps to get Melrōse working with Logic Pro such that you can play your melody per-channel.

DAW - Apple Garageband

Fri, 06 Mar 2020 16:53:58 +0100

GarageBand is a registered trademark of Apple Inc.

Goal

Garageband is a simple Digital Audio Workstation (DAW) that comes with the standard installation of Apple Mac OSX on devices such as MacBook or MacPro. Melrōse can communicate with GarageaBand by exchanging MIDI messages. GarageBand has a rich set of sounds and instruments to play MIDI notes.

This article describes the steps to get Melrōse working with GarageBand such that you can play your melodies.

protocheck: Lightweight Protobuf Validation in Go

Mon, 22 Dec 2025 21:23:11 +0300

For Go developers working with Protocol Buffers, ensuring data integrity is crucial. While Protobufs guarantee type safety, they don’t enforce semantic rules out of the box. This is where protocheck comes in, a lightweight and powerful tool for adding validation logic to your Protobuf messages.

This blog post will explore the design choices behind protocheck, focusing on its simplicity of declaration and code generation. We’ll also compare it to bufbuild/protovalidate to help you choose the right tool for your project.

The Growing Developer

Mon, 29 Jul 2024 17:28:00 +0200

Why you want this and how to become one

10-15 minutes read

This article is part of a series that began with The Replaceable Developer. That article examines how developers can prevent their current work from hindering their professional growth.

TL;DR

Growing your skills will open doors to new challenging opportunities, which in turn can lead to making a bigger impact and, with promotions, a higher salary. The TEC model is a structured approach for achieving this. Increase your theoretical knowledge, gain more diverse experience and communicate about it, both written and verbal. Pick a new and exciting technology, apply it to some small (pet) project and share your findings with your fellow developers. Repeat this.

AI, please explain this code base

Sat, 20 Jul 2024 19:28:12 +0200

Can AI tell me what design is implemented ?

Recently, I wanted to contribute to some open-source Go packages that I use. Some of them have a large codebase with lots of subpackages. Despite the carefully chosen names for this these packages, without an overview and design description, it will require quite some time reading sources and debugging tests before a mental model is created. Without such an understanding, contributing to that open-source project is likely to fail.

The Replaceable Developer

Wed, 18 May 2022 16:28:12 +0700

Why you want this and how to become one

TL;DR

Once you are replaceable, you are free to start new initiatives, explore new technologies, solve the next complex problem which will make you happy and interested to stay at your job. Your organisation has a lower risk of discontinuity and can benefit more from your expertise. To be a replaceable developer, you need to

deal with all the relevant unshared software that you have created in solitude;
document knowledge about relevant processes.

Photo: https://www.pexels.com/@jan-van-der-wolf-11680885/

Challenge

Over the years, as a developer as part of an organisation, you will work on many different software projects, learn a lot about the business and processes and will have created many software artefacts (packages, libraries, applications, services, architectures, infrastructure, …).

Melrōse, a language to program and play music

Sun, 21 Nov 2021 14:43:07 +0100

TL;DR

Melrōse is both a language and a tool to create and listen to music interactively, The language uses musical primitives (note, sequence, chord) and many functions (map, group, transpose) that can be used to create more complex patterns, loops and tracks. Melrōse uses MIDI output to produce sound by any (hard or software) device attached. Melrōse can also react on MIDI inputs to start, record and stop playing musical objects. A plugin is available for Microsoft Visual Studio for the best usage experience. For a quickstart, without any installation, you can use the Melrōse playground.

Drum patterns

Tue, 12 May 2020 19:37:44 +0200

After watching Play With Your Rythm: Drum Patterns, I was inspired to program some of these patterns in Melrōse.

Introducing gmig, infrastructure as code for GCP

Wed, 21 Mar 2018 08:10:49 +0100

Infrastructure automation

The Google Cloud Platform (GCP) can provide the IT infrastructure you need to run your own applications or services. In addition, the platform also provides many products and services that can be used to build your complete IT landscape. Setting up infrastructure no longer includes provisioning hardware, patching operating systems and cable wiring up network components.

Instead, you now manage resources such as virtual machines, accounts, datastore, networks, enable APIs and setting permissions. Basically, given a GCP project, you can have full control of managing such resources using either the Console, the gcloud tool or even program against their published API using a Google supported library.

GCP Next 2016 Demo

Sun, 10 Apr 2016 21:29:49 +0100

On March 23, Q42 and Google Amsterdam organized an event to watch the keynote from the GCP Next 2016 conference held in San Fransico.

As the Ubanita platform is hosted on the Google Cloud Platform, we were given the opportunity by Q42 to talk about our platform as part of a lightning talk. Ofourse, we had prepared a demo game and the audience was invited to join a simple multiplayer game.

Schedule a Message

Tue, 01 Mar 2016 11:28:10 +0100

Updates a linked list of future calls to send a message.

Ring Painter

Sat, 27 Feb 2016 08:18:47 +0100

Algorithm for drawing a 2D ring shape using OpenGL bindings in Go (from the firespark project).

Android Animated Chain

Fri, 26 Feb 2016 08:59:56 +0100

Hiding complexity of Android animators when chaining dependencies.

Thanks to our guest software artist: [Jamie Craane](http://jcraane.blogspot.nl/)

JSONPath

Thu, 25 Feb 2016 21:13:05 +0100

Implementation of an XPath-like function for JSON documents to test REST api’s using forest.

Blocky

Wed, 24 Feb 2016 08:31:47 +1200

A solution to a level of Blocky Games Maze.

Ring Benchmark Erlang

Tue, 23 Feb 2016 08:31:47 +1200

A solution to an exercise from Programming Erlang which I explained here

2016 - together, we celebrate

Fri, 01 Jan 2016 21:29:49 +0100

This short (2 min) video was created using a simple interactive Ubanita script that translated touch events into Triangle generation. See below the interesting part of that program.

For each touchMove event, a random colored Triangle sprite is added. For each touchEnd event, such Triangles are created with a outwards radial velocity.

// touchMove is called when the game detects a movement in a touch
function touchMove(event) {
        var dus = {};
        dust.x = event.data.x;
        dust.y = event.data.y;
        dust.fill = randomColor();
        dust.radius = 12;
        dust.vx = _.random(-20, 20);
        dust.vy = _.random(-20, 20);
        _addTriangle(0, dust)
    }
    // when a player moves a (single) touch then call this function
_on("touchMove", touchMove);

// touchEnd is called when the game no longer detects a touch
function touchEnd(event) {
    var dus = {};
    dust.fill = randomColor();
    dust.radius = 4;
    for (var e = 0; e < 360; e += 5) {
        var rad = Math.PI * e / 180.0
        var cx = Math.cos(rad)
        var cy = Math.sin(rad)

        dust.x = event.data.x + (5 * cx);
        dust.y = event.data.y + (5 * cy);

        dust.vx = 200 * cx
        dust.vy = 200 * cy
        _addTriangle(0, dust)
    }
}

Kimtato, a simple physics playground

Wed, 18 Nov 2015 21:30:45 +0100

Kimtato is the name of a simple interactive demo that runs on the Ubanita platform. It is a playground of physical objects which are created by players using touch gestures on the controller. Once created, the objects can be pushed around using the two-finger gesture, we call edge input mode.

The following will discuss the making of this demo using the Ubanita Script API.

get dimensions

To position objects on the 2D scene, it can be useful to known the actual dimensions of that scene. The scene has two properties for the width (pixels) and height respectively. Using this snippet, we assign those property values to global variables W and H.

Testing your REST api in Go with forest

Sat, 04 Jul 2015 13:28:12 +0700

Go package forest was created to simplify the code needed to write real tests of a REST api. Such tests need to setup Http Requests, send them and inspect Http Responses. The Go standard library has all that is needed to achieve this flow but the required amount of code, especially the error handling, makes tests harder to read and longer to write.

Testing github

Let's create a few tests that examine the response of the public github API call.


package main

import (
	"net/http"
	"testing"

	. "github.com/emicklei/forest"
)

var github = NewClient("https://api.github.com", new(http.Client))

func TestForestProjectExists(t *testing.T) {
	cfg := NewConfig("/repos/emicklei/{repo}", "forest").Header("Accept", "application/json")
	r := github.GET(t, cfg)
	ExpectStatus(t, r, 200)
}

The package variable github (line 10) is a forest Http client wrapper and provides the api to send Http requests (such as GET). On line 13, the cfg variable is a RequestConfig value that is used to build a http.Request with method,url,headers,body. The variable r is a *http.Response. The ExpectStatus function checks the status code. If the code does not match, then the following will be reported.

Artreyu, an artifact assembly tool

Tue, 23 Jun 2015 14:55:18 +0600

Artreyu is an open-source command line tool for software build pipelines that need to create artifacts which are composed of multiple versioned build parts. The design of this tool is inspired by the Apache Maven project which provides assembly support for Java projects. I created Artreyu to support a project that delivers compositions of many non-Java artifacts of which some are operating system dependent.

Artreyu works with a repository to archive, fetch and assemble artifacts. To support remote repositories such as Artifactory and Nexus, Artreyu has a simple plugin architecture ; each plugin is just a binary that gets invoked by the artreyu tool. Sources for the nexus plugin is on github.com/emicklei/artreyu-nexus.

Line scanning in Go

Tue, 10 Feb 2015 15:34:07 +0200

Today, I needed to keep track of the linenumber while scanning table driven tests. The standard Go bufio.Scanner does not provide such information. Fortunately, in Go you can create your own by embedding the standard type and overriding the right function. That’s it.

import (
	"bufio"
	"io"
)

type linescanner struct {
	*bufio.Scanner
	line int
}

func newScanner(reader io.Reader) *linescanner {
	return &linescanner{bufio.NewScanner(reader), 0}
}

func (l *linescanner) Scan() bool {
	ok := l.Scanner.Scan()
	if ok {
		l.line++
	}
	return ok
}

Guava-like EventBus for Go

Thu, 13 Nov 2014 10:06:45 +1100

I needed a simple solution to notify components about changes in some global settings. In my Java days, I have been using the Guava Eventbus to solve similar problems, so I decided to cook something that does the basics.

From Guava: “The EventBus allows publish-subscribe-style communication between components requiring the components to explicitly register with one another (and thus be aware of each other).”

The Java implementation uses annotations to register components and subscribe its methods to event types. In my Go version, with lack of such annotations, I decided to keep it simpler; just subscribe a function to an event by name. The singleton EventBus value will be an exposed package variable.

Smalltalk collect on Go slice of int

Sat, 07 Jun 2014 20:39:35 +0600

package main

import "fmt"

type intSlice []int

func (i intSlice) collect(block func(i int) int) intSlice {
	r := make(intSlice, len(i))
	for j, v := range i {
		r[j] = block(v)
	}
	return r
}

func main() {
	numbers := intSlice{1, 2, 3}
	squared := func(i int) int { return i * i }

	fmt.Printf("%v", numbers.collect(squared))
}

Try it.

Implementations of select,inject,detect are left as an excercise for the reader.

Javascript CLI in Go using Otto

Wed, 12 Feb 2014 11:52:21 +0200

Today, I was playing with Otto and hacked together a small command-line-interface program in Go.

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"

	"github.com/robertkrimen/otto"
)

var Otto = otto.New()

func main() {
	fmt.Println("otto\n")
	loop()
}

func dispatch(entry string) string {
	if len(entry) == 0 {
		return entry
	}
	value, err := Otto.Run(entry)
	if err != nil {
		return err.Error()
	} else {
		return fmt.Sprintf("%v", value)
	}
}

func loop() {
	for {
		fmt.Print("> ")
		in := bufio.NewReader(os.Stdin)
		entered, err := in.ReadString('\n')
		if err != nil {
			fmt.Println(err)
			break
		}
		entry := strings.TrimLeft(entered[:len(entered)-1], "\t ") // without tabs,spaces and newline
		output := dispatch(entry)
		if len(output) > 0 {
			fmt.Println(output)
		}
	}
}

One cool feature of Otto is the ability to expose your own Go functions in the Javascript namespace. This example below adds the function log to print its arguments using the standard log package.

From multiple to single-value context in Go

Mon, 25 Nov 2013 22:42:53 +1100

These are the results of exploring one aspect of the Go language; functions can return multiple values. Consider the following simple function:

func ab() (a,b int) {
	a,b = 1,2
	return
}

Clearly, this function cannot be used in other function calls that expect a single value.

fmt.Printf("%v\n",ab())

The compiler will help you: “multiple-value ab() in single-value context”.

Now suppose you want to take only the first value without introducing an intermediate variable. One possible solution might be to create this helper function:

A case of sizing and draining buffered Go channels

Thu, 10 Oct 2013 09:08:38 +1000

Update: Based on several comments posted on the Google+ Go community, I rewrote the solution presented here. See past the Conclusion section.

Recently, I was asked to write a small program for collecting product promotion information for a large collection of products. Given an input file of product identifiers, the following tasks had to be done:

read all identifiers from an input file
for each identifier, fetch product offer information in XML
parse the offer XML into in a DOM document
extract all promotions from the offer document
for each promotion, export its data into a CSV record

A straightforward implementation is to write a function for each task and call them in a nested loop. For this program, I created functions such that the basic flow is quite simple.

Hopwatch - a debugging tool for Go

Fri, 14 Dec 2012 19:54:46 +1200

Hopwatch is an experimental tool that can help debugging Go programs. Unlike most debuggers, hopwatch requires you to insert function calls at points of interest in your program. At these program locations, you can tell Hopwatch to display variable values and suspend the program (or goroutine). Hopwatch uses Websockets to exchange commands between your program and the debugger running in a HTML5 page.

Using Hopwatch

Basically, there are two functions Display and Break. Calling Display will print the variable,value pairs in the debugger page. Calling Break will suspend the program until you tell the debugger to Resume. The Display function takes one or more pairs of (variable name,value). The Break function takes one or more boolean values to be conditionally. Below is a test example.


	package main

	import "github.com/emicklei/hopwatch"

	func main() {
		for i := 0; i &lt; 6; i++ {
			hopwatch.Display("i",i)
			j := i * i
			hopwatch.Display("i",i, "j", j ).Break(j &gt; 10)
			hopwatch.Break()
		}
	}

Starting your Go program that includes a Hopwatch function call waits for a connection to the debugger page. You can disable Hopwatch by passing the command line parameters -hopwatch false.

Methods as objects in Go

Mon, 26 Nov 2012 12:18:09 +1100

In an earlier post, I discussed an example of using plain functions as objects. Today, I investigated solutions for using Methods as objects. As I understand it, Go methods are functions that are “bound” to a named type that is not a pointer or an interface.


	package main

	import "fmt"

	type T struct {
		S string
	}

	func (t T) GetS1() string {
		return t.S
	}

	func (t *T) GetS2() string {
		return t.S
	}

	func main() {
		t := T{"hello"}
		f := (*T).GetS1
		g := (T).GetS1
		h := (*T).GetS2
		// i := (T).GetS2   // invalid method expression T.GetS2 (needs pointer receiver: (*T).GetS2)
		fmt.Printf("%v, %v %v, who is there?", f(&t) ,g(t), h(&t))
	}

Run it yourself.

go-restful first working example

Sat, 24 Nov 2012 20:13:06 +1100

In a previous post, I discussed the design of go-restful which is a package for building REST-style WebServices using the Google Go programming language.

Today, I completed the implementation of that package which provides the basics:

Creating a WebService with Routes (mapping between Http Request and a Go function)
Each Route requires information about the Http method (GET,POST,...), URL Path (/users..), Mime-types and the function it binds to
Functions get passed in a Request and a Response
The Request is used to access Path and Query parameters , Headers and request content (XML, JSON,...)
The Response is used to set Status, Headers, and response content
Both Request and Response can Unmarshal and Marshal objects to and from XML,JSON using the standard packages

All of this can best be illustrated with a small example ; a Webservice for CRUD operations on User objects. We start by creating the file userservice.go inside its own folder userservice.


	package userservice

	import (
		"github.com/emicklei/go-restful"
		"log"
	)

	type User struct {
		Id, Name string
	}

Type User represents our domain object.

First class functions in Go

Tue, 13 Nov 2012 20:49:18 +1100

Today, I played with functions as objects in the Go programming language. If functions are first class citizens in Go then it must be possible to store them in fields of a struct, pass them as arguments to other functions and use them as return values of other functions.

So I visited play.golang.org for putting together a simple program that demonstrates this.


	package main

	import "fmt"

	func CallWith(f func(string), who string) {
		f(who)
	}

	type FunctionHolder struct {
		Function func(string)
	}

	func main() {
		holder := FunctionHolder{ func(who string) { fmt.Println("Hello,", who) }}
		CallWith(holder.Function,"ernest")
	}

The CallWith function takes a one string parameter function f and a string parameter who. The body of the CallWith function evaluates the function parameter with the string parameter.
The FunctionHolder is a struct type with a field called Function which must be a function with a string parameter.
In the main function, a FunctionHolder is created initializing the Function field with a function that prints an Hello message.
Next in the main function, the CallWith function is called with the Function value of the holder and a string value.

On play.golang.org can run this program yourself

go-restful api design

Sun, 11 Nov 2012 21:18:54 +1100

I have been using JAX-RS for many REST-based service implementations in Java.

As part of my journey into the Google Go programming language, I am exploring designs for such REST support using the standard net/http package in Go.

JAX-RS provides a set of Annotation classes which can be used to add meta-data to classes, methods and method arguments. In JAX-RS these annotation are used to specify the mapping between a Http Request to a Java method and its arguments.

renderShark - lean application server for renderSnake

Sun, 26 Aug 2012 19:43:18 +0800

I started working on this “yet-another-web-server” project for one of the most important reasons: because its fun. I got inspired for doing this after reading about the Netty framework and all the positive reviews that people write.

My requirements for this server are

provide a minimal MVC framework that uses renderSnake to render HTML pages
(distributed) Http session management using JBOSS Infinispan, a modern caching solution
use Netty , a well-designed fast server framework which I will use for its HTTP support
components are wired together using Guice, a lean dependency injection library
support for a minimal feature set to run Web applications
- GET, POST
- Redirects,Forwards
- Sessions, Cookies
- Error Handling (404,500,...)
Logging using SLF4j
Basic static content serving

To "eat my own dogfood", I re-implemented the renderSnake website (which is just a Java application) using the renderShark engine.

The project is hosted on googlecode. Have a look at the example project that demonstrates all the features.

6hoek.com, a showcase for renderSnake

Tue, 23 Aug 2011 20:14:48 +0800

For the past month, I have been working on a new iPad Web application that recently was launched at 6hoek.com. This application provides easy access to the complete product catalog of the Dutch online webshop bol.com.

Because it is targeted to owners of tablet devices such as the Apple iPad, I decided to embrace the upcoming JQuery Mobile framework (JQM), an open-source Javascript library that provides an unified UI to various mobile devices. For producing the HTML markup, I (obviously) choose renderSnake, an open-source HTML component library that promotes writing UI components in Java instead of templates.

Getting from HTML design to renderSnake components

Thu, 03 Mar 2011 21:22:33 +0300

rendersnake is a Java library for creating components and pages that produce HTML using only Java. Its purpose is to support the creation of Web applications that are better maintainable, allows for easier reuse, have testable UI components and produces compact HTML in an efficient way.

This blog post explains how to start from a carefully designed rich HTML page and create new or use the components available in the library.

Using renderSnake to build the presentation layer in Spring-MVC

Sun, 13 Feb 2011 18:57:58 +0200

renderSnake is a open-source library for creating components that produce HTML using only Java. By defining Java classes for HTML components and pages you can exploit all the language features (e.g. inheritance, composition, type-checking) and IDE tooling (e.g. refactoring, unit-testing, references search, debugging,…). In addition, renderSnake is designed to produce compact HTML in an memory efficient way.

The "V" in MVC

Basically, renderSnake is responsible for the presentation layer of a Web application. It has no dependencies with an application framework but it does provide classes to integrate with other technologies such as JavaServer Pages and Spring-MVC. Spring-MVC is a popular implementation of the MVC architecture. This pattern isolates "domain logic" (the application logic for the user) from the user interface (input and presentation), permitting independent development, testing and maintenance of each (separation of concerns).

Example

Below is an example of a Spring-MVC based setup of components. ProductListController is a component that is responsible to handling incoming requests. That execution starts by retrieving the Product objects (Model) through a Product Data Access Object. Then a ProductListPage object is created and asked to render itself. Each UI component that is part of the ProductListPage is asked to do the same. The response will have the resulting HTML content.

missing image /2011/02/spring-mvc-rendersnake.png

Controller

The method below is part of the ProductListController and is called with a prepared HtmlCanvas object that captures the request,response and output writer. Before rendering the page using the HtmlCanvas, all required domain objects are retrieved and made available to the PageContext (Map) of the HtmlCanvas object. Now the HtmlCanvas has all the information needed to perform the rendering phase.

@RequestMapping("/productlist.html")
@ResponseBody
public void showProductListPage(HtmlCanvas html) throws IOException {

        html.getPageContext().set("products", this.productListDao.getBestSellersProductList());
        html.render(new WebshopLayoutWrapper(new ProductListPage())));
}

View

Using renderSnake, the View layer is implemented by a collection of small, potentially reusable, UI component classes that are composed into Page objects that represent HTML content.

Class Head is an example UI component responsible for rendering the head section of every HTML page. It implements the Renderable interface and uses the HtmlCanvas parameter object for rendering. The HtmlCanvas object has methods of all elements (tags) in order to write HTML content. Using the HtmlAttributesFactory, you can specify the attributes for each HTML tag. By convention, the method source has a format that uses indentation to see the nesting of tags. This is not required but improves its readability.

Soek.goodies.st improved

Wed, 29 Sep 2010 08:25:47 +0900

The site soek.goodies.st gives access to the sources of open-source Smalltalk libraries and frameworks. A big advantage to developers is that they can explore Smalltalk classes without having to successfully load them into one of the Smalltalk dialect platforms. Recently, I have changed much of the Smalltalk generator and HTML/Javascript generated code.

Formerly, all Smalltalk source was highlighted using a client-side Javascript library. This resulted in long page loading times because it had to iterate through all DOM elements and replace the HTML content by a post-processing (using regex) result. Current version of Soek uses a highlighter written in Smalltalk that can pre-process all class source files.

Melissa for VA Smalltalk

Thu, 29 Jul 2010 19:20:24 +0700

Melissa is a simple tool that can help in building development and runtime images in a continous integration environment. It is being used extensively to create daily builds for Smalltalk images. This post describes the steps to use Melissa for VA Smalltalk 8+.

The intended way to use Melissa is to start with a clean VA image, load the Melissa config app and save it as melissa.im. In order to tell Melissa what to build, you need to start that image passing the command line parameter “-melissa buildscript.ws” like:

Google API access from Smalltalk using JNIPort

Thu, 29 Apr 2010 05:13:13 +0400

JNIPort for VisualWorks provides a way to use Java and its huge number of available libraries directly from Smalltalk.

For example, to access the Google Spreadsheets APIs and Tools, you need to download the Java client libraries and all its dependencies. The paths to there Jars must be known to the JVM and can be set through JNIPort. For easy deployment, I put together a single jar using an Ant build script such that the Runtime settings could be:

JQTouch library support for Seaside

Sat, 23 Jan 2010 14:32:19 +0100

One way to build applications for the iPhone is to create a Web application that tries to look and behave like a native one. Currently, many Javascript libraries are being developed that try to accomplish just that. One of the big reasons for choosing this route is that developing such applications is so much easier compared to the Apple-way (learn Objective-C, build and test on the local emulator and try to get it accepted by AppleStore).

soek.goodies.st - exploring open-source Smalltalk libraries

Fri, 13 Nov 2009 21:48:13 +1100

Soek is a Smalltalk application that provides a different way to navigate through documentation and source code of a Smalltalk library. Instead of the classic multi-list browser view in an image, Soek offers a flat view on all methods and classes and is build using the Seaside Web framework.

missing image /2009/11/screen-shot-2009-11-13-at-6-33-24-pm.png

I discovered this way of publishing a framework when I worked with Rails and did most of my searches on Railsbrain.com. Not only I could easily find a particular class or method, it also showed me similar methods, other implementations, classes and their sources. The learning effect was great and it became my standard search tool and recommendation to others.

Making a package visible to WebVelocity

Sat, 12 Sep 2009 19:13:21 +0900

If you want an existing package to register as a WebVelocity one and as a result make it visible to the browser page, you can evaluate this script:

(Store.Registry packageNamed: 'Your-Package-Name')
	propertyAt: #application put: true;
	propertyAt: #namespace put: 'Your-Namespace';
	propertyAt: #velocityThemeName put: 'Default'.

which I found when looking for the newApplication functionality in the image.

HypertextLogger for server application logs

Mon, 22 Jun 2009 19:53:39 +0600

Logging can be very helpful in analyzing the (faulty) behavior of a server application in response to client requests. HypertextLogger is a simple component that produces HTML in response to logging instructions. Its main purpose it to provide a better readable log file. By choosing you favorite CSS, you can highlight what is important and leave other information unfocused (timestamps).

missing image /2009/06/hypertextlogger.png

Upon creation of the logger, it produces a new .html file to which logging events are written. Because most Browsers can deal with open-ended (i.e. not properly closed by tags) HTML files, a single page can be used to collect lots of events. And if you let e.g. Apache serve these log files, you can monitor server applications remotely.

Getting started with Glare-DataServices

Tue, 26 May 2009 19:30:41 +0500

Glare-DataServices is a framework for building Flex Remoting services in VisualWorks Smalltalk. In this post, I will guide you through the steps for creating a small application that demonstrates the use of the framework.

Install the bundle

First, you have to connect to the Cincom Public Store Repository. Then open the list of Published Items and load the bundle GlareDataServices. It includes the Glare bundle and Glare-DataServices packages. The required dependencies AT MetaNumerics and Opentalk are automatically loaded if not present.

VAStGoodies.com services API

Fri, 24 Apr 2009 16:01:37 +0400

To make the VAStGoodies client work right from the VA image, I needed a service API in addition to the Seaside application that is running on VAStGoodies.com. Requirements for that service include “get all available configuration map names” and “get a download url for a particular version of a configuration map”.

Instead of implementing a full-blown end-to-end SOAP based Webservice, I decided to implement a much leaner RPC-style design that simply returns Smalltalk expressions.

Getting Monticello package changes into VisualWorks

Thu, 23 Apr 2009 09:09:45 +0400

The Cloudfork project is available for the three larger Smalltalk implementations: Squeak/Pharo, VA Smalltalk and VisualWorks. For maintaining the ports based on the Squeak implementation, we use the Package-Exporters package.

For porting to VA Smalltalk, we are using the VAPackageExporter as explained by Adriaan van Os. One important feature is the ability to maintain the port based on the changes to a project rather than repeating the all-in-one export.

For maintaining the VisualWorks port of Cloudfork, I extended the Package-Exporters project with a VWPatchExporter that can be used to export changes in the VisualWorks XML format. Having this feature, I can write the following expression to export only the additions/removals and changes to our project:

Changing the browser font in VisualWorks

Fri, 10 Apr 2009 20:07:58 +0400

Today I spent some time figuring out if and how I could change to default text font of the Smalltalk browsers in VisualWorks (76nc). For years I have been using my favorite coding font Dina (Win only) in any other tool such as Eclipse. Having this font also in VisualWorks would be very pleasing.

So I browsed through the source code of Look policies, Font policies and Font descriptions to find any clues. I was prepared to hack any method for this cause. Then I stumbled upon a little tool to assign Fonts to text styles:

Executable operation specifcations in Glare-DataServices

Sun, 05 Apr 2009 21:51:18 +0400

Glare< is a Flex Remoting and Messaging server written in VisualWorks Smalltalk by Philipp Bunge. I am extending his work with Glare-DataServices which basically provides a HttpServlet that dispatches operation invocations send from a AMF client (Flex,AIR) to Smalltalk objects.

To work with Glare-DataServices, you need Smalltalk classes that implement operations and ActionScript classes that have corresponding methods in which these operations are invoked remotely. Because both classes (client and server-side) must have the same signature, it is clear that code generation can be very helpful.

Method Categorization and Browse Unsent for VA Smalltalk

Fri, 27 Mar 2009 12:15:21 +0300

Method categorization is an important part of documenting the interface of classes, which is quite unique to Smalltalk to my knowledge. Therefore most developers spent time reorganization their methods in commonly known categories such as initialize-release, accessing and instance creation.

PhilemonToolMethodCategories is a goodie that contains some extensions to the standard browsers that deal with categorization. In particular, it offers a different “Move to category…” menu item that pops up a menu with existing categories and another submenu with suggested category names. You can change the default list on a per-user basis like this:

Class Search Browser for VA Smalltalk

Wed, 25 Mar 2009 16:02:44 +0300

The Classes Interface Browser is a small search tool to quickly find a Smalltalk class or one of its methods. The two inputs fields on top provide filters for class names and method names of that class. From a selected class or method, you can open a Class Browser by double-clicking. Using the list popup menus, you can navigate (superclass, subclasses…) in the class hierarchy, add a breakpoint and navigate (redefined, overridden) in the method implementation hierarchy.

VAStGoodies.com Statistics

Wed, 25 Mar 2009 08:39:28 +0300

VAStGoodies.com is the open source software repository for the VA Smalltalk community which was launched early this year by Adriaan van Os. As of today, the vastgoodies site has been extended with a page showing the activity statistics. Main purpose of this page is to let the community see that contributions are indeed downloaded and to give credits to those that maintain them.

Similar information has been available on Squeaksource for some time now and I was surprised to experience the effects on me with this kind of monitoring. When working on the Cloudfork packages for Squeak, the downloads statistics gives us immediately feedback about whether developers are interested. And a few times it felt like a contest to see whether I or the project could be the top committer for a while :-)

Navigating Inspector for VA Smalltalk

Thu, 19 Mar 2009 14:23:11 +0300

This goodie is also known as the “Diving” inspector as it allows you to navigate through an object structure by following each variable on a double-click. The inspection depth is shown in the inspector just above the “self”. You climb up the structure by clicking on that list item.

missing image of /2009/03/navigating_inspector.png

Once loaded into your image, it takes over the standard inspector but uses any dedicated inspector as its model (e.g. EtDictionaryInspector). To see that working, try inspecting “Array with: Smalltalk”.

FileBrowser for VA Smalltalk

Wed, 18 Mar 2009 13:01:33 +0300

FileBrowser is a new addition to the configuration map “Philemon Tools” , available at VAStGoodies.com, for VA Smalltalk. This little but powerful tool has the following features:

navigate through your local filesystem showing the contents of files (including images)
file selection based on pattern matching
support for custom templates for editing (see templateGroups:)
configurable contents font
navigation history
spawn external programs associated with the selected file (e.g. starts Notepad on Windows for .INI)

missing image of /2009/03/filebrowser.png

This goodie requires you to load the applications from the configuration map “Compuware SplitterWidget”, also available at VAStGoodies.com

Flex Remoting ignores class mapping

Sun, 15 Mar 2009 09:33:28 +0300

if your application does not yet actually use that client Class. In my application, the result of a remote invocation kept returning a dynamic Object instead of the intended ValueObject class “Slot” although I specified the mapping and the RemoteClass metadata:

weborb-config.xml

   <classMapping>
     <clientClass>com.cae.planning.models.Slot</clientClass>
     <serverClass>Slot</serverClass>
     <source>Slot</source>
   </classMapping>

Slot.as

    [Bindable]
    [RemoteClass(alias="com.cae.planning.models.Slot")]
    public class Slot { ... }

So merely including the “import com.cae.planning.models.Slot;” in my application does not instruct the compiler to actually include that Class and therefore knows about the class mapping. Obviously, this can only happen if you work on new client classes that you are not yet using anywhere in your application.

Tiny, single-purpose class: ResultToFunctionAdaptor

Sat, 14 Mar 2009 20:06:18 +0300

Every now and then I need a small piece of functionality that perfectly fits into a single, minimal-behavior thus single-purpose class. This time I am developping a Adobe Flex application that uses the RemoteObject facilities. Before invoking a method on a RemoteObject, you have to add two event handlers that will be called with a ResultEvent or a FaultEvent respectively. Typically in the “onResult(event:ResultEvent)” function, one takes the result of the event and calls another function or update a view.

Coding extensions for VisualAge for Smalltalk

Fri, 13 Mar 2009 12:54:02 +0300

The configuration map “Philemon Tools” , available at VAStGoodies.com, now contains an application that enhances the source code browser in VisualAge for Smalltalk. In short, it provides the following features:

code completion
paste buffer (hold shift while selecting menu item "paste" to select from previous copied source)
repeat edit action (like VisualWorks "again")
modifier+key combinations (see below)

Control+t	ifTrue:[ {selected source} ]
Control+g	ifFalse:[ {selected source} ]
Control+Shift+(	( {selected source} )
Control+1	Browse hierachy or implementors
Control+2	Browse references or senders
Control+3	Show previous occurrence of selected text
Control+4	Show next occurrence of selected text
Control+5	Show containing Block
Control+p	Cycle forward through suggestions of completing method\|variable\|class name
Control+Shift+p	Cycle backward through suggestions of completing method\|variable\|class name
F2	Format + Save
F5	Save
F6	Revert
F7	Indent selected source
F8	Un-indent selected source

The code completion part is written by Erik Stel. Current implementation does not allow for custom bindings ; you just have to change the class EmmKeyboardProcessor in the PhilemonToolsKeyboard application. Alternatively, drop me an email if you have suggestions.

Importing directly from VAStGoodies.com

Thu, 12 Mar 2009 08:49:24 +0300

A small but handy enhancement of the previous submitted VAStGoodies tooling, is the ability to import configuration maps from VAStGoodies directly into your library. This feature is available in the standard Configuration Maps Browser.

missing image of /2009/03/import_vastgoodies.png

It uses the same Envy dialog to select versions from available maps.

missing image of /2009/03/import_select_vastgoodies.png

As always as soon as one finishes a feature, a new idea pops up. What if the tool can automatically detect the recent changes available for downloaded material ? and does all those imports for you ? Who wants to contribute?

Tracking Object instances in VisualAge for Smaltalk

Wed, 11 Mar 2009 16:02:02 +0300

InstanceCounter is a tool that can be used to watch the number of instances present in your image. It can be started from the Transcript Philemon menu or by evaluating:

InstanceCountMonitor openOnClasses: #( ByteArray Process)

missing image of instance_count_monitor.png

The menu item named “Pointers 1st instance” opens the PointerFinder tool. This is a tool to find the path on which an object is referenced. It is based on an implementation in VisualWorks by Hans-Martin Mosner (c) 1995. The algorithm is based on an idea by Wim Boot.

Interactive compilation for VisualAge for Smalltalk

Wed, 04 Mar 2009 09:09:56 +0300

One of my favorite features of the Cincom VisualWorks IDE is the interactive compiler error handler. When trying to save Smalltalk source that result in compilation errors, the IDE prompts the developer with a menu of suggestions to correct that error. Although the VA compiler can detect these errors obviously, the code browsers merely put the error message in the source.

The application PhilemonToolCompilations has an interactive error handler that implements this behavior for the VisualAge for Smalltalk IDE. Features include:

Tooling available for VAStGoodies

Thu, 26 Feb 2009 10:18:39 +0200

Early this year, Adriaan van Os announced VAStGoodies.com that wants to be the open source software repository for the VA Smalltalk community. To promote this great initiative, I proposed to create some tools that allow you to contribute to VAStGoodies.com directly from your Smalltalk image. Initially, it includes an editor to edit project annotations and an uploader that takes a versioned ConfigurationMap to publish it. Future versions will enable you to download new and updated versions of projects directly into your repository.

Ring Benchmark - my first concurrent Erlang

Fri, 23 May 2008 22:47:39 +0500

Following the advice of Dave Thomas who said: “any developer should learn a new language every year” on RailsConf 2007 in Berlin, I decided that Erlang was going to be my challenge for 2008. However, the first months of 2008 passed without any Erlang until I listened to Joe Armstrong himself at Qcon in London. His talk was inspiring to me so right afterwards I bought his book and start reading it on my flight home.

SelfDiagnose for Ruby on Rails

Thu, 15 May 2008 11:41:49 +0500

SelfDianogse is a library of tasks to diagnose a running system with respect to its dependent external resources. Recently, I did some Rails development and was thinking about how to implement it for the Ruby on Rails framework ? Obvious choice is to make a plugin that on installation adds the SelfDiagnoseController.rb to the application. Because of the scripting nature of Rails framework, putting the configuration in XML (as it is done for Java) is not the Ruby-way. So either use YAML or put the configuration directly into the controller. Let’s investigate the latter.

Sorting XMLListCollection by attribute

Wed, 23 Apr 2008 20:14:37 +0400

Just want to share the result of a small puzzle I had about sorting elements of an XMLListCollection by one of the attributes of such an element. At first, I tried sorting the elements of the XMLList I had, but the API does not provide any methods to do that. Bruce Phillips wrote a snippet that pointed me to right direction. So, here it is:

var doc:XML = <root>
      <item name="C"/>
      <item name="B"/>
      <item name="A"/>
  </root>
var collection:XMLListCollection = doc.item
var sort:Sort = new Sort()
sort.fields = [ new SortField("@name", true) ]
collection.sort = sort
collection.refresh()

As expected, the collection will show:

External configuration for SelfDiagnose

Wed, 23 Apr 2008 17:46:38 +0400

Initialization of the SelfDiagnose component is done by reading the resource selfdiagnose.xml which must be located on the classpath of the Web application. This configuration declares the diagnostic tasks that are executed in the context of the Web application. The upcoming release (1.1) will have a new feature that allows you to override the local configuration and dynamically load the configuration from a provided URL:

http://your-app/selfdiagnose?config=http://some-other-server/selfdiagnose.xml

or even a local file can be passed:

Foreign compile-time dependencies in SelfDiagnose

Fri, 11 Apr 2008 09:26:25 +0400

In the upcoming release 1.1 of the SelfDiagnose task library, a new task has been added called CheckEndecaService. Endeca is commercial software that provides excellent Search services to e.g. e-commerce web applications. This particular task checks the availability of that service and can perform a simple query. To implement this, the following snippet has been used:

HttpENEConnection connection = new HttpENEConnection();
connection.setHostname(host);
connection.setPort(port);
UrlENEQuery eneQuery = new UrlENEQuery("N=0", "UTF-8");
ENEQueryResults eneResults = connection.query(eneQuery);
Navigation navigation = eneResults.getNavigation();
long numERecs = navigation.getTotalNumERecs();
double time = eneResults.getTotalNetworkAndComputeTime();

Without a full understanding, you can see that this snippet is using classes which belong to the Endeca API package. SelfDiagnose is a open-source library and therefore can and will not have any dependencies on commerical software. So how can we still use this code without the compile time dependencies?. Of course, in order to execute this code, the runtime dependencies must be available. It does not make sense to use the CheckEndecaService if your application is not using it.

Amazon Web Services Test Drive Needed

Tue, 18 Dec 2007 14:24:47 +1200

Designing and implementing applications that make use of Amazon Web Services such as S3, SQS and SimpleDB, require extensive testing to ensure a robust integration. In addition to scenarios for the “happy flows”, test scenarios should be created to handle the critical exceptional situations. How does my application respond to failures in communication, checksum errors, service unavailability, never ending transactions and extremely frequent or heavy traffic?

In the spirit of test driven development, I see a need for writing up such scenarios and simulate the unexpected behavior of AWS just to verify the correct handling of each exceptional event. Such a Test Drive service would implement the API of services available at Amazon Web Services. It should provide extra control services to put a Web Service in some “testing mode” such as “simulate disk failure”, “simulate terminated http connection” or “simulate invalid access key"or a combination thereof.

Flex Project version and buildnumber

Thu, 06 Sep 2007 15:32:24 +0900

I wanted to associate version and build information with every compilation of a Flex project. Such information is useful when deploying to different staging environments (e.g. are you sure you uploaded the correct SWF ?) and helps tracking feedback (e.g. bugs) from users using a particular build.

First, I added a simple resource version.xml to store version and build info:

<?xml version='1.0' encoding='UTF-8'?/>
<version name='0.1' build='124'/>

Then I defined a component Version.mxml to show that information in plain text:

Deploying Flex using Capistrano

Thu, 02 Aug 2007 20:21:21 +0800

Capistrano is a deployment tool initially created to support the remote installation of Rails applications. One of the assumptions Capistrano makes is that the application (source) can be pulled out of a source code management system such as Subversion.

In case of Adobe Flex applications, compiled sources (SWF,HTML,…) need to be deployed to the Web server. So instead of pulling sources from a repository, I needed to push compiled code to the server.

QuickSilver and Current Application

Fri, 20 Jul 2007 07:28:18 +0700

On a Mac, accessing the current application from QuickSilver provides interesting new possibilities as can been on an episode of the Merlin Show. If you agree that this is something you wanted all along, then follow these instructions to set it up. (Thanks to BOONE).

In QS prefs, make sure “Enable advanced features” is checked
In QS Plug-ins, enable the User Interface plugin
In MacOSX System Preferences–>Universal Access, check “Enable access for assitive devices”
In QS prefs–>Catalog–>Quicksilver, check and reload “Proxy Objects”

Flex Bindable Hash

Tue, 17 Jul 2007 09:58:00 +0700

For the Dunelox library, I needed a simplified Flex version of the Spring ApplicationContext which is a generic Hash object containing model objects accessed by a key (String). Visual components that are wired to these models objects need to be updated automatically using the standard event mechanism in Flex.

So, I had a look at the standard ArrayCollection to find out how it notifies components that are wired to elements by index. This gave me the idea to implement the HashCollection as a extension to this class.

s3browse.com

Tue, 20 Feb 2007 21:18:00 +0200

For some time now, Amazon S3 Web Services are available to the developer community. Since its inception, several client solutions made their way to the public. S3Browse.com provides both a simple Web Interface and a Java Web Start based client to your S3 accounts. The web client is typically used to create and browse your bucket contents. The Java client is used to upload large files or a large amount of files. S3Browse.com is a free intermediate service to Amazon S3.

Helper classes considered bad OO

Sun, 12 Mar 2006 21:30:46 +0300

Too often developers put logic in so-called Helper classes.

This practice of SPOD (Single Point of Definition) results in a higher level of reusability, so it seems. But in fact introducing these procedural structured behavioral methods impose a rigid structure. First of all, (other) developers need to be aware that such Helpers exist to work on their objects. Secondly, because behavior that should have been defined in the class of the object, is now defined elsewhere. The possibility of re-using such behavoir by inheritance is now unavailable. You cannot just extend an Helper class too!

Application Diagnoses Itself

Thu, 22 Sep 2005 09:16:29 +0900

How can I provide programs with self diagnostic behavior? How can I implement this in a way that has low impact on the way I write programs (or Java classes to be more specific). If programs could run such a self diagnose then perhaps it takes less time to find the cause of an observed problem.

These thoughts are sprung when I found an error in an application that went into production just a few days earlier. The problem itself was easily fixed (just a typo in some properties file) but I was a bit surprised that obviously my tests did not cover this particular execution path. Sure, I should have written more tests to have a higher coverage (JCoverage can tell me what percentage), but what if I had programmed this behavior differently(how?) such that a self diagnose run would have detected it?

Don'ts

Tue, 19 Jul 2005 21:37:58 +0700

Another example of how negative publicity can have a big learning effect (if understood). From a new entry @ slashdot about Multi-links, I surfed to WebsitesThatSuck. The authors are committed to show the worst designs that live on the web.

With respect to Software Design, my dialy work, a similar initiative has been around for a few years. In response to the popular Design Patterns book written by the Gang of Four, others introduced the Anti-Patterns as a means to teach designers about the dont’s in the design of systems using Object Technology. You can contribute to them using the Anti-Patterns Wiki.