Robert Strandh

Domain Specific High-Level Constraints for User Interface Layout

We present the Auckland Layout Model (ALM), a constraint-based technique for specifying 2D layout as it is used for arranging the controls in a graphical user interface (GUI). Most GUI frameworks offer layout managers that are basically adjustable tables; often adjacent table cells can be merged. In the ALM, the focus switches from the table cells to vertical and horizontal tabulators between the cells. On the lowest level of abstraction, the model applies linear constraints, and an optimal layout is calculated using linear programming. However, bare linear programming makes layout specification cumbersome and unintuitive, especially for GUI domain experts who are often not used to such mathematical formalisms. In order to improve the usability of the model, ALM offers several other layers of abstraction that make it possible to define common GUI layout more easily. In the domain of user interfaces it is important that specifications are not over-constrained, therefore ALM introduces soft constraints, which are automatically translated to appropriate hard linear constraints and terms in the objective function. GUIs are usually composed of rectangular areas containing controls, therefore ALM offers an abstraction for such areas. Dynamic resizing behavior is very important for GUIs, hence areas have domain-specific parameters specifying their minimum, maximum and preferred sizes. From such definitions, hard and soft constraints are automatically derived. A third level of abstraction allows designers to arrange GUIs in a tabular fashion, using abstractions for columns and rows, which offer additional parameters for ordering and alignment. Row and column definitions are used to automatically generate definitions from lower levels of abstraction, such as hard and soft constraints and areas. Specifications from all levels of abstraction can be consistently combined, offering GUI developers a rich set of tools that is much closer to their needs than pure linear constraints. Incremental computation of solutions makes constraint solving fast enough for near real-time use.

Efficient simulation of forward-branching systems with constructor systems

Abstract Strongly sequential constructor systems admit a very efficient algorithm to compute normal forms. Thatte found a transformation that allows us to simulate any orthogonal system with a constructor system. Unfortunately, this transformation does not generally preserve strong sequentiality. On the other hand, the class of forward-branching systems contains the class of strongly sequential constructor systems. Moreover, it admits a reduction algorithm similar to the reduction algorithm of the strongly sequential constructor class, but less efficient on the entire class of forward-branching systems. In this article, we present a new transformation which transforms any forward-branching system into a strongly sequential constructor system. The size of the system increases only modestly over that of the original one in many practical situations. We give an algorithm for this transformation and we prove its correctness and completeness. The new system is then proved to be equivalent to the input system, with respect to the behavior and the semantics. We then give a new transformation algorithm which increases the size of the system only linearly.

Resolving Metastability Issues During Bootstrapping

The fact that CLOS is defined as a CLOS program introduces two categories of issues that must be addressed, namely bootstrapping issues and metastability issues [2]. Of the two, the latter is the more difficult one, and also the one that has the most negative impact on the elegance of the code in that it requires base cases to be handled specially. We describe satiation, a technique by which metastability issues can be turned into bootstrapping issues, thereby simplifying them and keeping the code elegant. Satiation consists of pre-loading the call history of a generic function with respect to a set of argument classes so that the base cases are handled without invoking the full protocol for computing the effective methods at runtime.

Gsharp, un éditeur de partitions de musique interactif et personnalisable

In this article, we present Gsharp, a project with the purpose of creating an editor for traditional music scores. Gsharp is written in Common Lisp, and uses the CLIM (Common Lisp Interface Manager) library for interactions with the user. Several new algorithms and data structures were invented in order to ensure acceptable performance for simple interactions such as inserting or deleting a note or a chord.

Simulating Forward-Branching Systems with Constructor Systems

Strongly sequential constructor systems admit a very efficient algorithm to compute normal forms. The class of forward-branching systems contains the class of strongly sequential constructor systems, and admits a similar reduction algorithm, but less efficient on the entire class of forward-branching systems. In this article, we present a new transformation which transforms any forward-branching system into a strongly sequential constructor one. We prove the correctness and completeness of the transformation algorithm, then that the new system is equivalent to the input system, with respect to the behavior and the semantics. As a programming language, it permits us to have a less restrictive syntax without compromise of semantics and efficiency.

On Addition Schemes

We review a class of addition chains that are suboptimal but close to optimal. Addition chains in this class are generated by a very efficient algorithm. We present evidence that traditional algorithms for exponentiation may in fact be slower than a method where an addition chain is first constructed, then applied and finally discarded. Experimental evidence definitely indicates this to be true for slightly more complex domains than the integers.

Fast Generic Dispatch for Common Lisp

We describe a technique for generic dispatch that is adapted to modern computers where accessing memory is potentially quite expensive. Instead of the traditional hashing scheme used by PCL [6], we assign a unique number to each class, and the dispatch consists of comparisons of the number assigned to an instance with a certain number of (usually small) constant integers. While our implementation (SICL) is not yet in a state where we are able to get exact performance figures, a conservative simulation suggests that our technique is significantly faster than the one used in SBCL, which uses PCL, and indeed faster than the technique used by most high-performance Common Lisp implementations. Furthermore, existing work [7] using a similar technique in the context of static languages suggests that perfomance can improve significantly compared to table-based techniques.

An Improvement to Sliding Garbage Collection

Garbage collection algorithms are divided into three main categories, namely mark-and-sweep, mark-and-compact, and copying collectors. The collectors in the mark-and-compact category are frequently overlooked, perhaps because they have traditionally been associated with greater cost than collectors in the other categories. Among the compacting collectors, the sliding collector has some advantages in that it preserves the relative age of objects. The main problem with the traditional sliding collector by Haddon and Waite [4] is that building address-forwarding tables is costly. We suggest an improvement to the existing algorithm that reverses the order between building the forwarding table and moving the objects. Our method improves performance of building the table, making the sliding collector a better contestant for young generations of objects (nurseries).

ESA: a CLIM library for writing Emacs-Style Applications

We describe ESA (for Emacs-Style Application), a library for writing applications with an Emacs look-and-feel within the Common Lisp Interface Manager. The ESA library takes advantage of the layered design of CLIM to provide a command loop that uses Emacs-style multi-keystroke command invocation. ESA supplies other functionality for writing such applications such as a minibuffer for invoking extended commands and for supplying command arguments, Emacs-style keyboard macros and numeric arguments, file and buffer management, and more. ESA is currently used in two major CLIM applications: the Climacs text editor (and the Drei text gadget integrated with the McCLIM implementation), and the Gsharp score editor. This paper describes the features provided by ESA, gives some detail about their implementation, and suggests avenues for further work.