Search

As the number of Internet-of-Things (IoT) devices explosively increases, developing the IoT standard is essential to control those devices efficiently. To do this, many vendors and IT companies have established IoT standard organizations. In particular, the Open Connectivity Foundation (OCF), the most influential IoT standard organization, has been actively developing the OCF standard and an open-source software framework called IoTivity. The OCF standard supports interoperability through bridging techniques toward non-OCF devices of other ecosystems, such as ZigBee, Bluetooth low energy, oneM2M, and AllJoyn. Among several bridging techniques, we focus on developing an OCF-to-ZigBee (O2Z) bridging technique which is very important to provide the scalability of the OCF standard. This is because there are many ZigBee devices to construct IoT applications (e.g., lightening, heating, and sensing), and the number of them is steadily increasing. In this article, we introduce the O2Z bridging technique adopted in the OCF standard, and describe how to implement an O2Z bridging plugin as a software component of IoTivity. This work would provide a good guideline for developing other bridging techniques toward other IoT ecosystems.

Robotic manipulation is fundamental to many realworld applications; however, it is an unsolved problem that remains a very active research area. New algorithms for robot perception and control are frequently proposed by the research community. These methods must be thoroughly evaluated in realistic conditions before they can be adopted by industry. This process can be extremely time consuming, mainly due to the complexity of integrating different hardware and software components.

Analyzing real-world software is challenging due to complexity of the software frameworks or APIs they depend on. In this paper, we present a tool, PROMPT, that facilitates the analysis of software components using API model guided symbolic execution. PROMPT has a specification component, PROSE, that lets users define an API model, which consists of a set of data constraints and life-cycle rules that define control-flow constraints among sequentially composed API functions. Given a PROSE model and a software component, PROMPT symbolically executes the component while enforcing the specified API model. PROMPT has been implemented on top of the KLEE symbolic execution engine and has been applied to Linux device drivers from the video, sound, and network subsystems and to some vulnerable components of BlueZ, the implementation of the Bluetooth protocol stack for the Linux kernel. PROMPT detected two new and four known memory vulnerabilities in some of the analyzed system software components.

Autonomous unmanned aerial systems (UAS) could supplement and eventually subsume a substantial portion of the mission set currently executed by remote pilots, making UAS more robust, responsive, and numerous than can be achieved by teleoperation alone. Unfortunately, the development of robust autonomous systems is difficult, costly, and time-consuming. Furthermore, the resulting systems often make little reuse of proven software components and offer limited adaptability for new tasks. This work presents a development platform for UAS which promotes behavioral flexibility. The platform incorporates the unified behavior framework (a modular, extensible autonomy framework), the robotic operating system (a robotic software framework), and PX4 (an open-source flight controller). Simulation of UBF agents identify a combination of reactive robotic control strategies effective for small-scale navigation tasks by a UAS in the presence of obstacles. Finally, flight tests provide a partial validation of the simulated results. The development platform presented in this work offers robust and responsive behavioral flexibility for UAS agents in simulation and reality using a methodology originally proven on ground robots.

The availability of commercial Radio Frequency System on Chip (RFSoC) devices brings new possibilities for implementing Software Defined Radio (SDR) systems. Such systems are of increasing interest given the pace of innovation in wireless technology, and the pressure on RF spectrum resources, leading to a growing need to access the spectrum in more dynamic and innovative ways. In this paper, we present an SDR demonstration system based on the Xilinx RFSoC platform, which leverages the Python- based 'PYNQ' (Python Productivity for Zynq) software framework. In doing so, we highlight features that can be extremely useful for prototyping radio system design. Notably, our developed system features Python-based control of hardware processing blocks and Radio Frequency (RF) data converters, as well as direct visualisation of communications signals captured within the chip. The system architecture is reviewed, hardware and software components are discussed, functionality is demonstrated, and aspects of the system's performance are evaluated. Finally, it is noted that this combined RFSoC + PYNQ approach is readily extensible for other SDR systems; we highlight our online shared resources, and invite other engineers to investigate and build upon our work.

The Primary Mirror Device Control System (M1 DCS) is one of the many Device Control Systems (DCS) included in the Giant Magellan Telescope (GMT) control system and is responsible for the overall control and operation of the GMT primary mirror segments. The primary mirror is composed of seven 8.4m diameter segments, six off-axis and one in the center. The active support system of each segment comprises 170 support actuators for the off-axis segments and 154 actuators for the center segment to control the mirror figure, and 6 hardpoints to control the six degrees of freedom of rigid body motion. The software design follows a component model-based architecture, implemented using the GMT core software frameworks. Software components of the M1 DCS are specified using a custom Domain Specific Language (DSL) and inherit all key features of the core components such as communication ports, default behaviors, telemetry, logs, alarms, faults, state machines and engineering user-interface without the need of a separate implementation. The communication between the real time software and the controlled devices is implemented by an EtherCAT Fieldbus in a ring topology. This master-slave standard protocol enables the control system to reach 100 Hz closed loop rate for active support control. This paper describes the software of the M1 DCS, the tests performed with different software and hardware simulators, and the strategy to ensure software readiness with the final optical mirror.

