Search

With the continuous improvement of the level of social development, China's economic construction and scientific and technological innovation has achieved remarkable results, not only let us enter the Internet of things era as early as possible, but also from all aspects of the people's life mode and work style. Therefore, on the basis of understanding the definition and content of the Internet of Things, this paper studies the Internet of Things application architecture based on computer network and analyzes the key technologies contained therein, so as to provide an effective basis for the future development of the Internet of Things technology.

In the new global economy, web application has become a central issue for an enterprise organization with branches covering many countries around the world. One major issue in early business services research concerned in those organizations is that developing a web application that can support both global and local services at the same time is very difficult. Since at the local level, each country will have different languages, currencies, regulations. Therefore, to develop a system or web application to support business services around the world will have to be repeated the same, but with some details that are different, such as the same invoice form. However, to support services around the world that has repeated the same process but there is detailed information in each country or each language that is different. The objectives of this research are to determine whether to develop a platform that makes Form design to be shared in many countries more easily by automatically linking to the database via API. APIs can be embedded seamlessly into both the front-end and server side. The user interface can be designed smoothly. Export code can be used with HTML. In additional, it can work with serverless applications. Files can be managed in the form of JSON, csv and txt files. The results indicate that the designed platform can support the work that is intended to meet the objectives. Makes Form development in a web application very convenient and reduces many repetitive steps. In addition, data management is also effective. When creating this Form, it helps developers reduce the time it takes to create multiple Forms and reduces the form creation errors in the settings. Custom will help to keep the original Form.

The lack of access to real-world building data has long been a significant barrier to the development and evaluation of robust applications and analyses that operate on the built environment. The Mortar platform is an open testbed for portable building analytics containing timeseries data for over 100 buildings as well as rich semantic descriptions of the assets and data sources in buildings. Access to Mortar's data is performed through an API which enforces a staged application architecture intended to simplify the development and deployment of analytics applications across a large number of buildings. In practice, users felt overly constrained by the structure enforced by the API and needed a mechanism for discovering the data available in the testbed. In this demonstration, we present (1) an improved, declarative, API for Mortar that decouples application structure from data access, and (2) an interactive query builder interface that assists users in data discovery and in authoring Brick models.

Fog application design is complex as it comprises not only the application architecture, but also the runtime infrastructure, and the deployment mapping from application modules to infrastructure machines. For each of these aspects, there is a variety of design options that all affect quality of service and cost of the resulting application. In this paper, we propose an approach for evaluating fog-based IoT applications already during an early design phase. Our approach relies on modeling and simulation to provide estimates for quality of service and cost so that developers can interactively choose a good application design.

Quantum private communication has promoted the progress of key distribution technology. However, the practical quantum private communication technology only realizes the secure key distribution for symmetric cryptosystem, and can't realize the safe transmission of asymmetric key directly. It is difficult to form complete application architecture of quantum cryptography, and it cannot give full play to the strong security capabilities of quantum private communication infrastructure. This paper constructs a fusion of quantum cryptography and classical cryptography, and designs an application model of quantum cryptography cloud service platform. Based on the present technology, it extends the distribution range of quantum cryptography, and can realize the effective fusion of asymmetric cryptography, cryptographic hashing and quantum cryptography. It has positive guiding significance for constructing new network security defense with quantum private communication technology.

In this paper we present a new software architecture communication element, called communication trait. Communication trait allows the grouping declarations of complex architectural ports/roles of components/connectors communication mechanisms in software architecture. Traits are part of a new script language, jADL -- an architecture description language (ADL). We also present a reliable and dynamic mechanism for the dynamic configuration of ports and roles and the new extended semantic of the operators attach and detach. In order to demonstrate the expressiveness of the language and the communication traits, we use the case study of describing the dynamism encountered in the Enterprise Service/Message Bus (ES/MB) architectural pattern, used for the communication between heterogeneous systems.

