Structural Coverage Analysis Methods

Structural coverage analysis for any code is a very common approach to measure the quality of any test suit. Structural coverage determines which structure of the software or which portion is not exercised. This chapter describes two different phases to achieve structural coverage analysis using DO-178B/C standards. Statement coverage is the very basic coverage criteria which involves execution of all the executable statements in the source code at least once. Analysis of structural coverage can be done by capturing the amount of code that is covered by the airborne software. The first phase contains the instrumentation procedure which instruments the source code at execution time, and the second phase is generating a report that specifies which portion of source code is executed and which one is not in the form of a percentage.

White-Box Testing Automation With SonarQube

Modern work patterns like continuous integration (CI) have an implicit need for testing automation. In current CI solutions, white-box testing is left to the work methodology, typically addressed after code reviews. Code security inspection is often done in specific code reviews focusing on security. SonarQube is a tool that, to a certain extent, can automate white-box design and testing and serve as a guide for formal code reviews. Moreover, this tool can help audit the code for potential security issues. Most web programming today uses components readily available and transparently managed by package managers, like npm for Node.js or Composer for PHP. This use must also be audited at least for potential security problems; yet traditional white-box test design would require a good understanding of the vendor code, which can be difficult/impractical to achieve. This chapter will address SonarQube as a valuable tool to automate white-box and security testing and also provide suggestions on how to manage your vendor branches when there is a need to audit/change the vendor source code.

Dynamic Generation of Documentation, Code, and Tests for a Digital Marketing Platform's API

Detailed documentation and software tests are key factors for the success of a web application programming interface (API). When designing an API, especially in a design first approach, it is relevant to define a formal contract, known as API specification. This document must contain all necessary information regarding the API behavior. Thereby, the specification can be used to dynamically generate API components like documentation, client and server code, and software tests, reducing development and maintenance costs. This chapter presents a study of OpenAPI specification and its application on designing a new RESTful API for E-goi. It also presents a set of solutions for generating documentation, client code libraries, and test cases.

RESTful Web Services Development With a Model-Driven Engineering Approach

A RESTful web service implementation requires following the constrains inherent to REST architectural style, which, being a non-trivial task, often leads to solutions that do not fulfill those requirements properly. Model-driven techniques have been proposed to improve the development of complex applications. In model-driven software development, software is not implemented manually based on informal descriptions but partially or completely generated from formal models derived from metamodels. A model-driven approach, materialized in a domain specific language that integrates the OpenAPI specification, an emerging standard for describing REST services, allows developers to use a design first approach in the web service development process, focusing in the definition of resources and their relationships, leaving the repetitive code production process to the automation provided by model-driven engineering techniques. The code generation process covers the entire web-service flow from the description and exposure of the endpoints to the definition of database tables.

Teaching Model-Driven Engineering in a Master's Program

Model-driven engineering (MDE) is an approach to software engineering that adopts models as the central artefact. Although the approach is promising in addressing major issues in software development, particularly in dealing with software complexity, and there are several success cases in the industry as well as growing interest in the research community, it seems that it has been hard to generalize its gains among software professionals. To address this issue, MDE must be taught at a higher-education level. This chapter presents a three-year experience in teaching MDE in a course of a master program in informatics engineering. The chapter provides details on how a project-based learning approach was adopted and evolved along three editions of the course. Results of a student survey are discussed and compared to those from another course. In addition, several other similar teaching experiences are analyzed.

Tools for the Learning of Programming Languages and Paradigms

The learning of programming languages and paradigms is complex and requires a lot of training. For this reason, it is very important to detect students' main problems and needs to be able to provide professors with tools that help students to overcome those problems and difficulties. One type of tool that can be used for this purpose is the code validator. This chapter explores the possibilities and impact of using different tools and strategies for learning programming languages and paradigms. To achieve this goal, the authors have conducted a comprehensive search of relevant scientific literature that has been complemented with their experience using a JavaScript code validator and exercises module integrated into the e-learning platform Moodle, with university students during a web programming course.

Operator Overloading as a DSL Parsing Mechanism

This chapter describes an approach for the implementation of embedded domain-specific languages by using operator overloads and the creation of abstract syntax trees in run-time. Using the host language parser, an AST is created stating the structure of the DSL expression that is later analyzed, simplified, and optimized before the evaluation step. For the illustration of this process, the chapter proposes a domain-specific language for a basic linear algebra system dealing with matrices algebra and its optimization.

Evaluating the Refactoring Index Using Entropy Approach

Software often carries the structural deficiencies that make it hard to understand, change, or test; these deficiencies are categorized as a code smell. This code smell affects the performance of software adversely, thereby increase need of maintainability. Refactoring of code helps in reducing the code smell. But refactoring is an expensive process and hence identifies which and how much code need to refactor a challenging task and is termed as refactoring index. In this chapter, entropy approach is proposed to measure the refactoring index of 20 open source software programs. Refactoring index level is given to identify the critical project which urgently required refactoring in order to improve the quality of the project.

A Survey on Computer Programming Learning Environments

We are assisting the rise of online coding environments as a strategy to promote youth tech employment. With the growing importance of the technology sector, these type of technical training programs give learners emergent tech skills with a big impact and relevance to the current professional market needs. In this realm, MOOCs (massive open online courses) and online coding bootcamps are two increasingly popular options for learners to improve their code development skills and find work within a relatively short amount of time. Among all the features available on these environments, one stands out, which is the code generation. This chapter aims to detail and compare the most popular solutions for both learning contexts based on several criteria such as impact and maturity, user groups, and tools and features. In the features field, the authors highlight the code generation feature as an efficient way to enhance exercise resolution.