Initial (un-advertised) page on the Programming Language Summer School.
Speakers
Barrett Bryant, UAB (us) Barrett R. Bryant is Professor and Associate Chair of Computer and Information Sciences at the University of Alabama at Birmingham. His research interests include theory and implementation of programming languages, formal specification of software systems, and component-based software engineering, and he has authored or co-authored over 120 published papers in these areas. He is a member of ACM, EAPLS, an IEEE Senior Member, and Chair of the ACM Special Interest Group on Applied Computing (SIGAPP). Further details are available at http://www.cis.uab.edu/bryant
Christopher Dutchyn, USASK (ca) Christopher Dutchyn is an assistant professor of computer science at the University of Saskatchewan, after receiving a Ph.D. from the University of British Columbia. His research interests are programming language design, both formal and operational, especially of modularity constructs and their analysis and application. He is a member of the ACM. See http://www.cs.usask.ca/faculty/cjd032/.
Jacques Noyé, EMN (fr) Jacques Noyé is an associate professor at Ecole des Mines de Nantes and vice-head of OBASCO (OBjects, ASpects, and COmponents) a joint project of Ecole des Mines de Nantes, INRIA, and LINA. He has been working on many aspects of the implementation of programming languages across various paradigms. His current interests include the connection of various coarse-grain structuring concepts such as components, aspects, and processes as a foundation for lean architecture programming languages. He is also interested in the modular design and implementation of multi-language infrastructures.
Andy Kellens, VUB (be) Andy Kellens is a post-doctoral researcher at the Programming Technology Lab of the Vrije Universiteit Brussel, where he obtained his PhD in 2007. His research interests include software evolution, declarative meta-programming and aspect-oriented software development. Andy is one of the main contributors to the intensional views approach, and the associated tool-suite IntensiVE, that aim at support the co-evolution of design regularities and source code.
Alexandre Bergel, INRIA (fr) Alexandre Bergel is a permament researcher at INRIA Futurs, Lille, France. He obtained his PhD in 2005 from the University of Bern, Switzerland, under the supervision of Prof. Nierstrasz and Prof. Ducasse. His thesis focused on Classboxes, a new module system to ease software evolution and extension for large software systems. This PhD was awarded by the Ernst-Denert Software Engineering price in 2006. He realized a first post-doc at Trinity College Dublin, Ireland where he tackled, with Realtalk, the problem of modeling the control flow of application in presence of an event-based hardware and limited resources. In 2007 he went to Germany and became a Research Fellow at the Hasso-Plattner-Institut, Potsdam. He worked on Traits and Method Namespaces, new programming languages constructs to ease evolution of program source code. Since October 2007 he is working on the topics previously enumerated.
Johan Fabry, UChile (cl)
Johan Fabry is an assistant professor at the Computer Science Department (DCC) of the Universidad de Chile. His first research interest lies in the application of advanced forms of modularization (usually aspects, but also considering metaprogramming, generative programming, …) to the domain of distributed systems. The overall goal is to make life easier for the programmer of these systems. Secondly, he works on the design and implementation of Domain-Specific Aspect Languages (DSALs). The goal here is to help the language/weaver developer in creating such languages. This includes finding guidelines or methodologies for DSAL design and facilitating reuse of parts of DSAL specifications, amongst others.
Basic Topics: Tuesday Nov 11th
Object-Oriented Programming, Alexandre Bergel This basic lecture gives an introduction of class-based object-oriented programming. The notion of objects and classes will be on the spot. As an appetizer, the lecture will smoothly begin with a bit of history (where do objects come from?). The main dish will be composed of an introduction to objects, classes, the instantiation and super link. The desert will give an overview of how objects may be efficiently used to develop dynamic web applications.
Fundamentals of Functional Programming, Chris Dutchyn
Functional programming, after languishing in academia, is returning to mainstream applications, for several reasons:
- simpler concurrency models to support multiple threads and multiple cores
- expressive syntax for comprehensions
- a more direct programming style
This course will give an overview of functional programming, differentiating it from imperative programming, with examples from several functional languages.
Compiling Programming Languages, Barrett Bryant High level programming languages may be implemented by compiling into machine code (e.g., C), interpreting the program directly (e.g., Ruby), or compiling into virtual machine code which may then be further compiled into machine code or interpreted (e.g., Java). This talk will provide an overview of the techniques involved in compiling, the language issues that influence which of these three approaches to implementation is used, and current trends in language design and implementation.
Logic Programming, Andy Kellens Logic programming is a declarative programming paradigm that is rooted in formal logic. Programs in a logic programming language can be written by expressing basic relations using facts, and then writing queries that reason about these facts. One of the strengths of such a declarative approach is that it enables to think in terms of what the program should do, rather than how this should be achieved. In this talk, we will provide a brief overview of logic programming by taking a look at the PROLOG language.
Process Calculi, Jacques Noyé As a complement to the lambda calculus, which provides a wonderful foundation for purely computational systems, process calculi are calculi that make it possible to model and reason about interacting systems. This talk will quickly review the basic building blocks of a simple process calculus, FSP (Finite State Processes), with its relationship to finite state automata. We will show how such a calculus can be used, in a first step, to describe, in a compositional and abstract way, both the structure and the behavior of an architecture of interacting components, and, in a second step, to check some important properties of the architecture.
Aspect-Oriented Software Development, Johan Fabry Aspect-Oriented Software Development (AOSD) is a relatively new software development paradigm that complements and improves on many contemporary development paradigms. AOSD provides unique and advanced program structuring and modularization techniques. This allows for a better modularity of the software, i.e. a better implementation structure. This improves software qualities such as higher reusability and easier maintainability. In this talk we give a general introduction to the concepts of AOSD and a brief overview of the most popular aspect programming language: AspectJ.
Advanced Topics: Wednesday Nov 12th
Modularity: Beyond Classes, Alexandre Bergel Class inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. This lecture will point out limitations of single inheritance, multiple inheritance, and mixins. It will present state-to-the-art alternatives to class inheritance that overcome these limitations. It will be demonstrated how Traits, Classboxes, and Virtual classes are more expressive mechanisms to achieve software reuse.
Engineering of Domain-Specific Languages, Barrett Bryant In contrast to general purpose programming languages, domain-specific languages are designed for a specific task. Often such languages are more oriented toward the application domain expert instead of software engineers. As such, domain-specific languages are the primary new computer languages that will be developed and also their development will be more influenced by application domain demands than software engineering concerns. This talk discusses the principles of domain-specific languages and illustrates how they may be used and designed by application domain experts.
Domain-Specific Aspect Languages, Johan Fabry While AspectJ is currently the most popular aspect language, initial research on AOSD used radically different languages. Instead of being general-purpose, each aspect language was dedicated to one specific domain: each language was a domain-specific aspect language (DSAL). Research in this area has been dormant for some time due to a shift in focus within the community, but has recently started gaining popularity again. In this talk we show the difference between general-purpose aspect languages and DSALs, the interesting advantages that DSALs bring, as well as some of their drawbacks.
Programming with Intent, Chris Dutchyn Writing correct programs is hard; type-checking and testing help. But, they prove only weak properties of our programs. Using Sheard's Omega programming language, we will extend our ability to express programmer intentions, and see how these intentions can be automatically checked.
Aspects, Components and Processes, Jacques Noyé Based on the previous course on process calculi, this course will consider the relationship between stateful/temporal aspects, components equipped with behavioral protocols, and processes, shedding some light on three fundamental concepts of software organization.
Declarative Meta Programming, Andy Kellens Declarative Meta Programming is defined as the use of a declarative programming language for writing meta programs. Meta programs are programs that process programs; as opposed to more plain programs that process bank accounts, e-mails, text documents and so on. Any programmer and software engineer uses meta programs: compilers, program editors, integrated development environments, UML editors, program verifiers and other software engineering tools are all meta programs. In this talk we are going to demonstrate the logic meta programming language SOUL, and illustrate it's adeptness for writing programs that reason about other programs.