Over the past decade Software Architecture has proved to be a core component in software development processes. Therefore, the correctness of the software architecture is unsurprisingly crucial for the success of software products. Many methods for analyzing software architecture have been proposed in the literature in order to predict potential risks that impose far-reaching effects on the final product. However, almost none of these methods have been adopted in the industry as many of them require special knowledge or are simply not intuitive enough for the software developer. In this paper, we address this issue by proposing (the first step of) a framework for analyzing software architecture that is built using a semi-formal architecture description language (ADL), and a constraint based relational model. Architecture instances following our approach are then analyzed against a set of properties such as whether the architecture is complete, self-sufficient and self-contained. Satisfying these properties yields a well-formed architecture.

Today, a lot of commercial and open source tools exist allowing to describe the intended architecture and to check architecture conformance automatically in order to detect and eventually minimize erosion. Unfortunately, those tools are restricted in terms of which architecture concepts can be used in order to describe the intended architecture. Additionally, those approaches lack an appropriate formal foundation in terms of a well-defined syntax and semantic. Nevertheless, this is a crucial requirement for automatic support in architecture conformance checking. In this paper, we propose a formal approach enabling a) the definition of an architecture concept language that allows to capture the most important architecture concepts and their related architecture rules, b) the validation of the consistency of this language, c) the mapping of architecture concepts to source code and capturing this mapping in an explicit language in order to d) check architecture conformance. We also present an evaluation of the approach using the Common Component Modeling Example (CoCoME) case study in order to demonstrate the applicability.

Due to the increasing amount of computation in embedded devices, there is a need for software and systems architecture approaches specifically tailored for the needs of the domain. We present in this paper a view framework for the design of embedded systems that has evolved during various projects with industry customers. Our approach is complemented by architecture modeling constraints that can be used to automatically check the completeness and consistency of the created architecture models. In this article, we present our approach together with a preliminary experience report of the application of our approach in different domains.

Integrating independent, heterogeneous constituent systems in a collaborative environment is one of the most challenging aspects of software-intensive systems-of-systems (SiSoS). Since the constituent systems are in constant evolution and are managerially and operationally independent, modeling the architecture of an SoS becomes an even more complex activity. The design process of such systems are based on the so-called mission models that describe the goals and other facets of an SoS. In previous works, we lowered the gap between the mission model and the architecture. This work goes further, enhancing the proposal by providing an SoS modeling environment that produces architecture from mission models and allows verification, validation, and simulation of the involved models.

Complex software-intensive systems are more and more required as a solution for diverse critical application domains; at the same time, software architecture and also reference architecture have attracted attention as means to more adequately produce and evolve such systems. The main goal of this paper is to summarize our principal contributions in software architecture and reference architecture of software-intensive systems, including Systems-of-Systems. We intend this work can also inspire the opening of other related research lines towards founding the sustainability of such software-intensive systems.

Context-aware and autonomous smart architectures have become an important topic in architecting novel smart systems. No matter whether this is in the context of Internet of Things or Smart Cyber-physical Systems, they all are becoming software intensive systems, where the software carries the systems' smartness, their capability to address various (sometimes unanticipated) situations and the ability to scale, adapt and evolve. As proven in the past, especially the issues of scalability, evolvability, adaptability, etc. are primarily the properties of the architecture. It is the architecture that makes it possible to manage the complexity of the software and ensure that the software can evolve and change at runtime and also gradually in iteration cycles involving development.Traditional approaches to software architectures however fail to address needs of context-aware and autonomous systems. This is mostly because they largely do not provide first class concepts to deal with the dynamicity and evolution of the system at the level of the architecture. Thus, they lose the documentation value of an architecture and the ability to exploit the architecture description to drive, control and provide guarantees in architecture evolution.In this keynote we focus on how to capture architectures of dynamically evolving systems where a system is modeled as autonomic components that dynamically form collaboration groups (so called ensembles [1, 3]) to complete their tasks. We give examples of rich component-based architectural description that captures the potential dynamicity of a system and ties it to the context and the internal state of the components. We show how to balance the autonomy of the components and the group-wise collaborative aspect while respecting the often present real-time constraints and non-idealized communication [2] (i.e. communication with latency and dropouts). We show how the communication ability itself establishes part of the context of the system and how the system can adapt to it.Generally, this opens the broad question of what constitutes the context and how to capture the context-awareness and the knowledge to act based on the context at the level of the software architecture.

