Showing papers on "Database-centric architecture published in 2015"

System Architecture: Strategy and Product Development for Complex Systems

Abstract: Architecture and Function of Complex Systems System architecture is the study of early decision making in complex systems. This text teaches how to capture experience and analysis about early system decisions, and how to choose architectures that meet stakeholder needs, integrate easily, and evolve flexibly. With case studies written by leading practitioners, from hybrid cars to communications networks to aircraft, this text showcases the science and art of system architecture.

A case study in locating the architectural roots of technical debt

Abstract: Our recent research has shown that, in large-scale software systems, defective files seldom exist alone. They are usually architecturally connected, and their architectural structures exhibit significant design flaws which propagate bugginess among files. We call these flawed structures the architecture roots, a type of technical debt that incurs high maintenance penalties. Removing the architecture roots of bugginess requires refactoring, but the benefits of refactoring have historically been difficult for architects to quantify or justify. In this paper, we present a case study of identifying and quantifying such architecture debts in a large-scale industrial software project. Our approach is to model and analyze software architecture as a set of design rule spaces (DRSpaces). Using data extracted from the project's development artifacts, we were able to identify the files implicated in architecture flaws and suggest refactorings based on removing these flaws. Then we built economic models of the before and (predicted) after states, which gave the organization confidence that doing the refactorings made business sense, in terms of a handsome return on investment.

A systematic literature review on the description of software architectures for systems of systems

Abstract: Software architectures have been recognized as the backbone to the success of any software system. In addition, they are responsible to aggregate quality attributes, such as interoperability, dependability, and maintainability, to these systems. In parallel, currently, a new class of complex software systems has emerged, referred as Systems of Systems (SoS), resulting from a number of operationally and managerially independent software systems working together to fulfill a mission that none system alone could provide. Considering their complexity, the development of SoS has demanded special attention to their software architectures. In this scenario, the description of such architectures, i.e., the way that these architectures are represented/documented, becomes quite important as it can improve communication as well as evaluation and maintenance of these architectures. Despite its relevance, there is still no complete panorama about architectural descriptions of SoS. The main contribution of this paper is to present results of a Systematic Literature Review (SLR) on how SoS software architectures have been described. As main result, there are already important contributions in that direction; however, there is a lack of consensus on how better dealing with these descriptions. We conclude this paper with directions on how a consensus could be achieved and which aspects of the SoS architectural descriptions require further investigation.

Invisible Glue: Scalable Self-Tunning Multi-Stores.

Abstract: Next-generation data centric applications often involve di-verse datasets, some very large while others may be of mod-erate size, some highly structured (e.g., relations) while others may have more complex structure (e.g., graphs) or little structure (e.g., text or log data). Facing them is a variety of storage systems, each of which can host some of the datasets (possibly after some data migration), but none of which is likely to be best for all, at all times. Deploying and efficiently running data-centric applications in such a complex setting is very challenging. We propose Estocada, an architecture for efficiently han-dling highly heterogeneous datasets based on a dynamic set of potentially very different data stores. Estocada pro-vides to the application/programming layer access to each data set in its native format, while hosting them internally in a set of potentially overlapping fragments, possibly dis-tributing (fragments of) each dataset across heterogeneous stores. Given workload information, Estocada self-tunes for performance, i.e., it automatically choses the fragments of each data set to be deployed in each store so as to op-timize performance. At the core of Estocada lie powerful view-based rewriting and view selection algorithms, required in order to correctly handle the features (nesting, keys, con-straints etc.) of the diverse data models involved, and thus to marry correctness with high performance.

Supporting Dynamic Software Architectures: From Architectural Description to Implementation

Abstract: Dynamic software architectures are those that describe how components and connectors can be created, interconnected, and/or removed during system execution Most existing architecture description languages (ADLs) provide a limited support to expressively describe these architectures and entail architectural mismatches and inconsistencies between architecture and implementation due to their decoupling from implementation In this paper, we introduce the dynamic reconfiguration support provided by p-ADL, a formal, well-founded theoretically language for describing dynamic software architectures under structural and behavioral viewpoints p-ADL provides architectural-level primitives for specifying programmed dynamic reconfigurations, ie, Foreseen changes described at design time and triggered at runtime In addition, p-ADL allows enacting dynamic reconfiguration by means of: (i) an exogenous approach, in which it is possible to control all elements of the software architectures and to apply the changes on the whole structure, and (ii) an endogenous approach, in which the architectural elements can manage dynamic reconfiguration actions Furthermore, p-ADL is integrated with the Go programming language, thus enabling to automatically generate implementation code from architectural descriptions, thus tackling the existing gap between them We hereby use a real-world flood monitoring system as an illustrative example of how to describe dynamic software architectures in p-ADL and automatically generate source code in Go

