Archive for the ‘Software’ Category.

linux.conf.au 2007 Open Day

Joe Hurd is in town – he’s been working with some other local researchers on how to verify probabilistic computing systems. We were looking for some place to meet and catch up with each other, so I suggested we go to the Linux Conference Australia 2007 Open Day.

It was an interesting afternoon – a whole lot of exhibits, talks, and free food.

There were things like non-standard UI devices (dance mats, Wii Remotes, body/motion-detecting cameras) connected to Linux, Linux on amateur rockets and amateur satellites (“running Debian unstable”), commercial-and-homebrew Linux PVRs, a homebrew Linux-based Segway, and a homebrew Linux-based 3D-printer (“prints 1cc per hour”). Oh, and flashing fridge magnets from Google.

I took along Liam, my grade 1-aged son. I sat him down in front of one of the One Laptop Per Child laptops – there were three of them there at an exhibit. (These are the $100 laptops that you can’t actually buy yourself, even for $300.) We played around, and had someone run us through a demo. I don’t know… Liam happily uses both Windows and Linux at home, but he (and I) were a little stumped by the OLPC user interface. Maybe it was just our previous experience tainting us, but it seems a little strange to put a “non-standard” GUI on a mass-market item. Though I guess if it sells in the volumes they’re hoping, maybe it will end up being a “standard”!

SEPG Australia 2006

The day I got back from Rio, I was on the plane again to go to Melbourne, for the SEPG Australia conference, where I presented a talk Why Organisation’s (Don’t) Choose CMMI. The talk was a variant of the one I’d done for the ESE Breakfast seminar. For this audience I didn’t need to provide quite so much background on CMMI, and so I expanded a little on the setting and interpretation of the work instead.

The talk included some material from our paper An Exploratory Study of Why Organizations Do Not Adopt CMMI, which has now been accepted for publication, in the Journal of Systems and Software.

ISESE 2006

On Tuesday 26 September I got back from Rio de Janeiro, after having attended ISERN (a research network), IASESE (a school), and ISESE (a conference). A full week of empirical software engineering goodness, but sadly not much spare time to look around Rio.

ISESE (the International Symposium on Empirical Software Engineering) was the main reason I was there. I presented a paper Evaluating Guidelines for Empirical Software Engineering Studies, which was about how we evaluated a proposed set of guidelines for reporting controlled experiments in software engineering. I was one of 10 (!) authors. We used a perspective-based reading approach to review the guidelines from the perspectives of various kinds of stakeholders (Researchers, Reviewers, Replicators, Meta-Analysts, Practioner/Consultants, Authors). We expressed the needs of the stakeholders as questions about papers that we imagined had been written using the guidelines.

My last full day in Rio was almost too exciting – in the morning Emilia Mendes and I did a tag-team presentation of Maggie Wojcicki’s paper (Maggie had lost her voice on the flight to Rio), in the afternoon both (coincidentally) my paper and Emilia’s won distinguished paper awards at the conference, and then after a few rounds of volleyball on the beach, I got to do a bit of surf lifesaving when a student got caught in a rip. Luckily a local swam out to help with the rescue – I assisted for a while, but by the end of it all I was just rescuing myself. Everyone was OK.

Strategies for Reuse

Josef Nedstam and I have finally had our paper Evolving Strategies for Software Architecture and Reuse accepted for publication, in the Journal Software Process: Improvement and Practice. It’s been through a couple of iterations/submissions, but from go-to-whoa it will have taken about 3 years to see this published from when we first wrote it. It’s a nice story, mostly based on data from Josef’s PhD work, about how the best form of architecture-driven reuse for an organization depends on its business situation, and how they both can change over time. It’s an extension/response to Jan Bosch’s view of increasing levels of maturity for reuse (product line development).

F# Sample – Events, and .net Firebird

Michael left a comment, calling for some sample F# source code. Don’s already provided some samples on-line as part of the F# documentation, and there are a large number of samples in the F# distribution, so look there first!

But I thought I’d put up a sample of my own too. This is a GUI app which lets users insert, update, and delete rows from an SQL database table. The GUI part is built from a DataGridView in a Windows form. The database here is an embedded Firebird database called “DB.FDB”, in the working directory, containing a table called “MYTABLE”.