As long as a software development organization drives several development projects in parallel the enterprise architecture gets more and more complex. Every initiative and every project has its own goals and timelines. This context implies a great challenge steering and managing the architecture to achieve more homogeneity, evolve according to new technology stacks and still pay credit to a necessary independence between projects. Short-term goals of the projects need to be balanced out with mid- and long-term objectives of the company. Therefore, architecture management measures should be considered, planned, and realized. This paper describes eight high-level architecture management patterns as starting point for central architecture teams, chiefs of architects, lead and principal software architects or CTOs.

Application and/or data migration is a result of limitations in existing system architecture to handle new requirements and the availability of newer, more efficient technology. In any big data architecture, technology migration is staggered across multiple levels and poses functional (related to components of the architecture and underlying infrastructure) and non-functional (QoS) challenges such as availability, reliability and performance guarantees in the target architecture. In this paper, (1) we outline a big data architecture stack and identify research problems arising out of the technology migration in this scenario (2) we propose a smart rule engine system which facilitates the decision making process for the technology to be used at different layers in the architecture during migration.

Customized Architecture is one of the technical road for exascale high performance computing. We will give an overview about FPGA customized architecture. Research experiences on deep learning algorithms accelerators for data analyzing, footprint and cipher algorithms accelerators for information processing, and matrix processing algorithms accelerators for scientific computing will be discussed.

The architecture of a system specifies how the system should be designed and built. However, shortcomings are identified in current architecture process frameworks concerning evolving domains like healthcare. We claim that an iterative architecture process is required, where the technical concerns are separated from the non-technical ones. Furthermore, a strong guiding vision is required. Based on our experiences from a biobank IT infrastructure process, we present an architecture process that is modular, interoperable, controlled and abstracted, thus being capable of handling complex systems with large uncertainties.

A reference architecture guides an organization with best-practice knowledge about existing architectures, including an elaboration of the organization's mission, vision and strategy of a specific domain. Current e-learning architectures, however, focus on the theoretical framework of the application layer, service layer and database engineering while in reality, a networking layer is required for the implementation of e-learning systems. Existing publications do not focus on the collaborative aspect in the domain of national research and education networks (NRENs). This research tackles the creation of a reference architecture for e-learning in NRENs for which model driven engineering (MDE) is used. We analyze relevant aspects of NREN e-learning architectures by using the architecture tradeoff analysis method (ATAM). Next, we propose a NREN e-learning standard and concrete architecture.

Software architecture documentation is essential for preventing architecture erosion that is a major concern of sustainable software systems. However, the high effort for elaboration and maintenance of architecture documentation hinders its acceptance in practice. Most state-of-the-art research methods assume comprehensive architecture documentation. By reducing architecture documentation to those aspects that are most important for architecture erosion, we want to achieve more acceptance for architecture documentation especially in agile projects. This reduction, however, has effects on architecture-related activities during software design and implementation.

Architectural patterns represent reusable design of software architecture at a high level of abstraction. They can be used to structure new applications and to recover the modular structure of existing systems. Techniques like Architecture Compliance Checking (ACC) focus on testing whether realised artefacts adhere to the architecture. Typically, these techniques require a complete architecture as input. In this paper, we present a genetic approach to express and discover architectural patterns based on the allowed and disallowed dependencies between the pattern elements. Through static ACC, we validate the genuineness of the found instances. Initial validation shows the potential of the approach.

