|
Series:
Living OO Design
Lecture:
Introduction to UML for Developers and OO Best
Practices
A few questions addressed
in the lecture |
|
|
|
Monday
8 March |
|
|
10:00 10:55 |
Lecture
1 |
Introduction
to UML for Developers and OO Best Practices
|
Tim Muenchen
Bergische Universität Wuppertal - Germany |
|
Introduction to the series
of two lectures
In High Energy Physics, as in most areas of Science, using
Computers to simulate, analyse and interpret physical data
has become indispensable in the last decades, as the sheer
amount of data one has to process has grown to dimensions
difficult to handle manually. On top of that, the usage of
object orientation is on the advance, replacing legacy
programming languages like Fortran by modern ones like
(among others) C++, Java and Python.
Though, one can not just carry programming style and
concepts from procedural languages to object oriented
languages and hope to benefit from the advantages of this
new programming paradigm. Instead, there are numerous things
to keep in mind to produce working, error-free and
performing - but also understandable, maintainable and
expandable - object oriented software designs.
This series of two lectures aims to sensitize the "object
oriented programming physicist" to things he or she should be aware
of and keep in mind to fully utilize the OO-paradigm.
|
|
First lecture:
Introduction to UML for Developers and OO Best
Practices
In
this lecture, a powerful tool to express, communicate and
record software design concepts, ideas and structures is
briefly presented: the Universal Modeling Language.
Albeit being a complex and complete language to describe
most aspects of (not only) software design, we will focus on
the single most useful part of the UML when talking about
OO
best practices and patterns: the
Class Diagram. This
is then used in all of the rest of the series to visualize
the concepts presented.
The
main part of the lecture, then, focuses on ten best
practices every OO-developer should know. The best practices
and the reasons for them being crucial are described and
deepened by examples and anecdotes.
|
|
Audience and benefits
This series of two lectures
targets physicists designing and implementing physics
analysis code, event generators and the like in
object-oriented languages like C++, as well as more junior
developers of software infrastructure libraries used at
CERN.
On top of that, every interested programmer can
benefit from the concepts presented in these lectures.
In this first lecture, attendees will be sensitized to things to
know and keep in mind when designing software systems
to ensure the best possible quality of systems in
terms of maintainability, flexibility and extensibility,
comprehensibility and stability.
You will learn about a few simple rules to
adhere that will help in make your design better
in respect to those criteria, and what to avoid in
designing software.
Before that, the UML class diagram is introduced briefly as
means to communicate design concepts and to visualize the
Best Practices presented in this lecture, and the Design
Patterns in lecture 2.
|
|
Pre-requisite
Attendees should have basic knowledge about
object-oriented programming, concepts and idioms, as well as
object-oriented programming languages like C++ and Java."
|
Lecture:
Design Patterns and Anti-Patterns
A few questions addressed in the
lecture
|
|
|
Monday
8 March |
|
|
11:05 12:00 |
Lecture 2 |
Design Patterns and Anti-Patterns
|
Tim Muenchen
Bergische Universität Wuppertal - Germany
|
|
Introduction to the series of two lectures
In High Energy Physics, as in most areas of Science, using
Computers to simulate, analyse and interpret physical data
has become indispensable in the last decades, as the sheer
amount of data one has to process has grown to dimensions
difficult to handle manually. On top of that, the usage of
object orientation is on the advance, replacing legacy
programming languages like Fortran by modern ones like
(among others) C++, Java and Python.
Though, one can not just carry programming style and
concepts from procedural languages to object oriented
languages and hope to benefit from the advantages of this
new programming paradigm. Instead, there are numerous things
to keep in mind to produce working, error-free and
performing - but also understandable, maintainable and
expandable - object oriented software designs.
This series of two lectures aims to sensitize the "object
oriented programming physicist" to things he should be aware
of and keep in mind to fully utilize the OO-paradigm.
|
|
Second lecture:
Design Patterns and Anti-Patterns
In
this second lecture of the series, after the core ideas in
designing maintainable and well-designed software have been
shown in lecture 1, a powerful concept is presented: the
Design Pattern. Being reusable "blue print"
design snippets
- as opposed to reusable pieces of code or libraries
- such
patterns help in establishing high-quality software designs
without "reinventing the wheel".
Furthermore, Design Patterns fulfil the very important role
of establishing a common vocabulary between software
engineers and developers, leveraging knowledge transfer in
and between teams of software developers and turning
software designs into building blocks of software that are
easy to understand and easy to recognize.
After a few popular Design Patterns are presented and
examples are given, the second big topic of this lecture are
the so-called "Anti Patterns" - the exact opposite of Design
Patterns. These describe things to avoid when designing a
software system, albeit looking just like "the right thing
to do". We will try to explain why those look so good, and
what the consequences are.
|
|
Audience
This lecture builds up on lecture 1. Attendees will learn
about established Design Patterns that can be used to
ease creating object-oriented software designs and to
streamline the application of the design Best Practices
presented in the first lecture.
Furthermore, Anti-Patterns
are introduced that show typical things not to do when
designing software that lead to common problems, although
seeming attractive and easy to apply on the first
sight, and thus are very dangerous.
|
|
Pre-requisite
To draw maximum benefits from this lecture, the attendant
should preferably have followed lecture 1.
|
How to make web applications run faster
A few questions addressed in
the lecture
| |
|
Monday
8 March |
|
|
14:00 - 14:55 |
Lecture 3 |
How to make web applications
run faster |
David Horat |
|
Description
Response time in web applications is one of the most
important issues today. The whole stack of intermediate
software we use to deliver web interfaces added to the
increasing popularity of web services make web applications
very slow.
In this lecture we will present several methods on
how to improve web applications response time based
on optimizations and knowledge on HTML, HTTP and other web
protocols.
|
|
Audience
Web developers
|
|
Pre-requisite
HTML as well as basics on related web technologies
|
Distributed version control using Git: Get more efficient
managing your code
A few questions addressed in
the lecture
|
|
|
Monday
8 March |
|
|
15:05 16:00 |
Lecture 4 |
Distributed version control using Git: Get more
efficient managing your code |
David Svantesson |
|
Description
Distributed version control allow you to work more
efficient and with greater flexibility while keeping most of
the benefits of a centralized versioning system. This
lecture aims to explain why and how you use it and how it
differ from for example CVS and svn.
The history of development from local to centralized (e.g.
CVS and svn) to distributed version control systems will be
covered, explaining the difference between them and their
benefits and drawbacks.
The lecture
will contain a discussion on different work-flows for
collaborating in a group and how a distributed version
system give you more flexibility in this perspective.
For practical
examples, Git will be used (http://git-scm.com/).
An introduction to Git and basic as well as more advanced
usage will be given. This includes the use of branches and
how to rewrite the version history.
|
|
Audience
This lecture is intended for software developers or anyone
wanting to improve their management of source code, whether
it be for personal use of in large collaborations.
|
|
Pre-requisite
To draw maximum benefits of the lecture, it is an advantage
to have some experience of using version control systems
before (e.g. CVS or svn) but it is not essential for
understanding the lecture.
|
Recent Advances in Multivariate Data Visualisation
A few questions
addressed in the lecture
|
|
|
Monday 8 March |
|
|
16:30 - 17:25 |
Lecture 5 |
Recent Advances in Multivariate Data Visualisation |
Benjamin Radburn-Smith |
|
Presentation
The aim of this lecture is to make the
audience aware of alternative visualisation techniques
available and the possible benefits that might arise from
using them on their data.
|
|
Audience
This lecture targets anyone who has multivariate data; that
is to say data containing many variables, which they want to
analyse. Particle Physics data will be used in the
demonstrations.
|
Pre-requisite
This lecture can be followed by anyone who
has some experience of data analysis and data visualisation.
|
SNMP for
monitoring and operating devices
A few questions addressed in
the lecture
|
|
|
Tuesday 9 March |
|
|
09:00 - 09:55 |
Lecture 6 |
SNMP for
monitoring and operating devices |
Uwe Westerhof |
|
Description
This lecture will give an overview of the Simple Network
Management Protocol (SNMP) from a users point of view. It
will provide the basic knowledge to use SNMP
productively.
The lecture will explain the concepts of SNMP including
MIB definition files, the
communication protocol and security aspects.
At the end, examples will be given showing the
management of
different hardware components via SNMP.
|
|
Audience
This lecture targets anyone interested in monitoring and
controlling network attached hardware, like switches,
printers, power supplies or servers.
|
Pre-requisite
This lecture can be followed by anyone without requiring
special knowledge in network management or network
technologies.
|
Series:
Advanced Tools for system data collection:
Lecture:
Logs in software: How to record the what, the when and the
who
A few questions addressed in
the lecture
|
|
|
Tuesday 9 March |
|
|
10:30 - 11:25 |
Lecture 7 |
Logs in software:
How to record the what, the when and the
who |
Luis Muñoz Mejías
|
|
Description
In this part we'll
highlight the relevance of having good quality logs that are
easy to understand by both humans and machines. We'll
describe the properties good logs must have (relevant
contents, unambiguous timestamping, easy classification,
integrity...), and the existing tools designed to meet these
requirements, with examples for both developers (what and
how to log) and system administrators (what to do with those
logs). Real-world examples of good and bad practices will be
shown, together with some ideas for improvement.
|
|
Audience
Software
developers and, perhaps, system administrators.
|
|
Pre-requisite
Understanding of UNIX
systems. Programming experience with C/C++/Perl/Python/Java
will help.
|
Series:
Advanced tools for system data collection:
Lecture:
Systemtap - Tapping the Linux Kernel to Find out What Your
Machine is Really Doing
A few questions addressed in
the lecture
|
|
|
Tuesday 9 March |
|
|
11:35 - 12:25 |
Lecture 8 |
Systemtap - Tapping the Linux Kernel to Find out
What Your Machine is Really Doing |
Malte Nuhn |
|
Description
This lecture introduces Systemtap, a free software (GPL)
infrastructure to simplify the gathering of information
about the running Linux system.
The lecture's first part points out in which situations
administrators and developers are often lacking information
when diagnosing performance or functional problems.
A short overview about the Linux Kernel is given, enabling
the listener to get a feeling, which information is
accessible and might be interesting in his specific
use-case.
Next, a brief overview of Systemtap's inner workings is
given.
Therefore, common probing techniques, their prerequisites,
possible risks and downsides are presented. This part ends
by showing how these techniques are accessible in Systemtap
and what is needed to get them to run.
The lecture's last part introduces Systemtap's scripting
language. It explains a couple of commonly used scripts and
shows how the listener can practically introduce them to his
own logging and monitoring environment.
|
|
Audience
This lecture targets developers and
administrators who are running/ developing software on Linux
servers. This lecture will introduce a powerful toolchain,
allowing the listener to finally get a grip on his Linux
server.
|
Pre-requisite
To draw maximum benefits
of the lecture, the attendant should preferably have some
experience in Linux System administration and/or
programming. This lecture can be reasonably followed without
having attended the first lecture of this series.
|
|