01 - open System;;
02 - open System.Windows.Forms;;
03 - open FirebirdSql.Data.FirebirdClient;;
04 -
05 - let connection = new FbConnection("ServerType=1;User=SYSDBA;Password=masterkey;Dialect=3;Database=db.fdb");;
06 - let adapter = new FbDataAdapter("SELECT * FROM MYTABLE;", connection);;
07 - let builder = new FbCommandBuilder(adapter);;
08 - do adapter.UpdateCommand <- builder.GetUpdateCommand();;
09 - do adapter.InsertCommand <- builder.GetInsertCommand();;
10 - do adapter.DeleteCommand <- builder.GetDeleteCommand();;
11 -
12 - let table = new Data.DataTable();; // this is like a proxy for the database table
13 - do ignore(adapter.Fill(table));;
14 -
15 - let view = new DataGridView();; // this is tabular data viewing/entry GUI thingy
16 - do view.DataSource <- table;;
17 - do view.RowLeave.Add (fun _ -> ignore(adapter.Update(table)));;
18 -
19 - let form = new Form();; // this is the top-level form...
20 - do form.Controls.Add(view);; // ...which only contains our GUI thingy
21 -
22 - [<system .STAThread>] // some magic we need for GUI apps
23 - do Application.Run(form);; // go go go!!!

This example has been stripped back a lot – you’d need to embelish it heavily to make the form into something more pretty and useable. Nonetheless, there are a couple of nice things to notice here.

First, look at line 17, where we tell the DataGridView that when the user leaves a row, the database should be updated. The nice thing is that the code to handle the RowLeave event is an ordinary function, and in its body we refer to the table and adapter that are within its “closure”/enclosing environment. Nice – event handlers often need to work on things that are within their environment, but are not accessible from their event parameters. (The treatment of events in F# is nice for other reasons too, but that’s just icing on the cake.)

Second, the managed .net Firebird library is accessible so easily. We just need to tell the F# compiler that we’re using the dll for the Firebird ADO.NET Provider, FirebirdSql.Data.FirebirdClient.dll. To do that we use the -r compiler command-line option (not shown above). Then the library is available to be opened like a normal F# library (line 3), and its classes are available to be used like normal F# classes (lines 5-7).

Looking at F#

In my “copious spare time” over the past couple of weeks, I’ve been using the new F# language out of Microsoft Research.

It looks great. The F# language has a rock-solid heritage, from the ML family of functional programming languages. So, you get higher-order functions, strong typing with type inference, parametric polymorphism, closures, datatypes, and exceptions. But (unlike those whacky lazy functional languages such as Haskell) you also get strict evaluation like you already understand, side-effects like you know and love, and references like you just sometimes need. F# is more directly descended from Objective Caml, so you also get objects and classes.

What F# adds to the mix is seamless .net integration. You just tell F# about where a .net dll is, and then all of that managed code becomes available to call as if it were written directly in F#.

But F# is not just about the language itself – there’s also a good Visual Studio integration. Compared to the good old days of hacking around with Standard ML just on the interpreter command line, it’s a real pleasure to have an IDE with interactive debugging, and dynamic hints while-you-code, about types and about available functions and arguments.

Of course F# still has an interpreter too (also somewhat integrated with Visual Studio). Working with an interpreter is a huge productivity boon. It’s the ultimate in agile development – you can build your code from the “inside out”, so you always have working software without needing all the initial overhead of scaffolding for your proto-system.

The guy behind F# is Don Syme, another Aussie who shared an office and a PhD supervisor with me in Cambridge in the late ’90s. Beaudy Don!

ASWEC 2006

Last Friday afternoon, Ian Gorton wrapped up the four days of the Australian Software Engineering Conference (ASWEC) 2006 programme with a simple closing address. It was a huge week, and fantastic to see it all go off so well. Kudos to Ian – the conference general chair – for making it all happen.

Jun Han and I were the program chairs for the research papers at the conference. A lot of our preparation finished a few months ago, coordinating an international committeee of referees for the research papers submitted to the conference. We had the largest number of papers ever submitted to ASWEC (112) and finally accepted 41 to be presented. They’ve been published by IEEE Computer Society in a hard-copy proceedings, but the papers are also available electronically.

This year we built on the success of ASWEC 2005 in involving industry. We mixed the industry and research presentations together, had great keynote speakers, featured technical presentations from our sponsors talking about their areas of thought leadership, and had a huge response to the industry-focussed tutorial programme. Anna Liu and Chris Skinner pulled together the industry presentations, and Paul Mackie was key in getting the sponsors involved so well.

The conference finance chair Paul Bannerman was enjoying Fiji and so wasn’t there to see the results of his hard work. But Liming Zhu was – he’d made the website and submission systems run. The ATP was a great venue, we were very pleased with AVCorp who provided audio-visual equipment and support throughout the conference, and the food at Sugaroom was superb for the conference dinner. It was all good. Thanks to everyone who helped organise the conference!

After Ian’s closing address, a crowd of organisers and others kicked on to the after-party to celebrate what had been the biggest and perhaps best ASWEC ever. The after-party-goers enjoyed my homebrew (or at least politely feigned enjoyment of it! :-) ) – a good way to finish a great week.