Architecting in the Automotive Domain: Descriptive vs Prescriptive Architecture

Abstract: To investigate the new requirements and challenges of architecting often safety critical software in the automotive domain, we have performed two case studies on Volvo Car Group and Volvo Group Truck Technology Our findings suggest that automotive software architects produce two different architectures (or views) of the same system The first one is a high-level descriptive architecture, mainly documenting system design decisions and describing principles and guidelines that should govern the overall system The second architecture is the working architecture, defining the actual blueprint for the implementation teams and being used in their daily work The working architecture is characterized by high complexity and considerably lower readability than the high-level architecture Unfortunately, the team responsible for the high-level architecture tends to get isolated from the rest of the development organization, with few communications except regarding the working architecture This creates tensions within the organizations, sub-optimal design of the communication matrix and limited usage of the high-level architecture in the development teams To adapt to the current pace of software development and rapidly growing software systems new ways of working are required, both on technical and on an organizational level

An architecture of agent-based multi-layer interactive e-learning and e-testing platform

Abstract: E-learning is the synthesis of multimedia and social media platforms powered by Internet and mobile technologies. Great popularity of e-learning is encouraging governments and educational institutions to adopt and develop e-learning cultures in societies in general and universities in particular. In traditional e-learning systems, all components (agents and services) are tightly coupled into a single system. In this study, we propose a new architecture for e-learning with two subsystems, namely, e-learning and e-testing. The motivation of the research is to improve the effectiveness of the learning process by extracting relevant features for elastic learning and testing process. We employ a multi-agent system because it contains five-layer architecture, including agents at various levels. We also propose a novel method for updating content through question and answer between e-learners and intelligent agents. To achieve optimization, we design a system that applies various technologies, which guarantee various dynamic features for e-learning systems, such as intelligence, distributed nature, adaptive attitude, interaction, accessibility, and security. Agent assisted e- learning enable the users to collect the quantifiable and sensible material; examine, and distribute customized knowledge from multiple e-learning sources. Intelligent agents, being program helper or assistants, are deployed at different levels of abstraction in this architecture to manage information overload and create environment for learners. Moreover, this proposed system is designed by keeping in view several characteristics specific to e-learning system such as interaction, personalization, adaptation, intelligence, interoperability, accessibility and security. The architecture is designed to support instructional design, to retrieve relevant learning materials, to process and analyses data to enable meaningful e-learning recommendations for instructors and learners by considering all issues that existing e-learning architectures don’t address. Most of the existing e-learning architectures don’t consider all the features in a single system so there is a need for a generic architecture that should support all the features to make the e-learning system more efficient. The outcome of this approach is to provide flexible and lightweight systems for e-learning environments.

Characterizing architecture description languages for software-intensive systems-of-systems

Abstract: Systems-of-Systems (SoS) result from associating independent, complex systems for fulfilling given missions. In particular, SoS require software architectures that can cope with their dynamic, critical nature. Selecting adequate Architecture Description Languages (ADLs) for representing such architectures contributes for a better communication, analysis, and evolution of these systems. Nonetheless, a consensus on which characteristics are important for describing SoS is not available yet. In this context, the main contribution of this study is the identification of the main features to be provided by ADLs for describing SoS software architectures. In the light of these features, we assessed some existing ADLs that have been used for this task and we noticed that they still miss some of the identified features. With this set of features, we intend to contribute to the SoS field with directions for making ADLs more suitable for the description of SoS software architectures.

Review and retrofitted architectures to form reliable smart microgrid networks for urban buildings

