Advanced Development Techniques

This curriculum of the PhD school in Computer Science of the University of Milan focuses on the most recent and advanced development techniques and on their limitations. In particular the activated courses cover the whole software lifecycle (designing, programming, testing, debugging and development tools) providing a complete overview of the current trends in software development research area.

To complement the curriculum the interested student can attend:

• The AOSD Summer School

Curricula Coordinators: Walter Cazzola and Sebastiano Vigna.

Scientific and Teaching Board.

Paolo Boldi, Walter Cazzola, Mattia Monga Giovanni Pighizzini, Massimo Santini, Sebastiano Vigna

In this curriculum of the PhD school in Computer Science we have activated five courses that cover the whole software development process with particular attention to programming techniques. Courses are listed sorted by time; details can be found following the links.

Schedule

Lecturer

Sebastiano Vigna (Ph.D.) is currently an associate professor at the Department of Computer Science Department of the University of Milano, and a member of the Laboratory for Web Algorithmics. His research interests include web-graph compression and analysis, indexing of large document collections, high-performance parallel web crawling and automatic generation of software from conceptual models. He has written more than 70 technical papers about these research topics.

Topics

• Structure of the search engines
• Crawling
• Indexing
• Querying
• Ranking
• Large-scale static data structures

References

1. Christopher D. Manning, Prabhakar Raghavan and Hinrich Schütze. Introduction to Information Retrieval. Cambridge University Press, 2008
2. Ricardo A. Baeza-Yates and Berthier Ribero-Neto. Modern Information Retrival. Addison-Wesley. 1999.
3. Soumen Chakrabarti. Mining the Web: Discovering Knowledge from Hypertext Data. Morgan-Kauffman. 2002.

Schedule

This lecture has been split in two parts: the first part introduces some basic concepts on reflection and aspect-oriented programming and is propaedeutic to Chiba's lectures in the last week of September; second part will present some advance in aspect-oriented programming research, open issues and applications.

Fist Part

Second Part

Note that on Wednesday we will have a hands-on-session on aspect-oriented programming whereas on Friday the students will propose their seminars.

Lecturer

Walter Cazzola (Ph.D.) is currently an associate professor at the Department of Computer Science of the Università degli Studi di Milano, Italy and the chair of the ADAPT research group. His research interests include reflection, aspect-oriented programming, programming methodologies and languages. He is the designer of the mChaRM framework, of the @Java, [a]C#, Blueprint programming languages and he is currently involved in the designing of the neverlang general purpose compiler generator. He has written more than 70 technical papers about reflection and aspect-oriented programming.

This lecture will present one of the most recent approached to the software development, that is, the aspect-oriented programming and software development.

Topics

Aspect Oriented Programming and Software Development

• definitions and properties
• symmetric versus asymmetric
• obliviousness and quantification
• aspect-oriented modeling

Asymmetric Approaches: AspectJ and Prose

• introduction
• AspectJ's join point model
• reflection in AspectJ
• dynamic AOP in Prose

Symmetric Approaches: HyperJ

• introduction
• HyperJ's join point model
• building an application with HyperJ
• AOP via use cases

Aspect-Oriented at Work

• aspect-oriented refactoring
• aspect-oriented design patterns

Open Issues and Future Perspectives

• dependence on the base-program's syntax
  • a possible solution: annotations
  • @aspectj
• join point selection mechanism granularity
• aspect-orientation paradox
  • fragile pointcut problem
  • intentional pointcut, blueprint, ...

References

1. Robert E. Filman, Tzilla Elrad, Siobhán Clarke and Mehmet Aksit, editors. Aspect-Oriented Software Development. Addison-Wesley. 2004.
2. Joseph D. Gradecki and Nicholas Lesiecki. Mastering AspectJ: Aspect-Oriented Programming in Java. John Wiley and Sons. 2003.
3. Ivar Jacobson and Pan-Wei Ng. Aspect-Oriented Software Development with Use Cases. Addison-Wesly. 2004.

Schedule

Lecturer

