Jan Vitek, Purdue University
Programming Models for Concurrency and Real-time
Abstract: Modern real-time applications are increasingly large, complex and concurrent systems which must meet stringent performance and predictability requirements. Programming those systems require fundamental advances in programming languages and runtime systems. This talk presents our work on Flexotasks, an programming model for concurrent, real-time system inspired by stream-processing and concurrent active objects. Some of the key innovations in Flexotasks are that it supports both real—time garbage collection and region-based memory with an ownership type system for static safety. Communication between tasks is performed by channels with a linear type discipline to avoid copying messages, and by a non-blocking transactional memory facility. We have evaluated our model empirically within two distinct implementations, one based on Purdue’s Ovm research virtual machine framework and the other on Websphere, IBM’s production real-time virtual machine. We have written a number of small programs, as well as a 30 KLOC avionics collision detector application. We show that Flexotasks are capable of executing periodic threads at 10 KHz with a standard deviation of 1.2us and have performance competitive with hand coded C programs.
Bio: Jan Vitek is currently an Associate Professor in the Computer Science Department at Purdue University and an Academic Visitor at IBM T.J. Watson Research Center. His research interest span from programming language design and implementation, with particular emphasis on object-oriented languages. He has led the development of the Ovm real-time Java virtual machine. He is a member of the JSR-302: Safety Critical Java Expert Group and the IFIP Working Group 2.4. He sits on the steering committees of ECOOP, JTRES, VEE, Transact and Coordination conferences.
Gerti Kappel, Vienna University of Technology
On Realizing a Framework for Self-tuning Mappings
Abstract: Realizing information exchange is a frequently recurring challenge in nearly every domain of computer science. Although languages, formalisms, and storage formats may differ in various engineering areas, the common task is bridging schema heterogeneities in order to transform their instances. Hence, a generic solution for realizing information exchange is needed. Conventional techniques often fail, because alignments found by matching tools cannot be executed automatically by transformation tools. In this paper we present the Smart Matching approach, a successful combination of matching techniques and transformation techniques, extended with self-tuning capabilities. With the smart Matching approach, complete and correct executable mappings are found in a test-driven manner.
Bio: Gerti Kappel is a full professor at the Institute for Software Technology and Interactive Systems at the Vienna University of Technology, heading the Business Informatics Group. Until 2001, she was a full professor of computer science and head of the Department of Information Systems at the Johannes Kepler University of Linz. She received the Ms and PhD degrees in computer science and business informatics from the University of Vienna and Vienna University of Technology in 1984 and 1987, respectively. From 1987 to1989 she was a visiting researcher at Centre Universitaire d'Informatique, Geneva, Switzerland. She has been involved in national and international joint projects, both governmental and industry funded, as well as sponsored by the EU. From 2004 to 2007, she was also dean of student affairs for business informatics.
Benjamin Pierce, University of Pennsylvania
Foundations for Bidirectional Programming
Abstract: Most programs get used in just one direction, from input to output. But sometimes, having computed an output, we need to be able to update this output and then “calculate backwards” to find a correspondingly updated input. The problem of writing such bidirectional transformations—often called lenses—arises in applications across a multitude of domains and has been attacked from many perspectives.
The Harmony project at the University of Pennsylvania is exploring a linguistic approach to bidirectional programming, designing domain-speci?c languages in which every expression simultaneously describes both parts of a lens. When read from left to right, an expression denotes an ordinary function that maps inputs to outputs. When read from right to left, it denotes an “update translator” that takes an input together with an updated output and produces a new input that reflects the update. These languages share some common elements with modern functional languages—in particular, they come with very expressive type systems. In other respects, they are rather novel and surprising.
We have designed, implemented, and applied bi-directional languages in three quite different domains: a language for bidirectional transformations on trees (such as XML documents), based on a collection of primitive bidirectional tree transformation operations and “bidirectionality-preserving” combining forms; a language for bidirectional views of relational data, using bidirectionalized versions of the operators of relational algebra as primitives; and, most recently, a language for bidirectional string transformations, with primitives based on standard notations for finite-state transduction and a type system based on regular expressions. The string case is especially interesting, both in its own right and because it exposes a number of foundational issues common to all bidirectional programming languages in a simple and familiar setting. We are also exploring how lenses and their types can be enriched to embody privacy and integrity policies.
This talk surveys what we’ve learned from the work so far on Harmony, focusing on foundational issues and attempting to connect them to work ongoing in the model transformation community.
Bio: Benjamin Pierce joined the CIS Department at Penn in 1998. Previously, he was on the faculty at Indiana University and held research fellowships at Cambridge University, the University of Edinburgh, and INRIA-Roquencourt. He received his Ph.D. in Computer Science at Carnegie Mellon University in 1991. His research centers on programming languages, static type systems, concurrent and distributed programming, and synchronization technologies. His books include the widely used graduate text Types and Programming Languages. He is also the lead designer of the popular Unison file synchronizer.
Stéphane Ducasse, INRIA Lille
Putting Traits in Perspective
Abstract: Traits have been proposed as a mechanism to compose and share behavioral units between distinct class hierarchies. Several versions have been developed and they have been used to build complex libraries. This keynote puts in perspective the current versions and stress their relationships and limits.
Bio: Since 2007 Stéphane is research director at INRIA-Lille Nord Europe where he leads the RMoD team. He is expert in two domains: object-oriented language design and reengineering. He is expert in object-oriented language design, dynamic languages, reflective programming and language semantics. He worked on traits, composable method groups, and this work got some impact. Traits have been introduced in AmbiantTalk, Slate, and Squeak and under a variant into Scala, Fortress SUN Microsystems, Perl6. Stéphane is one of the developer of Pharo an open-source Smalltalk derived from Squeak. He is also expert on software quality, program understanding, program visualizations, reengineering and metamodeling. He is one of the core developer of Moose, an open-source reengineering environment. He is the president of the European Smalltalk User Group and organizes a yearly international conference on Smalltalk. He wrote a couple of fun books to teach programming and other serious topics such as dynamic web development.
Paul Klint, University of Amsterdam
Language Design for Meta-programming in the Software Composition Domain
Abstract: How would a language look like that is specially designed for solving meta-programming problems in the software composition domain? We present requirements for and design of Rascal, a new language for solving meta-programming problems that fit the Extract-Analyze-SYnthesize (EASY) paradigm.
Bio: Paul Klint is head of the software engineering department at Centrum voor Wiskunde en Informatica (CWI, the Dutch national research center for computer science and mathematics) and professor in computer science at the University of Amsterdam where he directs the master program on Software Engineering. He is also visiting professor at University of London (Royal Holloway), founding-president and now treasurer of the European Association for Programming Languages and Systems (EAPLS), and co-founder of the Software Improvement Group (SIG) that was awarded the ICTRegie Innovation Award in 2008. He is leader of ATEAMS, a recently started joint CWI-INRIA research group.
He holds a MSc in Mathematics from the University of Amsterdam and a PhD in Computer Science from the Technical University Eindhoven. He (co)authored three books and has published over a hundred scientific articles. He was advisor of 30 dissertations and over 150 master's theses. He has consulted for companies and governments worldwide. His research interests include generic language technology, domain-specific languages, software analysis and renovation, technology transfer and intellectual property rights. He is currently working on Rascal, a language that supports the Extract-Analyze-SYnthesize (EASY) paradigm for meta-programming and is aiming at analysis, refactoring and transformation of software. Download his favourite software from www.meta-environment.org.
Carlo Ghezzi, Politecnico di Milano
Decentralized Software Development: Pitfalls and Challenges
Abstract: The talk discusses different three main threads through which monolithic and centralized software development became increasingly distributed and decentralized. One is off-shoring, in which geographically distributed teams cooperate in the development of an application. Another is component-based software development, in which two separate development cycles interact: development of component and development of the composite. A third thread is software-as-service, in which the two main stakeholders (service provider and the service client) continue to interact at run time. Each of these threads has its own potential advantages over traditional software development, but also raises fundamental concerns. The talk discusses how they stress some of the conceptually difficult aspects of software development and how they introduce new problems and difficulties that did not exist before.
Bio: Carlo Ghezzi is a Professor and Chair of Software Engineering at Politecnico di Milano. He is the RectorÕs Delegate for research. In the past, he has been a member of the Academic Senate and a Member of the Board of Governors of Politecnico. He also held positions as Department Chair, Head of the PhD Program and Head of Òconsiglio di corso di laureaÓ. He has also been affiliated with: Universitˆ di Padova, University of California at Los Angeles, University of North Carolina at Chapel Hill, University of California at Santa Barbara (USA), Escuela Superior Latino-Americana de Informatica (Argentina), Technical University of Vienna and University of Klagenfurt (Austria), University of Lugano (Switzerland).
He is a Fellow of the ACM (citation: Numerous research contributions from compiler theory to real-time systems to software processes. A strong contributor to the software engineering community in Europe and worldwide.) and Fellow of the IEEE (citation: Contributions to programming languages and software engineering). He was awarded the ACM SIGSOFT Distinguished Service Award. He is a member of the Academy of Sciences. He has been a member of several governmental committees and was the Italian representative in the EU Information Technology Committee (Esprit Programme) during the 4th Framework Programme. He has been on the board of several international research projects and institutions in Europe, Japan, and the USA.
He is a regular member of the program committee of flagship conferences of the software engineering field, such as the International Conference on Software Engineering and Foundations of Software Engineering/ European Software Engineering Conference, for which he also served as Program and General Chair. He has been General Chair of the International Conference on Service Oriented Computing (ICSOC 2006, Chicago, USA). He has been the Editor in Chief of the ACM Transactions on Software Engineering and Methodology and Associate Editor of IEEE Transactions on Software Engineering. He is currently an Associate Editor of Science of Computer Programming (Elsevier), Service Oriented Computing and Applications (Springer), and Software Process Improvement and Practice (J. Wiley and Sons).
Carlo Ghezzi's research has been focusing on different aspects of software engineering and programming languages. Currently, he is active in the area of software architectures, especially evolvable and distributed software architectures for ubiquitous and pervasive computer applications. He co-authored over 150 papers, almost all of which are published internationally, and 8 books. He coordinated several national and international (EU funded) research projects. He has been a recipient of an ERC Advanced Research Grant in 2008.
Narayanasamy Ramasubbu, Singapore Management University
An Empiricist View of Managing Globally Distributed Software Development
Abstract: Software Engineering research is still catching up with the explosive growth in the adoption and proliferation of distributed software development in its many forms. In this talk, I will present the research roadmap I, as an empirical researcher, had taken to investigate distributed software development, and will highlight the key findings and inferences from my exploration. Drawing evidence from more than two hundred large scale distributed software development projects that I had observed in the past five years, I will discuss the challenges faced by distributed software teams along with the way these teams (and their organizations) have responded to the challenges. I will also share my views on the existing gaps, both theoretical and empirical, in software engineering economics literature that need to be bridged to further our understanding of distributed software development. These gaps specifically relate to how software engineering researchers and practitioners accommodate distributedness in project planning, execution, control and reflection activities. Overall, my discussions will call for a new set of governance schemes specifically suited for distributed software development projects, and will lay out a roadmap for empirical software engineers to build one.
Bio: Narayan Ramasubbu is an assistant professor at the School of Information Systems at the Singapore Management University. He has a Ph.D. in Business Administration from the University of Michigan, Ann Arbor, and an Electronics and Telecommunications Engineering degree from Bharathiyar University, India. Prior to pursuing the Ph.D., he was a senior developer and product management specialist, first at CGI Inc. and then at SAP AG. His research focuses on software engineering economics, distributed software product development, and software product standardization and customization. His research statement and projects can be viewed here.
Sriram Rajamani, Microsoft Research (India)
Property Checking by Combining Verification and Testing
Abstract: Software validation is the task of determining if the software meets the expectations of its users. For the most part, industrial practice of software engineering uses testing to validate software. Testing is incomplete in the sense that it validates the software only for the test inputs that we execute. The software might exhibit undesired behavior with test inputs we do not have. The holy grail of software validation is verification. Here, the goal is to formally prove that the software meets its expectations for all possible test inputs, and for all possible executions.
In practice, verification efforts run into two major difficulties. First, it is very hard to formally specify expectations as specifications in a formal language that can be input to a verification tool. Complete specifications of complex software (like an operating system) could be as complex as the software itself, and it is very hard to get programmers and system designers to write specifications. Next, even if specifications were to somehow exist, the scale and complexity of large software (which can run into tens of millions of lines of source code) is well beyond the capabilities of today's verification tools.
In this short paper, we discuss some possible approaches for these problems. First, in order to the address the difficulties in writing specifications, we believe that there are ways by which we can ask programmers for high-level guidelines about the structure of specifications, and use statistical techniques to automatically generate detailed specifications. Second, in order to address scalability, we believe that we can exploit the continuum between verification and testing, and design hybrid algorithms that combine testing and verification.
Bio: Sriram Rajamani is a Principal Researcher and Research Manager with Microsoft Research India, Bangalore. Sriram leads the Rigorous Software Engineering (RSE) group in Microsoft Research India. The RSE group does research in improving productivity by bringing rigor to all aspects of software development. Prior to moving to the India lab, Sriram was most recently manager of the Software Productivity Tools group in Microsoft Research Redmond, where he lead several projects together with is wonderful colleagues ---SLAM and Static Driver Verifier, Behave! and Zing. Sriram has a PhD in Computer Science from the University of California at Berkeley. In a previous life Sriram has worked as a programmer for over 5 years writing telecommunication software (for Syntek Inc) and electronic design automation software (for Xilinx Inc). He uses his first hand experience in the realities of commercial software development to guide his choice of problems and approaches to research in software productivity.
Boutheina Chetali, Gemalto
Security Testing and Formal Methods for High Levels Certification of Smart Cards
Abstract: We will discuss security testing and formal methods in the framework of the Common Criteria certification of smart cards. The discussion will introduce the requirements of the standard on the test activity and on the description of the design and will identify their impact on the methods and tools to use. Emphasis will be placed on the high levels of certification in which formal methods are required to demonstrate the correct design of the security. We will discuss the advantage of a mixed approach of formal model-based testing, that will allow us to reach, in a pragmatic way, high levels of certification.