For a typical smart city many IoT (Internet of Things) architectures have been proposed to integrate the various ICT Solutions. Since there are many perspectives, the emphasis and the design of each architecture vary. So at the moment there is no standard architecture. The best approach is to adapt architecture for its intended use. Most of the current IOT architectures are service centered. After surveying literature, there exists a gap in a user centered approach with intelligent edge devices. We propose Aura Minora: a novel architecture for IOT based on a bottom-up approach. Our approach in this paper is to see, how this user centric architecture would help end users as well as the smart city governing body to use existing Internet infrastructure to provide services. We also focus on user privacy and security aspect within this architecture. We further discuss the various views like informational, functional and deployment view of our architecture.

We propose an advanced architecture which works better than typical architecture of social networks. We are going to study architecture of social networking sites. Our architecture uses a load balancing module for buffering user queries before transmitting them to data server. In this paper, query optimization of user queries for faster results has been discussed. Our experimentation exhibits possibility of data failure reduction due to external disturbances.

We propose a practical solution for cloud application development using Node.js and Express library by presenting: (1) a software architecture which utilizes two standard inheritance pattern techniques, the top-down and divide and conquer approaches, to effectively organize the structure of the application for improved maintainability and extensibility in the long-run, and (2) an easy-to-follow guideline that instructs the implementation procedures for developing Node.js cloud applications.

Media architecture is a challenging novel research domain which demands a close partnership between human-computer interaction (HCI), the industry and architects. Using a design-process approach that involves early prototyping is especially in this discipline a mandatory task in order to get any design right. However, crafting early interactive prototypes and exploring low-res content, form variations and interaction concepts is still cumbersome, challenging and comes at high cost which is mainly feasible for larger studios. To enable smaller architectural practices start prototyping with media architecture from scratch we present our prototyping toolkit LightBricks. It is intended to build miniature models of media architectural designs and remove technical burdens with a playful approach. It further enables the rapid exploration of possible content applications for low-resolution media architecture in order to assist interdisciplinary design teams in early phases of the design process to envision, demonstrate and pre-test visual or interactive content when working on new projects involving low-resolution media architecture.

In this paper, we first discuss the concept of architecture debt and how this debt grows in virtually every software-intensive project. Next we propose a methodology for developers to monitor the health of a project's architecture through an analysis of the development artifacts that a project produces. Our objective is to monitor and manage architecture debt by leveraging an architecture model that we proposed recently, called the Design Rule Space (DRSpace). We use DRSpaces to split a complex system into smaller subsystems based on features, patterns, refactoring targets, etc., so that we can monitor and analyze the evolution and interaction of each subsystem separately. We also employ a recently proposed architectural metric---Decoupling Level---to quantitatively monitor changes in a project's overall level of architecture maintainability. Using these tools, we describe our vision for a software architecture "health monitor", on analogy with a health monitor used in a hospital, to continuously monitor the health of the "patient" and alert staff to any potential danger signs.

Acquirers, system builders, and other stakeholders of big data systems need to define requirements, develop and evaluate solutions, and integrate systems together. A reference architecture enables these software engineering activities by standardizing nomenclature, defining key solution elements and their relationships, collecting relevant solution patterns, and classifying existing technologies. Within the national security domain, existing reference architectures for big data systems have not been useful because they are too general or are not vendor-neutral. We present a reference architecture for big data systems that is focused on addressing typical national defence requirements and that is vendor-neutral, and we demonstrate how to use this reference architecture to define solutions in one mission area.

It is essential to architecture-centric product line development that product line architecture can be used to drive activities specific to product line development, such as product derivation. This requires a mechanism that can automatically derive the architecture and code of a product instance from the customization of product line architecture. In this paper, we analyze the insufficiency of two existing solutions in this area and present an architecture-centric approach that meets the requirement. The approach can support product line differences in platforms and functions, and generate both product line code and product code. It is based on a product line implementation mechanism that combines a code generation and separation pattern with an architecture-based code annotation technique. We have implemented the approach, and finished a preliminary evaluation with a chat application.

