Search

This article provides a current state of certification of safety-critical systems. The article begins with discussing limitations to current certification approaches, unsuccessful previous attempts to modernize certification, and potential areas of improvement in the development of these software-intensive systems and the certification of them. Areas of improvement include an emphasis on safety and incorporation of human factors into both system and software engineering and new hazard analysis methods.

This article details the work done to update a high-performance digital forensics tool, bulk_extractor (BE) to C++17 programming language. The article describes the complex nature of digital forensics and the tools that support it, an overview of BE, and the steps undertaken to update it which included improving the code quality, removing rarely used functionality, and performance tuning.

This article discusses the reuse of research results in the field of software engineering and how it can be quantified to indicate the health of the field overall. Topics include how the authors generated and applied their reuse graphs to published research in software engineering and the value of these graphs. The authors ask the software engineering community to use open source tools and work within the community to share artifacts from published research to allow for reproduction of research results.

This article focuses on misuses of computer technologies and potential remedies. Topics include the misuse of technologies to fix problems that are not exclusively technology-based problems, the misuse of technology for problems with poorly established or poorly administered foundations, and the misuse of compromised technology for questionable business models. Remedies to these misuses are discussed and include research and development in system assurance which would require improved hardware, improved software engineering practices, and increased oversight.

The article discusses various aspects of the use of machine learning (ML) in the software engineering field, and it mentions ML system failures, the basic elements of software engineering, and efforts to construct dependable and safe systems using ML. Machine learning operations (MLOps) techniques and software engineers are mentioned, along with a call for organizations to utilize data pipelines to manage data and protect personally identifiable information.

Cognitive biases are hardwired behaviors that influence developer actions and can set them on an incorrect course of action, necessitating backtracking. Although researchers have found that cognitive biases occur in development tasks in controlled lab studies, we still do not know how these biases affect developers’ everyday behavior. Without such an understanding, development tools and practices remain inadequate. To close this gap, we conducted a two-part field study to examine the extent to which cognitive biases occur, the consequences of these biases on developer behavior, and the practices and tools that developers use to deal with these biases. We found about 70% of observed actions were associated with at least one cognitive bias. Even though developers recognized that biases frequently occur, they are forced to deal with such issues with ad hoc processes and suboptimal tool support. As one participant (IP12) lamented: There is no salvation!. [ABSTRACT FROM AUTHOR]

The article examines the design of software for quantum computing. The application of quantum computing for drug discovery and vaccine development is described along with efforts at European research centers to build ion-trapped and 100-qubit supercomputer and alleged idiosyncrasies associated with testing and debugging quantum software.

The article calls for an emphasis on static analysis in the design of software development tools to detect and prevent anomalies, security risks, and nonfunctional code. Legal ramifications for safeguarding source code are outlined along with the alleged increasing complexity of software engineering and diversity of computer programming languages. The author calls for standardization of software engineering methods and computer architecture along with an increased emphasis on human-computer interaction.

The authors discuss the significance of machine learning (ML) and its applications as built and utilized by humans via a description of their development of the Overton and Ludwig declarative ML systems. It discusses software engineering and ML, technological advances of ML systems, and the unique aspects of declarative ML systems.

The article calls for the combination of human-computer interaction with programming languages. Examples of the alleged utility and benefits of combining the two fields are offered, the combination is contrasted with other fields dealing with human-centered aspects of programming languages including software engineering, the psychology of programming, and computer science education, and alleged misconceptions about programming languages and human-computer interaction are outlined.

The article presents a historical analysis of the development of computer operating systems with a focus on abstractions including processes, kernels, and files. Levels of abstractions are delineated along with their capabilities and an example of computer programming is offered describing the prevention of deadlocks and self-referential code loops.

The author discusses her thoughts about the top ten best working practices for software engineering productivity for software engineers who telecommute. She identifies defining individual productivity goals, establishing a set working routine in a good working environment in at-home offices, and taking personal responsibility for maintaining and improving human interaction. The article also discusses the concepts of empathetic review and self-compassion.

The article calls for computer students' involvement with open source software projects rather than focusing solely on computer programming. The integration of contributing to open source software projects within software engineering courses using a flipped classroom approach is recommended and the author describes the advice given to student contributors.

The article examines India's computer software industry as of November 2019. Topics covered include the economic aspects of the industry, innovations in software engineering, and the need for processes, engineering, and technologies to adapt.