Experiences Using Systematic Review Guidelines

On Tuesday, Mahmood Niazi presented a conference paper of ours, Experiences Using Systematic Review Guidelines, at EASE 2006. Systematic reviews use an explicit and characteristic methodology, and are intended to be unbiased and replicable study of a specific research question. They have a quite different purpose than conventional literature reviews. Barbara Kitchenham had previously written some guidelines about performing systematic reviews in software engineering research. We used the guidelines while performing our systematic review, and our EASE 2006 paper commented on both systematic review and these guidelines.

Overall, we thought systematic review was a valuable approach for software engineering. Many papers in software engineering are experience-based case studies. Systematic review can synthesis results from all relevant case studies, revealing patterns and information not readily apparent in any single case study.

We also though Barbara’s guidelines were useful. However, we’d like to see more guidance on piloting protocols and assessing the quality of selected studies. The systematic review protocol is a plan about ow you’re going to search for, select, assess, and extract data from the primary studies that address your research question. Protocols are valuable, but it’s hard to know when to stop reviewing and piloting the protocol, and when to actually start!

Despite reviewing and piloting a systematic review protocol, it will inevitably change during the execution of systematic review. So, just as with the debates on agile vs. planned development methodologies, you might ask “Why bother writing a protocol in the first place?” We would say it’s worthwhile, for similar reasons as described in the classic paper A rational design process: how and why to fake it (also here) – it improves the final outcome and helps communicate it to others. In our final technical report, we showed the final idealised protocol because it helps other researchers to understand and replicate our study. However, we also showed the original protocol (as footnotes describing changes) so other researchers to be able to assess any initial bias in the original protocol or in our changes.

Choosing a narrow and well-defined research question is critical to being able to reliably select relevant studies. In order to clarify the scope of our research question, we found it useful to define complementary research questions, that were similar, but different, to our actual research question. So for example, our research question was, Why do organisations adopt CMM-based SPI?, and our complementary research questions included questions like:

  • Why do practioners support the adoption of CMM-based SPI?
  • How do organisations adopt CMM-based SPI?
  • Why should organisations adopt CMM-based SPI?
  • What benefits do organisations gain after adopting CMM-based SPI?

The complementary research questions form exclusion criteria for the first stage of selecting studies, while the real research question form inclusion criteria for the second stage.

Finally, it’s previously been noted that systematic reviews have a high effort, but we also found they had a long duration! In a systematic review, a group of researchers go through many rounds of independent work interspersed with joint meetings. It’s hard to schedule joint meetings even with only two researchers who have otherwise busy schedules…

It’d be good to see a central site for software engineering systematic review (like the Cochrane Collaboration in medicine), and also to see some attempts to independently replicate some systematic review studies.

Study of Adoption of CMM-based SPI

NICTA has published a technical report (PDF here) containing the details of a systematic review of reasons why organizations adopt CMM-based SPI, which I co-authored with Mahmood Niazi. At the recent NICTA Software Engineering breakfast seminars I spoke about some of the results from this systematic review.