Abstract: Smart microgrid initiatives for recent urbanisation at power distribution level need an integrated and interoperable environment that can work collectively with local energy systems and utility grid. This is achieved through the design of an architecture by using contemporary information and communication technology. System architecture provides a common work process that span across all the critical subsystems of a building for better informed decisions with reduced human interventions. Two key aspects of architecture development are, the way of its presentation and network reliability. The architecture should be clear in its presentation for the understanding of various stakeholders and possess fault tolerant communication mechanisms to have high network reliability. Considering aforementioned aspects, this study presents review of state-of-the-art architectures developed by IEEE-1547, ISA-95, National Institute of Standards and Technology, IEC-61850 for smart microgrids formation and suggests retrofitted architectures to improve architecture clarity by presenting in a more lucid way and network reliability by the concept of redundant communication paths.

An Ontology-Based Product Architecture Derivation Approach

Abstract: Software product line (SPL) engineering has proven to improve software quality and shorten development cycles, cost and time. In product line engineering, product derivation is concerned with the realization of the variability at the implementation level. However, the majority of research works focuses on instantiating the variants selected in the final product, while the derivation at the architecture level has been poorly explored. As product line engineers often customize the product architecture by hand during the application engineering phase, the derivation and customization processes of the product line architecture (PLA) might be in some cases error-prone. Consequently, in this research we present an Ontology-based product Architecture Derivation (OntoAD) framework which automates the derivation of product-specific architectures from an SPL architecture. Our solution uses a language-independent model to specify the product line architecture and a model-driven engineering approach for architecture derivation activities. We use an ontology formalism to reason about the automatic generation of model-to-model transformation rules based on the selection of features and we illustrate our approach using a voice over IP motivating example. Finally, we report results about scalability and performance regarding the size of the variability model.

Big-data analytics: a critical review and some future directions

Abstract: The aim of the paper is to present a critical review of analytics and visualisation technology for big data, and propose future directions to overcome the shortcomings of the current technologies. The current machine learning and data-mining algorithms are operating mostly on predefined scales of aggregation, while in the vast amounts of data the problem arises at the level of aggregation which cannot be defined ahead of time. We therefore identify a novel and extended architecture to operate on flexible multi-resolution hypothesis space. With such architecture framework the goal is to open a space of possibly discovered models towards classes of data, which are by today's approaches discovered only for special cases. Furthermore, the multi-resolution approach to big-data analytics could allow scenarios like semi-supervised and unsupervised anomaly detection, detecting complex relationships from the heterogeneous data sources, and providing ground for visualisation of complex processes.

Shifting the Network-on-Chip Paradigm towards a Software Defined Network Architecture

Abstract: In the Many-Core era, parallel processing performance is generally limited by the communications infrastructure's adaptability to the applications data dependencies. By means of a management framework, Software Defined Network (SDN) architectures offer such adaptability for conventional computer networks. However, Networks-on-Chip (NoC) management subsystems have been implemented as specific solutions unable to be reused in further designs. In this paper we applied SDN principles to propose a Software Defined NoC (SDNoC) architecture. This architecture is focused in abstraction layers and interfaces that permit its deployment in a modular fashion. Our proposal will orchestrate the complex multi-objective optimization to adjust on-chip networking to the applications requirements and data dependencies. This architecture allows the addition of other optimization engines without changing the software or hardware contained in underlying planes, then, Non-Recurring Engineering costs can be diminished.

Quality-Driven Architectural Patterns for Self-Aware Cloud-Based Software

Abstract: Architecture-based self-adaptation has been recognised as one of the prominent ways to design autonomic systems, where self-manageable architectures tend to achieve the required level of dynamicity and compliance with the continual changing in QoS requirements during run-time. Self-awareness and self-expression have recently emerged as promising architectural concepts in the field of self-adaptive software. Self-aware architecture patterns are envisioned as enabler for self-adaptation, but they tend to provide limited support for the QoS run-time requirements. While the research community has developed in architecture quality management, patterns and tactics, addressing quality attributes in self-aware architectures has not been tackled yet. In this paper, we aim to provide quality-driven architectural patterns for emerging class of architecture enabled by the principles of self-awareness. We report on the feasibility of correlating QoS tactics with self-aware capabilities to better respond to QoS run-time requirements and trade-offs. We describe novel extensions which make the correlation between QoS tactics and self-awareness explicit. We quantitatively evaluate the feasibility, generality and fitness of the proposed approach, as well as its potential applicability to self-aware architectures. Though the proposed extensions can potentially benefit architectures which leverage on self-awareness, we use the case of cloud auto-scaling architecture.

