List of Training Courses

Below is a summary of each training course offered by Matrice to it clients. Courses specific to UML, C++ and Java are also listed on their own page.

We typically deliver our courses at customer sites throughout the UK and Europe. We can also arrange courses for customers here in the UK, in London or in Cambridge.

A nominal duration is given with each description. We are happy to discuss variations in duration.

Development Methods

Introduction to Software Engineering (2 days)

This course aims to bring to the same level of awareness, the diverse range of people who find themselves developing large and complex software systems, and to cover some aspects of software engineering which are often not covered during typical software engineering tertiary education.

Introduction to Analysis and Design (2 days)

Frequently ignored in these days of “methods” are the basic job skills still required of analysts and designers. Topics covered include interviewing, running meetings, moderating, facilitating and active listening. Technical training and experience usually do not equip people to cope with the sociology, politics and psychology inherent in software systems development. We encourage analysts and designers to come on this course.

Object-Oriented Analysis and Design using UML (4 days)

Grady Booch, Ivar Jacobson and James Rumbaugh are now working for the same organisation and are unifying their previously separate notations into a Unified Modelling Language (UML). Like the unification itself, this course offers the best of three of the most popular modern approaches for the modelling and design of software intensive systems. (See also Object-Oriented Analysis and Design using UML 2.)

Object-Oriented Analysis using UML (2 days)

This course focuses on the early phases of development and shows how the requirements and the subject matter ("real world") are used to guide the creation of the first models using the UML notation. It could be followed by the Object-Oriented Design using UML or a "hands-on" course such as Hands-On Object-Oriented Design & Programming with Java.

Object-Oriented Design using UML (2 days)

Given a set of requirements, and subject matter models, how does one choose and document a reasonably optimal, object-oriented architecture? This course shows how object-oriented design can be approached in two phases -- "subject-oriented" and "object-oriented" -- and via two important UML diagrams -- the static structural diagram and the interaction diagram.

Object-Oriented Analysis and Design using UML 2 (4 days)

The UML has enjoyed remarkable success. Work is nearly finished on a major revision of UML -- UML 2.0. Whilst many of the changes are to the underlying metamodel, there are significant changes to some of the major diagram types as well as several new diagram types including, for example, a diagram specifically to help with component-based development. The biggest changes are in the activity diagram, with the state machine being the next most changed.

We are now offering our normal analysis and design course but using UML 2 rather than UML1.

Design Patterns (2 days)

Part of the apprenticeship of a software designer is the gaining of an appreciation of architectures which have already proved their worth. Traditional training courses focus on notations, tools and techniques. Examining and understanding design patterns in this course, is the equivalent of a guided tour of existing great architectures in the small and in the large. This course is offered in language-neutral, C++, and Java versions.

Class Responsibility Collaboration (CRC) Workshop (2 days)

It isn't too difficult to begin object-oriented analysis. The same techniques as were used in entity modelling can still be used initially. Poor objects result, however, from taking an entity-based approach too far. An object is active and presents itself though a service interface, and this has to be considered early on. The most successful and truly object-oriented approach to this is the responsibility-driven quest for classes, responsibilities and collaborations. This workshop introduces and gives practice at CRC role-playing—a very effective technique for responsibility-driven design.

Back to Top

Technology Courses

Introduction to Databases (2 days)

Databases have been one of the success stories of computing. This course introduces the background and nature of databases, it describes when they are an appropriate solution, and it surveys some the products that are available. The core of course concerns the basics of how databases work and how they are used.

Advanced and Modern Databases (2 days)

Part of the reason for the undeniable success of databases has been their solid theoretical underpinning. This course looks at the common data models and DBMS architectures. As well as examining traditional approaches, the course looks at recent developments such as the extended relational model and the object model, and at architectural developments such as distributed databases.

Introduction to Object Technology, Methods and the UML (1 day)

The course answers questions like: where did objects come from? what are they? what do they do? why the excitement? The course also examines the impact of objects on analysis and design, and surveys the available languages and introduces the now standard UML notation.

