Developing, testing, building and maintaining an Eclipse project based on EMF and Xtext

In the last years there has been a growing interest in agile methods and their integration into the so called “unified” approaches. In the field of Web Engineering, agile approaches such as test-driven development are appealing because of the very nature of Web applications, while model-driven approaches provide a less error-prone code derivation; however the integration of both approaches is not easy. In this paper, we present a method-independent approach to combine the agile, iterative and incremental style of test-driven development with the more formal, transformation-based model-driven Web engineering approaches. We focus not only in the development process but also in the evolution of the application, and show how tests can be transformed together with model refactoring. As a proof of concept we show an illustrative example using WebRatio, the WebML design tool.KeywordsGenerate Test CaseTest TransformationAgile MethodXPath ExpressionNavigation ModelThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Chapter 11 - Test Driven Development

The ScalaDyno compiler plugin allows fast prototyping with the Scala programming language, in a way that combines the benefits of both statically and dynamically typed languages. Static name resolution and type checking prevent partially-correct code from being compiled and executed. Yet, allowing programmers to test critical paths in a program without worrying about the consistency of the entire code base is crucial to fast prototyping and agile development. This is where ScalaDyno comes in: it allows partially-correct programs to be compiled and executed, while shifting compile-time errors to program runtime.The key insight in ScalaDyno is that name and type errors affect limited areas of the code, which can be replaced by instructions to output the respective errors at runtime. This allows byte code generation and execution for partially correct programs, thus allowing Python or JavaScript-like fast prototyping in Scala. This is all done without sacrificing name resolution, full type checking and optimizations for the correct parts of the code -- they are still performed, but without getting in the way of agile development. Finally, for release code or sensitive refactoring, runtime errors can be disabled, thus allowing full static name resolution and type checking typical of the Scala compiler.

In this paper, we follow the Test-Driven Development (TDD) paradigm in the development of an in-house code to allow for the finite element analysis of finite periodic type electromagnetic structures (e.g., antenna arrays, metamaterials, and several relevant electromagnetic problems). We use unit and integration tests, system tests (using the Method of Manufactured Solutions—MMS), and application tests (smoke, performance, and validation tests) to increase the reliability of the code and to shorten its development cycle. We apply substructuring techniques based on the definition of a unit cell to benefit from the repeatability of the problem and speed up the computations. Specifically, we propose an approach to model the problem using only one type of Schur complement which has advantages concerning other substructuring techniques.

Test-Driven Development (TDD) is probably the most important agile engineering practice. Since it was first described in detail in [1], this development practice has been adopted widely. This adoption has been also well supported with tools that provide a framework for defining and executing unit tests on the different development platforms. Test-Driven Development provides a guideline how to develop applications unit by unit, resulting in well-designed, well maintainable quality software. TDD focuses on units and it ensures that the atomic building blocks and their interactions are specified and implemented correctly. There is certainly a need for automating other tests as well in order to ensure a working integration environment, to validate performance or to ensure that the application finally behaves as it was specified by the customer. Usually for automating these non-unit tests, developers (mis-)use the unit test frameworks and the unit test execution tools. This paper investigates the potential problems caused by misusing unit test tools for automated functional tests in cases when these functional tests are defined through the development technique called Acceptance Test Driven Development (ATDD). The misuse of the unit testing tools may have direct impact on the testing efficiency and it may also “close the doors” for features specialized for automated functional tests. Some results of this investigation have been prototyped in a tool called SpecRun, which aims to provide better automated functional testing efficiency.

The design of a Multiprocessor System-on-Chip (MPSoC) is a complex task, including steps as application development, platform configuration, code generation, task mapping onto the platform and debugging. An integrated environment covering most of these steps is a gap in the literature. The present work first details an MPSoC architecture, which supports the execution of distributed applications, including an operating system enabling multitask execution at each processing element. The MPSoC is heterogeneous, due to the support to different processor architectures. Then, a framework able to cover the design steps previously mentioned is presented. The framework enables the design space exploration for applications to be executed in the MPSoC, varying for example the number and type of processors, the memory size, the task mapping. Results demonstrate the correct operation for different MPSoC configurations, generated from the proposed framework. Such open-source framework enables the research community to investigate new subjects related to MPSoC and Network on Chip (NoC) design, as well as evaluate distributed applications in a multiprocessor environment.

