Hasil untuk "cs.SE"

Zahra Yazdanparast

With the increasing complexity of software systems, it becomes very difficult to install, configure, adjust, and maintain them. As systems become more interconnected and diverse, system architects are less able to predict and design the interaction between components, deferring the handling of these issues to runtime. One of the important problems that occur during execution is system failures, which increase the need for self-healing systems. The main purpose of self-healing is to have an automatic system that can heal itself without human intervention. This system has predefined actions and procedures that are suitable for recovering the system from different failure modes. In this study, different self-healing methods are categorized and a summary of them is presented.

Thalia S. Santana, Taciana N. Kudo, Renato F. Bulcão-Neto

The activities of requirements engineering and software testing are intrinsically related to each other, as these two areas are linked when seeking to specify and also ensure the expectations of a software product, with quality and on time. This systematic mapping study aims to verify how requirements and testing are being addressed together in the educational context.

Mark Reid, James Montgomery, Barry Drake et al.

This document presents the draft specification for delivering machine learning services over HTTP, developed as part of the Protocols and Structures for Inference project, which concluded in 2013. It presents the motivation for providing machine learning as a service, followed by a description of the essential and optional components of such a service.

Akanksha Gupta

Introduction of DevOps into the software development life cycle represents a cultural shift in the IT culture, amalgamating development and operations to improve delivery speed in a rapid and maintainable manner. At the same time, security threats and breaches are expected to grow as more enterprises move to new agile frameworks for rapid product delivery. Meanwhile, DevSecOps is a mindset change that revolutionizes software development by embedding security at each step of the software cycle, leading to resilient software. This paper discusses a framework organization can use to embed DevSecOps swiftly and efficiently into the general IT culture.

Matt Pope, Jonathan Sillito

It is essential that software systems be tolerant to degradations in components they rely on. There are patterns and techniques which software engineers use to ensure their systems gracefully degrade. Despite these techniques being available in practice, tuning and configuration is hard to get right and it is expensive to explore possible changes to components and techniques in complex systems. To fill these gaps, we propose Quartermaster to model and simulate systems and fault-tolerant techniques. We anticipate that Quartermaster will be useful to further research on graceful degradation and help inform software engineers about techniques that are most appropriate for their use cases.

Guillaume Melquiond

An invaluable feature of computer algebra systems is their ability to plot the graph of functions. Unfortunately, when one is trying to design a library of mathematical functions, this feature often falls short, producing incorrect and potentially misleading plots, due to accuracy issues inherent to this use case. This paper investigates what it means for a plot to be correct and how to formally verify this property. The Coq proof assistant is then turned into a tool for plotting function graphs using reliable polynomial approximations. This feature is provided as part of the CoqInterval library.

Manuel Mazzara, Antonio Bucchiarone, Nicola Dragoni et al.

In this chapter we offer an overview of microservices providing the introductory information that a reader should know before continuing reading this book. We introduce the idea of microservices and we discuss some of the current research challenges and real-life software applications where the microservice paradigm play a key role. We have identified a set of areas where both researcher and developer can propose new ideas and technical solutions.

Christian Dehnert, Sebastian Junges, Joost-Pieter Katoen et al.

We launch the new probabilistic model checker storm. It features the analysis of discrete- and continuous-time variants of both Markov chains and MDPs. It supports the PRISM and JANI modeling languages, probabilistic programs, dynamic fault trees and generalized stochastic Petri nets. It has a modular set-up in which solvers and symbolic engines can easily be exchanged. It offers a Python API for rapid prototyping by encapsulating storm's fast and scalable algorithms. Experiments on a variety of benchmarks show its competitive performance.

Nuno Macedo, Alcino Cunha

Alloy and TLA+ are two formal specification languages that are increasingly popular due to their simplicity and flexibility, as well as the effectiveness of their companion model checkers, the Alloy Analyzer and TLC, respectively. Nonetheless, while TLA+ focuses on temporal properties, Alloy is better suited to handle structural properties, requiring ad hoc mechanisms to reason about temporal properties. Thus, both have limitations in the specification and analysis of systems rich in both static and dynamic properties. This paper explores the pros and cons of these two frameworks when handling this class of systems through the step-by-step modeling, specification and verification of an example.

Tony Clark

Domain Specific Languages are used to provide a tailored modelling notation for a specific application domain. There are currently two main approaches to DSLs: standard notations that are tailored by adding simple properties; new notations that are designed from scratch. There are problems with both of these approaches which can be addressed by providing access to a small meta-language based on packages and classes. A meta-modelling approach based on meta-packages allows a wide range of DSLs to be defined in a standard way. The DSLs can be processed using standard object-based extension at the meta-level and existing tooling can easily be defined to adapt to the new languages. This paper introduces the concept of meta-packages and provides a simple example.

