Existing studies show that open source projects may enjoy high levels of socio-technical congruence despite their open and distributed character. Such observations are yet to be confirmed in the case of larger open source ecosystems in which developers contribute to different projects within the ecosystem. In this paper, we empirically study the relationships between the developer coordination activities and the project dependency structure in the Ruby ecosystem. Our motivation is to verify whether the ecosystem context maintains the high socio-technical congruence levels observed in many smaller scale FLOSS (Free/Libre Open Source Software) projects. Our study results show that the collaboration pattern among the developers in Ruby ecosystem is not necessarily shaped by the communication needs indicated by the dependencies among the ecosystem projects.

Telemedicine, the provision of health care at a distance, is arguably an effective way of increasing access to, reducing cost of, and improving quality of care. However, the deployment of telemedicine is faced with standards that are hard to use, application-specific data models, and application stove-pipes that inhibit the adoption of telemedical solutions. To which extent can a software ecosystem approach to telemedicine alleviate this? In this article, we define the concept of software ecosystem architecture as the structure(s) of a software ecosystem comprising elements, relations among them, and properties of both. Our objective is to show how this concept can be used (i) in the analysis of existing software ecosystems and (ii) in the design of new software ecosystems. We performed a mixed-method study that consisted of a case study and an experiment. For (i), we performed a descriptive, revelatory case study of the Danish telemedicine ecosystem and for (ii), we experimentally designed, implemented, and evaluated the architecture of 4S. We contribute in three areas. First, we define the software ecosystem architecture concept that captures organization, business, and software aspects of software ecosystems. Secondly, we apply this concept in our case study and demonstrate that it is a viable concept for software ecosystem analysis. Finally, based on our experiments, we discuss the practice of software engineering for software ecosystems drawn from experience in creating and evolving the 4S telemedicine ecosystem. The concept of software ecosystem architecture can be used analytically and constructively in respectively the analysis and design of software ecosystems.

The use of telemedicine is arguably beneficial even in densely populated areas in reducing cost and increasing efficiency of healthcare. However, the implementation of telemedicine solutions in the healthcare system of Denmark has been perceived as being faced with implementation and interoperability issues, silo solutions, and lack of guidelines and standards. In this paper, we characterise the ecosystem evolved around the telemedicine services in Denmark and study the actors involved in this ecosystem. We establish a method for this study, where we define two actor roles and ways of characterizing actor contributions, and apply the method to the largest healthcare region of Denmark. Our findings reveal an ecosystem that is relatively closed to new actors, where the actors tend to be related to single telemedicine applications, the applications have low connectivity, and the most influential actors of the ecosystem can be characterised as both being beneficial and inhibitory to the ecosystem prosperity.

Agile development methods favor speed and feature producing iterations. Software architecture, on the other hand, is ripe with techniques that are slow and not oriented directly towards implementation of costumers' needs. Thus, there is a major challenge in retaining architectural information in a fast-faced agile project. We propose to embed as much architectural information as possible in the central artefact of the agile universe, the code. We argue that thereby valuable architectural information is retained for (automatic) documentation, validation, and further analysis, based on a relatively small investment of effort. We outline some preliminary examples of architectural annotations in Java and Python and their applicability in practice.

Publish/subscribe is a communication paradigm for distributed interaction. The paradigm provides decoupling in time, space, and synchronization for interacting entities and several variants of publish/subscribe exists including topic-based, subject-based, and type-based publish/subscribe. A central issue in implementing publish/subscribe-based systems is for entities to agree on a common vocabulary. To support this, we present a conceptualization and a design of a publish/subscribe system that combine and generalize many of these paradigms by using Semantic Web technology. In doing so, we extend previous work on ontology-based publish/subscribe by describing the semantics of publish/subscribe using operations on ontologies and by using common Semantic Web technology. Furthermore, we present an implementation in the context of a middleware we are designing and show that this implementation has adequate performance.

When designing for a group of professionals, it is important to know their work practice. This is well-known and practised, e.g., in agile software development in which customers are involved in development work, but less so when the professionals are software engineers or in particular software architects. In the SA@Work project, we have extensively studied software architect work at four Danish companies using both qualitative and quantitative approaches. In this paper, we report on concerns (analysis, design, evaluation, realization, management, and interaction) that software architects have in their work. Our lessons learnt are software architecture work (in the setting that we studied) is as much about non-technical as technical work, that architecture is often found "in the small" and that architects vary widely in type. Furthermore, we point to lessons for future research and development of software architecture techniques.

