Browsing by Subject "Software architecture"

Now showing 1 - 20 of 27

Open Access
An approach for detecting inconsistencies between behavioral models of the software architecture and the code
(2012-07) Çıracı, Selim; Sözer, Hasan; Tekinerdoğan, Bedir
In practice, inconsistencies between architectural documentation and the code might arise due to improper implementation of the architecture or the separate, uncontrolled evolution of the code. Several approaches have been proposed to detect inconsistencies between the architecture and the code but these tend to be limited for capturing inconsistencies that might occur at runtime. We present a runtime verification approach for detecting inconsistencies between the dynamic behavior of the documented architecture and the actual runtime behavior of the system. The approach is supported by a set of tools that implement the architecture and the code patterns in Prolog, and automatically generate runtime monitors for detecting inconsistencies. We illustrate the approach and the toolset for a Crisis Management System case study. © 2012 IEEE.
Open Access
Archample-architectural analysis approach for multiple product line engineering
(Elsevier Inc., 2014) Tekinerdogan, B.; Erdoğan, Ö. Ö.; Aktuğ, O.
The increased size and complexity of software systems has led to the notion of multiple software product lines (MPLs) in which products are composed from subproducts in separate software product lines. Thus, it is important to identify the proper architectural decomposition of the MPL with respect to the stakeholders' concerns before large organizational resources are committed to the development. Designing MPL architectures is challenging due to the higher level of abstraction and the integration of different product lines. Different architecture analysis approaches have been introduced, but none of these focuses on the evaluation of MPL architectures. We propose the architecture analysis approach for MPL Engineering (Archample), which has been particularly defined for the analysis of MPL architectures. Archample also introduces architectural viewpoints for modeling and documenting MPL and likewise supporting the analysis of the decomposition of an MPL architecture. The approach has been designed and validated within a real industrial context of Aselsan REHI˙S Group (Aselsan REHI˙S), a leading high-technology company in defense systems development in Turkey. © 2014 Elsevier Inc. All rights reserved.
Open Access
Architecting in global software engineering
(Association for Computing Machinery, 2012-01) Tekinerdogan, B.; Cetin S.; Babar, M. A.; Lago, P.; Mäkiö, J.
This paper summarizes the results of the First Workshop on Architecting in Global Software Engineering (GSE), which was organized in conjunction with the 6th International Conference on Global Software Engineering (ICGSE 2011). The workshop aimed to bring together researchers and practitioners for defining and advancing the state-of-the-art and state-of-the practice in architecture design of global software development systems.
Open Access
Architectural viewpoints for global software development
(IEEE, 2011) Yıldız, Buğra M.; Tekinerdoğan, Bekir
Global Software Development (GSD) can be considered as the coordinated activity of software development that is not localized and central but geographically distributed. Designing an appropriate software architecture of a GSD system is important to meet the requirements for the communication, coordination and control of the distributed GSD teams. A common practice in software architecture design is to apply architectural views to model the design decisions for the various stakeholder concerns. Unfortunately, existing architectural viewpoint approaches are general-purpose and not directly dedicated towards GSD projects. In this paper we propose six architectural viewpoints that have been specifically defined to model GSD systems. The architectural viewpoints are based on a meta-model that has been derived after a thorough domain analysis of the GSD literature. © 2011 IEEE.
Open Access
Architecture framework for software safety
(Springer, 2014-09) Gürbüz, Havva Gülay; Pala Er, N.; Tekinerdoğan, Bedir
Currently, an increasing number of systems are controlled by soft- ware and rely on the correct operation of software. In this context, a safety- critical system is defined as a system in which malfunctioning software could result in death, injury or damage to environment. To mitigate these serious risks, the architecture of safety-critical systems needs to be carefully designed and analyzed. A common practice for modeling software architecture is the adoption of software architecture viewpoints to model the architecture for par- ticular stakeholders and concerns. Existing architecture viewpoints tend to be general purpose and do not explicitly focus on safety concerns in particular. To provide a complementary and dedicated support for designing safety critical systems, we propose an architecture framework for software safety. The archi- tecture framework is based on a metamodel that has been developed after a tho- rough domain analysis. The framework includes three coherent viewpoints, each of which addressing an important concern. The application of the view- points is illustrated for an industrial case of safety-critical avionics control computer system. © Springer International Publishing Switzerland 2014.
Open Access
Cache hierarchy-aware query mapping on emerging multicore architectures
(IEEE, 2017) Öztürk, Özcan; Orhan, U.; Ding, W.; Yedlapalli, P.; Kandemir, M. T.
One of the important characteristics of emerging multicores/manycores is the existence of 'shared on-chip caches,' through which different threads/processes can share data (help each other) or displace each other's data (hurt each other). Most of current commercial multicore systems on the market have on-chip cache hierarchies with multiple layers (typically, in the form of L1, L2 and L3, the last two being either fully or partially shared). In the context of database workloads, exploiting full potential of these caches can be critical. Motivated by this observation, our main contribution in this work is to present and experimentally evaluate a cache hierarchy-aware query mapping scheme targeting workloads that consist of batch queries to be executed on emerging multicores. Our proposed scheme distributes a given batch of queries across the cores of a target multicore architecture based on the affinity relations among the queries. The primary goal behind this scheme is to maximize the utilization of the underlying on-chip cache hierarchy while keeping the load nearly balanced across domain affinities. Each domain affinity in this context corresponds to a cache structure bounded by a particular level of the cache hierarchy. A graph partitioning-based method is employed to distribute queries across cores, and an integer linear programming (ILP) formulation is used to address locality and load balancing concerns. We evaluate our scheme using the TPC-H benchmarks on an Intel Xeon based multicore. Our solution achieves up to 25 percent improvement in individual query execution times and 15-19 percent improvement in throughput over the default Linux-based process scheduler. © 1968-2012 IEEE.
Open Access
CAPSULE: Language and system support for efficient state sharing in distributed stream processing systems
(ACM, 2012) Losa, G.; Kumar, V.; Andrade, H.; Gedik, Buğra; Hirzel, M.; Soulé, R.; Wu, K. -L.
Data stream processing applications are often expressed as data flow graphs, composed of operators connected via streams. This structured representation provides a simple yet powerful paradigm for building large-scale, distributed, high-performance applications. However, there are many tasks that require sharing data across operators, and across operators and the runtime using a less structured mechanism than point-to-point data flows. Examples include updating control variables, sending notifications, collecting metrics, building collective models, etc. In this paper we describe CAPSULE, which fills this gap. CAPSULE is a code generation and runtime framework that offers an easy to use and highly flexible framework for developers to realize shared variables (CAPSULE term for shared state) by specifying a data structure (at the programming-language level), and a few associated configuration parameters that qualify the expected usage scenario. Besides the easy of use and flexibility, CAPSULE offers the following important benefits: (1) Custom Code Generation - CAPSULE makes use of user-specified configuration parameters and information from the runtime to generate shared variable servers that are tailored for the specific usage scenario, (2) Composability - CAPSULE supports deployment time composition of the shared variable servers to achieve desired levels of scalability, performance and fault-tolerance, and (3) Extensibility - CAPSULE provides simple interfaces for extending the CAPSULE framework with more protocols, transports, caching mechanisms, etc. We describe the motivation for CAPSULE and its design, report on its implementation status, and then present experimental results. Copyright © 2012 ACM.
Open Access
Concern-oriented analysis and refactoring of software architectures using dependency structure matrices
(ACM, 2009-03) Tekinerdoǧan, Bedir; Scholten F.; Hofmann, C.; Akşit, M.
Current scenario-based architecture analysis methods analyze the architecture with respect to scenarios that relate to stakeholder concerns. Albeit the primary motivation is to analyze the impact of stakeholders' concerns, it appears that concerns are not explicitly represented as first class abstractions. The lack of an explicit notion of concern in scenario-based analysis approaches can result in an incomplete analysis because scenarios are too specific and can only partially represent the concerns. We propose the concern-oriented architecture analysis method (COSAAM) that builds on scenario-based approaches but includes an explicit notion of concern in the analysis. COSAAM applies Dependency Structure Matrices (DSMs) to represent and analyze the dependencies among scenarios, concerns and architectural elements. Further, COSAAM extends DSMs by introducing explicit DSM patterns and heuristic rules for analyzing the impact of concerns on the architecture and for supporting the refactoring of the architecture. Copyright 2009 ACM.
Open Access
Defining architectural viewpoints for quality concerns
(Springer, Berlin, Heidelberg, 2011) Tekinerdoğan, Bedir; Sözer H.
A common practice in software architecture design is to apply architectural views to model the design decisions for the various stakeholder concerns. When dealing with quality concerns, however, it is more difficult to address these explicitly in the architectural views. This is because quality concerns do not easily match the architectural elements that seem to be primarily functional in nature. As a result, the communication and analysis of these quality concerns becomes more problematic in practice. We introduce a general and practical approach for supporting architects to model quality concerns by extending the architectural viewpoints of the so-called V&B approach. We illustrate the approach for defining recoverability and adaptability viewpoints for an open source software architecture. © 2011 Springer-Verlag.
Open Access
Deriving feasible deployment alternatives for parallel and distributed simulation systems
(Association for Computing Machinery, 2013-07) Çelik, T.; Tekinerdogan, B.; Imre, K.
Parallel and distributed simulations (PADS) realize the distributed execution of a simulation system over multiple physical resources. To realize the execution of PADS, different simulation infrastructures such as HLA, DIS and TENA have been defined. Recently, the Distributed Simulation Engineering and Execution Process (DSEEP) that supports the mapping of the simulations on the infrastructures has been defined. An important recommended task in DSEEP is the evaluation of the performance of the simulation systems at the design phase. In general, the performance of a simulation is largely influenced by the allocation of member applications to the resources. Usually, the deployment of the applications to the resources can be done in many different ways. DSEEP does not provide a concrete approach for evaluating the deployment alternatives. Moreover, current approaches that can be used for realizing various DSEEP activities do not yet provide adequate support for this purpose. We provide a concrete approach for deriving feasible deployment alternatives based on the simulation system and the available resources. In the approach, first the simulation components and the resources are designed. The design is used to define alternative execution configurations, and based on the design and the execution configuration; a feasible deployment alternative can be algorithmically derived. Tool support is developed for the simulation design, the execution configuration definition and the automatic generation of feasible deployment alternatives. The approach has been applied within a large-scale industrial case study for simulating Electronic Warfare systems. © 2013 ACM.
Open Access
Distance laboratory applications ERRL: A study on radio communication in electronic field
(IEEE, 2008-05) Aydın, C. Ç.; Türkmen, G.; Özyurt, E.; Aydın, E. U.; Çaǧıltay, N. E.; Özbek, M. E.; Alparslan, N. Ceren; Kara, A.
In the last decade, the effect of internet usage in education is gradually increased. When we look from academic perspective, the new technologies provided alternatives for students learning. As distance education becomes important everyday, the indispensable elements of teaching and education, laboratories must be reachable via remote connection. Consequently, the education that is going to be given to the students will be more flexible with respect to place and time constraints and students can reach laboratory facilities at any time and anywhere not only in lectures and practical hours. In this study, European Remote Radio Laboratory (ERRL) which is a distance remote Radio Frequency (RF) laboratory designed for electrical-electronics students, is described generally. The software architecture, infrastructure and experiment that can be done with a remote connection have been described.
Open Access
Domain specific language for deployment of parallel applications on parallel computing platforms
(Association for Computing Machinery, 2014-08) Arkın, E.; Tekinerdoğan, Bedir
To increase the computing performance the current trend is towards applying parallel computing in which parallel tasks are executed on multiple nodes. The deployment of tasks on the computing platform usually impacts the overall performance and as such needs to be modelled carefully. In the architecture design community the deployment viewpoint is an important viewpoint to support this mapping process. In general the derived deployment views are visual notations that are not amenable for run-time processing, and do not scale well for deployment of large scale parallel applications. In this paper we propose a domain specific language (DSL) for modeling the deployment of parallel applications and for providing automated support for the deployment process. The DSL is based on a metamodel that is derived after a domain analysis on parallel computing. We illustrate the application of the DSL for a traffic simulation system and provide a set of important scenarios for using the DSL. © 2014 ACM.
Open Access
Evaluation framework for software architecture viewpoint languages
(ACM, 2013) Tekinerdogan, Bedir; Demirli, Elif
In general, software architecture is documented using software architecture views to address the different stakeholder concerns. The current trend recognizes that the set of viewpoints should not be fixed but multiple viewpoints might be introduced instead to design and document the software architecture. To ensure the quality of the software architecture various software architecture evaluation approaches have been introduced. In addition several documentation guidelines have been provided to ensure the quality of the software architecture document. Unfortunately, the evaluation of the adopted viewpoints that are used to design and document the software architecture has not been considered explicitly. If the architectural viewpoints are not well-defined then implicitly this will have an impact on the quality of the design and the documentation of the software architecture. We present an evaluation framework for assessing existing or newly defined software architecture viewpoint languages. The approach is based on software language engineering techniques, and considers each viewpoint as a metamodel. The approach does not assume a particular architecture framework and can be applied to existing or newly defined viewpoint languages. We illustrate our approach for modeling and reviewing the first and second editions of the viewpoint languages of the Views and Beyond approach. Copyright © ACM.
Open Access
Factors affecting architectural decision-making process and challenges in software projects: an industrial survey
(John Wiley & Sons Ltd., 2025-01) Demir, Merve Ö.; Chouseinoglou, Oumout; Tarhan, Ayca K.
Software architecture plays a fundamental role in overcoming the challenges of the development process of large-scale and complex software systems. The software architecture of a system is the result of an extensive process in which several stakeholders negotiate issues and solutions, and as a result of this negotiation, a series of architectural decisions are made. This survey study aims to determine the experiences of the software industry experts with respect to architectural decision-making, the factors that are effective in decision-making, and the technical and social problems they encounter. An online questionnaire-based survey was conducted with 101 practitioners. The responses were analyzed qualitatively and quantitatively. Analysis of responses revealed that the majority of the participants prefer to document some or all of the architectural decisions taken and to store these documents in web-based collaboration software. Decisions are usually made by teams of two or three, and discussion-based approaches (brainstorming and consensus) are adopted. In the software architecture decision-making process, “major business impact” is the most challenging situation. Information sharing and keeping track of decisions and decision rationale are areas in need of improvement as identified by most participants. From the participants' feedback and their answers to open-ended questions, we concluded that the software architecture decision-making process has an important role in the industry. Our key findings are that decisions made in the architectural decision-making process are taken by teams and generally all decisions are documented. In projects where decisions are made by a single person, peer pressure is found to be significantly different from pressure in projects where decisions are made by the group. This is an indication that as the number of people in the decision-making process increases, the disagreements also increase.
Open Access
Feature-based rationale management system for supporting software architecture adaptation
(World Scientific Publishing Co. Pte. Ltd., 2012) Tekinerdogan, B.; Sozer, H.; Aksit, M.
Each software architecture design is the result of a broad set of design decisions and their justifications, that is, the design rationale. Capturing the design rationale is important for a variety of reasons such as enhancing communication, reuse and maintenance. Unfortunately, it appears that there is still a lack of appropriate methods and tools for effectively capturing and managing the architecture design rationale. In this paper we present a feature-based rationale management approach and the corresponding tool environment ArchiRationale for supporting software architecture adaptation. The approach takes as input an existing architecture and captures the design rationale for adapting the architecture for a given quality concern. For this we define a feature model that includes the possible set of architectural tactics to realize the quality concern. The presented approach captures the rationale for deciding on feature selections and for selecting the corresponding architecture design alternatives. ArchiRationale customizes and integrates the Eclipse plugin tools XFeature, ArchStudio and XQuery to provide tool support for capturing, storing and accessing the design rationale. We illustrate the approach for adapting a software architecture for fault tolerance. © 2012 World Scientific Publishing Company.
Open Access
Flora: a framework for decomposing software architecture to introduce local recovery
(John Wiley & Sons Ltd., 2009-07) Sözer, H.; Tekinerdoǧan, B.; Akşit, M.
The decomposition of software architecture into modular units is usually driven by the required quality concerns. In this paper we focus on the impact of local recovery concern on the decomposition of the software system. For achieving local recovery, the system needs to be decomposed into separate units that can be recovered in isolation. However, it appears that this required decomposition for recovery is usually not aligned with the decomposition based on functional concerns. Moreover, introducing local recovery to a software system, while preserving the existing decomposition, is not trivial and requires substantial development and maintenance effort. To reduce this effort we propose a framework that supports the decomposition and implementation of software architecture for local recovery. The framework provides reusable abstractions for defining recoverable units and the necessary coordination and communication protocols for recovery. We discuss our experiences in the application and evaluation of the framework for introducing local recovery to the open-source media player called MPlayer. Copyright 2009 John Wiley & Sons, Ltd.
Open Access
From a calculus to an execution environment for stream processing
(ACM, 2012) Soulé, R.; Hirzel, M.; Gedik, Buğra; Grimm, R.
At one level, this paper is about River, a virtual execution environment for stream processing. Stream processing is a paradigm well-suited for many modern data processing systems that ingest high-volume data streams from the real world, such as audio/video streaming, high-frequency trading, and security monitoring. One attractive property of stream processing is that it lends itself to parallelization on multicores, and even to distribution on clusters when extreme scale is required. Stream processing has been co-evolved by several communities, leading to diverse languages with similar core concepts. Providing a common execution environment reduces language development effort and increases portability. We designed River as a practical realization of Brooklet, a calculus for stream processing. So at another level, this paper is about a journey from theory (the calculus) to practice (the execution environment). The challenge is that, by definition, a calculus abstracts away all but the most central concepts. Hence, there are several research questions in concretizing the missing parts, not to mention a significant engineering effort in implementing them. But the effort is well worth it, because using a calculus as a foundation yields clear semantics and proven correctness results. Copyright © 2012 ACM.
Open Access
Model-driven architecture view consistency checking
(2015-12) Ekşi, Gülsüm Ece
Software architecture is one of the key artefacts in the software development process since it provides the gross-level structure of the system and supports the stakeholder concerns. To benefi t from the architecture it is important that the code is consistent with the architecture and the corresponding design decisions. Unfortunately, changing requirements and/or the adaptations to the code can lead to undesired inconsistencies among the architecture and the code. This so-called architectural drift problem is the discrepancy between the architecture description and the resulting implementation. Several approaches have been proposed to detect the inconsistencies between the software architecture and the code to ensure that the original design goals are maintained. In practice, software architecture is documented using a coherent set of architecture views, each of view addresses particular stakeholder concerns. Similar to the consistency with the code it is important that an architecture view is consistent within itself and with other related architecture views. Unfortunately, the existing architecture conformance analysis approaches have primarily focused on checking the inconsistencies between the architecture and code, and did not explicitly consider the consistency among views. In this thesis, we provide a systematic architecture conformance analysis approach that explicitly focuses on conformance analysis among architecture views. The approach is used for detecting the inconsistencies within and across architectural views. To this end, we define the meta-models of architecture viewpoints, present the conformance analysis approach, and provide the tool ArchViewChecker. We illustrate our approach for detecting inconsistencies using the Views and Beyond approach. We adopt a fault injection approach to evaluate the effectiveness of the approach. The results show that the approach is effective in detecting inconsistencies within views and across views.
Open Access
Modeling and reasoning about design alternatives of software as a service architectures
(IEEE, 2011-06) Tekinerdoğan, Bedir; Öztürk, K.; Doğru, A.
In general, a common reference architecture can be derived for Software as a Service (SaaS). However, while designing particular applications one may derive various application design alternatives from the same reference SaaS architecture specification. To meet the required functional and nonfunctional requirements of different enterprise applications it is important to model the possible design so that a feasible alternative can be defined. In this paper, we propose a systematic approach and corresponding tool support for guiding the design of SaaS application architectures. The approach defines a SaaS reference architecture, a family feature model and a set of reference design rules. Based on the business requirements an application feature model is defined using the family feature model. Selected features are related to design decisions and a SaaS application architecture design is derived. © 2011 IEEE.
Open Access
S-IDE: a tool framework for optimizing deployment architecture of High Level Architecture based simulation systems
(2013) Çelik, T.; Tekinerdogan, B.
One of the important problems in High Level Architecture (HLA) based distributed simulation systems is the allocation of the different simulation modules to the available physical resources. Usually, the deployment of the simulation modules to the physical resources can be done in many different ways, and each deployment alternative will have a different impact on the performance. Although different algorithmic solutions have been provided to optimize the allocation with respect to the performance, the problem has not been explicitly tackled from an architecture design perspective. Moreover, for optimizing the deployment of the simulation system, tool support is largely missing. In this paper we propose a method for automatically deriving deployment alternatives for HLA based distributed simulation systems. The method extends the IEEE Recommended Practice for High Level Architecture Federation Development and Execution Process by providing an approach for optimizing the allocation at the design level. The method is realized by the tool framework, S-IDE (Simulation-IDE) that we have developed to provide an integrated development environment for deriving a feasible deployment alternative based on the simulation system and the available physical resources at the design phase. The method and the tool support have been validated using a case study for the development of a traffic simulation system. © 2013 Elsevier Inc.