Programming Technology Lab

The Programming Technology Lab (Prog for short) is a research and teaching lab within the VUB's Department of Computer Science. From a research perspective, Prog has always been active in the broad domains of software engineering and programming language engineering. In the former domain, our research consists of designing, implementing and formalising meta level techniques that support programming and modelling activities. In the latter domain, our research comprises the design, specification, formalisation and implementation of new programming languages belonging to the dynamic paradigm. See our Research Topics for more detailed information. From a teaching perspective, Prog has always taken a leading role in the design of the VUB's bachelor and master programmes in computer science. Prog's early history in dynamic programming paradigms is very tangible through the omnipresence of Scheme in the bachelor programme. Pico is Prog's homeground programming language for teaching. Throughout the years, Prog has been trying to disseminate its didactic values in international programmes such as EMOOSE. More recently, in UbiLab, we try to project these didactic values onto teaching embedded and ubiquitous systems. More details are found on the teaching pages. PROG's current research activities are being conducted within two (non-disjoint) groups of people which study software engineering and programming language engineering to ease the management of crosscutting phenomena and ambient phenomena... Aspect Technology and Understanding Crosscutting Phenomena Right from the start of the field in 1997, Prog has been active in aspect-oriented programming (AOP) and aspect-oriented software development (AOSD). AOP tries to centralise code that crosscuts an entire system -- but that conceptually belongs together -- into a new kind of module that is referred to as an aspect. An aspect weaver injects these aspects into a set of predetermined locations in the system. This set is described by an expression in a pointcut language. The power of a particular aspect-oriented language is largely determined by the expressiveness of its pointcut language: the easier and the more precise the injection locations can be described, the more complex systems the weaver can produce. Currently the notion of crosscutting phenomena in software engineering transcends mere AOP. Prog researchers are working on languages and techniques that strive for a better understanding and mastery of crosscutting phenomena. Designing better aspect-oriented languages. We design more powerful AOP languages by designing richer pointcut languages based on executable logic (e.g. Prolog's Horn clauses), by designing meta-aspect protocols and metacircular aspect languages, by inventing AOP for event-based languages using temporal-logic pointcuts, and by designing aspect languages for system level technologies such as C and make-files. Understanding crosscutting phenomena. We apply automated reasoning technology (e.g. Prolog, forward-chaining, abstract interpretation) on the meta level in order to extract crosscutting phenomena from existing code. Research includes dynamic analysis of code in order to verify crosscutting dynamic system properties, abstract interpretation techniques to enable behavioural queries over existing code, and meta-level reasoning technology that verifies system-wide structural properties of source code. Exploring non-aspect technologies to support crosscutting phenomena. Research includes the specification of how to convey inter-module knowledge in the implementation of modular compilers for domain-specific languages, and the design of context-oriented programming languages which allow us to express systems in which entire control flow paths (which crosscut a system) can be modified using a single instruction. More information can be found on the Context-Oriented Programming portal, the Logic Pointcuts in Carma portal, the declarative meta programming portal, and the intensional views portal. Programming Ambient Systems and Open Networks The term Ambient Systems is sometimes classified as euro-speak for "ubiquitous systems". The idea is that in the near future, human beings will be surrounded by a processor cloud of cooperating devices that together form a Personal Area Network. Such ambient systems have to function in the face of volatile connections, in the absence of shared infrastructure (like servers) and have to be highly aware of their context. Ambient-Oriented Programming (AmOP) is a name for Prog's research programme that strives for the design and implementation of high level programming technology that will facilitate the construction of such systems. Ambient-Oriented Programming Languages We are designing a family of programming languages that is designed to operate in environments where failure is the rule rather than the exception. We come up with new service discovery techniques, techniques to deal with managing facts (i.e. knowledge) that are distributed over volatile connections, advanced remote object referencing techniques, replication and reversible computations. Ambient-Oriented Virtual Machine Technology The programming languages conceived until now have been implemented on smart phones using prototypical recursive implementations. More recently, we are also doing research in implementation technology for our languages. Research includes distributed memory management in the face of volatile connections and lightweight virtual machines that are to be deployed on machinery as simple as sensor network nodes. Context-Aware Programming Ambient Systems are to be context aware. Instead of conceiving context dependencies by mere if-tests, we come up with techniques in which multi-layered programs can be written in which layers correspond to contexts. Also the application of rule-based formalisms is being investigated in this context. More information can be found on the Ambient-Oriented Programming Portal.