Planning (for example choosing most suitable services for self-configuration) is one important task in self-management for pervasive service computing, and can be reduced to the problem of multi-objective services selection with constraints. Genetic algorithms (GAs) are effective in solving such multi-objective optimization problems, and are one of the most successful computational intelligence approaches currently available. GAs are beginning to be used in planning for self-management, but there is a lack of comprehensive work that evaluates GAs performance and solution quality, and guides the setting of GAspsila parameters.This situation makes the application of GAs difficult in the pervasive service computing domain in which performance may be critical and the settings of parameters may have big consequences for performance. In this paper, we will present our evaluations of two GAs, namely NSGA-II and MOCell, in the GA framework JMetal2.1, for achieving multi-objective selection of available services. From these evaluations, suggestions on how and when to use NSGA-II and MOCell are given in the planning for self-management.Our experiences show that to get a true Pareto front for a problem, combining solutions set from different GAs is abetter way than using a single GA.

There is a growing trend to develop open world software with the forthcoming of the pervasive computing era.Traditional research on software architecture, components,and connectors is not geared towards the characteristics of open world software, and are not easily used in open world environments. In this paper, we present an extensible knowledge base called SACoCo (Semantic Architectural styles, Components, and Connectors), by applying Web Ontology Language (OWL) and Semantic Web Rule Language(SWRL) where an Open World Assumption (OWA)is adopted. Runtime validations of component configurations and software architectural styles can be specified with SWRL rules. SACoCo improves the semantics of classical architectural styles, components and connectors, andcan be used to dynamically validate software architectural styles and component configurations. Experiments with a pervasive web service compiler using OSGi and the Repository style show that the knowledge base is effective in improving the semantics of components and connectors, and is effective to validate component configurations and architectural styles, especially in open world environments.

There is a growing trend to deploy Web services in pervasive computing environments. Implementing Web services on networked, embedded devices leads to a set of challenges, including productivity of development, efficiency of Web services, and handling of variability and dependencies of hardware and software platforms. To address these challenges, we developed a Web service compiler called Limbo, in which Web Ontology Language (OWL) ontologies are used to make the Limbo compiler aware of its compilation context such as device hardware and software details, platform dependencies, and resource/power consumption. The ontologies are used to configure Limbo for generating resource-efficient Web service code.The architecture of Limbo follows the Blackboard architectural style and Limbo is implemented using the OSGi declarative services component model. The component model provides high flexibility for adding new compilation features. A number of evaluations show that the Limbo compiler is successful in terms of performance, completeness, and usability.

Designing and maintaining a software architecture that strikes the right balance between conflicting quality attributes is a daunting task facing every software architect. In the SA@Work project we have conducted ethnographical field studies of practicing software architects in four Danish software companies to study architectural work in general and architectural techniques in particular. In this paper, we describe observed techniques related to architectural quality as input to the architectural body of knowledge. Second, these techniques are classified according to the quality view classification framework of Garvin. Our analysis shows that techniques for assessing and ensuring quality in software architecture predominately view quality as an intrinsic quality of the architecture itself and less view it as related to business and users. This hints at a need to extend the architectpsilas toolbox and may explain observed mismatches between architectural work and agile processes.

Software architecture practice is highly complex. Software architects interact with business as well as technical aspects of systems, often embedded in large and changing organizations. We first make an argument that an appropriate research agenda for understanding, describing, and changing architectural practice in this context is based on an action research agenda in which researchers use ethnographic techniques to understand practice and engages directly with and in practice when proposing and designing new practices. Secondly, we present an overview of an ongoing project which applies action research techniques to understand and potentially change architectural practice in four Danish software companies.