A primary challenge involved in implementing product line architecture is realization of the included variation points (e.g. alternative components, optional interfaces) in source code. Existing architecture implementation techniques are focused on single system development. Software variability implementation techniques such as inheritance and overloading mainly support fine-grained variations at the programming language level. In this paper, we present a novel approach to implementing product line architecture. It combines a code generation and separation pattern with an architecture-based code annotation technique. It can support product line variability in platforms, functions, and implementation mechanisms that are at different degrees of granularity. The goal is to maintain architecture-implementation conformance and increase code reusability.

Product line architecture (PLA) captures the architectural commonality and variability among products of a product family. Existing PLA modeling approaches are limited in the sense that (1) it is often difficult to relate a product line feature to its implementation in the PLA, and (2) variation points in the PLA have to be manually developed and maintained. In this paper, we present a novel PLA modeling approach and a toolset called ArchFeature that addresses these two challenges. ArchFeature integrates PLA and feature specification in a single monolithic architecture model. It includes a graphical modeling environment that can (1) automatically capture, maintain, and visualize the feature-PLA relationship, (2) encapsulate variability modeling from the user, and (3) support automatic derivation of architecture instances from the PLA. ArchFeature is an Eclipse plugin integrated in ArchStudio, an Eclipse-based architecture development platform. We assessed its usability and effectiveness in a case study by using it to develop a full-featured architecture model for an open-source software system, Apache Solr.

Software Defined Network(SDN) is a promising technological advancement in the networking world. It is still evolving and security is a major concern for SDN. In this paper we proposed policy based security architecture for securing the SDN domains. Our architecture enables the administrator to enforce different types of policies such as based on the devices, users, location and path for securing the communication in SDN domain. Our architecture is developed as an application that can be run on any of the SDN Controllers. We have implemented our architecture using the POX Controller and Raspberry Pi 2 switches. We will present different case scenarios to demonstrate fine granular security policy enforcement with our architecture.

To keep the software development for vehicles cost efficient, software components are reused for different variants as well as for succeeding generations. Furthermore, cost reductions are achieved by software sharing between the Original Equipment Manufacturer (OEM) and the suppliers. However, as a consequence of the blackboxed view caused by software sharing, no common detailed software product line architecture specification for the Electronic Control Unit (ECU) software exists, as it would be required for analyzing the quality of the product line architecture, planning changes on the product line architecture, checking the compliance between the product architecture and the product line architecture, and therefore, avoiding architecture erosion. Thus, after several product generations, software erosion is growing steadily, resulting in an increasing effort of reusing software components, and planning of further development. Here, we propose an approach for repairing an eroded software consisting of a set of product architectures by applying strategies for recovery and discovery of the product line architecture. Furthermore, we give a methodology for a long-term manageable, plannable, and reuseable software product line architecture for automotive software systems.

Software product line (SPL) involved variability modeling in domain engineering that will be matched to the respected application engineering. Several researches existed within the scope of mapping from reference architecture (RA) in domain engineering to system architecture in application engineering within the same domain. However, the mapping of cross domain RA or Multi Product Line (MPL) required more systematic mapping due to the several participating product line architecture (PLA) that will further instantiated to specific system architecture. The objective of this paper was to propose an actor-oriented approach in the mapping process of reference architecture, product line architecture and system architecture of MPL. Since the reference architecture consisted of several components, the scope of this research was within the functional decomposition or source code level. The experiment was involving the runtime behavior of the java code. The code with actor-oriented approach had shown the least amount of time taken to complete the main method compared to the non-actor-oriented approach. In conclusion, actor-oriented approach performs better performance in the mapping of reference architecture to product line architecture and system architecture. For future work, the consistency of the mapping will be evaluated.