A Model of Service-Oriented Architectures

Abstract: Architectural styles and patterns play an important role in software engineering. Over the last years, a new style based on the notion of services emerged, which we call the service-oriented architecture style. However, this style is usually only stated informally, which may cause inherent problems such as ambiguity, wrong conclusions, and the difficulty of checking the conformance of a system to the style. We address these problems by providing a formal, denotational semantics of the service-oriented architecture style and two variants thereof: the layered architecture style and the strict architecture style. Loosely speaking, in our model of the service-oriented architecture style, services are a means of communication. Components exchange services between each other via ports. The layered architecture variant imposes a well-foundedness constraint on the communication structure, while the strict variant imposes an antitransitivity constraint. We analyze the notions of syntactic and semantic dependencies for service-oriented architectures and investigate their relationship. Moreover, the expected informal properties of the styles are formulated as theorems. Finally, we present a method for soundly analyzing instances of the style. Our rigorous approach enables building higher-quality architectures, for which properties can be mathematically stated and proven, by enforcing formal discipline on the inter-component scale.

RRA: Models and tools for robotics run-time adaptation

Abstract: Robotics applications are characterized by a huge amount of variability. Their design requires the developers to choose between several variants, which relate to both functionalities and hardware. Some of these choices can be taken at deployment-time, however others should be taken at run-time, when more information about the context is known. To make this possible, a software system needs to be able to reason about its current state and to adapt its architecture to provide the configuration that best suites the context. This paper presents a model-based approach for run-time adaptation of robotic systems. It defines a set of orthogonal models that represent the system architecture, its variability, and the state of the context. Additionally it introduces a set of algorithms that reason about the knowledge represented in our models to resolve the run-time variability and to adapt the system architecture. The paper discusses and evaluates the approach by means of two case studies.

A Reference Architecture for a Cloud-Based Tools as a Service Workspace

Abstract: Software Architecture (SA) plays a critical role in developing and evolving cloud-based applications. We present a Reference Architecture (RA) for designing Cloud-based Tools as a service work SPACE (TSPACE) - a platform for provisioning chain of tools following the Software as a Service (SaaS) model. The TSPACE RA has been designed by leveraging well-known design principles and patterns and has been documented using a view-based approach. The RA has been presented in terms of its context, goals and design elements by describing the requirements, design tactics, and components of the RA. We evaluate the RA in terms of completeness and feasibility. Our proposed RA can provide valuable guidance and insights for designing and implementing concrete software architectures of TSPACE.

D2WORM: A Management Infrastructure for Distributed Data-centric Workflows

Abstract: Unlike traditional activity-flow-based models, data-centric workflows primarily focus on the data to drive a business. This enables the unification of operational management, concurrent process analytics, compliance with process or associated data constraints, and adaptability to changing environments. In this demonstration, we present D2Worm, a Distributed Data-centric Workflow Management system. D2Worm allows users to (1) graphically model data-centric workflows in a declarative fashion based on the Guard-Stage-Milestone (GSM) meta-model, (2) automatically compile the modelled workflow into several fine-granular workflow units (WFUs), and (3) deploy these WFUs on distributed infrastructures. A WFU is a system component that manages a subset of the workflow's data model and, at the same time, represents part of the global control flow by evaluating conditions over the data. WFUs communicate with each other over a publish/subscribe messaging infrastructure that allows the architecture to scale from a single node to dozens of machines distributed over different data-centers. In addition, D2Worm is able to (4) concurrently execute multiple workflow instances and monitor their behavior in real-time.

Software Architectures - Present and Visions