Distributed Systems Issues for Managers (1 day)

There are a daunting number of components, standards, APIs and acronyms to be found in the subject of distributed systems. Even defining just what “distributed systems” and “client/server” mean isn't straightforward. Increasingly there are also connections with, and influences to and from, object-oriented and component-based development. This course offers definitions and explanations of the issues and introduces the key components and standards (and their acronyms), and looks at the strategic potential and impact of distributed systems.

Distributed Systems Issues for Analysts and Designers (2 days)

This course covers distributed systems technologies and standards from a developers point of view; a less strategic, more tactical approach than that of the Distributed Systems Issues for Managers course. As well as treating the technologies such as Enterprise Java Beans, CORBA and COM in a little more depth, this course looks at the impact of distribution on the analysis and design techniques.

Enterprise Java (2 days)

For more than a decade, some of the most successful generic solutions have been database management systems and transaction processing system; large enterprise computing is reliant on them. More recently, distributed systems have brought significant benefits over and above the mere geographic -- robustness, scalability, specialisation and standardisation.

Even more recently still, objects have shown themselves to be a good organising principle for large or complex software intensive systems. They also ease the distribution of functionality, particularly of course in developing Internet or Web applications.

One of Java's strengths has always been its responsiveness to the needs and nature of its environment. Clearly, bringing all these strands together in a coherent, server-side solution is a good idea -- Enterprise Java.

 This would normally be taken as follow up to the Hands-On Object-Oriented Design & Programming with Java course or the Advanced Java course.

Component Based Development (2 days)

Whilst components and component based development have been around for many years, it is only recently that component based development (CBD) has become a development strategy in its own right, with journals, standards and powerful forces fighting for market share in it. Everybody seems to be talking about it—so what exactly is it? Is it just a synonym for object technology? Is it a replacement for object technology? This course aims to define component based development and put it into perspective.

Back to Top

"Hands-On" Courses

Hands-On Object-Oriented Analysis & Design using UML with CASE tools (5 days)

This course extends the Object-Oriented Analysis and Design using UML course with an introduction to CASE tools. When a customer has chosen and obtained a CASE tool, such as Together, Software through Pictures, Object Engineering Workbench or Rose, the exercises can be carried out on the customer's CASE tool. Although the course still focuses on good analysis and design practices, participants can gain experience of CASE tool support. In addition to introducing the essentials of diagram creation and editing, we consider model detail and correctness, forward and reverse engineering, printing and document generation, and tools, utilities and integration

Hands-On Object-Oriented Design & Programming with Java (3 days)

The Java language is much talked about. In this course however, we are not particularly interested in the Internet or “applets”. Java is also an excellent language for learning object-oriented programming and for providing a good foundation of object-oriented design principles. It is a modern, “small” and elegant object-oriented language, and substantial progress can be made in the three days of the course.

Although Smalltalk is still probably the purest object-oriented language, it has a unique look and feel. Java on the other hand takes its syntactic style from C++ (but not its size or complexity). So effort spent in this course is very likely to be of benefit even if Java is not your implementation language.

Advanced Java (3 days)

This hands-on course is for Java programmers who want to understand and practise with the library classes. It would normally be taken as a follow up to the Hands-On Object-Oriented Design & Programming with Java course. We look at Collections, Internationalisation, Streams, Exceptions, multi-threading, Serialisation, JDBC, the native interface, networking, etc.

Java Servlets and JSP (3 days)

Although it was originally thought that Java might achieve success and take-up through client-side applets, it was on the server side that Java achieved its most consistent take-up.

Java Servlet technology and Java Server Pages (JSP) allow web developers to create dynamic content using a known, portable, standard, open language.

Enterprise Java Beans (3 days)

There is a sense in which objects have come to the rescue of distributed computing. Client-side presentation and server-side data were obvious and reasonably easy; but distributing the functionality, the "business" logic, was troublesome; that is it was troublesome whilst we were trying to do it via remote procedure calls. Distributing objects turns out to be a whole lot easier and more intuitive than distributing functions.