Building connected, pervasive, human-facing, and responsive applications that incorporate local sensors, smartphone interactions, device actuation, and cloud-based learning--the promised features of the Internet of Things (IoT)---requires a complete suite of tools spanning both hardware and software. We present a set of these pieces, including a gateway, four hardware building blocks, multiple sensor platforms, an indoor localization system, and software for connecting users and devices. Each piece plays an integral role towards enabling applications, from facilitating rapid development of wireless smart devices to composing data streams and services from a diverse set of components. By providing layered interoperable systems, our toolkit offers cohesive support for moving beyond single-device, cloud-centric applications---typical in today's IoT landscape--and towards richer applications that incorporate multiple data streams, human interaction, cloud processing, location awareness, multiple communication protocols, historical data, access control, and on-demand user interfaces. To show how the pieces in the toolkit cooperate, we demonstrate a location-based access control application where a user's smartphone can control a room's lighting, but only from within the room. Further, data streams from the phone and nearby sensors are used to provide a constant lighting service which attempts to maintain a user-set brightness under variable external lighting conditions.

We propose an architecture that frees application providers from designing direct end-to-end connectivity between end clients by spinning off end-to-end communications from applications. The business model of telecom carriers has been shifting from "business to consumer" to "business to business to consumer" (B2B2C), and the proposed architecture fits the B2B2C business model well. The proposed architecture also reduces unnecessary processing loads placed on application servers, and this feature is attractive to application providers. The effectiveness of the proposed architecture is also discussed along with implemented test results.

The paper investigates and analyzes problems of data protection in industrial corporations at all stages of the life cycle of its architecture. The basic risks and threats of information security are shown up, covering all layers of the enterprise architecture, which must be taken into account when building the security architecture. Also those threats of information security are investigated which are difficult to prevent through a variety of means and methods of special protection.

During software evolution, it is important to evolve not only the source code, but also its architecture to prevent architecture drift and architecture erosion. This is a complex activity, especially for large software projects, with multiple development teams that might be located in different countries or on different continents. To ease this kind of evolution, we have developed a domain-specific language for making decisions about the evolution. It supports the definition of architectural changes based on multiple implementation tasks that can have temporal dependencies among each other. Then, by means of a model-to-model transformation, we automatically create a constraint model that we use to generate, by means of the Alloy model analyzer, the possible alternative decisions for executing the implementation tasks. The tight integration with architecture abstractions enables architects to automatically check the changes related to an implementation task in relation to the architecture description. This helps keeping architecture and code in sync, avoiding drift and erosion.

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.

This is the author's version of the work. It is posted here for your personal use. Not for redistribution. The definitive Version of Record was published in Interacción '15: Proceedings of the XVI International Conference on Human Computer Interaction, http://dx.doi.org/10.1145/2829875.2829919., For the most part, Information Architecture processes include sets of activities and techniques to be carried out by the development team to create interactive applications effectively, involving usability concerns at every development step. In fact, plenty of process models have already been proposed to bridge the gap between User-Centered Development and Information Architecture, empowering the development team to build usable applications successfully. However, the combination of User- Centered Development and Information Architecture paradigms sometimes results in cumbersome process models containing lots of phases and activities to be considered, which increases the cycle time to have partial and validated software increments readily. As less effort has been devoted to speed up the usable Information Architecture development, the aim of this paper is to address such problem. To do so, we present Scrum-UIA, an agile and usable development process driven by the Information Architecture. This process is intended to develop web applications by splitting up responsibilities and tasks, and decreasing the time to perform technical activities, in order to readily obtain usable software increments., This work has been supported by the funding projects «eMadrid», granted by the Madrid Research Council (project code S2013/ICE-2715) and «Flexor», granted by the Spanish Government (project code TIN2014-52129-R).

Modern mobile application development is a fast reacting business. One success factor is the ability to be able to add new features rapidly into a product. This can be enabled by a process model designed to support it, and the use of a flexible architecture. Plug-in architecture is one approach to create a flexible architecture, because it enables adding new software components. We have refactored an existing application to a plug-in architecture, and implemented a process model to support rapid adding of features. In our approach new features are implemented as plug-ins, which are added to the application. In this paper we describe the process model, discuss of adding new plug-in using it, and describe our experiences of using the process model.

