[Home]

[Accomodation]

[Call For Papers]

[Chairs & Committees]

[Enquiries]

[Exhibitors]

[Speakers]

[Submissions]

[Tutorials]

[Timetable]

[Venue]

[Conference Papers]

Using COM to write distributed component software for Windows NT

Author:
David S. Platt                    
President of Rolling Thunder Computing           

Abstract:
The software industry today is moving from its original vertical structure, in which one manufacturer wrote all the elements of its software from bottom to top, to more of a horizontal approach, in which a software manufacturer assembles binary components written by different vendors. COM, the Component-Object Model, is the binary mechanism whereby one component locates, connects to, and interoperates with another. This class will start with the definition of a COM object and a COM interface. We will then examine the simple COM objects provided by the operating system, looking to abstract the conceptual simplicity, consistency, and elegance of the COM way of doing things. We will proceed to writing our own COM objects and interfaces and the support we need to provide to the operating system to accomplish this. Finally, we will look at how COM objects operate to and from different machines in a distributed computing environment. The notes for the class will consist of excerpts from the instructor's latest book, "The Essence of COM with ActiveX", published by Prentice-Hall. Sample code will be available from the instructor's Web site the day after the seminar.

Prerequisites:
As all code examples will be shown in C++, a reading knowledge this language is required. Familiarity with the mechanics of a Windows program, such as message processing, is helpful but not required. The seminar will be taught at a level of abstraction from which people who do not know Windows will be able to absorb the concepts, and no time will be spent on specific program syntax not related to COM.

Author's Profile:
David S. Platt is the President of Rolling Thunder Computing and an instructor in Computer Science at Harvard University. He has taught classes and mentored development teams on COM for client companies all over the world. He has written articles on COM for Microsoft Systems Journal. His latest book is "The Essence of COM with ActiveX", published by Prentice-Hall.

Designing Concurrent Object-Oriented Programs in Java
by David Holmes

Authors:
Professor Doug Lea                    
Computer Science Department           
State University of New York, Oswego  

To be presented by: David Holmes

Abstract:
Concurrent programming has mostly been the domain of systems programmers rather than application developers. Concurrent object-oriented programming has seen a resurgence recently, due mainly to the widespread acceptance of the Java programming language. Java's support for concurrent programming has enticed many developers to try their hand at concurrent applications, yet the use of concurrency within an application poses many traps for the unwary.

This tutorial demonstrates various design patterns and techniques for constructing concurrent object-oriented applications in Java and for managing that concurrency in an effective way. We look at the mechanisms and classes Java provides to support concurrent programming, what guarantees it makes regarding concurrent behaviour and we look at some concurrency issues that arise in the Java libraries. On the design side we look at object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems.

Expected Audience:
Anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. Although focusing on Java as the implementation language, most of the patterns and techniques discussed are equally applicable in other language environments. For those interested in Java this tutorial will give people a detailed working knowledge of it's concurrency mechanisms. In the broader sense people will be exposed to a variety of design strategies for introducing and managing concurrency within their applications.

Author's Profile:
Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns", co-author of the book "Object-Oriented System Development" and the author of several widely used software packages, as well as articles and reports on object oriented software development.

David Holmes is a Ph.D. student with the Microsoft Research Institute at Macquarie University, Sydney, researching more adaptable, flexible and re-usable approaches to synchronisation in concurrent object-oriented programs. He has a degree in Computer Systems Engineering and practical experience with concurrent programming through work on operating systems, distributed systems and real-time embedded systems, within a university environment.

Patterns (two day workshop)

Authors:
Jim Coplien, Martine Devos and Liping Zhao

Abstract:
Patterns describe problems that occur over and over again in our environment; patterns are a literary form for communications and sharing. You can only better  understand and use patterns by first writing them. Yet, writing patterns is hard; writing good patterns is even harder.  This workshop teaches you how to write good patterns and what to look for when reading and applying patterns. The workshop consists of one day's tutorial and one day's pattern writing sessions, in which attendees will be guided by experienced pattern writers.

Prerequisites:
A basic software design background is helpful, but not necessary, to fully enjoy the workshop. We encourage attendance by individuals with diverse backgrounds, including areas outside of computer science.

Author's Profile:
Jim Coplien is a Distinguished Member of Technical Staff at Bell Laboratories and a pattern laureate in the pattern community. His "C++ Programming Styles and Idioms" is one of the earliest works on software patterns. He is the author of  "Software Patterns" and co-editor of several pattern books. He writes a pattern column for the C++ Report. Among his many contributions is his highly acclaimed seminal work on Organizational Patterns. He sits on the
board of the Hillside Generative Patterns Group, a small consortium of industry leaders providing industry-wide leadership and support in the pattern discipline. He served as a program chair of ACM OOSPLA '96 and is a highly demanded conference presenter and speaker.