Analyzing real-world software is challenging due to complexity of the software frameworks or APIs they depend on. In this paper, we present a tool, PROMPT, that facilitates analysis of software components using programming model guided symbolic execution. PROMPT has a specification component, PROSE, that lets users define a programming model, which consists of a set of data constraints and life-cycle rules that define control-flow constraints among sequentially composed API functions. Given a PROSE model and a software component, PROMPT symbolically executes the component while enforcing the specified programming model. PROMPT has been implemented on top of the KLEE symbolic execution engine and has been applied to Linux device drivers from the video, sound, and network subsystems. PROMPT detected two new and two known memory vulnerabilities in some of the device drivers. The proposed tutorial on PROMPT will empower practitioners as well as researchers in analyzing components of system code for deep memory vulnerabilities.

The usage of Field Programmable Gate Arrays(FPGAs) as application-specific accelerators in data centers has grown rapidly in recent years. The main reasons for this are the higher throughput of application-specific accelerators, an improved latency behavior as well as higher energy efficiency compared to conventional computing systems with CPUs and GPUs. In particular, network-attached FPGA accelerators exhibit excellent latency behavior and very high energy efficiency. The high efficiency not only decreases operating costs, but also results in a lower carbon footprint. A disadvantage compared to conventional CPUs and GPUs is the difficult programmability as well as the integration into data centers, which hinders a widespread adoption. To simplify the integration of FPGA accelerators in heterogeneous data centers, we have designed a flexible hardware and software framework to overcome these problems. We also show which components are necessary to fulfill the requirements within a data center.

Realizing the potential of edge computing and networks connecting the edge and the cloud, researchers from academia and industries have increasingly developed techniques and tools for edge infrastructures and applications. This paper focuses on supporting complex edge application interactions, which span different layers and subsystems in edge-cloud environments. This paper addresses (i) diverse types of software components for emulating realistic functionality and configurations, like data transformation and service API interoperability, and (ii) techniques for connecting emulated scenarios to real edge software development and operations, and to IoT and cloud counterparts. We present IoTCloudSamples as a software framework with (i) modeling and implementation of diverse types of IoT, edge and cloud elements for complex edge scenarios, (ii) methods for constructing and steering emulations to study the interoperability across layers among different edge platforms and protocols, and (iii) extensive emulated scenarios and experiments integrated with real-world IoT and cloud services. IoTCloudSamples supports the approach of edge-simulation-as-code to allow the reuse and runtime steering of realistic emulation operations. We will present examples from our real-world projects concentrating on edge analytics applications.

International audience; Object-oriented Application Programing Interfaces (APIs) support software reuse by providing pre-implemented functionalities. Due to the huge number of included classes, reusing and understanding large APIs is a complex task. Otherwise, software components are accepted to be more reusable and understandable entities than object-oriented ones. Thus, in this paper, we propose an approach for reengineering object-oriented APIs into component-based ones. We mine components as a group of classes based on the frequency they are used together and their ability to form a quality-centric component. To validate our approach, we experimented on 100 Java applications that used four APIs.

Certification is a technique that plays a vital role in endorsing software components. It helps in increasing the importance of software components. It tries to validate the quality of components and makes it reliable for reuse. This increases the probability of software components to be reused. The study presented the framework for certification of reusable software components. While presenting the framework the study stated about the certifiable artifacts and certifying authority. It also stated the methods of certification, certification practices to be followed, and the certification services. The certification process actually ratifies the quality of software components. The certification methods involve the request for certification, processing the request, and issuance of certificates. The certification practices are categorized into ‘for reuse’ and ‘with reuse’. The certification services stated about the services provided in relation to certificates. It is easy to rely on products with valid certificates. The software components without certification do not guarantee the quality aspects. It may then be able to compromise the quality of software products, which in turn, can vitiate the reliability of software components and consequently, the software products.

Software reuse is a development strategy in which existing software components, called reusable assets, are used in the development of new software systems. There are many advantages of reuse in software development, such as minimization of development efforts and improvement of software quality. New methods for reusable asset extraction are essential to achieve these advantages. Extraction methods may be used in different contexts including software product lines derivation. However, few methods have been proposed in literature for reusable asset extraction and recommendation of these reuse opportunities. In this paper, we propose a method for extraction of reuse opportunities based on naming similarity of two types of object-oriented entities: classes and methods. Our method, called JReuse, computes a similarity function to identify similarly named classes and methods from a set of software systems from a domain. These classes and methods compose a repository with reuse opportunities. We also present a prototype tool to support the extraction by applying our method. We evaluate the method with 38 e-commerce information systems mined from GitHub. As a result, we observe that our method is able to identify classes and methods that are relevant in the e-commerce domain.