The paper introduces an architecture to support system engineering on the cloud. It employs the main benefits of the cloud: scalability, parallelism, cost-effectiveness, multi-user access and flexibility. The architecture includes an open toolbox which provides tools as a service to support various phases of system engineering. The architecture uses the Open Services for Life-cycle Collaboration (OSLC) technology to create a reactive middleware that informs all stakeholders about any changes in the development artefacts. It facilitates the interoperability of tools and enables the workflow of tools to support complex engineering steps. Another component of the architecture is a shared repository of artefacts. All the artefacts generated during a system engineering process are stored in the repository, and can be accessed by relevant stakeholders. The shared repository also serves as a platform to support a protocol for formal model decomposition and group work on the decomposed models. Finally, the architecture includes components for ensuring the dependability of the system engineering process.

Science gateways are more than user interfaces to computational grids and clouds. Gateways are middleware in their own right, providing flexible, lightweight federations of heterogenous collections of computing resources (such as campus clusters, supercomputers, computational clouds), all of which remain challenges for many alternative middleware approaches. Gateways also are notable for providing science application-centric interfaces to computing resources rather than resource-centric views. An important challenge for science gateway research is to generalize specific science gateway strategies, defining a reference architecture that emcompasses major gateway capabilities while enabling implementation flexibility. Such a reference architecture should also enable "platform as a service" approaches that provide hosted versions of common gateway capabilities. In this paper, we summarize the Apache Airavata software system as a candidate reference architecture for science gateways. We propose the use of a component-based architecture to encompass major gateway capabilities (such as metadata management, meta-scheduling, execution management, and messaging). We examine the messaging system component in this abstract architecture in detail and describe its re-implementation and validation using third party messaging system software to replace a custom-built messaging system. Besides the operational validation of this specific component, we infer a preliminary validation of the overall architecture. The flexibility of component implementations within an overall architecture is essential as it allows gateway middleware to be the subject of distributed computing research for its own sake while also ensuring that we don't get locked into less than optimal implementations for gateway operations.

The future Internet is expected from the evolution of today's IP networks. Content-centric networking (CCN) is a promising future communication architecture, and there has been much research into its applications and architecture. However, the most of communications in CCN focus on the delivery of individual content by using application specific interest-data exchanges. There are few studies on a generic framework for the delivery of multimedia data, which contains a series of content generated periodically.In this paper, we design and implement a system to support a new type of communication model called stream data, which covers a various types of multimedia data such as streaming and sensing, and its form of delivery over CCN. To obtain two important features of stream data, which are random access and flexibility, we design a CCN architecture that includes a seamless naming/addressing architecture to enable content provider controls. In particular, we target embedded devices, which have limited hardware resources, to realize easy stream data delivery. In addition, we develop a prototype to verify the feasibility of our proposed architecture.

The notions of architecture, component and composition are perceived differently in different communities. In order to discuss how component-based development can contribute to the definition and use of reference architecture in practice, in this position paper, we outline some fundamental characteristics of components and composition and posit their relevance to reference architecture.

NoSQL databases create tight coupling between data model, deployment topology, and application architecture, and so this technology selection must be one of the earliest architecture decisions. The NoSQL technology landscape is large and evolving rapidly, so architects need efficient and trusted design assistance to explore the solution space. Our solution was to create a queryable knowledge base, populated with curated information, which is rendered dynamically as content grows and changes. We built the knowledge base using Semantic MediaWiki, implementing a novel knowledge model that enables reasoning from quality attributes to architecture patterns and tactics to features implemented in specific NoSQL products. We also provide tabular and graphical visualizations to support both systematic and ad hoc exploration. Our contributions to the field of architecture design assistants are the knowledge model, its implementation in a semantic platform, and the resulting populated knowledge base for big data system architects.

As the Technology Readiness Levels (TRLs) of self-driving vehicles increase, it is necessary to investigate the Electrical/Electronic(E/E) system architectures for autonomous driving, beyond proof-of-concept prototypes. Relevant patterns and anti-patterns need to be raised into debate and documented. This paper presents the principal components needed in a functional architecture for autonomous driving, along with reasoning for how they should be distributed across the architecture. A functional architecture integrating all the concepts and reasoning is also presented.