Liping Zhao is a lecturer at the Department of Computer Science, RMIT, Australia. She has more than 10 years' experience in public transport systems modelling and development, and has worked on many large  projects, including the European Union DRIVE programme. She writes domain-specific patterns for public transport systems.

Basic user interface programming using
the AWT and JFC (half day)

Author:
Jan Newmarch

Abstract:
This tutorial covers the fundamentals of user interface programming for the JDK 1.1 and 1.2. It uses both the older AWT and the new Swing components of the Java Foundation Classes. The
intent is to write programs that will run now and in the future.
The material covered includes:

• Evolution of the GUI programming toolkits
• Delegation event model
• Geometry management
• Menus
• Dialogs
• Applets and applications

Expected Audience:
A basic knowledge of Java will be assumed.

Advanced user interface programming using the JFC (half day)

Authors:
Jan Newmarch

Abstract:
This tutorial covers more advanced features of the new Java Foundation Classes. It assumes a background in programming using the AWT. The material covered includes:

• Lightweight components
• Swing components
• MVC model
• Customisable user interface
• Drag and drop
• Event management
• Text handling
• List handling

Brief Biography:
Jan Newmarch is a Senior Lecturer at the University of Canberra, teaching a variety of topics such as Client Server Computing, Operating Systems and Graphical User Interface Programming. He leads a research group, the Distributed Information Laboratory and is head of the Programming Systems and AI department. He is a regular contributor with papers and tutorials at conferences. He has written papers and books on AI, X Windows, the Web and Java.

His non-work interests include eating good food, drinking better wine than he can afford and listening to all sorts of music.

Java, Eiffel and C++: the language comparison (half day)

Author:
Ian Joyner, Macquarie University - Microsoft Research Institute

Level:
Advanced

Abstract:
This tutorial is based on my upcoming book comparing Eiffel, Java and C++.

Objective:
Eiffel, Java and C++ programmers will get a direct comparison of these languages, and will see some of the issues that lead to many debates over language differences. Participants who do not have direct experience in these languages will gain an appreciation of the differences.

Attendee Background:
This is aimed at an intermediate to advanced level of expertise in OO for people with experience in any one or more of these languages. However, it will also be of interest to people who are considering which OO language to adopt.

Brief Biography:
Ian Joyner has been involved in object-oriented programming for almost 20 years, has developed many OO systems, notably communications programs and a music publisher in MacApp, and written OO compilers. He is also interested in programming language issues and is currently writing a book comparing Java, Eiffel and C++. He has ported EiffelS to the Macintosh, and has developed the MOTEL library. He is currently employed at Macquarie University in the Microsoft Research Institute where he is involved with project Bruce to translate Eiffel to Java, and interface the Eiffel and Java libraries. He also tutors the third year database course.

Introduction to STL (half day)

Author:
Angelika Langer

Level:
C++ programmers who have heard of the STL and want to know what it is. Practical experience with STL is not required. Familiarity withtemplates is helpful.

Abstract:
The STL (Standard Template Library) is part of the ISO/ANSI standard C++ library and consists of a number of collections and algorithms. This tutorial aims to give an overview of the STL with focus on understanding and using its elements.

Brief Biography:
Angelika Langer is a freelance instructor, courseware developer, and mentor. She is currently writing a book titled "Standard C++ IOStreams and Locales" for Addison Wesley Longman. She has been writing and lecturing on various aspects of C++ for may years, including a column titled "Effective Standard C++ Library" for C++ Report. Her preferred fields of interest are training, coaching, and courseware development in the area of object-oriented programming in C++ and Java. 

Angelika's teaching and mentoring is backed by 12+ years of experience in industrial software development, which includes project management, compiler construction, and C++ library development. She has been involved in the standardization of C++ since 1993. Since 1995 she is devoted to lecturing and writing. She developed several courses for Rogue Wave Software as well as her own curriculum covering numerous C++ related topics. She is also involved in production of instructional videos and multimedia courseware.

Advanced STL Programming (half day)

Author:
Angelika Langer

Level:
C++ programmers who have some degree of practical experience with the STL and want to learn how to customize and extend it.

