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
Agile software assessment
(2012), Agile software assessment, in Proceedings of International Conference on Program Comprehension (ICPC 2012).
Agile software assessment with Moose
(2012), Agile software assessment with Moose, in SIGSOFT Softw. Eng. Notes, 37(3), 1-5.
Answering Software Evolution Questions: An Empirical Evaluation
(2012), Answering Software Evolution Questions: An Empirical Evaluation, in Information and Software Technology, 1.
Big Software Data Analysis
(2012), Big Software Data Analysis, in ERCIM News, 89, 27-28.
Chameleon: Decoupling Instrumentation from Development Tools with Explicit Meta-Events (MSc thesis)
(2012), Chameleon: Decoupling Instrumentation from Development Tools with Explicit Meta-Events (MSc thesis).
Evolutionary and Collaborative Software Architecture Recovery with Softwarenaut
(2012), Evolutionary and Collaborative Software Architecture Recovery with Softwarenaut, in Science of Computer Programming (SCP), 1.
Hot Clones: A Shotgun Marriage of {Search-Driven} Development and Clone Management
(2012), Hot Clones: A Shotgun Marriage of {Search-Driven} Development and Clone Management, in European Conference on Software Maintenance and Reengineering.
Hot clones: Combining search-driven development, clone management, and code provenance
(2012), Hot clones: Combining search-driven development, clone management, and code provenance, in International Conference on Software Engineering (ICSE 2012).
How Do Developers React to API Deprecation? The Case of a Smalltalk Ecosystem
(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).
How to Make the Hidden Visible --- Code Clone Presentation Revisited
(2012), How to Make the Hidden Visible --- Code Clone Presentation Revisited, 35-38.
Incremental Dynamic Updates with First-class Contexts
(2012), Incremental Dynamic Updates with First-class Contexts, in TOOLS Europe 2012.
Modeling Domain-Specific Profilers
(2012), Modeling Domain-Specific Profilers, in Journal of Object Technology, 11(1), 1-21.
Object-Centric Debugging
(2012), Object-Centric Debugging, in International Conference on Software engineering, ICSE '12.
Object-Centric Reflection (PhD thesis)
(2012), Object-Centric Reflection (PhD thesis).
On how often code is cloned across repositories
(2012), On how often code is cloned across repositories, in International Conference on Software Engineering, ICSE 2012.
Ownership, filters and crossing handlers: flexible ownership in dynamic languages
(2012), Ownership, filters and crossing handlers: flexible ownership in dynamic languages, in Dynamic languages, DLS '12.
Recovering Software Architecture with Softwarenaut
(2012), Recovering Software Architecture with Softwarenaut, in ERCIM News, 88, 14-14.
Seuss: Decoupling responsibilities from static methods for fine-grained configurability
(2012), Seuss: Decoupling responsibilities from static methods for fine-grained configurability, in Journal of Object Technology, 11(1), 1.
Suicide Objects
(2012), Suicide Objects, in Dynamic Languages and Applications, DYLA '12.
Talents: an environment for dynamically composing units of reuse
(2012), Talents: an environment for dynamically composing units of reuse, in Software: Practice and Experience, 1.
Theseus: Whole updates of Java server applications
(2012), Theseus: Whole updates of Java server applications, in HotSWUp 2012.
A Study of Ripple Effects in Software Ecosystems (NIER)
(2011), A Study of Ripple Effects in Software Ecosystems (NIER), in International Conference on Software Engineering (ICSE 2011).
Domain-Specific Profiling
(2011), Domain-Specific Profiling, in TOOLS Europe 2011.
DoodleDebug, Objects Should Sketch Themselves For Code Understanding
(2011), DoodleDebug, Objects Should Sketch Themselves For Code Understanding, in Workshop on Dynamic Languages and Applications (DYLA'11).
Flexible object layouts: enabling lightweight language extensions by intercepting slot access
(2011), Flexible object layouts: enabling lightweight language extensions by intercepting slot access, in OOPSLA 2011.
How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk
(2011), How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk, in Mining software repositories, MSR 2011.
Runtime Class Updates using Modification Models
(2011), Runtime Class Updates using Modification Models, in Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'11).
Seuss: Cleaning up Class Responsibilities with Language-based Dependency Injection
(2011), Seuss: Cleaning up Class Responsibilities with Language-based Dependency Injection, in TOOLS Europe 2011.
SmartGroups: Focusing on Task-Relevant Source Artifacts in IDEs
(2011), SmartGroups: Focusing on Task-Relevant Source Artifacts in IDEs, in International Conference on Program Comprehension (ICPC 2011).
Software Evolution Comprehension: Replay to the Rescue
(2011), Software Evolution Comprehension: Replay to the Rescue, in International Conference on Program Comprehension, ICPC 2011.
Talents: Dynamically Composable Units of Reuse
(2011), Talents: Dynamically Composable Units of Reuse, in International Workshop on Smalltalk Technologies (IWST 2011).
Using First-class Contexts to realize Dynamic Software Updates
(2011), Using First-class Contexts to realize Dynamic Software Updates, in International Workshop on Smalltalk Technologies (IWST 2011).
Embedding Spatial Software Visualization in the IDE: an Exploratory Study
(2010), Embedding Spatial Software Visualization in the IDE: an Exploratory Study, in SOFTVIS 2010.
Natural Language Checking with Program Checking Tools
(2010), Natural Language Checking with Program Checking Tools, in Smalltalks 2010.
On recommending meaningful names in source and UML
(2010), On recommending meaningful names in source and UML, in International Workshop on Recommendation Systems for Software Engineering, RSSE '10.

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.
-