Shigeru Chiba (Ph.D.) is currently a full professor at the Department of Mathematical and Computing Sciences of the Tokyo Institute of Technology, Japan. His main research interests concern programming language design, open compilers, meta-object protocols, reflection, and aspect-oriented programming. Chiba is the designer of OpenC++, OpenJava, and Javassist. Javassist is his most successful software, which is now a core component of Redhat/JBoss products. He has written and has served as a reviewer of a number of technical papers about computational reflection and aspect-oriented programming.

Hands-on-session. The last day of the lecture will be partially devoted to a hands-on-session to develop an aspect-oriented framework. To deal with the hands-on-session each student should have their own laptop (the labs are busy with the grad/undergrad lectures) with JDK 1.5/1.6, Javassist and JastAddJ installed and running. Please let me know if you have problems in preparing your system.

This lecture presents implementation techniques for Aspect-Oriented Programming (AOP) and/or reflective languages. The reflection mechanism is one of the source of AOP. This lecture introduces the implementation of reflective languages as the basis of the implementation of early AOP languages.

Topics

• Abstraction provided by reflection and aspects
• Implementation with subclassing and interceptors
• Join point shadow and residue
• Java source code v.s. Java bytecode
• Java class loaders for Web application servers
• Run-time, compile-time, and load-time code transformation

References

1. Shigeru Chiba. Load-Time Structural Reflection in Java. In Proceedings of ECOOP 2000. LNCS 1850, pages 313-336, Cannes, France, June 2000. Springer
2. Shigeru Chiba and Kiyoshi Nakagawa. Josh: An Open AspectJ-like Language. In Proceedings of AOSD'04, pages 102-112, Lancaster, UK, March 2004.
3. Ira R. Forman and Nate B. Forman. Java Reflection in Action. Manning Publications. October 2004.
4. Yoshiki Sato, Shigeru Chiba and Michiaki Tatsubori. A Selective, Just-in-Time Aspect Weaver. In Proceedings of GPCE'03, LNCS 2830, pages 189-208, Erfürt, Germany, September 2003.

The lecturers can be found here

Schedule

Lecturer

Massimo Santini (Ph.D.) is currently an assistant professor at the Department of Computer Science of the University of Milano, and a member of the Laboratory for Web Algorithmics. His research interests include design and analysis of algorithms with particular regard to distributed high performance web algorithmics. He has written and has served as reviewer of several technical papers about these research topics.

Topics

• Introduction
• Observing
• Deducting
• Experimenting
• Fixing

References

1. Andreas Zeller. Why Programs Fail: A Guide to Systematic Debugging. Morgan Kaufman. 2009
2. Grötker T., U. Holtmann, H. Keding and Markus Włoka. The Developer’s Guide to Debugging. Springer-Verlag. 2008
3. David Astels. Test-Driven Development: A Practical Guide. Prantice Hall PTR, July 2003.
4. Brian W. Kerningham and Rob Pike. The Practice of Programming. Addison Wesley. 1999.
5. Steve McConnell. Code Complete: A Practical Handbook of Software Construction. Microsoft. 2004.

Schedule

A hands-on-session is foreseen for the 8 of February for those that want to use their laptops (mandatory for those not enrolled at the University of Milano) you need to install F# (it works on linux as well but it is better to have visual studio 2010) and XNA 4.0.

Code for the hands-on session ZIP

Note that, the exam consists on a 2-page paper on the benefits/drawbacks of using functional languages in your research area. The paper is due by the 15th of March and should be sent to giotam[_AT_]microsoft.com.

Lecturers

Giordano Tamburrelli is Academic Developer Evangelist at Microsoft Italia. He is currently responsible for all the academic initiatives for faculties and students in Italy. Giordano is currently a PhD candidate at the Politecnico di Milano in the DeepSe Group. During his research activity he was visiting Ph.D. student at Swinburne University in Melbourne, Australia. His research interests include : Service Oriented Architectures, Context-Aware Systems, and Non-Functional Requirements. Finally, he obtained in 2007 a Master in Computer Science Engineering from University of Illinois at Chicago, US.

