The Bootstrap

Domain-Specific Model Transformation in Building Quantity Take-Off

2011-10-24T07:52:00.003+02:00

Last week I presented a paper at the ACM/IEEE 14th International Conference on Model Driven Engineering Languages and Systems (or MODELS 2011 to its friends), held in Wellington, New Zealand. The abstract for the paper is as follows:

The two core concepts of model-driven engineering are models and model transformations. Domain-Specific Modelling has become accepted as a powerful means of providing domain experts and end users with the ability to create and manipulate models within the systems that they use. In this paper we argue that there are domains for which it is appropriate to also provide domain experts with the ability to modify and develop model transformations. One such domain is that of quantity surveying, and specifically the taking-off of quantities from a building design. We describe a language for expressing transformations between building models and bills of quantities, and its implementation within an automated quantity take-off tool, reflecting on the commonalities and differences between this language and a general-purpose model transformation language/tool.

The electronic version of the paper is up at the Springer site, and at my university's electronic repository when they get around to putting it up..

The presentation went pretty well, and I was presently surprised throughout the conference by the number of attendees interesting in modelling things that aren't software. The longer I work in modelling, the less I am interested in modelling the software itself, and the more I'm interested in using the models and modelling languages of the domains, and in how making them explicit can shape the software.

A Transformation Workbench for Building Information Models

2011-07-12T07:50:00.002+02:00

Last week I presented a paper at the 4th International Conference on Model Transformation, part of the TOOLS Europe federated conferences, hosted this year by ETH Zurich. The abstract of the paper is/was:

The building industry is undergoing a significant evolution, with increasing use of digital models during the design process and sub- sequent lifecycle of a building. These models, which span multiple de- sign disciplines, multiple stakeholders, and many phases of the build- ing’s life, represent an interesting study for the application of ideas from model-driven engineering, being large, complex, and highly interrelated. Building models are typically represented using the Industry Foundation Classes (IFC), an industry standard supported by many of the popu- lar CAD tools, defined in the STEP/Express technical space. Because the majority of research in MDE has focussed on the Eclipse Modeling Framework (EMF) technical space, it has previously been difficult to experiment with IFC models using model-driven engineering tools and techniques. In this paper we describe a workbench which provides for the integration of the STEP and EMF technical spaces. We also describe a number of initial experiments in bringing model transformation tech- niques and tools to bear on the domain of building models, and propose some future work.