Systematic review is a methodology for finding, collating, and analysing all published evidence relating to a particular research question. It’s much more than a typical literature review. It’s meant to avoid bias and to be replicable, by being planned, procedurally documented, open to inspection, and run by multiple researchers. Systematic reviews are among the most compelling kinds of research in evidence-based medicine. Systematic review in software engineering is less well established than in medicine, but over the last year or two it has been generating increasing interest.

Our searches gave us 591 papers which we whittled down to 43 primary studies that described why organizations had originally adopted CMM-based SPI. We grouped and counted responses and found the most common reasons were to improve product quality, performance (i.e. development cost/time, productivity), and for process reasons (process visibility, best practices, process measurement, etc). Companies less frequently mentioned customers or employees as motivating reasons. We also found some evidence to support a claim that there may be widespread bias within the SPI literature that favours process-related organizational motivations over product-related or performance-related motivations.

Software Engineering Breakfast Seminar

I just got back from a roadshow talking to people around Australia about some results from a couple of research projects that we’re wrapping up at NICTA. It was the first in a series of breakfast seminars that researchers in our group will be doing over the coming year.

It was all good. The organization went well, the audiences numbers were good (especially considering this is the first time we’ve run a breakfast seminar), and most importantly the audience seemed interested in what we were saying. We got lots of questions, opinions, suggestions, debate, and positive feedback from software development managers, CEOs, SPI practionerss, and academics. We’ve built a little more awareness about NICTA and ESE in the Australian ICT industry, and hopefully made some contacts that will lead to some collaborative projects with Australian companies. There’s also a chance that we might have said something directly useful for someone!

I was speaking about Why Organizations (Don’t) Use CMMI. In the first half of the talk I gave an overview about CMMI SPI and ratings, and their benefits and limitations. In the second half, I presented evidence we found in a systematic review about why organizations have originally decided to adopt CMM-based SPI. I also presented some evidence about why other organizations have chosen not to adopt CMMI.

It’s ironic that CMM was orginally developed in response to customer-related problems (the US Air Force wanted assurance that its suppliers could deliver software on time), but these days companies mostly say they adopt CMM(I) for reasons related to product quality, project performance (e.g. development efficiency), and also perhaps for process-related reasons (e.g. process visibility, best practice, process measurement). Companies usually don’t say they adopt CMM-based SPI to address customer-related issues (e.g. specific customer demands, or market advantage), and almost never say they adopt it to improve the capability of people within their organization.

Of course most companies don’t use CMMI, and I also spoke about why they don’t, based on an analysis of a couple of months of sales data from a consultancy selling CMMI appraisal and improvement services. Companies thought they were too small, or that CMMI would be too costly or time-consuming to adopt. Sometimes they were already doing some other sort of SPI. We found a significant relationship betwen the size of companies and the reasons they gave, which provided some evidence to support the common belief that small companies think that they can’t adopt CMMI – they don’t even get around to considering a ROI analysis because they think that CMMI is either not applicable or is infeasibly costly or time-consuming.

The next steps in this line of research are to understand organizational decision-making for the adoption of SPI, and to understand the needs and practical constraints in Australian software-developing companies, so that we can develop improvement and rating approaches that suit Australian companies.

Speaking with me on the tour was Barbara Kitchenham, on Software Productivity Measurements – The Dark Secrets. She spoke about lessons learned from data gathered by an Australian company about Statistical Process Control (SPC) charts. SPC charts are important in manufacturing industries, but when people use them for “controlling” productivity in software development, things can go strange in a few different ways.

First, ratio measurements (e.g. productivity, defect rates) are unstable when the denominator values (usually a software size measure) are small. So for small units-of-work, you can sometimes get huge but basically meaningless spikes in the SPC charts. Second, Barbara showed some charts from industry where the variances were so large that “one standard deviation below the mean” was negative – that’s a problem if you want to notice low productivity! Third, combining data from a range of different types of projects wasn’t helpful. There was a significant difference in productivity between applications, and so it was much more meaningful for companies to do application-specific productivity monitoring, even though this provided fewer data values for statistical analysis. Finally, SPC charts of productivity weren’t great for visual communication – they tended to under-emphasize low values, and over-emphasize high values.

Barbara recommended a simple alternative to SPC charts – use scatter plots of units-of-work in effort vs. size instead. These scatter plots were dramtically easier to interpret and also provided guidance about productivity for effort estimation.