Mobile sensing denotes the use of mobile devices and their integrated sensorsfor sensing and learning physical and social phenomena, and to use derivedinformation for sharing, informing, and persuading humans. From the perspectiveof software architecture, mobile sensing bears several design challenges regarding,e.g., use of battery powered mobile devices, and collection and processing ofsensor data. In this paper, we present tactics to address these architecturedesign challenges. We discuss the two architectural qualities energy efficiencyand resource adaptability, and describe them usinggeneral scenario-generation tables to support the systematic specification of architecturerequirements. Furthermore, we develop a catalog of architectural tacticsdistilled from literature to enable developers to systematicallyapply proven methods. For each tactic, we provide examples to relate therespective tactics to particular cases illustrating their use in practice.Finally, we provide a preliminary validation of the proposed systematizedtactics catalog, which was conducted with student teams. Our preliminary findings show thatthe tactics are beneficial to provide a guideline and to create awareness of thespecial challenges of energy-efficient and resource-adaptable architecture design.

Although many architecture evolution techniques exist, most of them are not able to perform a quality impact prediction. Most of these techniques concentrate on analyzing the expected performance and reliability of design alternatives on prototypes or previous experiences. In this paper, we propose a novel model-driven prediction approach, which is estimated, based on the extractable information from the User Behavioral Flow and the Continues-Time Markov Chain (CTMC) and its corresponding Hidden Markov Mode (HMM). This paper also reports our experience and the lessons we learned in applying this approach on MyUAlberta applications as a large-scale case study.

Modern frameworks are required to be extendable as well as secure. However, these two qualities are often at odds. In this poster we describe an approach that uses a combination of static analysis and run-time management, based on software architecture models, that can improve security while maintaining framework extendability.

Availability of scriptable resources in cloud empowers applications to be cost-efficient and meet their execution-time quality requirements. However, the application needs to be designed and built to exploit this feature of the cloud infrastructure. This paper proposes an idea to add quality attributes in the cloud-based applications at run-time. Here, a methodological framework, AutoQA, is conceptualized for building services that can facilitate on-demand provision of quality attributes to applications. The AutoQA framework is based on software architecture body of knowledge, especially tactics. Methodology of the AutoQA framework is to integrate architectural tactics with the application architecture at run-time. By using an AutoQA-based service, applications can meet some unpredicted quality requirements in a cost-efficient manner. Our prototype implementation of an AutoQA-based service provides support for four quality attributes (performance, availability, security, and testability) to web applications deployed on Linux containers. Experiments conducted by provisioning quality attributes to a web-based application demonstrate feasibility and benefits of the framework.

According to L. Bass et al. [8], software architecture of a system is "the set of structures needed to reason about the system, which comprise software elements, relations among them, and properties of both." Software architecture is often unavailable because of reasons like architecture erosion and absence of relevant documentations [13]. To recover software architecture for regaining its advantages, various methods for software architecture reconstruction (SAR) [1,3,5,6] were proposed [13].

International audience; For large component-based applications, identifying a valid deployment architecture has emerged as a major challenge. Actually, this deployment architecture (i.e, allocation of software components to its hardware hosts) should satisfy various constraints related to the software components and the target environment such as the hierarchical description of components, their connections and the resource constraints. The numerous constraints make hard to construct manually the correct deployment architecture. In this work, we propose a formal method based on a formal language called BRS (Bigraphical Reactive System) in order to guarantee the correctness of the deployment architecture. Furthermore , in order to support its automatic construction, our proposed method follows a multi-scale modeling. In fact, the designer starts by modeling the first scale architecture which is refined automatically by successively adding smaller scale components until obtaining the deployment architecture at the last scale. This refinement is ensured by applying a set of rules. In this paper, we address communicating systems as a study domain.