Projekt

Zurück zur Übersicht

Synchronizing Models and Code

Gesuchsteller/in Nierstrasz Oscar
Nummer 131827
Förderungsinstrument Projektförderung (Abt. I-III)
Forschungseinrichtung Institut für Informatik Universität Bern
Hochschule Universität Bern - BE
Hauptdisziplin Informatik
Beginn/Ende 01.10.2010 - 31.12.2012
Bewilligter Betrag 337'337.00
Alle Daten anzeigen

Keywords (7)

Software evolution, Reflection, Meta-modeling, Context-oriented programming, Clone detection, Software architecture, Reverse engineering

Lay Summary (Englisch)

Lead
Lay summary
Successful software systems are under constant pressure to adapt to changing circumstances. Software adaptations take many forms, are of varying granularity, and may need to take effect over extreme variations in time scale. Running software systems are often subject to fine-grained, short-term adaptation to available resources and run-time context. Modest requirements changes typically provoke medium-grained, medium and long-term evolution of software source code, with consequent short-term adaptation of running software. Deeper requirements changes can provoke coarse-grained, long-term adaptation at the architectural level. In this project we propose to explore the following approaches to synchronize models and code: - Dynamic meta-objects: A running system should be able to dynamically respond to changes in its environment (fine-grained and short-term adaptations). Dynamic meta-objects will manipulate high-level representations of an object's behavior, they can be introduced on a per-object basis, and they can be composed to address multiple adaptations at a time. - First-class, active contexts: A software system needs to be able to locally and incrementally update code and program state (medium-grained and medium-term adaptations). Instead of placing strict barriers between software components of different versions, we propose to associate versions to first-class, active contexts. A running object that enters such a context may need to be dynamically updated to reflect different versions of interfaces, behavior, or even state. - Linked, active source code: Current software development tools fail to address synchronization of code shared between independent systems (medium-grained and medium-term as well as long-term adaptations). Instead of treating software source code as passive text, we propose a novel approach in which source code is linked to other source code, to other relevant semantic information, and to high-level models. - Polyglot systems modeling and analyses: Novel analyses are needed to help software architects assess the impact of changes (coarse-grained and long-term adaptations). We then to research novel metrics-based visualizations to support analyses such as the detection of architectural patterns. Further details are available on the project's web site: http://scg.unibe.ch/research/snf10
Direktlink auf Lay Summary Letzte Aktualisierung: 21.02.2013

Verantw. Gesuchsteller/in und weitere Gesuchstellende

Mitarbeitende

Publikationen