The software monoculture favors attackers over defenders, since it makes all target environments appear similar. Code-reuse attacks, for example, rely on target hosts running identical software. Attackers use this assumption to their advantage by automating parts of creating an attack. This article presents large-scale automated software diversification as a means to shore up this vulnerability implied by our software monoculture. Besides describing an industrial-strength implementation of automated software diversity, we introduce methods to objectively measure the effectiveness of diversity in general, and its potential to eliminate code-reuse attacks in particular.

Software Cybernetics is adopted by our method to improve reliability of software.A nested control system is established to manage the process of verification.A model is built from requirements to formalize expected behaviors of software.Internal relationships of program are abstracted gradually to construct a model.The feedback is represented by a form of intermediate code. Software cybernetics aims at improving the reliability of software by introducing the control theory into software engineering domain systematically. A key issue in software verification is to improve the reliability of software by inspecting whether the software can achieve its expected behaviors. In this paper, the thought of software cybernetics is applied in the process of verification to address this issue and a nested control system is established. The proposed method verifies functional requirements in a dynamic environment with constantly changing user requirements, in which the program serves as a controlled object, and the verification strategy determined by software behavioral model (SBM) serves as a controller. The main contribution of this paper includes: (1) SBM is established in software design phase, and a concern-based construction approach is proposed, which starts from obtaining the software expected functionality extracted from a requirement text; (2) Program abstract-relationship model (PARM) is constructed basing on a process of gradual abstract to be a controlled object; (3) Feedback in a form of intermediate code is generated in the process of verification. The proposed method is validated by our case study.

Software engineers construct modern-day software applications by building on existing software libraries and components that they necessarily do not author themselves. Thus, contemporary software applications rely heavily on existing standard and third-party libraries for their execution and behavior. As such, effective runtime analysis of such a software application’s behavior is met with new challenges. To perform dynamic analysis of a software application, all transitively dependent external libraries must also be monitored and analyzed at each layer of the software application’s call stack. However, monitoring and analyzing large and often numerous external libraries may prove to be prohibitively expensive. Moreover, an overabundance of library-level analyses may obfuscate the details of the actual software application’s dynamic behavior. In other words, the extensive use of existing libraries by a software application renders the results of its dynamic analysis both expensive to compute and difficult to understand. We model software component behavior as dynamically observed data- and control dependencies between inputs and outputs of a software component. Such data- and control dependencies are monitored at a fine-grain instruction-level and are collected as dynamic execution traces for software runs. As an approach to address the complexities and expenses associated with analyzing dynamically observable behavior of software components, we summarize and reuse the data- and control dependencies between the inputs and outputs of software components. Dynamically monitored data- and control dependencies, between the inputs and outputs of software components, upon summarization are called dynamic dependence summaries . Software components, equipped with dynamic dependence summaries, afford the omission of their exhaustive runtime analysis. Nonetheless, the reuse of dependence summaries would necessitate the abstraction of any concrete runtime information enclosed within the summary, thus potentially causing a loss in the information modeled by the dependence summary. Therefore, benefits to the efficiency of dynamic analyses that use such summarization may be afforded with losses of accuracy. As such, we evaluate the potential accuracy loss and the potential performance gain with the use of dynamic dependence summaries. Our results show, on average, a 13× speedup with the use of dynamic dependence summaries, with an accuracy of 90% in a real-world software engineering task.

This article proposes a pragmatic approach to software composition based on matching criteria by mimicking integrated hardware counterpart. The tangible value of consumer goods as described by Cox instills this logical derivation of the proposed approach. As software gradually matures in component form, various software compositions can be systematically assembled from related existing software. Two application software are composed based on their functionality matching. Their composition complexities are measured by function point. The total effort unveils a noteworthy finding that high complexity software demands larger effort to deploy. Thus, the proposed software composition framework not only offers the freedom of development mandates to the development team, but also broadens the horizon of cost and project evaluations by arriving at the proper mix of constituent components in the software product.

Scalable and efficient numerical simulations continue to gain importance, as computation is firmly established as the third pillar of discovery, alongside theory and experiment. Meanwhile, the performance of computing hardware grows through increasing heterogeneous parallelism, enabling simulations of ever more complex models. However, efficiently implementing scalable codes on heterogeneous, distributed hardware systems becomes the bottleneck. This bottleneck can be alleviated by intermediate software layers that provide higher-level abstractions closer to the problem domain, hence allowing the computational scientist to focus on the simulation. Here, we present OpenFPM, an open and scalable framework that provides an abstraction layer for numerical simulations using particles and/or meshes. OpenFPM provides transparent and scalable infrastructure for shared-memory and distributed-memory implementations of particles-only and hybrid particle-mesh simulations of both discrete and continuous models, as well as non-simulation codes. This infrastructure is complemented with portable implementations of frequently used numerical routines, as well as interfaces to third-party libraries. We present the architecture and design of OpenFPM, detail the underlying abstractions, and benchmark the framework in applications ranging from Smoothed-Particle Hydrodynamics (SPH) to Molecular Dynamics (MD), Discrete Element Methods (DEM), Vortex Methods, stencil codes, high-dimensional Monte Carlo sampling (CMA-ES), and Reaction-Diffusion solvers, comparing it to the current state of the art and existing software frameworks., 32 pages, 12 figures

