Reading Group Archive (2015)

Computational Category Theory

In July we studied the computational category theory notes. You won't need to know ML to follow along, we are Haskell and Scala people after all.

Monto Disintegrated Development Environment

On July 10 we discussed the Monto Disintegrated Development Environment that is being developed at Macquarie. The aim of Monto is to provide features similar to those of integrated development environments such as Eclipse, but require much less effort on the part of developers to provide new components for the environment. We'll look at the architecture and implementation of as well as demonstrate some features that have been implemented so far.

Hacking Session

On June 26 we held a hacking session.

sbt-rats Parser Generator

On June 19 we discussed the sbt-rats parser generator that has been developed here at Macquarie. sbt-rats provides an sbt plugin that enables the Rats! parser generator to be used in Scala projects. The parser can be specified directly using a Rats! specification or using a simplified syntactic notation. The syntactic notation can also be translated into a Scala implementation of abstract syntax trees and a pretty printer for those trees. Pretty-printing support is provided by the Kiama language processing library.


On June 12 we discussed the Strategic Term Rewriting portion of the Kiama language processing library.

On June 5, we discussed the attribute grammar part of the Kiama language processing library based on a paper from Science of Computer Programming.

On May 22 Tony Sloane gave an overview of the Kiama language processing library that has been built at Macquarie. The overview included a simple, complete example of using Kiama to build a simple software language processor.

Trace Abstraction

On May 15 we will discuss the paper Refinement of Trace Abstraction by Heizmann et al.

Program Slicing

On May 8 we continued discussing program slicing and the paper A Survey of Program Slicing Techniques by Frank Tip, focusing on Section 3.2 onwards.

On April 24 we continued our discussion of program slicing by looking at the first three sections of the paper A Survey of Program Slicing Techniques by Frank Tip.

On April 17 we discussed the classic paper Program Slicing by Mark Weiser. Slicing is a program transformation technique that in its simplest form seeks to remove code from a program that cannot affect the value of a variable at a particular point. It is useful for debugging and program analysis tasks where we want to restrict the focus of attention to the subset of code that might be affecting some result, rather than have to consider the whole program.

LLVM in Scala

On April 10 Tony Sloane described progress on the library he is building to allow LLVM code to be processed in Scala. At present the library provides a parser, tree constructor and pretty-printer for LLVM intermediate representations. Discussion will centre around the suitability of this tree representation for further processing or generation from Scala, particularly on the design of a higher-level representation to make processing and generation easier.

Attendees who are unfamiliar with LLVM may find it useful to read LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation which provides an overview of the aims and approaches of the LLVM project.

Programming Language Design

On March 20, we discussed an old paper by Tony Hoare on programming language design.

Domain-Specific Profiling

On March 13, we discussed some work that Tony and Matt have done over the last couple of years on general profiling approaches for domain-specific languages.

Strategic Programming Errors

On March 6, we discussed work that Matthew Roberts has begun on characterising errors that arise when using strategic programming. A start on some typical examples can be found at this page.

Abstract State Machines

On February 27, we discussed the use of Abstract State Machines to specify the semantics of the Java programming language and the Java Virtual Machine. Tony Sloane presented a walk-through of simple versions of these machines to give an idea of how the method works.

On February 13, we continued our discussion of Abstract State Machines by looking how they are provided by the Kiama language processing library developed here at Macquarie. Matt Roberts showed how they can be used to model psychological processes. Tony Sloane gave a short walk-through of the Kiama implementation of ASM.

On February 6 we started discussing Abstract State Machines which are a generalisation of finite-state machines for system specification. Our source was a primer on ASMs by Huggins and Wallace.