The full paper is available from Springer (it'll be up on my university's publications repository when they get around to it). For the presentation, which I thought went reasonably well, I used the Prezi online presentation system, and the presentation is available here. (Note: I'll be coy about recommending Prezi - it can be cool, but it has some very serious issues).

The ICMT conference, and the TOOLS event as a whole, was very interesting, with an ongoing choice of conferences (4 in total) and workshops (8, including TTC) to get along to across the 5 days. I managed to sample all 4 conferences and 3 of the workshops, and pretty much found something of value in all of them.

Transformation Tools Contest 2011

2011-07-01T09:07:00.002+02:00

Tefkat (with me at the wheel) came in second (of 10) yesterday in the live challenge of the Transformation Tool Challenge workshop at the TOOLS Federated Conferences in Zurich. Congratulations go to the first-place winners, Tassilo Horn and GreTL, who also won awards for the offline problems (along with GrGen.net). The competition was a lot of fun, with lots of useful discussion and feedback amongst the different competition participants and organisers. I'd encourage people who are interested in model transformation and model transformation languages to get along to check it out, on the web site for this year's edition, and also at future events.

Graphical Programming

2011-06-14T08:12:00.003+02:00

Last Thursday I attended the second (well, kind of second) meeting of the Brisbane chapter of the Computational Design Group, kindly hosted by ARUP. There were interesting talks by Steve Downing from ARUP Sydney, Ben Doherty from BVN, and Abdullah Habash from Aurecon. I had been exposed to some of Steve's and Ben's stuff in my former life at QUT, but it was nice to see what they've been up to. It was also nice to see the ways that Abdullah and Aurecon have been using computational techniques for designs of their buildings in Abu Dhabi and Brisbane, including on the building currently under construction next door to me.

One of the thoughts that occurred to me, looking at some of the complex Generative Components and Rhino/Grasshopper models in the presentations, was about graphical programming. People in computer science talk about graphical programming from time to time, but the pointy end of the design industry are doing it for real, on big projects, in these tools.

* I am hoping to revive this blog a little bit. Time will tell whether that ambition yields fruit.

moving on

2011-03-04T01:58:00.002+01:00

Some people who follow me on twitter and had some inside connections already knew this was happening, but it probably warrants a proper announcement for anyone else who's still subscribed here or elsewhere.

A couple of weeks ago I tendered my official resignation to QUT. In just over a week I will be starting a new position as lecturer in the School of ITEE at the University of Queensland.

SoSyM paper on interoperability in BIM

2010-10-11T02:50:00.002+02:00

Last year, Robin and I presented a paper on interoperability of models in the architecture/engineering/construction space. Subsequent to that, with the aid of Bianca (a PhD student of Robin's), we expanded it for a special issue of SoSyM on model interoperability. The final accepted paper is now available online at Springer's site (requires subscription).

Here's the abstract:

The exchange of design models in the design and construction industry is evolving away from 2-dimensional computer-aided design (CAD) and paper towards semantically-rich 3-dimensional digital models. This approach, known as Building Information Modelling (BIM), is anticipated to become the primary means of information exchange between the various parties involved in construction projects. From a technical perspective, the domain represents an interesting study in model-based interoperability, since the models are large and complex, and the industry is one in which collaboration is a vital part of business. In this paper, we present our experiences with issues of model-based interoperability in exchanging building information models between various tools, and in implementing tools which consume BIM models, particularly using the industry standard IFC data modelling format. We report on the successes and challenges in these endeavours, as the industry endeavours to move further towards fully digitised information exchange.

Biden on Copyright

2010-07-05T09:02:00.003+02:00

Last week (or a little longer ago), US vice president Biden claimed

"Piracy is theft, clean and simple"

In fact, not only is "piracy" not theft, plain and simple (as per the US supreme court in Dowling vs United States), nor is copyright infringement, which is what he is talking about. The use of the term "piracy" for copyright infringement, is really very unhelpful, and interferes with any attempts to have any useful debate about intellectual property rights, how they should or shouldn't differ from material property rights, and how they can/should be enforced.

trying the "commercial" software thing

2010-07-01T07:55:00.003+02:00

A couple of friends and I have written an app for the Apple iPad, called Puzzlement. Its a jigsaw puzzle game, selected because we felt it was a good fit for the device's touch interface and form factor (bigger than iPhone). Its development (in which I was the lesser partner of 3) was more difficult than we anticipated, but we put it up in the app store last week.

This is just about the first piece of software that I've worked on that has been sold (actually LCADesign was the first, I think), and certainly the first in whose sales I've had a financial stake. Its been interesting tracking the sales numbers from day to day (and, informally, from hour to hour), and seeing which countries are buying the app and in what numbers. (I've even broken out and engaged in some spreadsheet-fu to track it all.) We had a good first day of sales, but after the initial honeymoon we have realised that making the app successful is going to require some marketing. How we do that remains an open question. The feedback we've had from people who played with the app has been very positive, but we will have to get it into people's hands in order for that to matter.

For the sake of relevance to my usual topics of interest, there is only the slightest bit of model-driven engineering in the app - we used Apple's Core Data framework to manage persistence of puzzle state, and it does quite a nice job of what I guess is the low-hanging fruit for MDE - autogenerated OO-DB bridges for managing application state.

2010-06-29T03:54:00.001+02:00

My paper on bridging STEP and EMF got knocked back from MoDELS'10 this morning. Shame, I really wanted to go. Its been a long time between conferences now.

maybe the NBN will be slower than what we have now

2010-05-07T07:35:00.005+02:00

I enjoy reading about the NBN (most recently here). What I do find frustrating, though, is that although everyone talks about high bandwidth, no-one seems to mention latency.

For those who haven't studied networks at uni, think of a network connection as a pipe (remembering that the internet is a series of tubes). The bandwidth is how many litres of water can flow down the pipe at once. The latency is the time for any give drop to get from one end to another. Replacing a pipe with a fatter pipe might improve your bandwidth, but unless you increase your pressure or reduce the pipe length, then it won't change your latency.

One of the things I use the internet for a lot is online gaming. The way a gamer cares about their connection is like this. They care about bandwidth a lot at first, because it dictates how fast they can download the game data onto their computer (remembering though that it depends on the width). After that, though, provided they have some minimum level of bandwidth (for current games this might be somewhere above modems but short of low-end ADSL), what they really care is latency. It is latency that determines how long it takes them to register that their enemy is doing something, and for the instruction they give in response to that to get back to the server, etc.

Its not just games, either. I'd imagine latency is important for commercial applications, too - realtime share or currency trading, for example. With the NBN, everyone is talking about bandwidth (100Mb/s to the home, etc). No-one is talking about latency.

Australia's at a physical disadvantage, firstly. For our packets to hit an American server, there's the small matter of traversing the Pacific Ocean, but I wonder how much of a factor that actually is. How much of the ping time is actually a packet screaming along a wire or a photon screaming down a fibre, and how much is a factor of how many computers are catching, processing and resending the packet in between?

My understanding is that the signal moving along the wire happens at something like 50-75% the speed of light (depending on whether its fibre, copper, etc), so I would have guessed that the hubs, switches, routers and firewalls (not to mention content filters) would have a much bigger effect on ping. I would also have guessed that new networks probably get more complex rather than simpler, so perhaps the NBN is going to hurt, rather than help, our ping times.

I wonder if one of the goals for the project shouldn't also be simplifying the network topology to try and control latency. Perhaps it is. I'd love it someone could tell me.

EDIT: There are plenty of other ways a gamer (or anyone else) cares about their network connection, obviously. Availability, packet loss, scalability under congestion, etc. Latency is the one I think about most, though :)

Uncertainty

2010-01-11T02:29:00.002+01:00

I am back at work this week, but in a strange position. My present 12-month contract with the university expires this Wednesday, and although my next (6-month) contract has been approved and budgeted within my team, whether it gets through the HR processes before Wednesday remains to be seen. I am fairly zen about it all; I have nothing particularly pressing this week, so a few days extra holiday won't phase me too much. The biggest impact may be on my 7 days of accrued leave from last year. If my contract is renewed, I will have to allocate it in the next few weeks. If not, then I expect it will be paid out, and I'll only have my normal 20 days to spend this year.

I feel like this is a significant year for my future at QUT. My last two years, for various reasons, haven't had the research impact that I would like to have going forward, so this is the year where I think I need to get some papers published, and get some good projects going, to convince myself (and to convince the university) that this is a research direction worth pursuing further.

model interoperability in virtual design and construction

2009-05-06T01:35:00.003+02:00

A couple of weeks ago, I presented a paper at the Knowledge Industry Survival Strategy (KISS) workshop (associated with the ASWEC conference) on the Gold Coast. The conference was about interoperability in domain-specific languages. Our paper (it was written with Professor Robin Drogemuller) was on the IFC language, the standardised language for interoperability in Architecture/Engineering/Construction software, including CAD tools, and on how it performs as an interoperability language. IFC, which I have been working with now for about 16 months, is comfortably the biggest metamodel I have seen or heard of (much bigger than, for example, CWM or UML2), certainly the broadest and among the most complex. The models are enormous - the example I present in the paper included 7.3 computational objects - and also very complex. It is a compelling example of a DSL.

The paper and presentation were very well received, and were singled out for mention in the call for submissions for the followup workshops at Code Generation and ASE. We also got a mention on the website and newsletter of the CRC for Construction Innovation, under whose auspices were conducted the projects that lead to the observations in the paper.

The paper and slides are up on the workshop website,

steal this blog post.

2008-10-13T07:09:00.002+02:00

From the book of xkcd. Amen.

(You really can steal my blog post, but you should say you did.)

refactoring EMF models

2008-10-13T05:59:00.004+02:00

I'm a software engineer now (well, kind of), so I am qualified to espouse great wisdom on my experiences in software engineering.

Last week we had cause for a couple of refactorings in our EMF models.

The first refactoring was very simple. One of our metamodels had a traceability link to source model objects, which needed to be generalised to be able to point to a more structured "assembly" of source model objects. For some reason, I already had a metamodel for these assemblies, so it was a simple matter of moving those metamodel elements into our main metamodel. The generated code for the assemblies hadn't been modified, so I was able to just cut&paste in the EMF editor, and add a reference to allow either single-element or assembly traceability. Then, using eclipse's call hierarchy view, I tracked down all the references to the single-element traceability, and generalised them to handle the new structure.

The second refactoring was more complicated. For one reason or another, we needed/wanted to change the name of one of our metamodel packages (and some other stuff, but let it just be the name). This meant that almost all of our code would change package, and a number of classes would change classname. Unlike the previous refactoring, this would have a huge effect on our generated code, which would need to be moved to new files, in a way that correctly overrode the default generated code. When you generate "over the top" of files, EMF is good at taking care of this, but I wasn't sure it would work when the generated files are "new". (I was pretty sure it wouldn't).

The approach we took was to anticipate all the effects of the metamodel changes we were making. We worked out that these were a number of changes to classnames (where the package prefix forms part of the classname), and a number of package renamings. We carried these out (in that order) using eclipse's Java refactoring (which is very good). Notwithstanding some complaints from SVN, this went smoothly. Then, when it came time to regenerate code from the changed metamodel, EMF found itself "overwriting" existing code, rather than creating new code. The refactoring was completed with only one or two lines of code needing to be hand-modified (for the curious, we had neglected to refactor some inner classes).

A refactoring framework for eclipse would be really nice. I do recall some mention of it on the EMF forum, but I don't know how far they got, or how they were going about it. If I were to go about it, experience like that above would probably lead me to look at essentially mapping eclipse refactorings onto generated Java refactorings (probably implemented as commands, off the top of my head).

In the interim, my advice would be that whenever you are refactoring a metamodel, think about the consequent changes for your non-generated code, and if necessary consider pre-empting the metamodel refactoring with Java refactoring. This way of thinking might not be elegant (the "no-one thinks about bytecode/binary when they're writing Java/C" argument), but it can save you some pain.

(From a more academic, "transformation" point of view, this is probably a good argument for traceability in transformations, and for treating "replay" transformations differently to "green field" transformations).

microsoft oslo

2008-09-30T10:06:00.003+02:00

I'm really impressed to see Microsoft's continuing push towards modelling as important. Their hiring of good people over the years - Jack, Wojtek, Stuart, Steve, etc - and recently of recognising the benefit of playing nicely with others on modelling (which I assume is the reason for Steve Cook being back at an OMG meeting after a long absence).

However, this kind of presentation really makes me cringe. The implication that Microsoft are the real drivers of modelling is kind of rough on the people and companies that have been working on the associated tooling (storing, creating, serialising models, among the things mentioned in the video - no mention of transforming, yet) for a decade or more. I do kind of realise that its not meant for me, and hopefully at some point I'll have the time to check out, or someone will point me towards, what MS are doing. Coming in late does offer them some advantages in terms of cherry-picking the ideas that work from those that maybe don't.

posting hiatus

2008-09-26T03:22:00.003+02:00

Its been a while since I've posted here, and its not the first time I've said that. I've been engineering away, trying to get the estimator feature-complete. I've had a couple of periods of high productivity, particularly when I implemented the rule language and rule engine, and when I was doing some of the traceability (selection sharing, etc) features. In the interim, there have been some slow sections, and some time spent doing non-development things like investigating how the software scales with really large models (not well), and doing some commercialisation- and publicity-motivated demonstrations.

meta-pizza

2008-07-22T01:42:00.001+02:00

Its creator dubbed it "Fractal Pizza", but for this blog, it can only be Meta-Pizza!

What am i reviewing?

2008-05-09T08:52:00.003+02:00

One of the jobs that becomes more prominent upon the completion of PhD is the reviewing of papers. I probably reviewed a half dozen papers a year during my PhD, usually on behalf of one of the full academics in our team. This year, it will probably wind up more like 20 or so, for a mix of conferences, workshops, and journals.

What I'm finding is that about 2 out of 3 papers that I review is riddled with basic grammatical errors. I'm more than happy to overlook a certain density of errors, but perhaps half of these present with errors in a density that would see a university paper sent back to the student with a fail, with little regard for the technical merit of the ideas being presented.

So, do we hold academics to a lower standard than students, on the grounds that a higher proportion are non-native speakers, and that the merits of the ideas outweigh the faults of the presentation?

Personally, I am finding that my critique of the technical merits of these papers is suffering because I am spending too much time correcting, or simply being frustrated by, faults of presentation. The paper is more difficult to read, so the review takes longer to complete, and the lost continuity makes the technical contribution harder to understand. I also spend less time thinking about the science and the relevant technical questions, because I'm instead scribbling down "needs a definite/indefinite article" and "plural: are not is".

I am not unsympathetic to the difficulty of writing in a non-native tongue; the summary chapter of my thesis was riddled with grammatical errors (ed: I confess I did send this chapter to a French journal; I regret doing so, and it was quite rightly rejected because of the poor quality of its writing). However, I also spent a long time correcting the grammar of my colleagues at the lab in France so that their papers might be more legible when they reached reviewers. This is when the majority of such correction should be done. By the time a paper reaches a reviewer, there shouldn't be more than a couple of errors per page, at the most.

Well, there's my rant for the day. It will make me feel 3% less guilty about my review taking so long to get done.

timely change

2008-04-16T08:52:00.003+02:00

I only started using Outlook (or Outrage, as Robin calls it) about 9 months ago, which was about 6 months after I started using Google Calendar. the lack of integration between the two was very frustrating.

I had initially heard a rumour that a bridge was possibly if one had Outlook 2007, but as I didn't, it didn't help me. Of course, I should have realised that it was a better idea to hope for a solution from Google than from Microsoft. Sure enough, Google Calendar Sync!

It's missing a few features - it only syncs to the first google calendar (which isn't my "work" calendar), and I'd like to be able to control the privacy settings of the incoming events - but it essentially works.