In the paper we describe a system for retrieving images by their features. The software components are built around a multi-layer architecture. We propose also an idea of finding similar images by the CEDD descriptor andvector similarity. We test the proposed method on the Pascal VOC dataset. We published the sources of the system in a public repository.

Automatic software build infrastructure has advanced significantly with software build tools such as EasyBuild and Spack. Similarly, scientific container tools such as Singularity have greatly eased the burden of maintaining individual software components at research computing centers. Typically, most research computing sites use tools such as Environment Modules or Lmod to present entire software hierarchies to users. These tools are designed to better serve individual sites or specific toolchains. Our aim is to complement these preexisting build tools by inverting the concept of site-specific software collections to serve multiple institutions. This shared framework relies on both Lmod and Singularity to allow individual sites to seamlessly deploy predefined collections of software components which can be further tailored to their needs.Maryland Advanced Research Computing Center (MARCC) at Johns Hopkins University, ResearchIT at Iowa State University, Ohio Super-computer Center, and the Partnership for an Advanced Computing Environment (PACE) at Georgia Tech have deployed an extendable framework based on Singularity and Lmod to enable "Community Collections" (CC), a software framework that allows multiple institutions to customize the deployment of Singularity software images as a module. This deployment allows for multiple institutions to trivially extend their existing Lmod-based software stacks and participate in a greater effort to reduce software deployment redundancy and to allow for re-duplication of software stacks in cloud environments. Most importantly, Community Collections constitutes an open source conversation to encourage HPC management centers to collaborate by sharing collections of software they build for their users.These efforts are centered around deployment that allows users and systems administrators to leverage shared Singularity containers. The tool facilitates the sharing of modulefiles and their interface to corresponding containers consisting of single-node, shared memory, GPU/CPU-based software. Future extensions to this tool may include regression testing workflows with CC across multiple HPC sites and the distribution of Singularity images as object stores inside the NSF-funded Open Storage Network.

Today’s requirements and challenges on production systems have led to an increasing importance of flexible assembly processes. At the same time, arising technologies in the context of Industry 4.0 offer the opportunity to tap previously unknown potentials. These provide both opportunities and risks for the most flexible and important resource in the production: the workers. Within the EU research project A4BLUE, Smart Workplaces are developed in order to raise productivity and quality, while sustaining and enhancing worker satisfaction. Enabled through both a software framework for adaptation management and contextual worker assistance as well as hardware solutions (e.g. automation mechanisms such as smart tools or co-operative robots) for physical support, the workplaces adapt to the workers’ specific characteristics considering both process and environmental variability. The presented research work provides an overview about the Frameworks’ software components and the application to a use case at the RWTH Aachen University.

Ontological context model that can be instantiated for the software domain.Context that supports information sharing and reuse among tools within the software domain.Application examples for the use of the context model in the software domain.Evaluation of the model to illustrate the applicability for mentor assignment. Recent years have witnessed rapid advances in the use of contextual information in ubiquitous and ambient computing. Such information improves situated cognition and awareness as well as stakeholders' usage experience. While domains such as Web 3.0 - the next generation of the web - have made context-awareness a main requirement of their solution space, the software engineering domain still lacks the same rate of adoption. In our research, we introduce an ontology based context-aware meta-model that takes advantage of Semantic Web technologies to capture and formalize context information. Providing such formal context representation allows us to make context information an integrated and reusable part of the software engineering domain. We present several case studies related to the software evolution domain to illustrate the benefit of sharing and reusing context for various software engineering tasks, such as mentor recommendation, code search, and result ranking.

One of the biggest obstacles to software reuse is the cost involved in evaluating the suitability of possible reusable components. In recent years, code search engines have made significant progress in establishing the semantic suitability of components for new usage scenarios, but the problem of ranking components according to their non-functional suitability has largely been neglected. The main difficulty is that a component's non-functional suitability for a specific reuse scenario is usually influenced by multiple, "soft" criteria, but the relative weighting of metrics for these criteria is rarely known quantitatively. What is required, therefore, is an effective and reliable strategy for ranking software components based on their non-functional properties without requiring users to provide quantitative weighting information. In this paper we present a novel approach for achieving this based on the non-dominated sorting of components driven by a specification of the relative importance of non-functional properties as a partial ordering. After describing the ranking algorithm and its implementation in a component search engine, we provide an explorative study of its properties on a sample set of components harvested from Maven Central.

