Proceedings of the 1983 ACM SIGPLAN symposium on Programming language issues in software systems - SIGPLAN '83

1983 ◽  
Keyword(s):  
Programming Language ◽  
Software Systems ◽  
Language Issues

scholarly journals Industrial hardware and software verification with ACL2

2017 ◽  
Vol 375 (2104) ◽  
pp. 20150399 ◽  
Author(s):  
Warren A. Hunt ◽  
Matt Kaufmann ◽  
J Strother Moore ◽  
Anna Slobodova
Keyword(s):  
Programming Language ◽  
Software Verification ◽  
Formal Analysis ◽  
Shared Vision ◽  
Theorem Prover ◽  
Software Systems ◽  
Levels Of Abstraction ◽  
Quarter Century ◽  
Industrial Use ◽  
Technical Features

The ACL2 theorem prover has seen sustained industrial use since the mid-1990s. Companies that have used ACL2 regularly include AMD, Centaur Technology, IBM, Intel, Kestrel Institute, Motorola/Freescale, Oracle and Rockwell Collins. This paper introduces ACL2 and focuses on how and why ACL2 is used in industry. ACL2 is well-suited to its industrial application to numerous software and hardware systems, because it is an integrated programming/proof environment supporting a subset of the ANSI standard Common Lisp programming language. As a programming language ACL2 permits the coding of efficient and robust programs; as a prover ACL2 can be fully automatic but provides many features permitting domain-specific human-supplied guidance at various levels of abstraction. ACL2 specifications and models often serve as efficient execution engines for the modelled artefacts while permitting formal analysis and proof of properties. Crucially, ACL2 also provides support for the development and verification of other formal analysis tools. However, ACL2 did not find its way into industrial use merely because of its technical features. The core ACL2 user/development community has a shared vision of making mechanized verification routine when appropriate and has been committed to this vision for the quarter century since the Computational Logic, Inc., Verified Stack. The community has focused on demonstrating the viability of the tool by taking on industrial projects (often at the expense of not being able to publish much). This article is part of the themed issue ‘Verified trustworthy software systems’.

Source Code Analysis: Current and Future Trends & Challenges

2016 ◽  
Vol 685 ◽  
pp. 877-880
Author(s):  
Alexey Ponomarev ◽  
Hitesh S. Nalamwar ◽  
Ragesh Jaiswal
Keyword(s):  
Programming Language ◽  
System Architecture ◽  
False Positive ◽  
Time Complexity ◽  
State Of The Art ◽  
Source Code ◽  
Software Systems ◽  
Future Trends ◽  
Source Code Analysis ◽  
Code Analysis

The increasing complexity of software systems is making source code analysis a more economic option to automate the identification of defects, vulnerabilities and inefficiencies. This paper initially outlines the general anatomy of automatic source code analyzers, dimensions of analysis that can be performed with today’s state-of-the-art tools, various limitations of automatic source code analysis in the areas of programming language coverage, quantity of false positive claims, system architecture breakdowns and code/time complexity. The paper is concluded by presenting future tentative trends of source code analysis.

scholarly journals Extending programming language to support object orientation in legacy systems

2013 ◽  
Vol 10 (4) ◽  
pp. 1661-1672
Author(s):  
Hemang Mehta ◽  
S.J. Balaji ◽  
Dharanipragada Janakiram
Keyword(s):  
Programming Language ◽  
Object Orientation ◽  
Exception Handling ◽  
Target System ◽  
Software Systems ◽  
Legacy Systems ◽  
Performance Study ◽  
Tight Coupling ◽  
Runtime Support

The contemporary software systems written in C face maintainability issues because of tight coupling. Introducing object orientation can address these problems by raising the abstraction to objects, thereby providing better programmability and understandability. However, compiling a C software with a C++ compiler is difficult because of the incompatibilities between C and C++. Some of the incompatibilities such as designated initializers are nontrivial in nature and hence are very difficult to handle by automation such as scripting or by manual efforts. Moreover, runtime support for features such as global constructors, exception handling, runtime type inference, etc. is also required in the target system. Clearly, the traditional procedural language compiler cannot provide these features. In this paper, we propose extending programming language such as C++ to support object orientation in legacy systems instead of completely redesigning them. With a case study of Linux kernel, we report major issues in providing the compile and runtime support for C++ in legacy systems, and provide a solution to these issues. Our approach paves the way for converting a large C based software into C++. The experiments demonstrate that the proposed extension saves significant manual efforts with very little change in the g++ compiler. In addition, the performance study considers other legacy systems written in C and shows that the overhead resulting from the modifications in the compiler is negligible in comparison to the functionality achieved.

scholarly journals Modeling and Programming by Commitment Rules in Agent Factory

2010 ◽  
pp. 393-421 ◽  
Author(s):  
Rem Collier ◽  
Gregory M.P. O’Hare
Keyword(s):  
Mobile Computing ◽  
Programming Language ◽  
Mixed Reality ◽  
Software Systems ◽  
Future Trends ◽  
General Introduction ◽  
Rule Based ◽  
Agent Programming ◽  
Wide Range ◽  
Agent Factory

Agent-Oriented Programming (AOP) is a relatively new programming paradigm, proposed by Yoav Shoham, which views software systems as consisting of a set of agents that interact with one another to solve problems beyond their individual capabilities. Since the inception of the paradigm, a number of AOP languages have been proposed. This chapter focuses on one such language, the Agent Factory Agent Programming Language (AFAPL), a practical rule-based language that has been applied to a wide range of problem domains including robotics, virtual and mixed reality environments, and mobile computing. AFAPL is placed in context through a general introduction to the state-of-the-art in AOP. The chapter finishes with a discussion of some future trends for AOP and some concluding remarks.

Sign in / Sign up

Export Citation Format

Share Document