Jehad Al Dallal

Improving modularity and reusability are two key objectives in object-oriented programming. These objectives are achieved by applying several key concepts, such as data encapsulation and inheritance. A class in an object-oriented system is the basic unit of design. Assessing the quality of an object-oriented class may require flattening the class and representing it as it really is, including all accessible inherited class members. Thus, class flattening helps in exploring the impact of inheritance on improving code quality. This paper explains how to flatten Java classes and discusses the relationship between class flattening and some applications of interest to software practitioners, such as refactoring and indicating external quality attributes.

Sami Alajrami

The cloud computing paradigm is being adopted by many organizations in different application domains as it is cost effective and offers a virtually unlimited pool of resources. Engineering critical systems can benefit from clouds in attaining all dependability means: fault tolerance, fault prevention, fault removal and fault forecasting. Our research aims to investigate the potential of supporting engineering of dependable software systems with cloud computing and proposes an open, extensible, and elastic cloud-based software engineering workflow system which represents and executes software processes to improve collaboration, reliability and quality assurance, and automation in software projects.

Alison Talbot, Andy M. Connor

This paper presents research on current industry practices with respect to requirements engineering as implemented within software development companies in New Zealand. A survey instrument is designed and deployed. The results are analysed and compared against what is internationally considered "best practice" and previous New Zealand and Australian studies. An attempt is made to assess the requirements engineering capability of New Zealand companies using both formal and informal frameworks.

Hans Grönninger, Bernhard Rumpe

A systematic way of defining variants of a modeling language is useful for adopting the language to domain or project specific needs. Variants can be obtained by adopting the syntax or semantics of the language. In this paper, we take a formal approach to define modeling language variability and show how this helps to reason about language variants, models, and their semantics formally. We introduce the notion of semantic language refinement meaning that one semantics variant is implied by another.

Bernhard Rumpe, Astrid Schröder

In recent years the Extreme Programming (XP) community has grown substantially. Many XP projects have started and a substantial amount are already finished. As the interest in the XP approach is constantly increasing worldwide throughout all software intensive application domains, it was time to start a first survey on XP. This paper presents the results of 45 evaluated questionnaires that have been received during the Summer 2001 survey.

Bernhard Rumpe

This paper discusses a model-based approach to software development. It argues that an approach using models as central development artifact needs to be added to the portfolio of software engineering techniques, to further increase efficiency and flexibility of the development as well as quality and reusability of the results. Two major and strongly related techniques are identified and discussed: Test case modeling and an evolutionary approach to model transformation.

Christian Colombo, Adrian Francalanza, Ian Grima

Contract conformance is hard to determine statically, prior to the deployment of large pieces of software. A scalable alternative is to monitor for contract violations post-deployment: once a violation is detected, the trace characterising the offending execution is analysed to pinpoint the source of the offence. A major drawback with this technique is that, often, contract violations take time to surface, resulting in long traces that are hard to analyse. This paper proposes a methodology together with an accompanying tool for simplifying traces and assisting contract-violation debugging.

Laura Bocchi, José Fiadeiro, Noor Rajper et al.

This paper provides an outline of a formal approach that we are developing for modelling Virtual Organisations (VOs) and their Breeding Environments (VBEs). We propose different levels of representation for the functional structures and processes that VBEs and VOs involve, which are independent of the specificities of the infrastructures (organisational and technical) that support the functioning of VBEs. This allows us to reason about properties of tasks performed within VBEs and services provided through VOs without committing to the way in which they are implemented.

Ivan Jureta, John Mylopoulos, Stephane Faulkner

A requirements engineering artifact is valid relative to the stakeholders of the system-to-be if they agree on the content of that artifact. Checking relative validity involves a discussion between the stakeholders and the requirements engineer. This paper proposes (i) a language for the representation of information exchanged in a discussion about the relative validity of an artifact; (ii) the acceptability condition, which, when it verifies in a discussion captured in the proposed language, signals that the relative validity holds for the discussed artifact and for the participants in the discussion; and (iii) reasoning procedures to automatically check the acceptability condition in a discussions captured by the proposed language.

B. Diertens

In previous work we described how the process algebra based language PSF can be used in software engineering, using the ToolBus, a coordination architecture also based on process algebra, as implementation model. We also described this software development process more formally by presenting the tools we use in this process in a CASE setting, leading to the PSF-ToolBus software engineering environment. In this article we summarize that work and describe a similar software development process for implementation of software systems using a client / server model and present this in a CASE setting as well.