Matteo Pradella is a researcher at the IEIIT (Istituto di Elettronica e di Ingegneria dell'Informazione e delle Telecomunicazioni) of the Italian National Research Council (CNR) since December 2001. He received his Ph.D. in January 2001 from Politecnico di Milano. In 2000, 2001, and 2002 he was first visiting Ph.D. student, then visiting reasearcher at the Software Engineering group (code 5546) of the Naval Research Laboratory, Washington, DC. His research interests are mainly in formal languages and automata theory, picture languages, and formal methods for safety-critical and real time systems.

Matteo Rossi received a PhD in Compouter Engineering from Politecnico di Milano in 2003. Since 2005 he is an assistant professor at the Dipartimento di Elettronica e Informazione of Politecnico di Milano. His research interests are centered on Software Engineering, with a focus on languages (in particular formal ones), methods and tools for the specification and analysis of time- and safety-critical systems. He is the co-chair of the Student Contest on Software Engineering (SCORE), which will be held as part of the 33rd International Conference on Software Engineering (ICSE 2011).

Giuseppe Maggiore obtained a Master's Degree in Computer Science from Università Ca' Foscari di Venezia a few years ago. He is now completing a Ph.D. in Computer Science on functional languages, videogames and software engineering. Giuseppe teaches computer graphics and game development at Università di Verona. In the meantime he is also working as a Metro Trainer for the upcoming Windows Phone 7 and he is consulting for various firms on XNA.

Abstract

The functional programming paradigm has received increasing attention in the last few years, as the level of abstraction it provides is well-suited to programming complex applications such as concurrent ones. In this lecture we will present the basic concepts underlying the functional programming paradigm, using the Haskell language as reference. We will also present some more advanced concepts, like type classes and monadic computations.

In the second part of the lecture we will study the functional language F#. F# is unique in that it is the first functional language with a clear commercial (rather than academic) target, and as such is supported by very advanced tools and IDEs. We will start with the basic operators (bind and lambda) and data structures (tuples and lists); then we will move to the imperative constructs (refs and mutable binding); we will study functional datatypes in more detail (tuples, records, discriminated unions); we will see ActivePatterns, a powerful form of computed patterns and we will build a simple and small monadic-style parser; we will study the OO capabilities of the language and its interop capabilities with the rest of .Net; we will then move to computation expressions (monads) and finally we will see code quotations.

Schedule

Some hands-on-sessions are foreseen during the lectures, due to the variability of the teaching mechanism we chosed to have the lectures in a normal classroom without PCs and you will do the exercises on your own laptop. To do so, you have to install the Pharo system. In case of problems with the installation contact the lecturers that will be happy to help you.

Lecturers

Kim Mens is full Professor in Computer Science at the Université Catholique de Louvain (UCL), Belgium where he leads the REsearch Laboratory on software Evolution And Software Development technology (RELEASeD). He holds the degrees of Licentiate in Mathematics, Licentiate in Computer Science, and PhD in Computer Science from the Vrije Universiteit Brussel (VUB), Belgium. His main research interests include software development, software maintenance and software evolution with a particular emphasis on the programming aspect and tool support. He is one of the originators of the reuse contracts technique for automatically detecting conflicts in evolving software, of the IntensiVE toolsuite for documenting, checking and correcting structural regularities in the source code of software systems. Other research topics that fit this common theme and in which he is interested are software architecture, software variability, reverse engineering, software transformation, software restructuring and renovation, and co-evolution between source code and earlier life-cycle software artifacts. In addition to that he is interested in language engineering and a variety of programming language paradigms such as object-oriented and aspect-oriented programming, reflection and metaprogramming, logic metaprogramming and, more recently, context-oriented programming.

Sebastián González is a postdoc research fellow at the Computing Science Engineering pole of the ICTEAM institute at Université Catholique de Louvain, Belgium. His research currently focuses on programming language engineering for adaptive systems and dynamic software composition. He is the main driving force behind the context-oriented software development research team that is part of the RELEASeD lab led by Prof. Kim Mens. Sebastián's principal areas of interest include programming paradigms, programming language design, formalization and implementation, meta-programming and computational reflection, adaptive computing, live software evolution, context-oriented programming, and software composition and variability.

Abstract

The aim of this course is to take a closer look at the paradigm of computational reflection and the novel programming paradigm of context-oriented programming. The object-oriented programming language Smalltalk will be used as a vehicle to introduce the course matter. After having introduced the basics of reflection and the essence of the Smalltalk programming language, the reflective features and meta-object protocol of the Smalltalk language will be studied. The Smalltalk language was chosen because of its conceptual pureness and because it is a fully reflective language which has been a source of inspiration for many other languages (like Java, Ruby or Objective-C). All sessions will be a mixture of traditional course lectures and practical hands-on sessions on the computer. At the end of this course the students will have acquired both a conceptual knowledge of and hands-on experience with the concepts of computational reflection and context-oriented programming, while at the same time having being exposed to the Smalltalk programming language.

Course Organization

The course is organized in 4 slots of 3/4 hours.

Slot 1 : (4 hours) Introduction to reflection and Smalltalk

• Basics of reflection 2h essentially theory course
• Introduction to Smalltalk 2h mixture of theory and hands-on session on the computer

Slot 2 : (4 hours) Reflection in Smalltalk

• Reflection in Smalltalk 4h mixture of theory course and hands-on activities

Slot 3 : (4 hours) Context-oriented programming

• Introduction to Context-oriented programming 2h theory course
• Building a context-oriented framework in Smalltalk 2h hands-on

Slot 4 : (~3 hours) Context-oriented programming (2)

• Building a context-oriented framework in Smalltalk ~3h hands-on

For the hands-on sessions you need to install on your laptop the Pharo system.

Schedule

Lecturers

Eugenio Moggi (Ph. D) is currently a full professor in computer science at Università degli Studi di Genova. Previously he was lecturer in computer science at the University of Edinburgh and assistant professor at Univesità degli Studi di Pisa. His research interests are semantics of programming languages and program logics. He first described the general use of monads to structure programs. Details are available from http://www.disi.unige.it/person/MoggiE/ .

Abstract

In the context of programming languages type systems provide a general and convenient tool for classifying different kind of entities, and in doing so they are relevant for error detection and optimization. We introduce computational types and collection types, appropriate syntax associated to these types (borrowing mainly from Haskell), their mathematical semantics in terms of monads (and algebraic theories), and give an overview of their uses (mainly in the context of Haskell).

Lecturer

Mattia Monga (Ph.D.) is currently an associate professor at Università degli Studi di Milano (Department of Computer Science) where he teaches "operating systems" courses. He has also worked as a research assistant at the University of Italian Switzerland and as a lecturer at Politecnico di Milano. His main research interests concern software engineering and security. Further information about his research work can be found at http://homes.dico.unimi.it/~monga/

Design by contract (DBC) is an approach to the design and development of software based on explicit "contracts" between the provider and the user of a programming feature. Its roots are in the Hoare's work on the axiomatic basis of programming and was popularized by the Eiffel language. Today several tools can be used to apply DBC in mainstream systems: this course will present basic DBC techniques and explore how to use them to define and check contracts in Java programs.

Topics

What is a contract

• procedural abstraction
• Hoare's triple
• pre-conditions, post-conditions and invariants
• the contract as part of the code
• dealing with contract deviations

Contracts and Abstract Data Types

• Data abstraction
• Abstract data type implementation
• Abstraction functions and representation invariants
• Modular reasoning
• Type Hierarchies and polymorphism

Design by Contract in Java

• Java Modeling Language
• Run-time Verification
• Compile-time Verification
• Test-case generation

References

1. Barbara Liskov and John Guttag. Program Development in Java: Abstraction, Specifications and Object-Oriented Design. Addison-Wesley. 2000.
2. Bertrand Meyer. Object-Oriented Software Construction. Prentice Hall, second edition, 1997.