Abstract: 1 IntroductionThe software systems currently face a multitude of challenges resulting from different factors such as high complexity, changing technology and the need for interoperability of heterogeneous data. All these factors have led to the emergence of various architectural models that have tried to address these challenges. Chronologically speaking, we believe that the most important steps are those focused on monolithic architectures and service oriented architectures. We estimate that the new wave will have in the forefront the micro-services based architectures in response to the challenges of interoperability. For example, in the last 10 years the market of the solutions dedicated to the interoperability [1] has grown from $3.4 billion (2004) to $11 billion (2008) and over $20 billion in 2015. The monolithic architectures focused on a traditional approach; although some authors consider them outdated, many current systems are designed in this style. Their integration is achieved mostly through SOA, but SOA limitations and challenges have prompted the emergence of a new vision: micro-services. In this paper we will try to make a comparison of these approaches and highlight their specific in the academic field.2 Monolithic ArchitectureWhen referring to monolithic architecture, the literature in this field avoids defining the term. According to Aoyama [2] this type of architecture is considered to be conventional and belongs to the older styles adopted during the development of new software. Having as starting point the idea promoted by Aoyama, Lake [3] considers that the monolithic name refers to the organizing of the fundamental application elements together in a single component or unit. In other words, the monolithic approach can be viewed as an integrated architecture design in comparison to a modular one. In general, the expression "monolithic" is used for lack of a better term, to indicate that all different types of the foundational architectural elements of the application can be used together in one block.In fact, the subject has been approached by the researchers especially when referring to other categories of architecture. Arguing the importance of the codebase architecture in the development of an open source program, Baldwin & Clark [4] underline the differences between monolithic and modular architectures. While in the first case the participants have no access to other co-workers codes, in the second case the developers can join their efforts when writing the code. A similar idea has been stated by Carbonell et al. [5] when discussing the solving capabilities of PRODIGY architecture, which is modular. As a result, in comparison with SOAR (a monolithic architecture), the authors consider that PRODIGY is superior in terms of engineering principles.Starting from some relevant articles concerning monolithic architecture, we notice that this concept is considered to be obsolete, the need of architectural restructuration being suggested by other researchers of the field. As an example, Mens et al. [6] propose the architectural restructuration of a monolithic model into a client-server or a three-tiered one, through which the user interface, business logic, and data layer can be clearly separated. Using a monolithic architecture, the user interface elements can be mixed with the business logic, and the data management code. It doesn't mean that all elements will always be present in all software classes of the code, but the design allows them to be mixed together into one unit. The positive aspect of a monolithic approach regards a lower complexity of interaction between parts when multiple components or modules can be gathered into a single unit. Another positive is the ease of seeing a whole process in one place. For example, the user interface code can be seen along with the processing of data from the interface and the persisting of it to a database in a single class and file. …

Using metric time-lines for identifying architecture shortcomings in process execution architectures

Abstract: Process Execution with Service Orchestrations is an emerging architectural style for developing business software systems. However, few special metrics for guiding software architecture decisions have been proposed and no existing business process metrics have been evaluated for their suitability. By following static code metrics over time, architects can gain a better understanding, how processes and the whole system evolve and whether the metrics evolve as expected. This allows architects to recogniize when to intervene in the development and make architecture adjustments or refactorings. This paper presents an explatory study that uses time-lines of static process size metrics for constant feedback to software architects that deal with process-oriented architectures.

Preventing software architecture erosion through static architecture conformance checking

Abstract: Software architecture erosion is a problem faced by many organizations in the software industry. It happens when ‘as-implemented’ architecture does not conform to the ‘as-intended’ architecture, which results in low quality, complex, hard to maintain software. Architecture conformance checking refers to assessing the conformity of the implemented architecture to the intended architecture and can provide a strategy for detecting software architecture erosion and thereby prevent its negative consequences. When considering the current state-of-the-art of software architecture research and popular industry practices on architectural erosion, it obviously appears that such solution strategy is much needed to address the ever increasing demands for large scale complex software systems. In this paper an analysis of existing static architecture conformance checking is undertaken. Extending previously conducted research, we are in the process of developing a static architecture conformance checking tool for Java, based on GRASP ADL as a mean to overcome the challenges of software architecture erosion. Early design/implementation details of this tool are also presented.

On the Equivalence between Reference Architectures and Metamodels

Abstract: Reference Architectures (RA) are a special class of software architectures which comprises a family of concrete architectures. On the other hand, Model-Driven Development (MDD) has been largely adopted in software development. In MDD, a metamodel is usually used to "derive" concrete models. Analogously, RA are used to "derive" concrete architectures. In this direction, we claim that there exist an equivalence between metamodels and RA in a conceptual level. To confirm this, we collected a small set of criteria available in literature and compared metamodels and RA characteristics. We concluded that these concepts are quite equivalent. And, as a corollary, all of the techniques, frameworks, methods, and processes related to MDD could be extended and used in architecture derivations based on RA. Thus, the main contribution of this paper is presenting evidences that support this hypothesis. The theoretical and practical inferences from this discovery indicates new research directions for software architecture domain.