Abstract:
The STL offers several hooks for customization. One of them are the template arguments of the STL collections. In this tutorial we will talk about user-defined comparitors and allocators. What is their purpose? What kind of customization do they allow? How do the collections use them? What do I have to know if I want to provide a non-default comparitor or allocator?  Iterators play a central role in the STL. They are the glue between collections and algorithms. We will try to understand the design of the iterator types. How are they implemented? How can we define new iterator types? We will also take a look at some particularly interesting iterators like inserters and stream iterators.

Brief Biography:
Angelika Langer is a freelance instructor, courseware developer, and mentor. She is currently writing a book titled "Standard C++ IOStreams and Locales" for Addison Wesley Longman. She has been writing and lecturing on various aspects of C++ for may years, including a column titled "Effective Standard C++ Library" for C++ Report. Her preferred fields of interest are training, coaching, and courseware development in the area of object-oriented programming in C++ and Java. 

Angelika's teaching and mentoring is backed by 12+ years of experience in industrial software development, which includes project management, compiler construction, and C++ library development. She has been involved in the standardization of C++ since 1993. Since 1995 she is devoted to lecturing and writing. She developed several courses for Rogue Wave Software as well as her own curriculum covering numerous C++ related topics. She is also involved in production of instructional videos and multimedia courseware.

Analysis By Contract - An introduction to UML's Object Constraint Language (OCL) (half day)

Author:
Richard Mitchell, University of Brighton

Abstract:
Towards the end of 1997, the Object Management Group accepted a proposal from Rational Software Corporation and others that the Unified Modeling Language, UML, be adopted as a standard.

Target audience

The tutorial is intended for two (overlapping) groups of people:

• those with some knowledge of the ideas of design by contract, who would like to know how the ideas can be applied at higher levels of modeling
• those with some experience of modeling with UML-like notations (including earlier variants, such as OMT), who would like to know how to add precision to their models.

Brief Biography:

Richard Mitchell is Professor of Computing at the University of Brighton, UK, where he has been teaching and researching object technology since the 1980s.

An earlier version of the tutorial was presented at TOOLS USA 98.

Introduction to the Unified Modeling Language (half day)

Author:
Richard Thomas, School of Computing Science, Queensland University of Technology

Level:
Introductory to Intermediate. Participants need to be familiar with object technology concepts. Experience with object oriented methods would be advantageous.

Abstract:
The Unified Modeling Language (UML) has been adopted by the Object Management Group (OMG) as the standard notation for object oriented analysis and design. UML is a rich language that attempts to accomodate all aspects of object oriented system development.  This tutorial uses the design of a CASE tool to introduce the key features of UML. The important modelling concepts underlying UML will be highlighted.

Content:

The tutorial will cover the breadth of the latest version of UML.  All of the UML diagrams will be presented with an explanation of their syntax and semantics.  Hints as to how these diagrams can be used within an Object Oriented Software Engineering Process will be given throughout the presentation.

The Object Constraint Language (OCL) will be referenced in the tutorial, but will not be explained in detail.

The UML notation will be presented by showing the design of a real system documented in UML.  The system is a simple CASE tool that supports UML.

The aspects of UML that will be covered in this tutorial are:

• UML Metamodel
      - the basic components within UML
      - how to extend the metamodel and reasons for extending it
• UML Packages
      - how to organise a large model
• Use Cases
      - actors and use cases treated as classes
• Class Diagram
      - the class icon and its features, generalisation and associations
• Interfaces
      - how they fit into other diagrams
• Sequence Diagram
      - instance and generic versions of the diagram
      - focus of control information
• Collaboration Diagram
      - relationship and differences to Sequence Diagram
      - message passing details and low level concurrency
• State Diagram
      - relationship to Harel State Diagrams
      - intended use within UML
• Activity Diagram
      - relationship to state transition diagrams
• Component Diagram
      - how it shows dependencies between implementation components
• Deployment Diagram
     - how it shows the topology of the system at execution time

Objective:

Upon completing this tutorial participants will have an understanding of UML and its application to object oriented analysis and design. Participants will be able to apply the UML notation to real problems. Participants will also understand the importance and use of the UML metamodel.

Brief Biography:

Richard Thomas is a lecturer in software engineering in the School of Computing Science at the Queensland University of Technology (QUT). At QUT Richard has established a range of
undergraduate and graduate programs in software engineering.  His current research interest is in developing a process to guide organisations adopting object technology.  He is a member of the Centre for Object Technology Application and Research (COTAR), the premier object technology research centre in Australia.

Richard is also a director of Thomaco Consultancies, a technology consultancy that specialises in software engineering and object technology. He has practiced object technology for over a decade as a designer, implementer, researcher, lecturer and consultant.

C++ Program Efficiency

Author:
Stan Lippman