STEP/Express

2008-04-16T07:13:00.003+02:00

Over the last couple of weeks I've been getting to know STEP/Express. STEP is the language used to define IFC, which is the standard modelling language interchange format in the world I'm working at the moment.

STEP bears a resemblance to MOF, both in its purpose as a language for defining modeling languages, and structurally, in terms of defining object types, attributes, references (right down to opposites), etc.

The first two days of the course were to do with Jotne's model server, which is essentially like a MOF repository but with domain-specific extensions for model visualization (plugging into a 3-D IFC viewer). There was a fair bit of support for model versioning (versioned at the model level rather than the object level, and with customisable and/or partial checkin/checkout), permissions (although I wasn't very satisfied with their permission model), and even domain-specific merging.

The last few days were to do with associated technologies. There is a language, Express-X, for writing what they call "query functions", which are really just server-side procedures. In many ways, Express-X fits the sort of role Kermeta tries to fill for MDE, a language for the manipulation of models. The similarity ends there, though. Express-X is procedural, with global variables, and various other language design decisions that I've never seen (real literals without trailing 0s ("1."), "++" as a generic insertion operator applicable equally for integer increment, set insertion and string concatenation) or things I wouldn't personally have done (1-relative arrays). I won't be carving out a career as an Express-X programmer.

They also have a bunch of tools that one can imagine for MOF/MDE. They have an ontology-like language which they use for common model elements, much the same way as I've heard MDE people talk about using ontologies. They have a validation framework for people to build model-checking modules, and they're sniffing around some process-modelling stuff.

This isn't the first architecture I've seen with a lot of things in common with MOF/MDA, and I won't be switching, but its interesting to see people in different fields moving in the same direction.

STEPS

2008-03-20T05:54:00.002+01:00

(Via LtU) Viewpoints Research have published the first year's status report on their previously discussed project.

This is a rebadging of the Squeak-Croquet crowd, who do cute enough stuff with Smalltalk, but whom I've always found much more grandiose in their presentation than in their products. I confess I was a little underwhelmed by Squeak/Croquet when I tried it.

What struck me about their progress report was its similarity to a lot of the principles of MDE, in terms of lots of languages and transformations between them.

The central tool – called IS – is a pattern directed transformation system with various levels of
language descriptions from very high level languages in which we write code, all the way to descriptions
of the machine language instructions of our target machines.