Publikation
Domain-Specific Profiling
Bergel Alexandre, Nierstrasz Oscar, Renggli Lukas, Ressia Jorge (2011), Domain-Specific Profiling, in TOOLS Europe 2011, Springer-Verlag, -.
How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk
Callau Oscar, Robbes Romain, Tanter Eric, Roethlisberger David (2011), How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk, in Mining software repositories, MSR 2011, IEEE Computer Society, -.
Software Evolution Comprehension: Replay to the Rescue
Hattori Lile, D'Ambros Marco, Lanza Michele, Lungu Mircea (2011), Software Evolution Comprehension: Replay to the Rescue, in International Conference on Program Comprehension, ICPC 2011, IEEE Computer Society Press, -.
Embedding Spatial Software Visualization in the IDE: an Exploratory Study
Kuhn Adrian, Erni David, Nierstrasz Oscar (2010), Embedding Spatial Software Visualization in the IDE: an Exploratory Study, in SOFTVIS 2010, ACM, -.
On recommending meaningful names in source and UML
Kuhn Adrian (2010), On recommending meaningful names in source and UML, in International Workshop on Recommendation Systems for Software Engineering, RSSE '10, ACM, -.
Natural Language Checking with Program Checking Tools
Perin Fabrizio, Renggli Lukas, Ressia Jorge (2010), Natural Language Checking with Program Checking Tools, in Smalltalks 2010, Smalltalks 2010, -.
Talents: Dynamically Composable Units of Reuse
Ressia Jorge, Girba Tudor, Nierstrasz Oscar, Perin Fabrizio, Renggli Lukas (2011), Talents: Dynamically Composable Units of Reuse, in International Workshop on Smalltalk Technologies (IWST 2011), International Workshop on Smalltalk Technologies , -.
A Study of Ripple Effects in Software Ecosystems (NIER)
Robbes Romain, Lungu Mircea (2011), A Study of Ripple Effects in Software Ecosystems (NIER), in International Conference on Software Engineering (ICSE 2011), ACM, -.
SmartGroups: Focusing on Task-Relevant Source Artifacts in IDEs
Roethlisberger David, Nierstrasz Oscar, Ducasse Stephane (2011), SmartGroups: Focusing on Task-Relevant Source Artifacts in IDEs, in International Conference on Program Comprehension (ICPC 2011), IEEE Computer Society, -.
Seuss: Cleaning up Class Responsibilities with Language-based Dependency Injection
Schwarz Niko, Lungu Mircea, Nierstrasz Oscar (2011), Seuss: Cleaning up Class Responsibilities with Language-based Dependency Injection, in TOOLS Europe 2011, Springer-Verlag, -.
DoodleDebug, Objects Should Sketch Themselves For Code Understanding
Schwarz Niko (2011), DoodleDebug, Objects Should Sketch Themselves For Code Understanding, in Workshop on Dynamic Languages and Applications (DYLA'11), 5th Workshop on Dynamic Languages and Applications (DYLA'11), -.
Runtime Class Updates using Modification Models
Verwaest Toon, Schwarz Niko, Wernli Erwann (2011), Runtime Class Updates using Modification Models, in Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'11), 8th Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'11), -.
Flexible object layouts: enabling lightweight language extensions by intercepting slot access
Verwaest Toon, Bruni Camillo, Lungu Mircea, Nierstrasz Oscar (2011), Flexible object layouts: enabling lightweight language extensions by intercepting slot access, in OOPSLA 2011, ACM, -.
Using First-class Contexts to realize Dynamic Software Updates
Wernli Erwann, Gurtner David, Nierstrasz Oscar (2011), Using First-class Contexts to realize Dynamic Software Updates, in International Workshop on Smalltalk Technologies (IWST 2011), International Workshop on Smalltalk Technologies (IWST 2011), -.
Answering Software Evolution Questions: An Empirical Evaluation
Hattori Lile, D'Ambros Marco, Lanza Michele, Lungu Mircea (2012), Answering Software Evolution Questions: An Empirical Evaluation, in Information and Software Technology, 1.
Recovering Software Architecture with Softwarenaut
Lungu Mircea, Nierstrasz Oscar (2012), Recovering Software Architecture with Softwarenaut, in ERCIM News, 88, 14-14.
Evolutionary and Collaborative Software Architecture Recovery with Softwarenaut
Lungu Mircea, Lanza Michele, Nierstrasz Oscar (2012), Evolutionary and Collaborative Software Architecture Recovery with Softwarenaut, in Science of Computer Programming (SCP), 1.
Big Software Data Analysis
Lungu Mircea, Nierstrasz Oscar, Schwarz Niko (2012), Big Software Data Analysis, in ERCIM News, 89, 27-28.
Agile software assessment with Moose
Nierstrasz Oscar (2012), Agile software assessment with Moose, in SIGSOFT Softw. Eng. Notes, 37(3), 1-5.
Agile software assessment
Nierstrasz Oscar, Lungu Mircea (2012), Agile software assessment, in Proceedings of International Conference on Program Comprehension (ICPC 2012), IEEE, USA.
Chameleon: Decoupling Instrumentation from Development Tools with Explicit Meta-Events (MSc thesis)
Quadri Andrea (2012), Chameleon: Decoupling Instrumentation from Development Tools with Explicit Meta-Events (MSc thesis), U Bern, U Bern.
Object-Centric Debugging
Ressia Jorge, Bergel Alexandre, Nierstrasz Oscar (2012), Object-Centric Debugging, in International Conference on Software engineering, ICSE '12, IEEE, USA.
Modeling Domain-Specific Profilers
Ressia Jorge, Bergel Alexandre, Nierstrasz Oscar, Renggli Lukas (2012), Modeling Domain-Specific Profilers, in Journal of Object Technology, 11(1), 1-21.
Suicide Objects
Ressia Jorge, Perin Fabrizio, Renggli Lukas (2012), Suicide Objects, in Dynamic Languages and Applications, DYLA '12, ACM, New York.
Object-Centric Reflection (PhD thesis)
Ressia Jorge (2012), Object-Centric Reflection (PhD thesis), U Bern, U Bern.
Talents: an environment for dynamically composing units of reuse
Ressia Jorge, Girba Tudor, Nierstrasz Oscar, Perin Fabrizio, Renggli Lukas (2012), Talents: an environment for dynamically composing units of reuse, in Software: Practice and Experience, 1.
How Do Developers React to API Deprecation? The Case of a Smalltalk Ecosystem
Robbes Romain, Lungu Mircea, Roethlisberger David (2012), How Do Developers React to API Deprecation? The Case of a Smalltalk Ecosystem, in International Symposium on the Foundations of Software Engineering (FSE'12), ACM, New York.
How to Make the Hidden Visible --- Code Clone Presentation Revisited
Schulze Sandro, Schwarz Niko (2012), How to Make the Hidden Visible --- Code Clone Presentation Revisited, in Koschke Rainer (ed.), Software Clone Management Towards Industrial Application (Dagstuhl Seminar 12071), Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik, Leibniz-Zentrum fuer Informatik, 35-38.
On how often code is cloned across repositories
Schwarz Niko, Lungu Mircea, Robbes Romain (2012), On how often code is cloned across repositories, in International Conference on Software Engineering, ICSE 2012, IEEE Press, New York.
Seuss: Decoupling responsibilities from static methods for fine-grained configurability
Schwarz Niko, Lungu Mircea, Nierstrasz Oscar (2012), Seuss: Decoupling responsibilities from static methods for fine-grained configurability, in Journal of Object Technology, 11(1), 1.
Hot clones: Combining search-driven development, clone management, and code provenance
Schwarz Niko (2012), Hot clones: Combining search-driven development, clone management, and code provenance, in International Conference on Software Engineering (ICSE 2012), IEEE, New York.
Hot Clones: A Shotgun Marriage of {Search-Driven} Development and Clone Management
Schwarz Niko (2012), Hot Clones: A Shotgun Marriage of {Search-Driven} Development and Clone Management, in European Conference on Software Maintenance and Reengineering, IEEE, New York.
Incremental Dynamic Updates with First-class Contexts
Wernli Erwann, Lungu Mircea, Nierstrasz Oscar (2012), Incremental Dynamic Updates with First-class Contexts, in TOOLS Europe 2012, Springer Verlag, Berlin.
Theseus: Whole updates of Java server applications
Wernli Erwann (2012), Theseus: Whole updates of Java server applications, in HotSWUp 2012, IEEE, New York.
Ownership, filters and crossing handlers: flexible ownership in dynamic languages
Wernli Erwann, Maerki Pascal, Nierstrasz Oscar (2012), Ownership, filters and crossing handlers: flexible ownership in dynamic languages, in Dynamic languages, DLS '12, ACM, New York.

Auszeichnungen

Titel Jahr
EAPLS Best paper award at TOOLS 2012 2012
European Smalltalk User Group 2012 Technology Innovation Award (1st prize) 2012

Verbundene Projekte

Nummer Titel Start Förderungsinstrument
121594 Bringing Models Closer to Code 01.10.2008 Projektförderung (Abt. I-III)
144126 Agile Software Assessment 01.01.2013 Projektförderung (Abt. I-III)

Abstract

Successful software systems are under constant pressure to adapt to changing circumstances. Software adaptations take many forms, are of varying granularity, and may need to take effect over extreme variations in time scale. Running software systems are often subject to fine-grained, short-term adaptation to available resources and run-time context. Modest requirements changes typically provoke medium-grained, medium and long-term evolution of software source code, with consequent short-term adaptation of running software. Deeper requirements changes can provoke coarse-grained, long-term adaptation at the architectural level. In each of these cases we are faced with the challenge of keeping the source code and the running software synchronized with changes in the higher-level domain and requirements models. This synchronization, however, is often difficult because current languages and runtime systems assume global consistency. They cannot cope with typical inconsistencies of systems with rapidly changing requirements, such as unpredictable variations in the execution environments, inconsistent versions of components, or dispersed code sources. Our current SNF project, Bringing Models Closer to Code, has been exploring various ways to close the conceptual gap between models and the software systems they apply to. In this new project we propose to study novel techniques to keep software systems synchronized with models in the face of varying granularities of change over different time scales. - Dynamic meta-objects: A running system should be able to dynamically respond to changes in its environment (fine-grained and short-term adaptations). Most common approaches to realize run-time adaptation are low-level, fragile, and unsuitable for composition. We propose to address these problems by means of dynamic meta-objects. These meta-objects will manipulate high-level representations of an object’s behavior, they can be introduced on a per-object basis, and they can be composed to address multiple adaptations at a time. - First-class, active contexts: A software system needs to be able to locally and incrementally update code and program state (medium-grained and medium-term adaptations). Running applications must increasingly cope with interface and data representation mismatches. Instead of placing strict barriers between software components of different versions, we propose to associate versions to first-class, active contexts. A running object that enters such a context may need to be dynamically updated to reflect different versions of interfaces, behavior, or even state. Objects may even be in multiple contexts at once, yet still behave in a predictable way. - Linked, active source code: Current software development tools fail to address synchronization of code shared between independent systems (medium-grained and medium-term as well as long-term adaptations). As software evolves, libraries, components and even fragments are frequently duplicated, adapted and specialized across software projects. Instead of treating software source code as passive text, we propose a novel approach in which source code is linked to other source code, to other relevant semantic information, and to high-level models. We plan to draw inspiration not only from sites such as Wikipedia as possible models for linked software, but also from popular social networking sites. - Technology-centric modeling and analyses: Novel analyses are needed to help software architects assess the impact of changes (coarse-grained and long-term adaptations). These analyses need to account for sub-systems built with diverse technologies and programming languages. We propose to analyze these “polyglot” systems focusing on the technologies involved. To detect hidden architectural dependencies between diverse sub-systems we need to develop a new meta-model that captures and connects the idiosyncrasies of each involved technology. We then plan to research novel metrics-based visualizations to support analyses such as the detection of architectural patterns.