The role of design pattern in the form of software metric and internal code architecture for object-oriented design plays a critical role in software en-gineering in terms of production cost efficiency. This paper discusses about code reusability that is a frequently exercised cost saving methodology in IT produc-tion. After reviewing existing literatures towards study on software metrics, we found that very few studies are witnessed to incline towards code reusability. Hence, we developed a simple analytical model that establishes relationship between the design components of standard software metric and code reusability using case studies of three software projects (Customer Relationship Management project, Supply Chain Management project, and Enterprise Relationship Management project). We also testify our proposal using stochastic based Markov model to find that proposed system can extract significant information of maximized values of code reusability with increasing level of uncertainties of software project methodologies.

Next generation cloud systems will require a paradigm shift in how they are constructed and managed. Conventional control and management platforms are facing considerable challenges regarding flexibility, dependability and security that next generation systems must handle. The cloud computing technology has already contributed in alleviating a number of the problems associated with resource allocation, utilization and management. However, many of the elements of a well-designed cloud environment remain "stiff" and hard to modify and adapt in an integrated fashion. This includes the underlying networking topologies, many aspects of the user control over IaaS, PaaS or SaaS layers, construction of XaaS services, provenance and meta-data collection, to mention but few. In many situations the problem may be due to inadequacy of service abstraction. Software Defined Systems (SDSys) is a concept that help abstract the actual hardware at different layers with software components; one classical example of this abstractions are hypervisors. Such abstraction provides an opportunity for system administrators to construct and manage their systems, more easily, through flexible software layers. SDSys is an umbrella for different software defined subsystems including Software Defined Networking (SDN), Software Defined Storage (SDStorage), Software Defined Servers (Virtualization), Software Defined Data Centers (SDDC), Software Defined Security (SDSec) etc. and ultimately Software Defined Clouds (SDCloud). Individual solutions and seamless integration of these different abstractions remains in many respects a challenge. In this paper, the authors introduce Software Defined Cloud (SDCloud), a novel software defined cloud management framework that integrates different software defined cloud components to handle complexities associated with cloud computing systems. The first part of paper presents, for the first time, an extensive state of the art critical review of different components of software defined systems, constructing the proposed SDCloud. The second part of the paper proposes the novel concept of SDCloud, which is implemented and evaluated for its feasibility, flexibility and potential superiority. A comprehensive survey for Software Defined Systems.Proposing a novel framework for Software Defined Cloud.Integrating different Software Defined Systems components in one platform.Validate applicability of the proposed model using simulation.

Owing to the extreme parallelism and the high component failure rates of tomorrow's exascale, high-performance computing (HPC) system software will need to be scalable, failure-resistant, and adaptive for sustained system operation and full system utilizations. Many of the existing HPC system software are still designed around a centralized server paradigm and hence are susceptible to scaling issues and single points of failure. In this article, we explore the design tradeoffs for scalable system software at extreme scales. We propose a general system software taxonomy by deconstructing common HPC system software into their basic components. The taxonomy helps us reason about system software as follows: (1) it gives us a systematic way to architect scalable system software by decomposing them into their basic components; (2) it allows us to categorize system software based on the features of these components, and finally (3) it suggests the configuration space to consider for design evaluation via simulations or real implementations. Further, we evaluate different design choices of a representative system software, i.e. key-value store, through simulations up to millions of nodes. Finally, we show evaluation results of two distributed system software, Slurm++ (a distributed HPC resource manager) and MATRIX (a distributed task execution framework), both developed based on insights from this work. We envision that the results in this article help to lay the foundations of developing next-generation HPC system software for extreme scales.

Examines initiatives to get the most out of programming and software applications by selecting the most appropriate platform and software architecture.

This paper presents a documentation and development method to facilitate the certification of scientific computing software used in the safety analysis of nuclear facilities. To study the problems faced during quality assurance and certification activities, a case study was performed on legacy software used for thermal analysis of a fuelpin in a nuclear reactor. Although no errors were uncovered in the code, 27 issues of incompleteness and inconsistency were found with the documentation. This work proposes that software documentation follow a rational process, which includes a software requirements specification following a template that is reusable, maintainable, and understandable. To develop the design and implementation, this paper suggests literate programming as an alternative to traditional structured programming. Literate programming allows for documenting of numerical algorithms and code together in what is termed the literate programmer's manual. This manual is developed with explicit traceability to the software requirements specification. The traceability between the theory, numerical algorithms, and implementation facilitates achieving completeness and consistency, as well as simplifies the process of verification and the associated certification.

Nine rising stars in software engineering describe how software engineering research will evolve, highlighting emerging opportunities and groundbreaking solutions. They predict the rise of end-user programming, the monitoring of developers through neuroimaging and biometrics sensors, analysis of data from unstructured documents, the mining of mobile marketplaces, and changes to how we create and release software.

In this paper, several problems functioning as the obstacles against software reuse were summarized. Among them, the issues dealt with in this paper include the effective method for constructing the library, the proper structure of the library, and the efficient retrieval technique. The knowledge-based approach and the information retrieval approach were integrated to construct and manage the library. The former is on the objectoriented model. Basically the object-oriented library is based on the classes and organized by inheritance. Because inheritance hierarchy is based on syntactical information, it dose not present the relationship of functionality. Using the information retrieval approach, the index file which characterizes the component and similarity among the components can be analyzed. Especially, we focused on the reusable library for the object-oriented programming environments.