This paper introduces B, a mathematically based method and a computer based tool-kit for software engineering. The B-Method provides a notation and a method for the formal specification and design of software. Incremental construction of layered software as well as incremental mathematical verification have been guiding principles in its development. The method uses a ‘pseudo’ programming language Abstract Machine Notation as the language for design as well as for specification within the software process. AMN is based on an extension of Dijkstra’s guarded command language, with built-in structuring mechanisms for the construction of larger systems. The B-Method is explained in The B-Book [Abrial, 1997].The B-Toolkit supports the method over the spectrum of activities from specification through design and implementation into maintenance. The B-Toolkit comprises automatic and interactive theorem-proving assistants, and a set of software development tools: an AMN syntax & type checker, a specification animator and code generators, and promotes an object oriented approach at all stages of development. All tools are integrated into a window-based development environment. The B-Toolkit is developed and sold by B-Core.KeywordsGeneralise SubstitutionProof ObligationAbstract MachineSoftware Development ToolRefinement RelationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

YAJCo is a tool for the development of software languages based on an annotated language model. The model is represented by Java classes with annotations defining its mapping to concrete syntax. This approach to language definition enables the abstract syntax to be central point of the development process, instead of concrete syntax. In this paper a case study of Oberon-0 programming language development is presented. The study is based on the LTDA Tool Challenge and showcases details of abstract and concrete syntax definition using YAJCo, as well as implementation of name resolution, type checking, model transformation and code generation.

Many advances in automatic parallelization and optimization have been achieved through the polyhedral model. It has been extensively shown that this computational model provides convenient abstractions to reason about and apply program transformations. Nevertheless, the complexity of code generation has long been a deterrent for using polyhedral representation in optimizing compilers. First, code generators have a hard time coping with generated code size and control overhead that may spoil theoretical benefits achieved by the transformations. Second, this step is usually time consuming, hampering the integration of the polyhedral framework in production compilers or feedback-directed, iterative optimization schemes. Moreover, current code generation algorithms only cover a restrictive set of possible transformation functions. This paper discusses a general transformation framework able to deal with non-unimodular, non-invertible, non-integral or even non-uniform functions. It presents several improvements to a state-of-the-art code generation algorithm. Two directions are explored: generated code size and code generator efficiency. Experimental evidence proves the ability of the improved method to handle real-life problems. 1.

Untargeted white-box adversarial attack with heuristic defence methods in real-time deep learning based network intrusion detection system

Martian Moons eXploration (MMX) is a joint project of the French, German and Japanese space agencies Centre national d'etudes spatiales (CNES), German Aerospace Center (DLR) and Japan Aerospace Exploration Agency (JAXA) for an exploration mission to the moons of Mars, i.e. Phobos and Deimos. CNES and DLR are providing a rover payload to the mother spacecraft of JAXA which is designated to be the first rover to drive in milli-g-environment. Locomotion in milli-g-environment on potentially hazardous terrain with steep slopes and high sinkage raises increased demands on the locomotion subsystem and control algorithms. The MMX-Rover chassis control algorithms (CCA) are embedded as part of the MMX-Rover locomotion software partition in a three layer architecture between the Command and Control Software and the hardware-related Basic Software. This paper proposes a trajectory-based generic chassis control framework as extended chassis control variant for the MMX-Rover. The rover locomotion possibilities are formulated upon a generic rover motion interface to derive analytical solutions for the specialized MMX-Rover locomotion modes. The resulting algebraic chassis control algorithms (A-CCA) are mathematically formulated in detail. A connection to meta-modelling for kinematic locomotion functions is established. The generic chassis control framework can be used to formulate the onboard control algorithms as minimal application code or generic application code. The decision between the minimal or generic code formulation variant practically influences the control software architecture and implementation. The generic chassis control framework is used as a practical analysis and verification tool to ensure the qualification of a geometrically inspired and kinematically simplified control algorithm variant (G-CCA) as flight software candidate. In particular, the algebraic equations originating from the generic chassis control framework are compared to the geometric control algorithms regarding their functional scope, kinematic formulation and practical software implementation. Results for the analysis and verification of G-CCA are shown and their qualification in terms of the locomotion functional coverage and rover motion behavior discussed. The generic chassis control framework contributes to ensure and enhance the functioning and quality of the control algorithms in the MMX-Rover mission context.