Clearly, given Java's success on servers, having portable, standard, open Java offerings for distributable objects would be great. Enterprise Java Beans give us not only that, but also distributable, transaction, persistent, secure distributable objects.

Web Services (2 days)

Java already had a strong component model in EJB, and comprehensive support for web servers in servlets and JSP. With support now available for SOAP messages, XML data and WSDL (Web Services Description Language),  Java objects can truly offer interoperable services across the Web.

Java Data Objects (2 days)

Java has already had one success achieving persistent objects: Enterprise JavaBeans (EJB). EJB's approach is that of making transactionally secure database entities appear to their clients as Java objects. There is another approach recently emerged from the Java Community Process -- Java Data Objects (JDO). This is a subtly different, and complementary approach: making Java program objects automatically persistent.

Hands-On Object-Oriented Design & Programming with C++ (3 days)

C++ is clearly a common choice of language for object-orientation. Yet it is one of the most difficult languages to use well. This course focuses strongly on achieving good object-oriented designs and code using C++ rather than on C++ the language, in all its detail. The follow up course -- Advanced C++ -- has a deeper examination of detail (along with an emphasis on safe C++).

Advanced C++ (Traps and Pitfalls) (4 days)

This course introduces more of the detail of C++. Participants would normally already have attended the Hands-On Object-Oriented Design & Programming with C++ course. The particular emphasis of course is avoiding the traps and pitfalls of C++ and producing good, safe, object-oriented or generic (template-based) C++.

C++ Templates and the "STL" (1 day)

Although the most famous feature of C++ is object-orientation, template-based programming is also powerful and important. Although templates are covered in our basic C++ courses, the focus there tends to be on object-orientation, so this separate course is offered as a supplement. The second function of this course is to cover, in detail, the template classes and functions of the standard library (known historically as the Standard Template Library or STL).

C++ Exceptions (1 day)

The decision to use exceptions is not one to be taken lightly in any language. In C++ the issues are complicated by the difficulties of correctly handling resources such as the free store. We therefore make this separate course available as a supplement to our C++ courses.

Hands-On CORBA Development with Java (2 days)

This is for people who have been on our Hands-On Object-Oriented Design & Programming with Java course. We look at how CORBA can be used to make Java objects interoperable, not only with other Java objects, but with objects implemented in other languages.

Hands-On Object-Oriented Design & Programming with C# (3 days)

The world didn't necessarily need another programming language, but C# turns out to be a rather nice language. Combining most of Java with one or two very nice Object Pascal features, whilst making use of its position in the Microsoft family and the .NET architecture, C# will probably be of interest to many. As usual, our emphasis is learning the language whilst experiencing sound object-oriented design principles being put into practice.

Hands-On Object-Oriented Design & Programming with Smalltalk (3 days)

It is generally agreed that Smalltalk is the most elegant object-oriented programming language; and an excellent language for learning object-oriented programming and design principles.

This three-day, hands-on course encourages those necessary insights and “cultural shifts” that can be very successfully gained by exploring Smalltalk. It can be used to round off more theoretical course, such as analysis and design, with some practical, but object-oriented experience. It also, of course, serves as an excellent introductory course for Smalltalk programming.

Back to Top

Briefings and Updates

Briefings and updates usually take half a day or a day.

• UML 2.0 (1 day)
• Java 1.5 (1 day)
• C# for Java programmers (1 day)
• Software engineering (0.5 day)
• Object-orientation (0.5 day)
• Client-server, distributed systems (0.5 day)
• Java (0.5 day)
• Enterprise Java (J2EE) (0.5 day)
• Component-based development (0.5 day)
• Objects in the context of information systems (0.5 day)
• Objects in the context of scientific applications (0.5 day)

Back to Top

Details on the booking and organising of courses can be found on the course logistics page.

[ Top | Home | Training | Consulting | Contacting]

Questions or problems regarding this web site should be directed to webmaster@matrice.co.uk.
Copyright © 2005 Matrice. All rights reserved.
Last updated: 21 May, 2004