The authors discuss the issue of site reliability engineering (SRE) and its use by Google. They mention the importance of measuring the right aspects of service, the question of studying internet speed from the users' perspective, and the need to accurately forecast future load based on these metrics.

An interview is presented with software developers at Microsoft including Jacek Czerwonka, Michaela Greiler, Christian Bird, Lucas Panjer, and Terry Coatta. They discuss the best practices and company policies developed to improve how Microsoft reviews its computer code in the software development process.

The author presents his thoughts on the need for regulation in the software industry to ensure long-term prosperity. He cites comments from computer programmer Tony Hoare that predicted the need for laws governing computer software to prevent malpractice and security risks.

The article reports on the use of supercomputers in China. It mentions the development of computer systems by Chinese companies, the software developed for the computers to work with artificial intelligence and big data, and the kinds of applications for which the supercomputers are used.

The article discusses the benefits of automating the process of generating demonstration data, which treats the data as code and supports the need for iteration, collaboration and updates. Topics include the use of scripting languages to create ad hoc functions that act like a language, the ability of a repeatable process to help with enabling delegation, and challenges associated with anonymizing data.

The author presents his thoughts on how to improve the practice of developing and using computer systems that can be trusted to satisfy specific system requirements. Topics covered include establishing standards and best practices, identifying the security risks with the Internet of Things, and restructuring the software engineering and system engineering disciplines.

Improving performance is a central concern for software developers. To locate optimization opportunities, developers rely on software profilers. However, these profilers only report where programs spend their time: optimizing that code may have no impact on performance. Past profilers thus both waste developer time and make it difficult for them to uncover significant optimization opportunities. This paper introduces causal profiling. Unlike past profiling approaches, causal profiling indicates exactly where programmers should focus their optimization efforts, and quantifies their potential impact. Causal profiling works by running performance experiments during program execution. Each experiment calculates the impact of any potential optimization by virtually speeding up code: inserting pauses that slow down all other code running concurrently. The key insight is that this slowdown has the same relative effect as running that line faster, thus "virtually" speeding it up. We present Coz, a causal profiler, which we evaluate on a range of highly-tuned applications such as Memcached, SQLite, and the PARSEC benchmark suite. Coz identifies previously unknown optimization opportunities that are both significant and targeted. Guided by Coz, we improve the performance of Memcached by 9%, SQLite by 25%, and accelerate six PARSEC applications by as much as 68%; in most cases, these optimizations involve modifying under 10 lines of code. [ABSTRACT FROM AUTHOR]

The article discusses the relevance of energy efficiency as a consideration for application software development. Topics include research on software energy consumption, the relation of energy consumption to software engineering methodology, and the maintenance of software for energy efficiency in relation to refactoring, reengineering, and visualization.

The article discusses industrial-scale agile computer software development, particularly the transition to engineering agile adoptions. It examines costs to information technology (IT) departments, the benefits of moving from craft to engineering to the software industry, and the intersection of human ingenuity collides with codified knowledge and collective goals.

The article discusses the use of satisfiability modulo theory solvers in formula-based software debugging as form of computer-assisted debugging. Topics include the use of symbolic techniques to extract candidate specifications, the use of an Address Resolution Protocol (ARP) implementation, and the use of interpolants to find error root-causes.

The article discusses the use of statistics by engineers in dealing with operations data. Topics include data visualization methods including rug plots, histograms, and scatter plots; the use of summary statistics including mean values and standard deviations; and the evaluation of quantiles and outliers.

The article discusses the security of personal data with regard to the Internet of Things (IoT). Topics include software engineering challenges associated with building transparent and auditable systems, the potential use of digital provenance to record system events, and the importance of industry practitioners to know and understand the threat posed by the IoT, the potential solutions, and the challenges associated with the deployment of such solutions.

The article discusses the causes of the increasing complexity of software systems. Topics include the idea of a mismatch between computer hardware and computer software in relation to the history of the computer industry; the complexity of software development, deployment, and sustainment; and problems facing software engineering as a discipline.

The article discusses the lawsuit regarding emissions from Volkswagen diesel automobiles that produced fraudulent test results. It mentions the need for emissions standards, the software that produced the test results, and the responsibility of software engineers to behave morally and not produce software the violates the law.

The article discusses the use of model checking and artificial intelligence in diagnosing and repairing problems in the software development cycle. The authors describe a four-step framework for a basic train-controller system that includes model checking, elicitation by the software engineer of system states that address inconsistencies in counterexamples produced by the model checking, repair of defective states by logic-based learning, and implementation of a selection mechanism to choose among alternative approaches to the same repair task.