Mobile games are one of the primary entertainment applications at present. Limited by scarce resources, such as memory, CPU, input and output, etc, mobile game development is more difficult than desktop application development, with performance as one of the top critical requirements. As object-oriented technology is the prevalent programming paradigm, most of the current mobile games are developed with object-orientation (OO) technologies. Intuitively OO is not a perfect paradigm for embedded software. Questions remain such as how OO and to what degree OO will affect the performance, executable file size, and how optimization strategies can improve the qualities of mobile game software. These questions are investigated in this paper within the mobile Role-Playing-Game (RPG) domain using five industrial mobile games developed with OO. We analyzed them and found excessive usage of OO features used for the development of mobile device applications (but normal for usual desktop applications). We then apply some optimization strategies along the way of structural programming. The experiment shows that the total jar file size of these five optimized games decreases 71 % the lines of codes decreases 59%, and the loading time of each optimized game decreases 22.73%, 34.62% 25.79% 24.65% and 16.70% respectively. Therefore, we conclude from our experiments that 00 should be used with great care in the development of mobile games, and that structural programming can be a very competitive alternative.

Current mobile middleware is designed according to a 'one-size-fits-all' paradigm, which lacks the flexibility for customization and adaptation to different situations, and does not support user-centered application scenarios well. In this paper we describe an ongoing intelligent mobile middleware research project called PLIMM that focuses on user-centered application scenarios. PLIMM is designed based on software product line ideas which make it possible for specialized customization and optimization for different purposes and hardware/software platforms. To enable intelligence, the middleware needs access to a range of context models. We model these contexts with OWL, focusing on user-centered concepts. The basic building block of PLIMM is the enhanced BDI agent where OWL context ontology logic reasoning will add indirect beliefs to the belief sets. Our approach also addresses the handling of ontology evolutions resulting from the timely adaptation of ontology to changes and the consistent propagation of these changes to all related artifacts, using Frame based product line configuration techniques.

Recent research shows runtime architectural reflection is instrumental in, for instance, building adaptive and flexible systems or checking correspondence between design and implementation. Moreover, experience with computational reflection in various branches of computer science shows that the interface through which the meta-information of the running system is accessed, and possibly modified, lies at the heart of designing reflective systems. This paper proposes that such an interface should be like a database: accessed through queries expressed using the concepts with which architecture is described. Specifically, our contributions are: (1) a presentation of the general idea of a query-based approach to architectural reflection, (2) a definition of an Architectural Query Language (AQL) in which perspectives on an architectural model can be expressed as queries, (3) a prototype of a system which both creates runtime models of specific distributed architectures and allow for evaluation of AQL queries on these models. We illustrate the viability of the approach in two particular applications of such a model: constraint checking relative to an architectural style, and reasoning about certain quality attributes of an architecture.

A major part of software architecture design is learning how specific architectural designs balance the concerns of stakeholders. We explore the notion of "architectural prototypes", correspondingly architectural prototyping, as a means of using executable prototypes to investigate stakeholders' concerns with respect to a system under development. An architectural prototype is primarily a learning and communication vehicle used to explore and experiment with alternative architectural styles, features, and patterns in order to balance different architectural qualities. The use of architectural prototypes in the development process is discussed, and we argue that such prototypes can play a role throughout the entire process. The use of architectural prototypes is illustrated by three distinct cases of creating software systems. We argue that architectural prototyping can provide key insights that may otherwise be difficult to obtain before a system is built. Furthermore, they define skeleton systems that serve as communication means and knowledge transfer among stakeholders.

Modeling is central to doing and learning object-oriented development. We present a new tool, Ideogramic UML, for gesture-based collaborative modeling with the Unified Modeling Language (UML), which can be used to collaboratively teach and learn modeling. Furthermore, we discuss how we have effectively used Ideogramic UML to teach object-oriented modeling and the UML to groups of students using the UML for project assignments.

In this paper, we describe Kimura, an augmented office environment to support common multitasking practices. Previous systems, such as Rooms, limit users by constraining the interaction to the desktop monitor. In Kimura, we leverage interactive projected peripheral displays to support the perusal, manipulation and awareness of background activities. Furthermore, each activity is represented by a montage comprised of images from current and past interaction on the desktop. These montages help remind the user of past actions, and serve as a springboard for ambient context-aware reminders and notifications.

Modeling is important in object-oriented software development. Although a number of Computer Aided Software Engineering (CASE) tools are available, and even though some are technically advanced, few developers use them. This paper describes our attempt to examine the requirements needed to provide tool support for the development process, and describes and evaluates a tool, Knight, which has been developed based on these requirements. The tool is based on a direct, whiteboard-like interaction achieved using gesture input on a large electronic whiteboard. So far the evaluations have been successful and the tool shows the potential of greatly enhancing current support for object-oriented modeling.