|
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++.
|
|
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
|
|
TM1
|
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]
|
Robert.Jones@cern.ch,
+41-22-767-1203
|
Text to be provided by
lecturer
|
Lectures
|
3
|
TM1.1/L
|
Introduction to Software Engineering (Given by B.Jacobsen)
|
|
TM2
|
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.
-----------------------------------------
Refactoring
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]
|
tonella@itc.it,
+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.
|
Lectures
|
3
|
TM2.1/L
|
Static code analysis, slicing
|
|
TM3
|
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]
|
jake@physics.berkeley.edu,
+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.
|
Lectures
|
3
|
TM3.1/L
|
Tools
|