Designing for usability, usefulness, and unit-testing ... the linux.conf.au GTK & GNOME tutorial, part 2
In 2007 (and again in 2008) we presented a tutorial on the basics of programming with GTK. This year we're going to move on to the next level.
Applications are about more than packing a few Buttons into a Window. They are about effectively presenting information and providing usable interfaces for manipulating data. What do you have to think about to design such a user interface? Even more challenging, how do you structure your program code so that it will scale up as you build a real application?
The answers to these questions are all about design patterns. There are UI design considerations:
- User interface density: creative use of colour, sizing, and whitespace to make my program look cool and to maximize the thing that matters: the program *communicating* information to the user.
- Consistency: what do I have to do to meet GNOME's Human Interface Guidelines (ie, should I really care? What do I have to do to make people happy, and what you can I just leave alone?)
- Pitfalls: why is it so many applications look like endless "seas of forms". Gah! What causes that, and what can I do about it? How can I customize GTK Widgets to create custom presentations of my data?
and there are programming best-practise considerations:
- How do I lay out my code? Where does everything _go_? We tend to want to just "get on with it" but what structure (whether at the outset or, in an already growing project) can I put in place that will pay dividends not only by giving each element of the application a logical home but allowing the program to scale?
- even more importantly, how do can I create layers of abstraction that can actually be unit tested thoroughly?
- How can I best leverage GTK? What design patterns should use when coding my application? The toolkit seems really large; aren't there parts I can ignore?
- How do I integrate an event-driven graphical user interface with a large back-end or external enterprise system? Should I use threads? What are the pros and cons?
We will actually approach all of these from the perspective of anti-patterns: these are each areas where things tend to go _wrong_. We'll discuss why these mistakes occur (usually made by people with the best of intentions), how to recognize them, and how to engineer things so you don't hit them in the first place.
Again, we're going to use examples in not just one language but in *three*: C, Python, and Java. We will, again, and to the amazement of our audience, program LIVE and on screen in front of them. Obviously I can't write entire applications during a couple-hour tutorial, so this time the focus will be solving design problems. To that end, we'll have the code which is the starting point for each part of the tutorial posted online well before the conference, allowing attendees who want to get even more out of the tutorial to prepare ahead of time (though the presentation will be paced so that people who don't wish to do so will still be able to get the essential messages out of the tutorial).
Too often we hear from programmers, "I'm no good at doing user interfaces" (it's right up there with "programmers can't write documentation"). Our core belief is that any programmer can create beautiful UI, and this year's GTK tutorial will help equip people to do that. Even if you're not overly into the GNOME desktop, considerations about application architecture, user interface usability, software testing, and graphic design will be of interest to wide audience.
Somewhat unusually for a free software hacker, Andrew Cowie was an infantry officer in the Canadian army, having graduated from Royal Military College with a degree in engineering physics. He saw service across North America and a peacekeeping tour in Bosnia. He later ran operations for an new media company in Manhattan and was a part of recovering the firm after the Sept 11 attacks. Now based in Sydney, Andrew works for Operational Dynamics, a corporate operations consultancy working in crisis resolution, change management, robust architectures, and leveraging open source to achieve these ends. On the technical side, Andrew has extensive experience as a Unix/Linux sysadmin, Java developer, and has long been an Open Source advocate. Most recently, he has been contributing to the GNOME project, having written the java-gnome bindings allowing you to write GTK programs from Java.