A Contribution to the Establishment of Reference Architectures for Mobile Learning Environments

Abstract: The development and the use of learning environments, coupled with the evolution of mobile computing, have contributed significantly to the establishment of a new learning modality known as mobile learning (m-learning). In this new scenario, the educational environments, despite having many benefits and facilities with regard to teaching and learning, have problems and challenges that need to be addressed. One of the important aspects to be investigated concerns the establishment and adoption of architectural patterns. In fact, most of these environments are built in an isolated form, having their own architectures and structures, which may negatively impact the ability of standardization and support of architectural definition. The main goal of this paper is to investigate and define a service-oriented reference architecture for m-learning environments. The proposed architecture, named Ref-mLearning, aims to contribute to the evolution, reuse, and interoperability of such environments, enabling an increase in quality and cost reduction during their development, due to the use of features provided by service-oriented architecture. Ref-mLearning was also evaluated through qualitative and quantitative aspects: 1) in comparison with a reference architecture model and 2) with the support of specialists. The results showed that the proposed architecture comprises relevant elements with respect to a service-oriented reference architecture.

The ARAMIS Workbench for Monitoring, Analysis and Visualization of Architectures based on Run-time Interactions

Abstract: Up-to-date software architecture models dramatically ease the understanding and meaningful evolution of a software system. Unfortunately they are rarely available. Mostly the static view of the architecture is modeled and only stipulations are made regarding how architecture units should communicate. However, a software system tends to evolve independently from its description. This results in violations of the previously stipulated communication rules. A plethora of tools to recover up-to-date architecture models have been proposed, but little emphasis has been put on analyzing and validating the run-time interactions on various abstraction levels defined in the static view of the architecture. In our previous work we have presented ARAMIS - a conceptual infrastructure for the analysis and monitoring of data extracted during run-time - and some first evaluations thereof. This paper presents the current state of the ARAMIS Workbench, which automatically validates if the communication between the units of a software system matches its architecture model, provides visualizations of these interactions on higher and more understandable abstraction levels, and presents evaluations of the various units involved in the analyzed communication. We exemplify its capabilities on a case study based on the Carcass system used in teaching activities at our research group.

Data Centric Discovery with a Data-Oriented Architecture

Abstract: Increasingly, scientific discovery is driven by the analysis, manipulation, organization, annotation, sharing, and reuse of high-value scientific data. While great attention has been given to the specifics of analyzing and mining data, we find that there are almost no tools nor systematic infrastructure to facilitate the process of discovery from data. We argue that a more systematic perspective is required, and in particular, propose a data-centric approach in which discovery stands on a foundation of data and data collections, rather than on fleeting transformations and operations. To address the challenges of data-centric discovery, we introduce a Data-Oriented Architecture and contrast it with the prevalent Service-Oriented Architecture. We describe an instance of the Data-Oriented Architecture and describe how it has been used in a variety of use cases.

Instruments to Evaluate and Improve IT Architecture Work