Level:
Intermediate.

Abstract:
C++ program efficiency is of critical concern in many application environments. At Walt Disney Feature Animation, for example, Math and Geometry libraries written in C++ originally ran significantly slower than the C libraries they were intended to replace. The fault for this was initially attributed to the general nature of C++. Reviewing the library code, we discovered rather misunderstandings in the use of C++ language idioms. Without change to the underlying algorithms, we were able to work out a reimplementation that equaled or surpassed the earlier C libraries in performance. This was critical for the acceptance of C++ in this environment.

Brief Biography:

Stan Lippman is a consultant specializing in C++ and Object-Oriented programming and design. For the past four years, Stan was principal software engineer at Walt Disney Feature Animation, where he was involved in the efficient workplace application of C++ (in his last year, he served as software technical director on the Firebird segment of Fantasia 2000). Prior to that, he was a member of technical staff at Bell Laboratories, where he was involved in the implementation and development of C++. Stan is the author of C++ Primer, 3rd Edition, considered the standard introductory text on C++, Inside the C++ Object Model, and editor of C++ Gems, a collection of articles from the C++ Report, for which he served as Editor. Stan teaches and lectures extensively worldwide for both novice and advanced users.

Teaching Java the Blue Way (talk and demonstration)

Author:
Michael Kölling

Abstract:
This presentation demonstrates the JavaBlue environment. JavaBlue is an integrated Java development environment that was developed specifically for teaching Java to first year students. It includes support for sophisticated visualisation and interaction techniques which allow incremental development and direct object interaction.  Because of its flexibility, it enables teachers to approach object-orientation in a purer form than previously possible.

Brief Biography:

Michael Kölling is an Assistant Lecturer at the School of Computer Science and Software Engineering, Monash University. He graduated with a Computer Science degree in Bremen, Germany, before coming to Australia, where he first worked at the University of Sydney and then at Monash University. His interest over the past years has been in tools and environments for teaching object-orientation, which has led to the development of the Blue language and environment. The JavaBlue system presented here is a direct successor to this work..

Building Distributed CORBA Applications

Author:
Steve Vinoski

Presenter:
Michi Henning

Abstract:
This tutorial provides the basics that developers need to begin writing industrial-strength systems in C++ based on CORBA technology. You will learn about the basics of the OMG's Object Management Architecture (OMA), with a focus on its CORBA component. By the end of the tutorial, you will understand how to write object interface specifications using the OMG Interface Definition Language (IDL), how to write simple distributed applications in C++, how to use the new Portable Object Adapter (POA), the Dynamic Invocation Interface (DII) and the Dynamic Skeleton Interface (DSI), and the Interface Repository (IFR). You will also know the basics of several CORBAservices such as Naming, Trading, and Events. C++ examples will be used throughout the tutorial to show what working CORBA C++ code looks like, and ample course notes serve as reference material for post-tutorial study.

Brief Biography:

Michi Henning is a Senior Research Scientist at Triodia Technologies in Brisbane, Australia, where he spends much of his time providing CORBA consulting and training to international customers. He has contributed to a number of OMG specifications, is involved in ongoing CORBA-related research, and is a member of the OMG's C++ Revision Task Force. He has led a number of major object-oriented development projects as a system architect, and has worked on application development, the UNIX kernel, device drivers, embedded systems, compilers, debuggers, libraries, and system utilities. Together with Steve Vinoski, he is the author of "Advanced CORBA Programming with C++". When not doing computer-related things, he desperately tries to improve his golf handicap -- hope springs eternal...

Is Failure an Option? - Pattern Driven Requirements Engineering

Author:
Christopher Creel,
Information Architect with the Technical Resource Connection

Level:
The prerequisites for this class are few.  Those encouraged to attend are those interested in establishing a requirement engineering practice within their organization for which there is effectively none.

Abstract:
Requirement engineering is one of the oldest engineering practices, dating back long before the era of software construction.  It is the art of finding out a client's need as opposed to what they want.  Amazingly, those of us in the art of software construction rarely practice requirements
engineering and when we do, we often botch the job.  As a result, the vast majority of our projects that fail (which happen to be the vast majority of the projects we attempt), fail due to poor requirement engineering. The excuses for not expending effort on requirement engineering are extensive.  But now methods are emerging that take the wind away from the sails of our excuses.  Pattern based requirement engineering is an emerging technique that this Author successfully used and improved on real world projects with much at stake.  This method works much like the Design Patterns movement for software architecture.  Look for successful requirements engineering patterns that bring large gains, document them, and use them again.
 