The article focuses on human-agent collectives (HAC) systems, a new class of socio-technical systems in which humans and smart software engage in flexible relationships in order to achieve both their individual and collective goals. Topics discussed include scientific challenges that must be addressed in developing systems that interact and motivate humans to work alongside agents and features that make it particularly challenging to engineer and predict their behavior. Also explored are the challenges that relate to how incentives are chose and presented in the context of HAC.

The authors argue that software engineering is not an engineering discipline. They believe that a new software engineering is needed that is built on the experience of software craftsmen. They explores how the software community go about their task of refounding software engineering and the implications of the essence of a new software engineering for the future of the discipline.

The authors discuss abstraction as a significant skill in computer science (CS) and software engineering (SE) and whether abstraction skills are assessable. The authors argue that directly querying experts on whether abstraction are assessable would not produce a clear response, and propose a set of survey question patterns to assess abstraction skills.

This article demonstrates how high-level embedded DSLs (EDSLs) really can alleviate low-level programming with no contradiction. Topics discussed also include the need for software engineers not to be hesitant when it comes to writing computer programs that generate programs, an EDSL used to generate code that can provide safety guarantees in the generated code if structured properly, deferred-array data as an example of encapsulating code-generation tactics with a nice application programming interface.

The article focuses on cloud computing and data security. It states that providers of cloud computing services have strong incentives to engineer systems that maintain performance and features while providing strong isolation and security guarantees and mentions incentives toward proprietary software and management techniques to safeguard competitive advantages. It suggests that it can be difficult for users to evaluate if a commercial virtualization platform is suitable for their application. It comments on the role of company history, regulations, and reputation in developing trust in a cloud provider and suggests a trend toward transparency will continue due to competing demands of cloud infrastructure business. INSET: Anatomy of an Attack.

The article presents information on why executive should care about the Software Engineering Method and Theory (SEMAT) initiative. The initiave is aimed at providing software engineering with a foundation that allows best practices to be described and supports the goals of providing more with less by delivering value at team as well as organizational levels. According to the findings of the 2014 Gartner Application Architecture, Development, and Integration (AADI) Summit survey, the goals of trying to do more with less by standardizing single development process is not the answer.

The article discusses precautions that the software engineering team with the U.S. National Aeronautics and Space Administration's (NASA) Jet Propulsion Laboratory (JPL) took to improve the reliability of the software used on the martian rover Curiosity. Topics include the size and complexity of the computer code in both the hardware and software of the Mars Science Laboratory (MSL) mission, standard precautions that can help reduce risk in complex software systems, such as building strong fault-protection mechanisms, standard codes of compliance, such as level-one compliance (LOC-1), the use of peer reviewers to identify design flaws, and model-checking techniques that automate the verification process, such as a logic model checker, called Spin.

The article discusses the agile movement, which is an initiative to improve the ways in which software is developed, and the Software Engineering Method and Theory (SEMAT) initiative, which is a novel way of looking at the domain of software engineering. The authors argue that when the two initiatives are combined, it empowers teams to be innovative, to experiment, and to improve the results they deliver. Topics include what SEMAT adds to the agile movement, the support that SEMAT provides in helping organizations become agile, the goal of the SEMAT initiative, and what the agile movement add to SEMAT.

The article considers computer software development and sogtware life cycle management. The obsolescence of the traditional pattern of waterfall development in which development, quality assurance and operations were separate functions, with development and operations now merged into a single function known as DevOps is discussed. It is noted that there is no set definition of DevOps among software engineers. The increased standardization within the computer software industry of the product development process is discussed.

The article discusses publishing practices within subareas of computer science as of August 2013, suggesting that publishing practices in fields such as image processing and software engineering may require different practices and presenting the results of a study concerning subarea productivity. Topics include the importance of journal publications in subareas such as computer architecture, research evaluation methodologies, paper citation rates, and the number of students managed by computer science researchers in various subareas.

The author presents his thoughts on a debate over classifying computation as a field of science. He states that computation includes areas including computer science, information science, and software engineering, noting that critics have considered these as subcategories of mathematics or technology. In discussing the history of computation, he suggests that it was originally a science that entered into engineering before returning to a science field in the 1990s.

The article discusses a thinking framework that can be applied to software engineering based on an actionable kernel, a main component in computer operating systems. It states that development of the kernel was inspired by a prompt from the Software Engineering Methods and Theory (SEMAT), an initiative to redefine software engineering based on proven principles and best practices. The authors note that the kernel's benefits include providing a method of discussion and improvement regarding software-engineering methods, a foundation for defining practices for assessing software quality, and a way for engineers to track their progress. Other topics covered include software development methods, iterations, and practical applications of the kernel.