Abstract: IT Architecture work is demanding and includes, inter alia, identifying architectural significant requirements, designing and selecting solutions for these requirements, and ensuring that the solutions are implemented according to the architectural design. The research presented here, contributes to the advancement of the effectiveness of IT architecture work by means of the development and improvement of supporting instruments and tools. In the domain of software architecture, the research focuses on modular architectures and architecture compliance checking (ACC) support. An important requirement in the presented research concerns the support of semantically rich modular architectures (SRMA). The term SRMA is used for an expressive modular architecture description, composed of semantically different types of modules (e.g., layers, subsystems, components), which are constrained by different types of rules, such as basic dependency constraints, constraints related to layers, and naming constraints. In practice and literature, many architectures can be labeled as SRMA. However, a comparative tool tests revealed that only limited support was available for SRMAs in ACC-tools, and that solutions are needed to bridge the gap between modular architectures in software architecture documents on one side, and module and rule models in ACC-tools on the other side. Subsequently, an approach of design science research resulted in a metamodel for SRMA support, and an ACC-tool that provides extensive and configurable SRMA support. To validate our approach, we have performed ACCs with our tool on professional systems and open source systems. Another requirement regarding ACC support concerns the accuracy of dependency detection. Ten tools were tested and compared by means of a custom-made test application. In addition, the code of an open source system was used to compare these tools on the number and precision of reported violation and dependency messages. The test results show large differences between the tools, but the main conclusion is that all tools could improve the accuracy of the reported dependencies and violations. Based on the test results, ten hard-to-detect dependency types and four challenges in dependency detection are identified. To substantiate the relevance of the findings, the results of a frequency analysis of the hard-to-detect dependencies in five open source systems are presented. Layers are commonly used in modular software architectures, but many layered architectures are poorly designed and documented, especially with respect to the assignment of responsibilities. To support the design of layered architectures of high quality, two novel instruments are proposed and illustrated: the Typology of Software Layer Responsibility and the complementary Responsibility Trace Table. In the domain of enterprise architecture, this dissertation proposes an assessment instrument that can be used to measure and improve the EA management function's ability to realize its goals: the Enterprise Architecture Realization Scorecard. The instrument with its metamodel and metrics are presented, as well as the accompanying method. Furthermore, two assessment cases are discussed to illustrate the use of the instrument.

A Generic Software Platform for Brain-inspired Cognitive Computing

Abstract: We have been developing BriCA (Brain-inspired Computing Architecture), the generic software platform that can combine an arbitrary number of machine learning modules to construct higher structures such as cognitive architectures inspired by the brain. We discuss requirements analysis and design principles of this cognitive computing platform, report its implementation, and describe plans for further development.

A novel versatile architecture for Internet of Things

Abstract: This paper presents an overview of contemporary architectures for Internet of Things and then introduces a simple novel architecture. The main goal of proposed architecture is to remain simple but still applicable to any Internet of Things environment. Specific applications of IoT should be implemented in application layer, using proposed architecture as backbone. Proposed architecture isn't yet fully defined, but ideas on which is based are well defined and should provide straightforward design and implementation.

Modeling and simulation of infrastructure architecture for big data

Abstract: Embodiments for modeling and simulation of one or more architecture models for Big Data of an organization are described. In one example, at least one user requirement and set of model requirements are received from a user associated with the organization, where the set of model requirements is indicative of information relating to the one or more architecture models. Subsequently, one or more architecture models are generated for providing recommendation to the user, where the one or more architecture models are generated based on the at least one user requirement and the set of model requirements. Further, the one or more architecture models are simulated to ascertain performance of each of the one or more architecture models based at least on a pre-defined specification of architecture components associated with each of the one or more architecture models.

On Architectural Qualities and Tactics for Mobile Sensing

Abstract: Mobile sensing denotes the use of mobile devices and their integrated sensors for sensing and learning physical and social phenomena, and to use derived information for sharing, informing, and persuading humans. From the perspective of software architecture, mobile sensing bears several design challenges regarding, e.g., use of battery powered mobile devices, and collection and processing of sensor data. In this paper, we present tactics to address these architecture design challenges. We discuss the two architectural qualities energy efficiency and resource adaptability, and describe them using general scenario-generation tables to support the systematic specification of architecture requirements. Furthermore, we develop a catalog of architectural tactics distilled from literature to enable developers to systematically apply proven methods. For each tactic, we provide examples to relate the respective tactics to particular cases illustrating their use in practice. Finally, we provide a preliminary validation of the proposed systematized tactics catalog, which was conducted with student teams. Our preliminary findings show that the tactics are beneficial to provide a guideline and to create awareness of the special challenges of energy-efficient and resource-adaptable architecture design.

Design of a Business-to-Government Information Sharing Architecture Using Business Rules

Abstract: Information sharing between businesses and government agencies is of vital importance, yet business are often reluctant to share information, e.g. as it might be misused. Taking this into account is however often overlooked in the design of software architectures. In this research we apply a design science approach to develop an software architecture that is acceptable by businesses. From a case study we derive the requirements an architecture should meet in order to contribute to increasing willingness to share information. In this paper the architecture is developed and evaluated according to the requirements. We recommend the use of different types of business rules that provide businesses with control over their data, in combination with encryption and decryption of data to provide access to parts of the data within an organization.