component" paradigm appeared in response to boundaries of the object approach. It introduced a new method for designing software applications. This method is based on the assembly of prefabricated software entities called components. The Technology of connector is thus proposed to facilitate assembly. We present in this paper a model of multi- views software components for systems based components. A multi-views software component allows each user to manipulate a system with a vision own to its needs. The assembly of the components in this model is implemented by a new type of connector named visibility connector. Keywordscomponent, Assembly, Viewpoint, Visibility connector.

Software Product Lines and Component-based systems can be combined to maximize reuse in a predictable and opportunistic manner. When a product line is built for a certain subdomain within a more generic domain, future needs from a closely subdomain may be fulfilled by mining the line's internal components to build a new product line. In this work, we present an approach to classify internal and external (third party) reusable components into a repository, by applying a K-Nearest Neighbors strategy, as a support for building new product lines. Natural language techniques and the WordNet lexical database is also used to process information from software components. We validate the approach with an experiment based in a dataset of external third-party components and reusable components from a product line that we built in the geographic subdomain of marine ecology.

The Uintah software framework for the solution of a broad class of fluid-structure interaction problems has been developed by using a problem-driven approach that dates back to its inception. Uintah uses a layered task-graph approach that decouples the problem specification as a set of tasks from the adaptive runtime system that executes these tasks. Using this approach, it is possible to improve the performance of the software components to enable the solution of broad classes of problems as well as the driving problem itself. This process is illustrated by a motivating problem: the computational modeling of the hazards posed by thousands of explosive devices during a deflagration-to-detonation transition that occurred on Highway 6 in Utah. In order to solve this complex fluid-structure interaction problem at the required scale, substantial algorithmic and data structure improvements were needed to Uintah. These improvements enabled scalable runs for the target problem and provided the capability to mode...

The development of appropriate water management strategies requires, in part, a methodology for quantifying and evaluating the impact of water policy decisions on regional stakeholders. In this work, we describe the framework we are developing to enhance the body of resources available to policy makers, farmers, and other community members in their e orts to understand, quantify, and assess the often competing objectives water consumers have with respect to usage. The foundation for the framework is the construction of a simulation-based optimization software tool using two existing software packages. In particular, we couple a robust optimization software suite (DAKOTA) with the USGS MF-OWHM water management simulation tool to provide a flexible software environment that will enable the evaluation of one or multiple (possibly competing) user-defined (or stakeholder) objectives. We introduce the individual software components and outline the communication strategy we defined for the coupled development. We present numerical results for case studies related to crop portfolio management with several defined objectives. The objectives are not optimally satisfied for any single user class, demonstrating the capability of the software tool to aid in the evaluation of a variety of competing interests.

Software development considered to be an important part of software industry. Various metrics, algorithms and reusable process models has been designed but ultimately our main goal is only to find that part which will help us to select the optimal one which may be a metric, algorithm or a reusable software process model. For the various large applications some components need to be built separately and some of the components need to be modified according to the requirement for searching the optimal components. Now a day's component based software engineering considered to be the best approach for the software development at low cost and this software development best approach will totally dependent on the optimal selection of components. The aim of this paper is to describe the characteristics of some selected state of art CBSD models and a new reusable software process model has been designed for the optimal selection of components based on the new optimal algorithm.

This paper presents the technology of constructing and linearization of binary program utilized for program generation, analysis and transformation into a self-modifying code. An example model of the self-modifying software system and its experimental application in vehicle control have been presented in this paper. The module responsible for vehicle control comprising two subsystems has been created within the simulation software. The first subsystem has emerged through the classical software process developed by a human-programmer. The second subsystem has been created as a result of a separate piece of software substituting the part of a programmer in a software process part. The result of this approach is software creation in conjunction with natural and Artificial Intel- ligence in addition to experimental integration into the vehicle control system.

A method to measure the weights of nodes and edges of software-based complex network.Forty open-source software systems were chosen to evaluate the proposed technique.Common statistical patterns from the software systems can be identified easily.When compared based on maintenance efforts, their patterns are more distinctive.The proposed method allows software maintainers to identify fault prone classes. Modeling software systems using complex networks can be an effective technique for analyzing the complexity of software systems. To enhance the technique, the structure of a complex network can be extended by assigning a weight to the edges of the complex network to denote the strength of communicational cohesion between a pair of related software components. This paper proposes an approach to represent an object-oriented software system using a weighted complex network in order to capture its structural characteristics, with respect to its maintainability and reliability. Nodes and edges are modeled based on the complexities of classes and their dependencies. Graph theory metrics are applied onto the transformed network with the purpose to evaluate the software system. Comparative analysis is performed using 40 object-oriented software systems, with different levels of maintenance effort. We found that common statistical patterns from the software systems can be identified easily. It is when these software systems are grouped and compared based on their levels of maintenance effort that their statistical patterns are more distinguishable to represent some common behavior and structural complexity of object-oriented software. The evaluations indicate that the proposed approach is capable of identifying software components that violate common software design principles.

