4,627 research outputs found
Quality assessment technique for ubiquitous software and middleware
The new paradigm of computing or information systems is ubiquitous computing systems. The technology-oriented issues of ubiquitous computing systems have made researchers pay much attention to the feasibility study of the technologies rather than building quality assurance indices or guidelines. In this context, measuring quality is the key to developing high-quality ubiquitous computing products. For this reason, various quality models have been defined, adopted and enhanced over the years, for example, the need for one recognised standard quality model (ISO/IEC 9126) is the result of a consensus for a software quality model on three levels: characteristics, sub-characteristics, and metrics. However, it is very much unlikely that this scheme will be directly applicable to ubiquitous computing environments which are considerably different to conventional software, trailing a big concern which is being given to reformulate existing methods, and especially to elaborate new assessment techniques for ubiquitous computing environments. This paper selects appropriate quality characteristics for the ubiquitous computing environment, which can be used as the quality target for both ubiquitous computing product evaluation processes ad development processes. Further, each of the quality characteristics has been expanded with evaluation questions and metrics, in some cases with measures. In addition, this quality model has been applied to the industrial setting of the ubiquitous computing environment. These have revealed that while the approach was sound, there are some parts to be more developed in the future
Developing a distributed electronic health-record store for India
The DIGHT project is addressing the problem of building a scalable and highly available information store for the Electronic Health Records (EHRs) of the over one billion citizens of India
Autonomic Wireless Sensor Networks: A Systematic Literature Review
Autonomic computing (AC) is a promising approach to meet basic requirements in the design of wireless sensor networks (WSNs), and its principles can be applied to efficiently manage nodes operation and optimize network resources. Middleware for WSNs supports the implementation and basic operation of such networks. In this systematic literature review (SLR) we aim to provide an overview of existing WSN middleware systems that address autonomic properties. The main goal is to identify which development approaches of AC are used for designing WSN middleware system, which allow the self-management of WSN. Another goal is finding out which interactions and behavior can be automated in WSN components. We drew the following main conclusions from the SLR results: (i) the selected studies address WSN concerns according to the self-* properties of AC, namely, self-configuration, self-healing, self-optimization, and self-protection; (ii) the selected studies use different approaches for managing the dynamic behavior of middleware systems for WSN, such as policy-based reasoning, context-based reasoning, feedback control loops, mobile agents, model transformations, and code generation. Finally, we identified a lack of comprehensive system architecture designs that support the autonomy of sensor networking
A review of software project testing
In this article a review of software projects based on a taxonomy project is established, allowing the development team or testing personnel to identify the tests to which the project must be subjected for validation. The taxonomy is focused on identifying software projects according to their technology. To establish the taxonomy, a development method comprised of 5 phases was applied
ACMiner: Extraction and Analysis of Authorization Checks in Android's Middleware
Billions of users rely on the security of the Android platform to protect
phones, tablets, and many different types of consumer electronics. While
Android's permission model is well studied, the enforcement of the protection
policy has received relatively little attention. Much of this enforcement is
spread across system services, taking the form of hard-coded checks within
their implementations. In this paper, we propose Authorization Check Miner
(ACMiner), a framework for evaluating the correctness of Android's access
control enforcement through consistency analysis of authorization checks.
ACMiner combines program and text analysis techniques to generate a rich set of
authorization checks, mines the corresponding protection policy for each
service entry point, and uses association rule mining at a service granularity
to identify inconsistencies that may correspond to vulnerabilities. We used
ACMiner to study the AOSP version of Android 7.1.1 to identify 28
vulnerabilities relating to missing authorization checks. In doing so, we
demonstrate ACMiner's ability to help domain experts process thousands of
authorization checks scattered across millions of lines of code
Unified GUI adaptation in Dynamic Software Product Lines
In the modern world of mobile computing and ubiquitous technology, society is able to interact with technology in new and fascinating ways. To help provide an improved user experience, mobile software should be able to adapt itself to suit the user. By monitoring context information based on the environment and user, the application can better meet the dynamic requirements of the user. Similarly, it is noticeable that programs can require different static changes to suit static requirements. This program commonality and variability can benefit from the use of Software Product Line Engineering, reusing artefacts over a set of similar programs, called a Software Product Line (SPL). Historically, SPLs are limited to handling static compile time adaptations.
Dynamic Software Product Lines (DSPL) however, allow for the program configuration to change at runtime, allow for compile time and runtime adaptation to be developed in a single unified approach. While currently DSPLs provide methods for dealing with program logic adaptations, variability in the Graphical User Interface (GUI) has largely been neglected. Due to this, depending on the intended time to apply GUI adaptation, different approaches are required. The main goal of this work is to extend a unified representation of variability to the GUI, whereby GUI adaptation can be applied at compile time and at runtime.
In this thesis, an approach to handling GUI adaptation within DSPLs, providing a unified representation of GUI variability is presented. The approach is based on Feature-Oriented Programming (FOP), enabling developers to implement GUI adaptation along with program logic in feature modules. This approach is applied to Document-Oriented GUIs, also known as GUI description languages. In addition to GUI unification, we present an approach to unifying context and feature modelling, and handling context dynamically at runtime, as features of the DSPL. This unification can allow for more dynamic and self-aware context acquisition. To validate our approach, we implemented tool support and middleware prototypes. These different artefacts are then tested using a combination of scenarios and scalability tests. This combination first helps demonstrate the versatility and its relevance of the different approach aspects. It further brings insight into how the approach scales with DSPL size
Design Criteria to Architect Continuous Experimentation for Self-Driving Vehicles
The software powering today's vehicles surpasses mechatronics as the
dominating engineering challenge due to its fast evolving and innovative
nature. In addition, the software and system architecture for upcoming vehicles
with automated driving functionality is already processing ~750MB/s -
corresponding to over 180 simultaneous 4K-video streams from popular
video-on-demand services. Hence, self-driving cars will run so much software to
resemble "small data centers on wheels" rather than just transportation
vehicles. Continuous Integration, Deployment, and Experimentation have been
successfully adopted for software-only products as enabling methodology for
feedback-based software development. For example, a popular search engine
conducts ~250 experiments each day to improve the software based on its users'
behavior. This work investigates design criteria for the software architecture
and the corresponding software development and deployment process for complex
cyber-physical systems, with the goal of enabling Continuous Experimentation as
a way to achieve continuous software evolution. Our research involved reviewing
related literature on the topic to extract relevant design requirements. The
study is concluded by describing the software development and deployment
process and software architecture adopted by our self-driving vehicle
laboratory, both based on the extracted criteria.Comment: Copyright 2017 IEEE. Paper submitted and accepted at the 2017 IEEE
International Conference on Software Architecture. 8 pages, 2 figures.
Published in IEEE Xplore Digital Library, URL:
http://ieeexplore.ieee.org/abstract/document/7930218
Feature-based generation of pervasive systems architectures utilizing software product line concepts
As the need for pervasive systems tends to increase and to dominate the computing discipline, software engineering approaches must evolve at a similar pace to facilitate the construction of such systems in an efficient manner. In this thesis, we provide a vision of a framework that will help in the construction of software product lines for pervasive systems by devising an approach to automatically generate architectures for this domain. Using this framework, designers of pervasive systems will be able to select a set of desired system features, and the framework will automatically generate architectures that support the presence of these features. Our approach will not compromise the quality of the architecture especially as we have verified that by comparing the generated architectures to those manually designed by human architects. As an initial step, and in order to determine the most commonly required features that comprise the widely most known pervasive systems, we surveyed more than fifty existing architectures for pervasive systems in various domains. We captured the most essential features along with the commonalities and variabilities between them. The features were categorized according to the domain and the environment that they target. Those categories are: General pervasive systems, domain-specific, privacy, bridging, fault-tolerance and context-awareness. We coupled the identified features with well-designed components, and connected the components based on the initial features selected by a system designer to generate an architecture. We evaluated our generated architectures against architectures designed by human architects. When metrics such as coupling, cohesion, complexity, reusability, adaptability, modularity, modifiability, packing density, and average interaction density were used to test our framework, our generated architectures were found comparable, if not better than the human generated architectures
- …