If I understand their reference (they don't cite anything, so its hard to tell), they are a bit dismissive of MDE:

Similarly,
the recent work in modeling (too bad this term got co-opted for this) is only convincing to us if
the models can be automatically extracted

... which they can, at least in my envisioning of it all. Nonetheless, beyond the pejorative bits, they're doing some cute stuff, with some striking similarities to things I know about.

IS can instantiate new programming paradigms and systems, including itself. It demonstrates the
power of “extreme late binding” and treats many of the static vs. dynamic choices that are traditionally
rigid (compilation, typing, deployment, etc.) more like orthogonal axes along which design
decisions can be placed.

This gets at the aim of Kermeta as a language engineering workbench - the structural part works well, and the operational part is pretty much there. The idea of compilation, typing, deployment etc as orthogonal design decisions was something that I hinted at in my thesis (modeling type systems as opposed to typing modeling systems) as a direction for Kermeta (one that hasn't yet been explored much, to my knowledge). Indeed, part of the idea of model typing was to enable the implementation of "language aspects", I guess (once again, not yet explored much).

Its a shame, but there seems to be a lot of "turf" differences between crowds like these guys, the graph transformation crowd, the MIC crowd, the MDE crowd (even within the MDE crowd), which leads to a lot of reinvention of the same paradigm.

starting with a trickle

2008-02-15T03:13:00.002+01:00

After four weeks, we now finally have a source code repository, our adopted base framework has been checked in, and stuff from our project is just starting to trickle in. I know we haven't been sitting on our hands up to this point, but it does somehow feel like the project is actually underway now. It's a good feeling.

good gantt

2008-02-05T01:13:00.000+01:00

I've promised to do some Gantt charts. By the end of the week, no less. Honest to blog, what am I becoming?

random notes from a forgotten workshop

2008-01-31T07:14:00.000+01:00

I stumbled across some random notes I took in a workshop a while back.

"W3C does not produce standards" - you just keep tellin' yourself that!

Standards groups as a means for market research.

Cult of TBL

A hundred-pound gorilla is a very small gorilla.

Still no evidence of understanding of conceptual vs representational schemata.

This post may be interesting to no-one. I'm not sure why I'm posting it.

back to work

2008-01-16T04:57:00.000+01:00

I started at QUT on Monday. I'm working for the Faculty of Built Environment & Engineering, but I'm physically located in the CRC for Construction Innovation.

We're going to be working on migrating some construction-related modelling tools across to Eclipse, as well as expanding and integrating them. Very big metamodels (bigger than UML by some measures), and very big models. I once heard someone from Boeing explain that an aeroplane was not a single thing, but tens of thousands of components flying in very close formation. The models with which we will be dealing are the same, with the exception that, with any luck, they don't fly.

moving on

2008-01-07T05:48:00.000+01:00

I resigned as a NICTA employee at the start of December, and worked my last day there on the 21st.

I will start a new position with QUT next Monday.

someone using model types

2007-12-10T05:01:00.000+01:00

Note to self: Antonio seems to have implemented model types.

What I'd like: Face Search

2007-11-22T08:14:00.000+01:00

When I was half-awake yesterday, I was thinking about image search. Google offers image search, has for a while, and recently added the ability to restrict results to faces. What I want, though, is the ability to use an image as a search term.

Now, in the general case, I can see that this would be pretty much impossible. If you restrict it to faces, though, I figure it must start to become tractable.

I mean, in the short term you could let the user supply a face image and a text search term, then grab all the face results from a google image search, and order them based on their compatibility with the face search term. That'd be cool, I would think.

Longer term, you could have spiders that search for face pictures and store their characteristics for future comparison against image search terms. I'm not a face recognition person, so maybe I'm kidding myself...

David submits

2007-10-19T02:14:00.000+02:00

(Via Michael) David Hearnden has submitted his thesis, on "Deltaware", about (in broad terms) incremental propagation of changes in model transformations.

I think this is a really good piece of work, albeit pretty heavy-going for the layman (and, I have to confess, for the non-layman!). Rather than posting a link to the document (which at 541 pages is enormous and I presume still in draft until the reviewers are done with it), I'd encourage people to contact David and discuss it if they're interested, as well as checking out his paper from MoDELS '06, which should give a taste of what he's on about.

EMF vs ECore

2007-10-09T02:17:00.000+02:00

Ed Merks responds to a poll about "EMF vs MOF". As Ed points out, there is by no means a conflict; one is an implementation of the other.

ECore vs EMOF is more interesting, but once again, as Ed points out, ECore has been an influencer of the recent MOF standards, and there is really little difference. Getting rid of associations was a bit of a drag, but other things like property redefinition and package merges were probably ripe for separating into a "fancier" variant of the MOF standard.

One issue that might bear future consideration is the introduction of generics into EMOF. In my opinion, the way they're modelled in ECore now is pretty ugly, mainly because of the desire to support in-metamodel erasure of type parameters in order to better mirror Java's generics. I'm a big fan of generics - I was heavily involved in their design, and somewhat involved in their implementation, in Kermeta - but I certainly wouldn't like to see the EMOF metamodel introduce them in the same way as EMF has.

The Eclipse Modeling Symposium, also mentioned by Ed, looks reasonably interesting, although there are some notable omissions. Its a shame its on the other side of the world, or I might have looked more closely at the possibility going along.

seems fair

2007-10-08T02:25:00.000+02:00

Programming languages throw down.

CORBA: Can't we all just get along?
Java: Wow, who knew that guy was still alive.

near future of programming languages

2007-09-25T08:08:00.000+02:00

From Found Red, via LtU, a survey of what will be the main programming languages in 2013. Random tidbits I found disappointing:

HTML/CSS, Ajax, and .Net aren't really programming languages (one could make a case for .Net by reading it as the core "bytecode" language, but I'm skeptical about how many people will be coding in that, for all that is reasonably interesting).
There isn't much in there suggesting any takeup of innovation in language features. What is the 2013 list that isn't already in the 2001 list? Java generics, I guess. Things like closures, introspection and regexps in the dynamic languages, although it'd be hard to argue they're anything that hadn't already been done 20 years ago. Prototype-based OO (Javascript)? Meh.
No Scala. No Erlang. I'd even settle for an OCaml or Haskell just for diversity's sake. Would ontology zealots argue for a reasoning language? That'd be interesting, but all of these are admittedly unlikely to be top-10 material in that time frame.

quiet

2007-09-13T02:03:00.000+02:00

I've been quiet for a while. The things I'm working on now aren't really related to the originally intended subject of this blog - MDE. Specifically, we're working on a Rails app for passing around XML messages based on a couple of emergency specs.

My initial impressions of Rails have been frustrating. There is a lot of scaffold code that really isn't very obvious, and it seems like you have to have a pretty solid understanding of how the code generation works to be able to use it. Something in me wants to say that this needing to know about things that really should be under the hood is a "bad smell" (I can't immediately find where the phrase "bad smell" comes from in the context of software engineering, I'm afraid).

My impressions of XML and particularly the XML schemata we're using are also not particularly glowing. I still insist that XML schema is a bad language in which to do conceptual modelling. I'm finding the lack of true graph structures frustrating - there are a whole bunch of places in the schemata where references to other elements are through ID lookups, in order to keep the thing tree-like, and writing helper functions to re-link the graph is monkey work that should be done by a computer.

welcome aboard, tim

2007-07-24T13:31:00.000+02:00

When I got my first summer project with DSTC, I was assigned to the Orbit project, under the direction of Tim. On the day I arrived, though, I was told that another student hadn't shown up, so I would be working on MOF, which led me down the road I've been walking for the last 10 years.

Apparently Tim and I will soon be colleagues again, albeit it at a distance. Welcome aboard, Tim! (I would have left this as a comment on Tim's blog, but I couldn't be arsed registering.)

JSON

2007-07-23T08:40:00.000+02:00

JSON is HUTN for javascript. They really are almost identical, only JSON doesn't include the class of each object, which makes sense because javascript is prototype-based not class-based.

Something to keep in mind. I've started to think about a MOF mapping towards something like a prototype-based OO language, and JSON would be a logical alternative HUTN-equivalent if/when I do so.

Program Committees

2007-07-23T07:34:00.001+02:00

If anyone is looking for someone to serve on program committees for conferences or workshops related to software modelling (or related areas), then please feel free to contact me. I've previously served as a reviewer for SoSyM, as well as doing reviews on behalf of my superiors for ECOOP, MoDELS, EDOC, ASE, FMCO, ISSRE, ASWEC, MoDeVa, and LMO. For more on my research interests and expertise, I've plonked a list of publications over here (I'll add more links to papers as I'm able). I'm now at a point where I'd like to, and I think am qualified to, contribute more directly to the academic processes.

UML vs DSL panel @ Code Generation 2007

2007-07-23T06:24:00.000+02:00

Via Steve Cook, a taped panel session from Code Generation 2007 discussing UML vs DSLs.

I've met and heard most of the panelists speak before (with the exception of Matthew Fowler), so I kind of knew their stories, and can understand and respect their positions (made easy since each of them work with good businesses from a technical sense).

Although I reckon he often goes a little too far and bordering on vituperative, I do find Steve the most convincing of them. The point that DSL design should start with good language design principles is well taken, although I do think he sometimes tars the OMG too widely with the UML brush. Jos Warmer backs him up in this panel, saying that UML makes a pretty crap choice as a general purpose language, and an even worse basis for building DSLs. I wouldn't argue with that at all.

The discussion about general purpose modelling languages is interesting. I think UML does try to be a general purpose modelling language, and I think it does so poorly. This last week I've been working with ontology languages like OWL and RDF, which I think get closer to general purpose modelling languages. I think languages like these might be the best foundation to what is mentioned in the panel about building up languages as incremental abstractions on top of a GPML.

Soon after that, the idea put by Andrew that all upcoming languages are cursed to resemble C/C++ is interesting, in the implication that modelling languages might come to be similarly cursed syntactically by UML. I can see that happening, and as much as I have a soft spot for class diagrams, I can see the danger.

The points about the need for more sharing between programming language people and modelling language people are spot on. I would say that, though, since I just finished a PhD adapting programming language ideas and techniques for use in a modelling language context. Based on that experience, modelling language people need to do most of the legwork, since they have the most to gain, and possibly have a more agile community in terms of adapting to new ideas. This last point is probably down to just being a much younger space.

Employed again

2007-07-10T06:56:00.000+02:00

Last Wednesday I started as a researcher for NICTA in the Safe Applications For Emergencies (SAFE) Project, specifically in the SAFE Information strand. I don't know much about it yet, but it will almost certainly involve a lot of ontologies, which I'm enjoying learning more about. At some point in my future I'll probably offer my opinions on their strengths and weaknesses relative to other modelling techniques I've used.

Defended

2007-04-24T09:27:00.000+02:00

I defended my thesis yesterday before (in my opinion) an illustrious jury: Krzysztof Czarnecki, Birger Møller-Pedersen, Bernhard Rumpe, Robert France, and my director, Jean-Marc Jézéquel. Another member, Thomas Jensen, was unable to attend due to personal reasons.

The defense was successful, and I now have my PhD.

recruiting

2007-04-13T22:05:00.000+02:00

I'm looking for jobs in the wrong industry :)

(via Stefan Tilkov)

More UML bashing

2007-04-06T17:03:00.000+02:00

Further to my cryptic message of a few weeks back.

Mark, who is next door to my office, is working on a big project (metamodel will probably wind up being 60-100 classes, at a guess), where one of the deliverables is a UML profile.

Particularly horrifying (to me - I won't speak for him) this week has been watching him try to come to grips with the part of the UML metamodel dealing with templates (somewhere in superstructure). Like any part of UML, it involves skipping through different chapters, volumes and even versions of the UML spec to track down from whence each property has come, then tearing out hair when one realises that it is a case of either:

A simple idea modelled in a very complicated or unintuitive way (e.g. Partial ordering in Interactions, as I looked at with Jacques a while back), or

A simple modelling made complicated by being defined through indecipherably long and indirect chains of inheritance and package merges.

Mark's case was a mix. Some of it is relatively simple/logical when you can grok the spec (no easy task). On the other hand, there are some things (ParametrableElement) that are really quite weird.

Another observation is that some people in the project insist that, since a UML profile is a deliverable, they build their metamodel with that of UML in mind. Being a metamodel purist, I would say the opposite: they should concentrate on the essential ideas of their language, and then worry about the profile when they get to that. I'd be interested to hear people's takes.

insufficient controversy

2007-03-21T13:32:00.001+01:00

Every time a UML profile dies, an angel gets its wings.

what I'm up to

2007-03-07T14:36:00.000+01:00

It's pleasant, sometimes surprising and, in the most recent case, flattering, to hear about people who happen by my blog from to time. The most recent case made me realize that, although I recently posted about my status in the near future, I haven't commented on my current status for a while.

I sent my thesis off to my external examiners a couple of weeks ago (just before heading over to London), and am currently working on a French summary in order to please the administration here at the end of this week. After that, and depending on the feedback of my examiners, I expect to defend my thesis in late April. There is a provisional date, and if and when it fixes itself (once again, at the good graces of my examiners), then I'll post it here.

In the meantime, I have a few things to occupy myself, in terms of getting a paper written for an upcoming conference deadline and fixing some things in Kermeta in order that its model types might be made ready for prime time.

unemployed

2007-02-26T11:24:00.000+01:00

I guess its worth mentioning that, as of the end of April, I will be unemployed. If anyone reading this has offers for interesting work in either academic or applied research in software engineering, and particularly in model-driven engineering, then I'd be happy to hear about it. My preference is to return to Australia, but I'll listen to ideas from pretty much anywhere.

MAST (ASTReNet 12)

2007-02-26T11:02:00.000+01:00

Last week I went over to London for the 12th ASTReNet workshop, on Model Analysis, Slicing and Transformation, having been invited by Laurie.

The ASTReNet group (of which I am happy to now be a member), as represented by those attending, seems to consist mainly of source-code analysis folks, with a periphery of people from formal methods and modelling. This installment had a focus on modelling, and we congregated at the too-modestly-named Goodenough College.

There were a handful of talks on various things, the most interesting to me being those by Tony Clark and Richard Paige. We also had a fairly good discussion at the end of the day, much of which was kind of a meeting of the modelling and analysis folks to see what each was doing and what each thought of the other. Perhaps people were just being very English, but I was surprised at how civilized and productive the discussion was.

Of course, I also had the chance to catch up with people. I had good chats with people I knew like Laurie, Iman and Andrew Watson, with people I'd heard of but not previously met like Tony Clark and Awais Rashid, and with people I hadn't, like Richard Paige from York.

Strangely, the MDE folks I talked to said that this was pretty much the first assembly they'd had since the workshop I attended in Canterbury back in 2004. Its a shame; between the people working at places like Kings, Canterbury, York and Sheffield, I would have thought they certainly have the critical mass to do so more often.

towards formalisms for model-like structures

2007-01-31T13:26:00.000+01:00

Michael posts, based on an LtU post[1], about a paper for formalising associations as first-class language concepts. Indeed, I cite this paper in my SoSyM paper on model types and in my thesis, and its very interesting work.

The other element of modelling structures (as understood by us MOF-ites) that is not necessarily common in type system models, is that of metaclasses, and by implication meta-levels (if you believe in that sort of thing).

There's a paper by Tobin-Hochstadt and Allen from Sun about this, which was presented at FOOL[2] the same year that Bierman & Wren's association stuff was. Recommended.

For those inclined to more ambitious type theories, there was some work done on this by folk like Robert Constable in the 90s using constructive type theory (which is elegant, promising, not quite ready for the mainstream due to problems like decidability of dependent types). Along the same lines, Iman Poernomo has had a couple of good papers recently about mapping the MOF to CTT, although without special emphasis on metaclasses as such.

[1] Laurie once called LtU the last resort of the programming scoundrel, and he's probably right
[2] If there was ever a series of workshops with higher quality papers than FOOL, I haven't heard of it. Stuff there is off the hook, yo.

update

2007-01-23T21:29:00.000+01:00

I suppose it makes little sense to excuse a lack of post for a blog that has only seen twenty in the last year. Its not been so much for a lack of ideas, but for a lack of ideas that stand on their own and strike me as blog-worthy. This blog has proven much less satisfying than my personal blog, just because I've been less inclined to keep it active. With a little luck, that may change at some point in the nearish future.

I'm in the midst of writing up my thesis, which is basically about model types, along the lines of what my SoSyM paper talks about. The thesis is coming along, and I hope to be able to send it to reviewers in the next few weeks. The process of choosing who exactly these reviewers will be is quite a distraction, and although begun, is proving frustrating to finalise.

Model Typing paper

2007-01-17T23:48:00.000+01:00

The paper I presented at Models 2005 was invited for extension and submission for the SoSyM journal, and the extended version was accepted and is now online here. For those who don't have access to the journal, its also here. I would encourage those who do to patronise the site of the publisher, who do a good job.

I won't repeat the abstract, since it hasn't changed much from the original paper. The ideas of the paper are the same, that having the idea of model as a first-class concept is a good idea, and that these models may be typed in a way so as to make programs robust to variation in metamodels.

In the original paper the formalisation of these ideas, such as it was, was expressed as OCL constraints, and was certainly naive and probably flawed. In the revised version, the formalism is expressed as an adaptation of existing type systems ideas, notably Bruce & Vanderwaart's Type Groups.

David on EMF

2006-12-12T11:39:00.000+01:00

Software should be described along the lines of the following:

What seemed to begin as a promotion of extensibility has now resulted in premature abstraction from too much coupling and it just makes the platform flaccid - all of the classes are too timid to take responsibility for anything.

David is blogging again, it appears (and has been for a while). He seems to move blogs often, and I had lost track of him. Its good to have him back on the 'roll.

scala

2006-12-11T17:38:00.000+01:00

Throughout the year I've been running more and more into programming language research. The most impressive thing I've seen therein is Scala. For anyone who knows or is curious about current work in type systems and programming languages, Scala is pretty much the cat's pyjamas.

purity lost

2006-10-19T11:04:00.000+02:00

I worked up an algorithm (and the little data structure for supporting it) on a whiteboard on Tuesday night, refined it on Wednesday morning, and it was all shiny and good. Then I sat down to implement it into the system, and it all went to crap. The devil lives in the details, and although I think the algorithm is still sound, the hoops I'm having to jump through to handle corner cases are making the actual implementation so much less pleasant than the shiny design suggested it was going to be.

For those who are interested, the algorithm is object-type matching (<#) for comparison of two metamodels. Pretty simple, except its heavily cyclical - one match depending on another, or on the disjunction of a bunch of others. Runs the risk of being pretty expensive, but hey, its prototyping! The complicating factors include enumerations, primitive types, parameterised types, virtual types and type variables, and duplicate objects who don't properly implement equals().

fallback

2006-10-17T10:54:00.000+02:00

One day, when research loses its appeal and I'm no longer fascinated by what's new in programming, I'll just learn COBOL and go find a mail-it-in 9-to-5 maintenance job.

*Shiver*

Seriously, though. 62% of IT managers says they use COBOL? Those are horror film numbers. Most students aren't learning COBOL in school any more? No kidding. I'm surprised that any are.

(via Patrick Logan, Nat Torkington)

mofstalgia

2006-09-27T10:57:00.000+02:00

I was surprised when a Brazilian cited a kinda-publication of mine early last year. Well, here we go again. Our new Brazilian masters student, Rodrigo, is interested in the work too. As an update, what we did was a mapping from MOF models and metamodels to F-Logic facts and predicates in order to permit F-logic reasoning for searching and transforming models.

This time it was nice in that, courtesy of Michael, I was able to grab the source of our old mapping and show it to Rodrigo. It was a little embarassing - the MOFLog work was very much cardboard and string and, looking now, fairly poorly-architected cardboard. Beyond embarassing, what is sad is that I'm unable to actually demonstrate it to him since I no longer have a dMOF repository against which to run the mapping, and since only non-generated files where checked into the CVS repository, I have no examples of the mapping - only its implementation.

In many ways, dMOF has been superseded in any case. MOF 2.0 really is much nicer to model in and program against than MOF 1.x was, and having a repository like EMF supported by IBM is nice. That said, dMOF had some nice advantages in terms of deployability, and some stuff like its database connectivity that, though I didn't use it at the time, remains cool.

service

2006-09-27T10:51:00.000+02:00

Upgraded to Blogger Beta, and fixed my blogroll to reference bloglines. Normal (non-)service continues.

doppelganger

2006-09-14T19:32:00.000+02:00

David Akehurst and Wentworth Miller are the same man. Its scary.

paper reviews

2006-07-27T11:43:00.000+02:00

Part of my job (such as it is) is to review papers for workshops, journals, conferences, and such like. The majority of the time, I have only limited or moderate expertise in the domain, and have to do a little background research into it, or to an extent trust the authors' characterisations of the field.

Every now and then, I get a paper that is really in my backyard, where I know the works they cite, and am very familiar with the characterisations they make. Usually, such a case ends with me swearing every half-page at something they've gotten (IMHO) wrong, or a decision where they've taken (IMHO) the wrong path. This has never been more true than the paper I'm reviewing at the moment. I'm right in the field, and every page or so I have the almost irresistable urge to hunt them down and beat them upside the head. If their gross misconceptions weren't bad enough, they're basically working on (IMHO) a non-existent problem masquerading as a serious roadblock, and are pretty much wasting their time and, more importantly, mine.

This post is a salve (-o?) in order to avoid tipping my hand by getting into the problem or authors in question. At some point in the not-too-distant future, I'll find a pretext to discuss the research problem outside the context of this review, which must obviously remain confidential and anonymous.

DabbleDB pitch

2006-07-26T14:01:00.000+02:00

Seriously impressive pitch of DabbleDB (via Stefan Tilko).

This is the sort of slick app that comes about when a technology (in this case basically databases, though there's a lot of web 2.0 in there as well) is mature. I want to see DabbleModel within about 3-4 years' time, where instead of fiddling data tables and db schemas behind the scenes, it fiddles models, metamodels and transformations. Its really not a big change - the modelling stuff is already there, although model and metamodel refactorings, and the relationship between them, are things I haven't seen done well yet, even conceptually.

paper accepted

2006-07-07T10:23:00.000+02:00

A paper with my name on it got accepted to ISSRE 2006 the other week, on test case generation for model transformations. This is pretty satisfying. I wasn't directly involved with the writing of this revision, but its the fourth or fifth conference to which we have submitted this work, and I was pretty heavily involved in the ideas at the beginning. Whether our continuing revisions made the difference, or whether the domain evolved to make our work more interesting, or whether its just dumb luck to get some reviewers who get what we're doing, it'll be published now, which should let Erwan & Benoit in particular move on with the work.

MoDeVa 2006

2006-06-21T09:29:00.000+02:00

MDA/E/SD is coming along, but one of the areas where it still really needs work is on verification and validation. Testing model transformations was something that I looked at with Franck a while ago, and while it seems difficult at first, it only gets moreso the closer you look. We also had some frustration when we were building Tefkat in terms of writing and particularly maintaining a test suite for the engine. More recently, my model typing ideas play a little into the verification space.

Ergo, we have the MoDeVa workshop. The first MoDeVa workshop was held a couple of years ago at ISSRE'04 in Rennes/St Malo, and it ran again last year at MoDELS'05 in Montego Bay. The quality of papers has improved at each step, I think, and this year there should be a better breadth of papers again, with more people starting to look at verifying and testing model-driven systems. I'd encourage anyone with interest in these problems to come along, and to submit a paper (deadline: 31 July) if they have ideas or experiences they'd like to share.

Disclaimer: I'm on the program committee.

Benjamin Pierce on bidirectional transformation

2006-06-19T16:41:00.000+02:00

I got my copy of Types and Programming Languages (along with Advanced Topics in Types and Programming Languages and Fundamentals of Object-Oriented Languages: Types and Semantics) last week, and while reading it wandered over to Benjamin Pierce's site. His latest presentation talks about the data synchronisation issues that they address in their Harmony project. There may very well be things to be learnt from Harmony for model transformation, and particularly for bidirectional transformation and change propagation.

mutation testing workshop

2006-06-13T11:01:00.001+02:00

In the interests of keeping this blog active, and of giving Benoit some much-needed press, this is a heads-up for the Mutation '06 workshop, linked to ISSRE 06.

I'm not working with mutation testing myself, but MDA-wise, Jean-Marie Mottu here at our lab has done some interesting things on mutation testing for transformations, both for Kermeta and for Tefkat. I believe there has also been some work done at the uni of Queensland by Soon-Kyeong Kim and her group. Its an interesting field, and pleasingly meta- for someone like me, since its generally about testing your testing (as I understand it). Appropriate also given the name of this blog, I suppose.

question?

2006-06-02T10:49:00.000+02:00

So, for the 2 people who actually read this blog, I have a question. What's the prevailing doctrine on generated files and version control?

I'm getting back to code today, and instantly realised the magnitude of the error I made by not branching my changes from the main trunk right from the start. Having a checked-out copy with changes while 2 busy months passed on the trunk means that I now have 400 or so changed files to sift through, 260 of which are conflicts. I reckon a good three quarters of those are generated files. Its my own fault for not managing my development properly, but are my problems being amplified by having generated files checked in?

talk at UQ

2006-04-19T04:48:00.000+02:00

I gave a talk at UQ on model typing the other day (last Wednesday afternoon, to be exact), for the Systems & Software Engineering Research Group. Present were people I know from recent times, David Hearnden, Jörn-Guy Süss & Geoff Watson, people I knew from my undergraduate days, David Carrington & Paul Strooper (and perhaps Luke Wildman), and others whom I hadn't previously met, including Soon-Kyeong Kim. The latter has been doing some work on testing model transformations using the test criteria proposed in the MoDeVa paper I wrote with Franck & Benoit a couple of years back, so there will probably be some follow-up on that. I chatted with Jörn about workshop proposals for this year's MoDELS conference, and with David about various model typing and model-driven system evolution issues.

I'll be giving the talk at QUT tomorrow (Thursday). On the off chance that anyone reading this is interesting in coming and hasn't already been made aware, I believe it's at midday at 126 Margaret St.

tefkat

2006-03-06T10:50:00.000+01:00

That is, The Engine Formerly (Ed: and Formally, but mainly Formerly) Known as Tefkat. It wasn't really a geekronym until it was recursive, in any case.

By way of explanation, Tefkat is back on the air, and now opensourc-ier than ever. As Michael suggests, its pretty basic at this point viz-a-viz builds, website, and refactoring, but that'll no doubt change before too long.

Just when I thought I was out...

2006-02-24T14:44:00.000+01:00

I suggested 18 months ago that HUTN would be soon forgotten, and I wasn't far wrong. Every now and then, though, someone dredges it up. Someone wrote a paper for a MoDELS workshop last year bagging it, even though I reckon they just misunderstood how formal it wasn't supposed to be. And last night some poor fool tried to raise issues against the spec! Poor fool only because he doesn't realise that no-one in the OMG gives a good goddamn anymore if the HUTN spec has a few bugs. Of course, the OMG don't care because basically no-one else cares, so its all fair play.

(NiceLanguage) Java

2006-02-16T18:57:00.000+01:00

I'd forgotten just how often you cast in Java. It's giving me the shits already. Ruby spoilt me.

EMF refactorings

2006-02-16T13:22:00.000+01:00

I'm just dipping my toes back into development waters this week. One thing I've noticed is that the refactoring support in Eclipse is really nice, and it would be really nice to have a similar thing in EMF.

For example, I was rummaging around in Kermeta yesterday and found a spelling mistake in one of the classes of its metamodel. Now, if the mistake was in a java interface I could refactor it and have help finding all the references to it, in order to change them accordingly. However, since there's no refactoring in EMF, it becomes a nasty task of using java refactoring where possible and then scrambling around to make sure all the cases have been caught.

There's probably an implied story here about change propagation. Really, the change of the class name needs to be propagated across the code generator, which can then invoke the refactoring tools.

This is what some people call a "worthy" problem.

a quick update

2006-02-16T13:09:00.000+01:00

To be honest, I'm not very satisfied with this blog. I think my biggest problem comes from the fact that I posted something online (not even here actually) last year and someone reused my idea without the level of attribution that I would have liked. Since then I've been reluctant to post ideas here for fear that others might claim them as their own.

As an update to what I've been doing, a couple of weeks ago I submitted a revised version of my MoDELS paper to SoSyM. It changed quite a bit - I've been working on type systems formalisms for better defining the concepts of model type substitutability, and I think its a much more credible piece of work now. I still need to finish it off though and turn it into a coherent type system, something I intend to get to next month.

Right now, I'm starting to build the model typing ideas into Kermeta. There are a bunch of things that make this more complicated that the theory I've been doing - product types, function types and most interestingly parameterised types - but mainly this just makes it more exciting, since these things really raise interesting usage scenarios. If I can get it working, it should be a good validation of my ideas. Also, I believe it would make Kermeta the first model-oriented language (transformation language or otherwise) with models as a first-class concept. Correct me if I'm wrong, people.

tefkat paper now online

2006-01-23T14:09:00.000+01:00

The paper I co-wrote with Michael Lawley last year for the Model Transformations In Practice (MTIP) workshop at MoDELS '05, entitled "Practical Declarative Model Transformation with Tefkat", is now available online for those with a Springer subscription. Though Michael did the bulk of the writing, I presented the paper at the workshop, which I thought was a really useful forum, and we were lucky enough to have it subsequently selected as one of two papers from the workshop published in the conference's satellite proceedings.

One day, when I have some time, I'll try to put up a PDF version for the larger public.

Update: The full proceedings from the workshop are also available online from the workshop web site.

Announcing RMOF - a MOF for Ruby

2005-11-23T14:59:00.000+01:00

Motivated by a request via a passing reference in my Models paper, Franck and I have cleaned up the implementation of EMOF in Ruby that we wrote last year, and put it up as a project on RubyForge, at http://rmof.rubyforge.org. For the moment the download is only via CVS, there are some pretty distracting bugs, almost no documentation and not many test cases. That said, it works, given a sufficiently wide definition of the term. We're neither of us working on it or using as part of our studies, but we'll certainly try to respond to questions and fix bugs where possible.

model typing paper

2005-10-17T15:15:00.000+02:00

Two weeks ago at the MoDELS '05 conference in Montego Bay, I presented a paper on the idea of a type systems for models. The PDF can be found here. The abstract is as follows:

Where object-oriented languages deal with objects as described by classes, model-driven development uses models, as graphs of interconnected objects, described by metamodels. A number of new languages have been and continue to be developed for this model-based paradigm, both for model transformation and for general programming using models. Many of these use single-object approaches to typing, derived from solutions found in object-oriented systems, while others use metamodels as model types, but without a clear notion of polymorphism. Both of these approaches lead to brittle and overly restrictive reuse characteristics.

In this paper we propose a simple extension to object-oriented typing to better cater for a model-oriented context, including a simple strategy for typing models as a collection of interconnected objects. Using a simple example we show how this extended approach permits more flexible reuse, while preserving type safety.

The definitions presented within for model, model type, and for model type substitutability, are quite simple. This is partly because the paper represents an initial effort, and partly because I believe the solution need not be a complex one.

I had some feedback, both positive and negative, at the conference, but I'd love to hear more. If you feel the urge, either drop a comment or email me.

booch-scootin'

2005-10-14T11:51:00.000+02:00

I can't resist it. Grady Booch is dancing about architecture, which is like writing about music (apologies to Frank Zappa).

intelligent design

2005-09-01T12:07:00.000+02:00

You know what the funny thing about the creationism vs evolution debate? We're presented with two cases. We have this really complex system : the universe, or the earth if you prefer to consider a nominal subsystem.

In one story, someone put it together a few thousand years ago as a static system, and has been intervening from time to time since.

In the other story, someone designed a set of processes, notably evolution, that have kept the system running for a few tens of millions of years, without extensive intrusion. That's serious uptime for a dynamic, evolving system, and the computer scientist in me says its way more impressive than the first story. If its a choice between a god who made man and a god who made evolution, which made man, then I'll take the programmer god.

Microsoft on wider MDA

2005-05-26T15:19:00.000+02:00

I've been waiting about a year to hear this clearly from the Microsoft (admittedly, it may be my not listening that has delayed as much as their not saying clearly). This comes from their Modeling [sic] Strategy and FAQ page, via Steve Cook:

Some organizations pursuing model-driven development accept a wider interpretation of the term MDA than the interpretation prescribed by the OMG; indeed, as we've described, they must do so in order to succeed. The use of any of the OMG's specifications to drive model-driven development is typically marketed as MDA, whether or not it involves PIMs and PSMs. Some organizations, for example, see the OMG's MOF specification as key to MDA. This view relies on new modeling languages defined using MOF, not the modeling languages that are predefined in UML, and is effectively similar to our approach. We will support interchange with popular UML and MOF tools on other platforms, either via XMI or native formats, to help customers who are using them succeed with model-driven development.

Its a pleasant change from their usual (and understandable) bashing of UML, which has the unfortunate effect of scaring people away from other useful things that go on at OMG. And who knows, if they keep saying sensible things like that, I might wind up barracking for them a little. Perish the thought.

brittle schemas

2005-03-10T16:07:00.000+01:00

In this post from Philip Wadler's blog, he mentions people who are finding that Schemas pose some interesting problems for typing, for example with regard brittleness of programs when adding elements. This is exactly what I'm trying to get around.

FP for web apps

2005-03-10T10:38:00.000+01:00

Philip Wadler, Xavier Leroy, Simon Peyton Jones, and Benjamin Pierce are organising a workshop in Edinburgh to talk about designing a functional programming language for building web apps. It might not be the approach that I would take, but when a list of names like that appears, anyone interested in programming languages should listen (via LtU).

more paper dumping

2005-02-23T14:55:00.000+01:00

This paper, on incremental model transformation, might be interesting for David Hearnden, although I don't doubt he's way, way ahead of the game by now, or for Michael, if he ever decides to add incremental transformation to Tefkat.

MODELog

2005-02-23T13:42:00.000+01:00

Its always nice to see yourself cited, but particularly when you haven't really published properly.

Via Benoit, I stumbled across this paper (PDF, longer non-citing version with oodles of technical detail here) this morning, on mapping UML class diagrams to OO logic programming. In it, they cite a brief reference we made in our ICGT paper to the work we did at DSTC a couple of years ago with MOFLog. They make two observations about what we said. Firstly, performance can be increased by compiling to Prolog, which was indeed what we ended up doing, I guess after we published. Secondly, that a later version of Flora-2 resolves some of the problems we had with negation.

In hindsight, I kind of regret that we didn't publish our MofLog stuff, or follow it up, since I thought it was a really nice language. I talked a bit about it last year with a postdoc here who had done his PhD in logic programming, but my background in logic isn't strong enough. One day when I have more time, perhaps I'll remedy that and resurrect the idea.

Update: Chasing around, this work was the topic of Franklin Ramalho's thesis, during which it appears he spent some time at LIP6, which I visited last year. Furthermore, it seems that he gave a seminar on this work at LIP6 a month before I was there. That's messed up.

new club

2005-01-27T10:23:00.000+01:00

I've finally gotten around to transferring my membership across to the French branch of the "I hate UML" club. Tomorrow I'll talk to someone about getting on board for the "Action semantics is a cruel joke" subcommittee.

opinions on MOF-Text submissions

2005-01-26T14:26:00.000+01:00

MOF-to-Text initial submissions are in, being presented next week in Burlingame. Given my background with HUTN, I would probably have played in this game if I didn't have a PhD to do. My initial reaction to the RFP was that were two credible paths. Path 1: you do a template language, perhaps based on Velocity or something, using QVT/Q or OCL for selecting model elements, and deem round-tripping too hard. Path 2: You take a grammar approach, using similar query ideas, and then look at possible syntactic sweetening or partial mapping to templates to make it usable. We had a peek down the second path with Anti-Yacc a few years back at DSTC, and it poses many usability problems, so my money would have been on the template approach as the most ready for the OMG.

There are two groups:

Softeam/SINTEF: Seems to just add print statements and File manipulation to the imperative part of QVT. I don't think this gets us anywhere.

Interactive Objects (M2T): Template-based, but also with notions of more levels of structuring, of decorators, and of protected text blocks.

Compuware/Pathfinder/Mentor: Template-based, but heavily influenced by aspect-oriented ideas, which I don't quite follow and need to read more about. Seems on the surface like a bigger language than IO's, but that may be just a superficial impression from the document.

TCS: Template-based, fairly simple, borrows syntactically from JSP, I think, which isn't a bad thing. Lacks advanced structuring concepts that IO and (I think) Compuware have.

I was asked whether I would support the Softeam submission. I wouldn't because it is the least "MDA" approach to the problem - it is a general programming approach that I don't think will scale. Probably the IO submission is the one I'd go for, but I need to read the Compuware/Pathfinder/Mentor document more closely to grok their aspect stuff.

I was surprised also that Wim Bast wasn't on any of the submission teams, because he presented a nice little system at EWMDA last year, kind of halfway between the IO and Compuware ideas, I suspect. I also would have liked to see AntiYacc in there, not as a viable ready solution, but just to make people think about the ideas of a grammar-based approach.

papers on interdependent types

2005-01-26T14:08:00.000+01:00

In my MOF typing travels, I finally found something interesting this morning. First, this paper by Erik Ernst on Family Polymorphism, and then this paper by Kim Bruce that works on a similar problem, but uses the term Type Groups (he also has another interesting paper here, and a presentation here).

These papers come very much from a programming language theory perspective, whereas I'm coming more from a data structures perspective, I guess, but I suspect we're knocking on different doors to the same room.

Incidentally, I came across this while trying to find works on polymorphism/conformance algorithms for graphs (probably typed graphs or maybe attributed graphs). I haven't been successful, so if anyone knows of some work in that space, let me know. I'm sure it must exist, because the graph grammar and graph transformation folks have been working hard around that for a long time.

Booch on MS/DSM

2004-12-07T14:58:00.000+01:00

Every time Grady Booch posts these days, my expectation of seeing something interesting from him decreases.

This time its the MS/DSM vs OMG/MDA debate. He responds to a post by Alan Wills about why Microsoft is avoiding UML by trotting out a whole lot of rot (factual rot, but it doesn't make it any less whiffy) about UML stereotypes and profiles, none of which makes a lick of difference to the issue at hand, in my view.

Look, I'm supposed to be on his side here. I mean, I've played the OMG game for a while, am still playing it with QVT, and generally I believe in the idea of basing this stuff on open standards. However, this sort of defense of UML helps no-one. UML is not going to cut it for some applications of MDA, and I think pretty much everyone is clear on that. The response to the MS separatism is not to defend UML's ability to do things it was never really built to handle, but to remind them that we know it has problems, and we have other standards to use in those cases.

I know I'm a MOF guy and Grady's an original 'amigo', and that I'm hardly impartial. However, I'm getting worried by the things I'm seeing people doing with UML and, scarier, seeing that the standardisation response seems to be to change the Unified to Universal and hope for the best. I think its going to sink, and I hope it doesn't pull other things down with it.

Grady, please don't turn me into a Microsofty.

food for thought: types vs tests

2004-12-06T15:45:00.000+01:00

And furthermore good food for good thought.

In a list of recent "essay of the year" articles, a couple appealed to me; "Strong Typing vs Strong Testing" by Bruce Eckel, and "Modern Static Typing: Less Code, Better Code" by Bryn Kellar. The first is a nice focus, effectively, on the question of why languages like Python and Ruby are so much nicer to program in than, say, Java and C++. The second discusses why it is wrong to blame this on static typing per se.

Both are excellent, but I would advise people to make sure to read them together. The first doesn't stand alone because it needs the definition/theoretical discussions in the second, and the second doesn't stand alone because it quotes pretty selectively, and is in any case very much a response to a question.

I would make one point in addition to the second article. He explains at one point the "problem" of accidental conformance, although he doesn't name it as such. I think you really have to be careful waving this problem about, because while it is sometimes a real problem, it is also sometimes a real solution. It is one of my views at the moment that systems that are, for example, distributed, or subject evolution, actually benefit greatly from "accidental conformance". This was something I stumbled across last year, in some ancient slides by Andrew Watson, more recently of OMG fame.

Adam Bosworth on simplicity

2004-11-30T11:29:00.000+01:00

This from Adam Bosworth, a talk he gave at a SOC conference a couple of weeks ago. My gut says to agree with him, but it's complicated. I think, in fact, that we probably need the tension between the monolithic approaches that he talks about (WS-*, Java, .Net, throw UML in for good measure) and the thin approaches. Eventually, the new thin approaches are going to pick and choose what really worked and was easy from the last-generation fat approaches.

ISSRE 2004

2004-11-08T11:43:00.000+01:00

Last week was ISSRE.

On Tuesday I attended a workshop at Rennes entitled "SIVOES (Specification Implementation and Validation Of Embedded Systems)-MoDeVa (Model Design and Validation)", where Franck presented a paper that we had written (with Benoit). There was some good discussion with Bernhard Rumpe and others afterwards about semantics in UML.

On Wednesday, the conference proper got underway with a very good keynote from Bob Binder, about different levels of rigour in testing, which I found very interesting, and about the difficulties of testing software in mobile environments, which I found somewhat less interesting. The conference itself was pretty good, although I was generally out of my depth when it came to things like statistical/random testing and reliability analysis. I was also a bit surprised that, in general, a lot of the work only relates to basic data types (ints, floats, not even strings usually), and very low level abstractions, which seems a bit dated for a modelling guy like me.

The theme was nominally testing for model-driven systems, but there were almost no papers on the topic beyond the one I presented to stony faces on Thursday morning. I got through to a couple of people though, and had some good feedback. Bernhard Rumpe also gave a keynote on model-driven development stuff on Friday, although nothing I hadn't heard before. He also claimed that the "V" in QVT stands for "Validation", and not "Views", as one might have guessed by looking at the RFP. Oh, well. The panel in the afternoon was a little better, but still dealt more with model-based testing (generating tests from custom models of the system) as opposed to testing in model-driven systems. To be fair, the latter is way too immature for a panel.

i turn my back for 10 months, and...

2004-11-04T14:11:00.000+01:00

Bad news. Yeah, everyone knows that Bush got re-elected but, according to Tinni, her employer has been knocked back for their funding application. I'm really, really biased, but DSTC was a great place to do research. Don't believe me though. Another Jim, Jim Coplien, said a couple of years back that:

“I hold the DSTC to be one of the most effective software research organisations in the world…”

That sucks and, like the elections (also American but particularly Australian), it suggests to me that the people making the decision must have been woefully uninformed or monumentally stupid to make such a choice. Whatever you think of the proposal specifics (and, although I didn't see the full proposal, only the first summary one, I had some criticisms), one look at who's involved screams, or should scream: "Give these people money and they will do world-class research".

Of course, funding bodies, like voters, aren't always that interested in details like excellence (or lack thereof) in doing what you're required and paid to do. Or maybe it's me. Again. For the third time in a month. Dammit.

conferences

2004-10-21T14:21:00.000+02:00

You can bet that I'm going to be trying to get a paper up at the next UML/MoDELS conference; it's in Montego Bay, Jamaica. Enschede, in the Netherlands, isn't quite so much as a drawcard, but I'll have to try and get something sorted out for EDOC, too.

note to self

2004-10-14T14:51:00.000+02:00

Note to self: APA (and associated stuff) applications close on 31 October.

programming languages

2004-10-12T16:42:00.000+02:00

10 years on (plus or minus one or two), and the MOO programming language might still be the programming environment I have most fondness for. I haven't used it since high school, but a lot of its principles still appeal to me, and I wonder how much that is because it influenced the way I think about programming. Looking back now, the syntax was pretty awful, but perhaps it was just the interacting with the objects that was nice, in that you could really see and understand object-orientation when you "were" one of the objects. There were some very sophisticated things in the underlying tech, though: prototype-based OO and stuff like that, but also that it was just the done thing to add and modify classes and methods at runtime. I never really thought about it at the time, but its a pretty neat trick.

wherefore?

2004-10-11T13:27:00.000+02:00

So, last week I was sitting in a talk from Stephane Ducasse, about traits and classboxing, some wacky "separation of concerns" type mechanisms that he's been building for squeak. There was this wacky guy sitting on one side of the room, who kept intervening with questions like "hasn't this already been done in X?", where X varied between functional stuff (ML and its variants), Lisp, and even variations like Self. At one level, he's just a moron with no concept of etiquette (disturbingly common in computing), but at another level, it raises interesting questions. He's right in some very vague sense - FP and Lisp and stuff like them are implemented, in some cases very well, and have got strong theoretical foundations, but no-one using them. Why is that?

ear, ear

2004-09-23T11:14:00.000+02:00

Its good to hear that someone is telling Bill Gates about modelling, and that its smart folk doing the telling; I've not met Keith Short, but Jack Greenfield and Steve Cook are smart cookies. Jack has had a very strong MDA* vision going back a long time. I remember excellent discussions with him, Dave Frankel and many others in Palm Springs back in 2000. The differences that Steve wrote about between Microsoft's views on models and the widely- but not universally-held views of the more conspicuous OMG companies are, in many cases, very valid points.

* rename as appropriate, the term certainly didn't exist at the time

what the...

2004-09-22T11:01:00.000+02:00

Gee, I'm getting sick of my boring old mouse. Hey, I know, I'll use my nose! (via SVM)

*blink* No, I didn't mean to click, I'm just confused...

I have a problem

2004-09-15T10:55:00.000+02:00

Having admitted that I have a blogging problem, its time to do something about it. I'm starting with Scoble. I realise increasingly that I don't really care about "Channel 9", tablet PCs, geek dinners, or MS promotion. Unsubscribed. Likewise Radovan Janecek, Dare Obsanjo, Mike Clark, Joel on Software, Leigh Dodds, Cafe con Leche, and Metaphilm. I just don't have the time any more.

(More accurately, they all into the "ignored" folder on bloglines - maybe one day I'll get paid to read blogs.)

fowler on closures

2004-09-15T10:42:00.000+02:00

Its hardly rocket science, but Martin Fowler joins in asserting that closures are Good. His point on the importance of brevity pushes my buttons, too. (The phrase "just concrete syntax" annoys me - keeping concrete syntax under separate consideration from the rest of the language is of course important, but it is important!). What he doesn't mention is the role that the type system plays in the brevity equation. In Java, for example, even if you add closures, the fact that you have to type all of your variables is going to be a big hit on the brevity of the closure.

As I've mentioned previously, they are indispensible in model-driven systems, where you frequently spend a lot of your time navigating structures, and building up, filtering, and tearing down collections. I heard similar sentiments last week in Canterbury from other people, such as Marcus Alanen, who've been using dynamic languages in connection with MDD* type activities.

*Yes, Stuart, I hear you :)

product lines

2004-09-14T17:35:00.000+02:00

There seems to be a general confusion about software product lines. In particular, people seem to be confusing them with what might better be called software production lines, meaning some sort of automated or semi-automated process by which a software product or family thereof is produced. By contrast, all of the literature I've read on software product lines uses the term for a group of software products specified in terms of a base model with carefully defined variation points.

The two are related, but I think its pretty important to keep them well-separated. (I am aware that some readers might perceive irony with respect to my thoughts about MDA term-slippage).

the typing divide

2004-09-14T17:15:00.000+02:00

The typing divide came up at a typing panel at the MDA workshop I was at last week, and was also mentioned recently on LtU (programming languages blog, naturally with a lot of types stuff). +1 from me.

I'm currently writing up a 1-page summary of what we talked about in the aforementioned panel, and will post it or link to it when I'm done. I probably should put the workshop paper I presented up, too.

CORBA reflection

2004-09-03T16:50:00.000+02:00

Let's get this straight right now. I love reflection. It lets you do the most ugly, evil, interesting things, and without it, metaprogramming just doesn't work properly. Anyway, it looks like they might finally get around to adding reflection to CORBA (even though I've ceased using it recently), which is a good thing. I'll have to read the doc to see if they'll add any support for reflective application (calling operations, etc) in addition to introspection.

Incidentally, in speaking with Ian on Monday, it seems that he (and particularly Paul) don't believe in reflection. However, I really think this comes down to appropriate definitions of reflection.

of all the gin-joints in all the world

2004-08-30T10:42:00.000+02:00

Imagine my surprise getting on the bus this morning when the first person I see is Ian Peake. Background: Ian was one of my lecturers (one of my best lecturers, too, I might add) at UQ in fourth-year, and I also did a little work with him while I was at DSTC. Anyway, it turns out he's now working for Heinz Schmidt at Monash, and is in Rennes (in fact at IFSIC, just downstairs) for this week's EuroMicro conference.

Its a small world after all.

GMail invite

2004-08-24T13:38:00.000+02:00

GMail invite for the person person I know (that means I've met you!) who emails me that they want one.

Cactus

2004-08-19T13:39:00.000+02:00

Tim Bray can add cactus to his list.

(Also, 'H' comes after 'F' and 'G' in most alphabets I've seen).