Version 6, as of 12 February 2002

Tools and Methods Track

Track description: a 200-500 words text describing the objective of the thread, listing briefly  the breakdown  into lecture series, as well as exercises as appropriate

This track presents modern techniques for software design and modern tools for understanding and improving existing software.  The emphasis will be placed on the large software projects and large executables that are common in HEP.   The track will consist of lectures, exercises and discussions.  The first discussion session will occur after several hours of exercises have been completed.    The last discussion session will be held at the end of the track.

The first 3 lectures will cover software engineering, design, methodology and testing. This is followed by three lectures on working with large software systems, including methods for analysing their structure and improving it.  The final 2 lectures will focus on the tools that are commonly used in software design and testing.  

In the exercise sessions, the students will have a chance to use the tools that are described in the lectures.  They will work with CVS and configuration management tools.  They will be asked to use the test and debugging tools on some simple examples.  By showing how these tools can locate known problems, students will learn how to use them on new problems.  Students will then be given a functional program and a brief description of what it does.  The goal is to extend the program to handle a larger problem domain.  It is expected that the example programs and exercises will be primarily in C++.

Track coordinators

Bob Jacobsen, LBL,  Patty McBride, FNAL


Series Ref

Title of the Lecture Series

Description of the Lecture Series: a ~50-100 word text describing the series of lecture

Lecturer (s) name, affilaition, status (P, A, C) (1)

Lecturer (s) data: email, tel number

Lecturer (s) Biography: a 100-200 word text

L / E

Total # of hours

Lecture Description

Lecture / Exercise reference

Lecture description (a title or a short text as appropriate)


Software Engineering

An introduction to the principles of Software Engineering, with emphasis on what we know about building large software systems for high-energy physics.  These lectures cover the principles of software engineering, design, methodology and testing.

Bob Jones, CERN, [C], +41-22-767-1203

Text to be provided by lecturer




Introduction to Software Engineering (Given by B.Jacobsen)


Software Design


Long-term Issues of Software Building






Analysis of Software Systems

This lecture series aims at investigating the issues related
to program understanding and evolution. Since most of the programming
activities are conducted on existing systems, it is important to know how
their comprehension can be faced effectively and how interventions can be
made without undesired side effects. Moreover, the system under evolution may
require a preliminary restructuring.
During the lectures some fundamental notions about static program analysis
will be given. Then, program slicing will be presented as a support to
program understanding and impact analysis. Reverse engineering techniques that
extract an architectural description of existing systems will be also
described. Finally, restructuring will be considered.
Program slicing

Program slicing is a static analysis technique that extracts from a program
the statements relevant to a particular computation. Informally, a slice
provides the answer to the question "What program statements potentially
affect the computation of variable v at statement s?" Programmers are known
to formulate questions of this kind when performing activities such as
program understanding and debugging.

In this lecture, the basic notions of program dependences will be
introduced, so as to allow a formal definition of the program slicing
problem. A program slicing algorithm will be then described. Finally, some
variants of slicing and the available tools will be presented.
Reverse Engineering

During software evolution, knowledge about the high level organization of
the system is important. In fact, it can help locating the focus of the
change and hypothesizing ripple effects. Often, available architectural
views do not accurately reflect the existing system. Their automatic
extraction is thus desirable.

In this lecture, reverse engineering techniques based on the
specification of architectural patterns will be presented. The validation
of the extracted model through the reflexion method is then
described. Finally, dynamic approaches to the identification of
functionalities within components will be considered.

Software systems are subject to a phenomenon called "architectural drift",
consisting of a gradual deviation of the code implementing the system from
its original design. One of its consequences is a progressive degradation of
the code organization, making program maintenance harder. Refactoring is the
process of modifying the code so that the external behavior is not altered,
while the internal structure is improved.

In this lecture, some examples of code refactoring will be presented with
reference to the object oriented programming paradigm. They will be
introduced on a small program, used throughout the lecture. Implications
and approaches to use with large scale systems will be discussed.

Paolo Tonella, Instituto Trentino di Cultura, [C], +39.0461,314524

Paolo Tonella received his laurea degree  cum laude in Electronic
Engineering from the University of Padua,  Italy, in  1992, and his PhD
degree in Software Engineering from the same University, in 1999, with the
thesis "Code Analysis in Support to Software Maintenance".

Since 1994  he has been a full  time researcher of the Software Engineering
group at IRST   (Institute   for Scientific and  Technological   Research),
Trento, Italy. He partecipated in several industrial and European Community
projects on software analysis and testing. He is now the technical
responsible of a project with the Alice, ATLAS and LHCb experiments at CERN
on the automatic verification of coding standards and on the extraction of
high level UML views from the code.

In 2000-2001 he gave a course on Software Engineering at the University of
Brescia. Now he teaches Software Analysis and Testing at the University of
Trento. His   current research  interests  include  reverse engineering,
object oriented programming, web applications and static code analysis.




Static code analysis, slicing


Reverse Engineering






Automation in code analysis and restructuring is fundamental to make the
techniques studied from a theoretical point of view usable in
practice. Among the available tools, during the exercises the tool TXL
( will be used. It supports code transformation and
analysis and it comes with grammars for several widely used programming

Exercises will focus on the implementation of some simple code
transformations based on the restructuring techniques presented during the
theoretical lectures. Basic refactoring operations for object oriented
systems such as moving methods,  replacing variables and renaming entities
will be considered.


Tools and Techniques

These lectures present tools and techniques that are valuable when developing software for high energy physics.  We discuss how to work more efficiently while still creating a high quality product that your colleagues will be happy with. The exercises provide practice with each of the tools and techniques presented, and culminate in a small project.

Bob Jacobsen, University of California at Berkeley, [C], +1-510-486-7355

Bob Jacobsen is an experimental high-energy physicist and a faculty
member at the University of California, Berkeley.  He's a member of
the BaBar collaboration, where he lead the effort to create the
reconstruction software and the offline system.  He has previously
been a member of the ALEPH (LEP) and MarkII (SLC) collaborations. His
original academic training was in computer engineering, and he worked
in the computing industry before becoming a physicist.








Recap, combining all three parts of the track




2 hours+ 2 hours +  Project (2hours)