The article discusses the complexity of information technology (IT) systems, examining the challenges they pose in system engineering. The article argues that the development of complex systems requires a socio-technological perspective, suggesting that it is necessary to consider organizational, human, and technical factors. The article suggests that software engineering has relied on reducing complexity, arguing that software engineering focuses on the development of single programs instead of interacting systems. INSET: Socio-Technical Systems.

The article discusses the use of software metrics in project management, examining common mistakes that managers and software engineers make while using software metrics. The article examines the importance of adding context and establishing a relationship with the project's goal, arguing that using metrics without interpretation, making changes only to improve the value of metrics, and focusing on too many or too few metrics can be harmful to a project. The authors conclude that software metrics can be useful for software developers if they avoid these errors.

Good software engineering practice demands generalization and abstraction, whereas high performance demands specialization and concretization. These goals are at odds, and compilers can only rarely translate expressive high-level programs to modern hardware platforms in a way that makes best use of the available resources. Generative programming is a promising alternative to fully automatic translation. Instead of writing down the target program directly, developers write a program generator, which produces the target program as its output. The generator can be written in a high-level, generic style and can still produce efficient, specialized target programs. In practice, however, developing high-quality program generators requires a very large effort that is often hard to amortize. We present lightweight modular staging (LMS), a generative programming approach that lowers this effort significantly. LMS seamlessly combines program generator logic with the generated code in a single program, using only types to distinguish the two stages of execution. Through extensive use of component technology, LMS makes a reusable and extensible compiler framework available at the library level, allowing programmers to tightly integrate domain-specific abstractions and optimizations into the generation process, with common generic optimizations provided by the framework. LMS is well suited to develop embedded domain-specific languages (DSLs) and has been used to develop powerful performance-oriented DSLs for demanding domains such as machine learning, with code generation for heterogeneous platforms including GPUs. LMS has also been used to generate SQL for embedded database queries and JavaScript for web applications. [ABSTRACT FROM AUTHOR]

The article focuses on the concept of technical debt, or shortcuts that can accelerate progress in software engineering or reduce costs while potentially increasing expenses or slowing down progress in the future. It states technical debt occurs when engineers fail to utilize best practices and compares technical debt to financial debt. It mentions that software developers are rewarded on the speed of implementation more than long-term maintainability which provides little incentive for initial developers to properly do the job the first time. It suggests the avoidance of some technical debts such as taking shortcuts in security and comments on the tendency for Web-based services to take on and resolve technical debt.

The article focuses on Agile software development and its use by practicing software engineers. It talks about the state of software development methodology in the 1990s which led to independent consultants developing agile software development tools and mentions that in 2001 17 software engineers codified the 12 original agile principles into the Agile Manifesto. It analyzes data from surveys of software programmers to determine how many of them used agile principles and their thoughts on the value of the principles. It mentions the introduction of lean software development kanban practices.

Why the next language you learn should be functional. [ABSTRACT FROM AUTHOR]

Predictive models are fundamental to engineering reliable software systems. However, designing conservative, computable approximations for the behavior of programs (static analyses) remains a difficult and error-prone process for modern high-level programming languages. What analysis designers need is a principled method for navigating the gap between semantics and analytic models: analysis designers need a method that tames the interaction of complex languages features such as higher-order functions, recursion, exceptions, continuations, objects and dynamic allocation. We contribute a systematic approach to program analysis that yields novel and transparently sound static analyses. Our approach relies on existing derivational techniques to transform high-level language semantics into low-level deterministic state-transition systems (with potentially infinite state spaces). We then perform a series of simple machine refactorings to obtain a sound, computable approximation, which takes the form of a non-deterministic state-transition systems with finite state spaces. The approach scales up uniformly to enable program analysis of realistic language features, including higher-order functions, tail calls, conditionals, side effects, exceptions, firstclass continuations, and even garbage collection. [ABSTRACT FROM AUTHOR]

The article discusses how design of the scripting language Lua was affected by a desire to make it well-suited to embedding in a system language. The authors survey general considerations regarding the integration of scripting and host languages, then turn their attention to issues specific to Lua. Topics covered include how Lua is able to function as both a standalone program and an embedded scripting language, how data flows between Lua and its host are handled, and how Lua compensates for not offering an "eval" function.