Recent advancements in in situ methods, such as multiplexed in situ RNA hybridization and in situ RNA sequencing, have deepened our understanding of the way biological processes are spatially organized in tissues. Automated image processing and spot-calling algorithms for analyzing in situ transcriptomics images have many parameters which need to be tuned for optimal detection. Having ground truth datasets (images where there is very high confidence on the accuracy of the detected spots) is essential for evaluating these algorithms and tuning their parameters. We present a first-in-kind open-source toolkit and framework for in situ transcriptomics image analysis that incorporates crowdsourced annotations, alongside expert annotations, as a source of ground truth for the analysis of in situ transcriptomics images. The kit includes tools for preparing images for crowdsourcing annotation to optimize crowdsourced workers' ability to annotate these images reliably, performing quality control (QC) on worker annotations, extracting candidate parameters for spot-calling algorithms from sample images, tuning parameters for spot-calling algorithms, and evaluating spot-calling algorithms and worker performance. These tools are wrapped in a modular pipeline with a flexible structure that allows users to take advantage of crowdsourced annotations from any source of their choice. We tested the pipeline using real and synthetic in situ transcriptomics images and annotations from the Amazon Mechanical Turk system obtained via Quanti.us. Using real images from in situ experiments and simulated images produced by one of the tools in the kit, we studied worker sensitivity to spot characteristics and established rules for annotation QC. We explored and demonstrated the use of ground truth generated in this way for validating spot-calling algorithms and tuning their parameters, and confirmed that consensus crowdsourced annotations are a viable substitute for expert-generated ground truth for these purposes.

Formal specifications of software systems are extremely useful because they can be rigorously analyzed, verified, and validated, giving high confidence that the specification captures the desired behavior. To transfer this confidence to the actual source code implementation, a formal link is needed between the specification and the implementation. Generating the implementation directly from the specification provides one such link. A program transformation system such as Paige's APTS can be useful in developing a source code generator. This paper describes a case study in which APTS was used to produce code generators that construct C source code from a requirements specification in the SCR (Software Cost Reduction) tabular notation. In the study, two different code generation strategies were explored. The first strategy uses rewrite rules to transform the parse tree of an SCR specification into a parse tree for the corresponding C code. The second strategy associates a relation with each node of the specification parse tree. Each member of this relation acts as an attribute, holding the C code corresponding to the tree at the associated nodes the root of the tree has the entire C program as its member of the relation. This paper describes the two code generators supported by APTS, how each was used to synthesize code for two example SCR requirements specifications, and what was learned about APTS from these implementations.

ABSTRACTA cursory read of the popular press and the JDM research field suggest that they have very different beliefs regarding the consequences of confidence. And these beliefs have important consequences themselves. For individuals, how one views the consequences of confidence (and whether they are positive or negative) likely influences the extent to which one pursues the development of confidence and how one interprets confidence in others. For JDM researchers, their beliefs about the consequences of confidence inform research programs. For example, a belief that overconfidence leads to inappropriate medical treatments, legal advice, or investments suggests an emphasis on reducing overconfidence rather than on developing confidence. This paper aims to improve understanding of both the general public's and JDM researchers' beliefs about the consequences of confidence in knowledge. We present a general theoretical framework for thinking about the consequences of confidence, followed by two exploratory studies designed to access these beliefs, first with the general public and then with JDM researchers. We used structured, open‐ended questioning to generate a large dataset (over 10,000 responses) of potential consequences of low confidence, high confidence, overconfidence, and underconfidence. Qualitative coding identified a broad set of respondent‐generated beliefs regarding psychological and behavioral consequences, organized into antonym pairs (e.g., arrogant/high self‐image vs. low self‐image). Respondents made few distinctions between low confidence and underconfidence, viewing both negatively. However, the general public drew a sharp distinction between high confidence (described positively) and overconfidence (described negatively), a trend less prevalent among JDM researchers.

Availability was considered a critical factor of Network Function Virtualization(NFV) platforms. And many existing testing tools with fault injection features for NFV, only aim at availability, while now more and more attention have been paid to the performance degradation when failure happens. Moreover, performance data on hardware/software resources, like CPU consumption, memory usage, are required to collect in performance and fault-tolerant testing. To fulfill the requirements above, this paper proposes a service-based testing framework for NFV platform performance evaluation, under workloads and fault loads. By taking advantage of the Microservice Architecture, the proposed framework will integrate some existing open-source testing frameworks, including performance testing tools, fault injection tools, and monitoring tools, and build a more comprehensive testing scenario. A case study is conducted on Clearwater, a widely used open-source NFV application, to validate the efficiency and usability of the proposed framework.