This is Christopher Creel's nineteenth year constructing commercial software.  He started his own company, Pirates Anonymous, and spent several years writing software for radio stations and fireworks companies.  While working towards his BA, he built expert systems for Cornell University and inventory prediction systems for university bookstores.  After receiving his Master's degree, he joined Hewlett-Packard and built software for laser printers that won 6 US patents and 6 European patents in addition to several Hewlett-Packard awards.  He is now a lead requirement engineer with the Technical Resource Connection, a bleeding edge consulting firm with a diverse, worldwide client base.  He has written numerous articles and lectures whenever he is not actively working with clients.  He now lives in Tampa with his wife and Labrador Retriever, Emma.
.

OO Metrics for Analysis and Review
Profiling Evolving Systems for Product and Process Improvement

Author:
Christine Mingins,
Monash University

Level:
Intermediate.

Abstract:
OO system development can be viewed as an iterative process of naming, specifying, coding, testing and committing classes to the production repository. This tutorial demonstrates a method and some practical metrics which combine project management and product analysis to assist in achieving the following outcomes and benefits:

control: project managers have continuous access to accurate timely information (cf milestones)

analysis:  processes such as abstraction, specialisation, iterative development, can be visualised, and potential hotspots identified.

granularity: a developing system may be analysed at any time during or after development from many perspectives, some of which are: individual object lifecycles; snapshots of current system or subsystem status;   degree of completion at point of incremental delivery; patterns of collaboration across distributed environments

transparency: the data gathering and analysis support system does not disrupt the application architecture

process improvement: visualisation of  the actual iterative development lifecycle leads to better understanding and lays foundation for process improvement

Brief Biography:

Christine Mingins is a Senior Lecturer at Monash University, Australia, with extensive teaching and consulting experience in Object Oriented methods and research interests in software quality metrics.
.

Designing for quality: the Eiffel method

Author:
Bertrand Meyer,
ISE

Abstract:
Object technology addresses the need to produce high-quality software for both large and small systems. One of the most complete attempts to take advantage of object-oriented ideas and modern principles of software engineering is Eiffel, which includes a method, a language, and a set of supporting tools. Eiffel is devoted to systematic construction of quality software and to increasing programmer productivity; the key ideas include a simple and effective modular structure adapted to the successful construction of large systems, the use of assertions to guarantee the correctness and robustness of the software, a systematic approach to single and multiple inheritance for organizing software architectures, and a seamless lifecycle which unifies analysis, design, implementation, testing and maintenance.

This tutorial will present the essentials of the Eiffel approach and analyze its contributions as well as future developments.

Managing OO Projects using a UML compliant process: Process Mentor

Author:
Dr Julian Edwards
Manager and Principal Consultant of the Consulting and Capability Improvement Division of Object Oriented Pty Ltd.

Abstract:
Managing OO Projects using a UML compliant process: Process Mentor This tutorial will cover the overall process, steps and deliverables used to manage OO projects using the Process Mentor methodology. The tutorial is aimed at practising project managers, quality managers and others responsible for the effective management of OO projects. Process Mentor is a software development methodology that has been  developed over the past 10 years by Object Oriented Pty Ltd, Australia's leading OO consultancy. Process Mentor is based on the Object Management Groups Unified Modelling Language (UML) as well as process standards from the
Software Engineering Institute (SEI). This tutorial will provide attendees with an understanding of a full lifecycle process, an overview of the UML, as well as a plan for the effective deployment
of object technology and process within your organisation..

Author's Profile:
Julian Edwards is Manager and Principal Consultant of the Consulting and Capability Improvement Division of Object Oriented Pty Ltd. He joined Object Oriented Pty Ltd in 1992 and has spent the last five years developing and refining the world-class component-based software development process - Process MeNtOR.

As the company's senior methodologist, Dr Edwards has consulted on object technology to some of Australia's largest companies including BHP, MLC and AMP. Dr Edwards now heads up the Consulting and Capability Improvement Division which provides training and consulting services to organisations looking to adopt object technology and to improve their software development capability. His specialities include providing assistance to organisations developing object oriented methodologies and developing strategies for adopting object technology and undertaking process improvement activities.

Dr Edwards has published numerous research papers in international journals and conferences as well as publishing a number of articles in popular magazines dealing with object technology. He is also co-author with Brian Henderson-Sellers of The Working Object (Prentice Hall, 1994).

Dr Edwards has a PhD in Object-Oriented Development Methodologies from the School of Information Systems, University of New South Wales, where he also worked as an Associate Lecturer. Dr Edwards has considerable experience teaching and has given numerous industrial training courses.