Computer simulation is used for many purposes and is one of the first applications of computer programming. Given this long history and the many intended use of the simulation software written so far, writing about simulation software architectures without an additional strong point of focus would certainly turn into a challenging and endless exercise. In this chapter, our additional point of focus is placed on reuse. In general purpose software engineering (as opposed to simulation software engi- neering), the motivations for reuse have long been advocated and dem- onstrated: lower risks of defects, collective support of potentially larger user community, lower development costs, and so on. In simulation soft- ware architectures, we can also cite business-specific motivations, such as providing a better reproducibility of simulation experiments, or avoiding a complex validation process. In practice, although it is rarely discussed, reuse is a problem that may be considered in two opposite directions: reus- ing and being reused. Accordingly, this chapter is divided into two parts, each geared at one of these two directions. This dichotomy also reflects the dual nature of modeling & simulation (MS the second part is rather intended for experienced simu- lation software developers, that look for ideas and techniques to further improve the design of their more mature simulation software.

As result of improved computing and communication capabilities, the use of sensors and sensor networks for environmental monitoring has gained considerable importance in the recent years. For an interoperable integration of sensor data like sensor descriptions, sensor measurements and alarm events, the Open Geospatial Consortium (OGC) started the Sensor Web Enablement (SWE) initiative and proposed several specifications in respect to a geospatial sensor web. First implementations of SWE software frameworks are available. In this paper, we present the results of the recent WEBBOS project. Its objective was to build up a system for early flood warnings by measuring soil moisture profiles. The use of soil moisture profiles is motivated by the fact that traditional approaches like the observation of water gauges are suitable for the prediction of large-river flooding but not for smaller drainage areas. We describe the architecture of our system and how it is built up by using existing software components to a large extent. Our special focus is on the incorporation of 3D soil moisture profiles into the SWE data model, on the integration of the new OGC Sensor Event Service, and on the development of a flexible web client for mapping and other visualization purposes.

Electromagnetic tracking (EMT) is a core platform technology in the navigation and visualisation of image-guided procedures. The technology provides high tracking accuracy in non-line-of-sight environments, allowing instrument navigation in locations where optical tracking is not feasible. Integration of EMT in complex procedures, often coupled with multi-modal imaging, is on the rise, yet the lack of exibility in the available hardware platforms has been noted by many researchers and system designers. Advances in the field of EMT include novel methods of improving tracking system accuracy, precision and error compensation capabilities, though such system-level improvements cannot be readily incorporated in current therapy applications due to the `blackbox' nature of commercial tracking solving algorithms. This paper defines a software framework to allow novel EMT designs and improvements become part of the global design process for image-guided interventions. In an effort to standardise EMT development, we define a generalised cross-platform software framework in terms of the four system functions common to all EMT systems; acquisition, filtering, modelling and solving. The interfaces between each software component are defined in terms of their input and output data structures. An exemplary framework is implemented in the Python programming language and demonstrated with the open-source Anser EMT system. Performance metrics are gathered from both Matlab and Python implementations of Anser EMT considering the host operating system, hardware configuration and acquisition settings used. Results show indicative system latencies of 5 ms can be achieved using the framework on a Windows operating system, with decreased system performance observed on UNIX-like platforms., Comment: 8 pages, Accepted to MICCAI 2018

The problem of distributed storing and processing of streaming data in IoT systems is considered. A mathematical model and agent-based software architecture for distributed streaming data processing over heterogeneous computer network is offered. The software architecture determines the following features of IoT nodes software: structure of software components, models of interoperability, algorithms of resource management and also xml-based language which allows to descript distributed IoT applications. The offered architecture is implemented as a software framework ABSynth.

A component model enabling to construct new software components from existing ones dynamically, at runtime, without their bytecodes generation is presented with supporting it software framework. The framework is implemented using JavaBeans component model, but is aimed to eliminate its drawback – the inability to create user-defined components without bytecodes generation. To construct user-defined component dynamically, a composed prototype object is built using predefined (hardcoded and/or composed) component instances; that prototype object can provide functionality required and can be transformed at runtime into a new component (instantiable type) whose instances are able to provide the same functionality, but more efficiently. The prototype object is composed using meta-components – the framework provided components to produce user-defined components dynamically.

Why scientists in risk-averse application domains are not "end-user programmers".Characteristics of scientists who develop software in risk-averse domains.Presentation of knowledge acquisition software development model.Why traditional development methodologies hamper development of scientific software.Observations of how scientists develop software outside methods. This paper presents a model of software development based on knowledge acquisition. The model was formulated from 10 years of studies of scientific software and scientists who develop software as part of their science. The model is used to examine assumptions behind software development models commonly described in software engineering literature, and compare these with the observed way scientists develop software. This paper also explains why a particular type of scientist, one who works in a highly risk-averse application domain, does not conform to the common characterization of all scientists as "end-user programmers". We offer observations of how this type of scientist develops trustworthy software. We observe that these scientists work outside the ubiquitous method-based software development paradigms, using instead a knowledge acquisition-based approach to software development. We also observe that the scientist is an integral part of the software system and cannot be excluded from its consideration. We suggest that use of the knowledge acquisition software development model requires research into how to support acquisition of knowledge while developing software, how to satisfy oversight in regulated application domains, and how to successfully manage a scientific group using this model.

Unexpected responses to a study questionnaire led to the realization that the context in which software is being used is extremely important. One particular thing to keep in mind is the software's operating range; that is, the conditions in which the software works best.

Adaptivity is the capacity of software to adjust itself to changes in its environment. A common approach to achieving adaptivity is to introduce dedicated code during software development stage. However, since those code fragments are designed a priori, self-adaptive software cannot handle situations adequately when the contextual changes go beyond those that are originally anticipated. In this case, the original builtin adaptivity should be tuned. For example, new code should be added to provide the capacity to sense the unexpected environment or to replace outdated adaptation decision logic. The technical challenges in this process, especially that of tuning software adaptivity at runtime, cannot be understated. In this paper, we propose an architecture-centric application framework for self-adaptive software named Auxo. Similar to existing work, our framework supports the development and running of self-adaptive software. Furthermore, our framework supports the tuning of software adaptivity without requiring the running self-adaptive software to be terminated. In short, the architecture style that we are introducing can encapsulate not only general functional logic but also the concerns in the self-adaptation loop (such as sensing, decision, and execution) as architecture elements. As a result, a third party, potentially the operator or an augmented software entity equipped with explicit domain knowledge, is able to dynamically and flexibly adjust the self-adaptation concerns through modifying the runtime software architecture. To truly exercise, validate, and evaluate our approach, we describe a self-adaptive application that was deployed on the framework, and conducted several experiments involving self-adaptation and the online tuning of software adaptivity.

Summary Three persistent common problems in satellite ground control software are obsolescence, lack of desired features and flexibilities, and endless software bug fixing. The obsolescence problem occurs when computer and ground equipment hardware become obsolete, usually after only one-third into the satellite mission lifetime. The software needs to be updated to accommodate changes on the hardware side, requiring significant work of satellite operators to test, verify, and validate these software updates. Trying to help solve these problems, we have proposed an object-process methodology model and guidelines for developing satellite ground control software. The system makes use of a database-driven application and concepts of object-process orientation and modularity. In the new proposed framework, instead of coding each software function separately, the common base functions will be coded, and combining them in various ways will provide the different required functions. The formation and combination of these base functions will be governed by the main code, definitions, and database parameters. These design principles will make sure that the new software framework would provide satellite operators with the flexibility to create new features and enable software developer to find bugs quicker and fix them more effectively. Copyright © 2015 John Wiley & Sons, Ltd.

The internet of things (IoT) represent the current and future state of the Internet. The large number of things (objects), which are connected to the Internet, produce a huge amount of data that needs a lot of effort and processing operations to transfer it to useful information. Moreover, the organization and control of this large volume of data requires novel ideas in the design and management of the IoT network to accelerate and enhance its performance. The software defined systems is a new paradigm that appeared recently to hide all complexity in traditional system architecture by abstracting all the controls and management operations from the underling devices (things in the IoT) and setting them inside a middleware layer, a software layer. In this work, a comprehensive software defined based framework model is proposed to simplify the IoT management process and provide a vital solution for the challenges in the traditional IoT architecture to forward, store, and secure the produced data from the IoT objects by integrating the software defined network, software defined storage, and software defined security into one software defined based control model.

A ranking based EA for the discovery of software architectures is proposed.An expert-oriented model based on a comprehensible encoding and genetic operator.A complete experimental analysis of the algorithm setup is carried out. Software architectures constitute important analysis artefacts in software projects, as they reflect the main functional blocks of the software. They provide high-level analysis artefacts that are useful when architects need to analyse the structure of working systems. Normally, they do this process manually, supported by their prior experiences. Even so, the task can be very tedious when the actual design is unclear due to continuous uncontrolled modifications. Since the recent appearance of search based software engineering, multiple tasks in the area of software engineering have been formulated as complex search and optimisation problems, where evolutionary computation has found a new area of application. This paper explores the design of an evolutionary algorithm (EA) for the discovery of the underlying architecture of software systems. Important efforts have been directed towards the creation of a generic and human-oriented process. Hence, the selection of a comprehensible encoding, a fitness function inspired by accurate software design metrics, and a genetic operator simulating architectural transformations all represent important characteristics of the proposed approach. Finally, a complete parameter study and experimentation have been performed using real software systems, looking for a generic evolutionary approach to help software engineers towards their decision making process.