A parallel-programming process model

A process model is presented for constructing and executing parallel programs on a shared-memory multiprocessor running under Unix. The model involves some simple extensions to the standard Unix process model, a set of language extensions, runtime library support, and additional operating-system support. The model is easy to use, and it supports several higher-level parallel programming constructs in several languages, including microtasking in C and Fortran and multitasking in Ada and C++. It frees programmers to concentrate on parallel algorithms instead of low-level implementation details, and it yields good performance     

Achieving dependability throughout the development process: adistributed software experiment

Distributed software engineering techniques and methods for improving the specification and testing phases are considered. To examine these issues, an experiment was performed using the design diversity approach in the specification, design, implementation, and testing of distributed software. In the experiment, three diverse formal specifications were used to produce multiple independent implementations of a distributed communication protocol in Ada. The problems encountered in building complex concurrent processing systems in Ada were also studied. Many pitfalls were discovered in mapping the formal specifications into Ada implementations     

Experience with multi-transputer Ada

The transputer is one of the most cost-effective multicomputer components to buy, but still one of the hardest to program. Even if the parts of a program that are destined for individual transputers are programmed in a familiar high-level language (Ada or Fortran or C), users are forced to be aware of occam when connecting transputers together with harnesses. Moreover, the design of parallel and distributed algorithms is in itself a challenging field. This paper describes experience with using the Alsys Ada compiler on single and multiple transputer configurations, and considers whether Ada makes it any easier to gain access to the power of multi-transputers. Early performance figures indicate that Ada running on transputer arrays compares favourably with the speed of other languages. An assessment of the impact of the proposed Ada 9X support for distribution is made.     

基于Ada的交叉引用语言CRL/Ada

本文介绍一种基于Ａｄａ的交叉引用语言ＣＲＬ／Ａｄａ,它用于描述Ａｄａ程序实体的定义与引用信息,在软件维护的过程中,利用它可以方便地获得软件源程序中的实体信息。本文将介绍它的设计思想、程序结构与应用。     

Abstract Data Type Development and Implementation: An Example

Data abstraction is an effective tool in the design of complex systems, and the representation independence it provides is a key factor in the maintenance and adaptation of software systems. This paper describes a system development methodology based on the development of hierarchies of abstract data types (ADT's). The methodology preserves a high degree of representation independence throughout both the design and implementation of complex systems. The methodology is illustrated with examples from the design and implementation of a Vision Research Programming System. These examples include ADT specifications, ADT interface specifications, and partial implementation code for the system in two different programming languages, Ada1 and Fortran.     

The importance of static structures in software construction

The static structure is the physical organization of a system's functional modules in terms of their structural relations. It is the packaging of the dynamic structure into textually self-contained modules, taking into consideration the construction strategy and how much of module's internal part should be visible to other modules. Hierarchical modular diagrams (HMD), a module-interface-oriented graphics language that develops can specify the structural relations among modules and map design concepts into a hierarchy of program components independently of the implementation language, is described. The application of HMD to manage a real-time system in a library of separately compiled Ada units is described. It is shown that by using HMD in conjunction with modern software engineering languages like Ada, the static structure can be built earlier in the design process. This lets designers evaluate safety-critical issues as well as reusability concerns long before they make safety checks and implementation decisions. More important, engineers can analyze the effect of approaches to incremental construction before committing additional resources     

PSS／Ada程序切片系统的设计与实现

ＰＳＳ／Ａｄａ是一个Ａｄａ程序静态切片生成系统，可广泛应用于Ａｄａ程序的测试、排错、理解、维护以及Ａｄａ软件的波动性分析、并行性检测和复杂性度量等诸方面，本文介绍ＰＳＳ／Ａｄａ系统的设计思想、系统的结构、工作原理以及系统实现的重要技术细节。     

Ada program partitioning language: a notion for distributing Adaprograms

Ada Program Partitioning Language (APPL) has been designed as part of Honeywell's Distributed Ada project. The goal of the project is to develop an approach for reducing the complexity of building distributed applications in Ada. In the proposed approach, an application is written as a single Ada program using the full capabilities of the Ada language. It is not necessary to factor the underlying hardware configuration into the program design. Once the program has been completed and tested in the host development environment, it is partitioned into fragments and mapped onto the distributed hardware. The partitioning and mapping are expressed in APPL and do not require changes to the Ada source. The main thrusts of the project include the design of APPL and the development of language translation tools and the run-time system to support Ada and APPL for a distributed target. The authors present an overview of APPL, the goals considered in the design, and issues that impact its implementation     

Design recovery for distributed systems

Two factors limit the utility of reverse engineering technology for many distributed software systems. First, with the exception of tools that support Ada and its explicit tasking constructs, reverse engineering tools fail to capture information concerning the flow of information between tasks. Second, relatively few reverse engineering tools are available for programming languages in which many older legacy applications were written (e.g., Jovial, CMS-2, and various assembly languages). We describe approaches that were developed for overcoming these limitations. In particular, we have implemented an approach for automatically extracting task flow information from a command and control system written in CMS-2. Our approach takes advantage of a small amount of externally provided design knowledge in order to recover design information relevant to the distributed nature of the target system     

Halo：基于Eclipse的逆向工程工具

在集成开发环境Eclipse平台上为Java项目构建逆向工程工具Halo,描述Halo工具的设计思路和实现步骤,包括利用抽象语法树从程序源代码提取模型信息的方法,通过改进的Sugiyama布局算法将提取出的逻辑模型变换成适合于开发者阅读的UML类图,讨论Halo工具构建过程中的技术难点并给出相应的解决方案。实验结果表明,Halo工具能够满足开发者对逻辑模型可视化的需求。     

A tool for design pattern detection and software architecture reconstruction

It is well known that software maintenance and evolution are expensive activities, both in terms of invested time and money. Reverse engineering activities support the obtainment of abstractions and views from a target system that should help the engineers to maintain, evolve and eventually re-engineer it. Two important tasks pursued by reverse engineering are design pattern detection and software architecture reconstruction, whose main objectives are the identification of the design patterns that have been used in the implementation of a system as well as the generation of views placed at different levels of abstractions, which let the practitioners focus on the overall architecture of the system without worrying about the programming details it has been implemented with.In this context we propose an Eclipse plug-in called MARPLE (Metrics and Architecture Reconstruction Plug-in for Eclipse), which supports both the detection of design patterns and software architecture reconstruction activities through the use of basic elements and metrics that are mechanically extracted from the source code. The development of this platform is mainly based on the exploitation of the Eclipse framework and plug-ins as well as of different Java libraries for data access and graph management and visualization. In this paper we focus our attention on the design pattern detection process.     

Handling type information when compiling a language with user-defined types

A discussion of the handling of type information by the translator for the Portable Programming Language is broadened to include some related details of the PPL design and the way in which type information is used during storage management. No knowledge of PPL is assumed and the presentation is sufficiently broad-based to provide insight into the compiling actions needed for more complicated languages such as Algol 68 and Ada; some design details of the three languages are contrasted. The implemented type-handling in the PPL translator takes many details from a denotational semantics for a forerunner of the language.     

一种基于逆向程序流的程序切片算法*

传统的程序切片方法一般基于程序依赖图(PDG)和系统依赖图(SDG)的可达性算法,但是在建立PDG和SDG的过程中会计算一些与切片无关的数据依赖,造成时空资源的浪费及切片效率的降低。提出了一种基于程序逆向流的切片算法,它事先建立逆向程序流,再从切片点开始沿逆向程序流扫描程序以获得程序切片,只计算与切片相关的数据依赖,从而提高了切片计算的时空效率。通过实验发现该算法具有一定的可行性和实用性。本算法适用于包括Fortran、C等编程语言在内的命令式程序的切片生成。     

Reverse Engineering of Mobile Banking Applications

Software reverse engineering is the process of analyzing a software system to extract the design and implementation details. Reverse engineering provides the source code of an application, the insight view of the architecture and the third-party dependencies. From a security perspective, it is mostly used for finding vulnerabilities and attacking or cracking an application. The process is carried out either by obtaining the code in plaintext or reading it through the binaries or mnemonics. Nowadays, reverse engineering is widely used for mobile applications and is considered a security risk. The Open Web Application Security Project (OWASP), a leading security research forum, has included reverse engineering in its top 10 list of mobile application vulnerabilities. Mobile applications are used in many sectors, e.g., banking, education, health. In particular, the banking applications are critical in terms of security as they are used for financial transactions. A security breach of such applications can result in huge financial losses for the customers as well as the banks. There exist various tools for reverse engineering of mobile applications, however, they have deficiencies, e.g., complex configurations, lack of detailed analysis reports. In this research work, we perform an analysis of the available tools for reverse engineering of mobile applications. Our dataset consists of the mobile banking applications of the banks providing services in Pakistan. Our results indicate that none of the existing tools can carry out the complete reverse engineering process as a standalone tool. In addition, we observe significant differences in terms of the execution time and the number of files generated by each tool for the same file.     

Program Reusability through Program Transformation

How can a program written in pure applicative LISP be reused in a Fortran environment? One answer is by automatically transforming it from LISP into Fortran. In this paper we discuss a practical application of this technique-one that yields an efficient Fortran program. We view this process as an example of abstract programming, in which the LISP program constitutes an abstract specification for the Fortran version. The idea of strategy-a strategy for getting from LISP to Fortran-is basic to designing and applying the transformations. One strategic insight is that the task is easier if the LISP program is converted to ``recursive' Fortran, and then the recursive Fortran program is converted to nonrecursive standard Fortran. Another strategic insight is that much of the task can be accomplished by converting the program from one canonical form to another. Developing a strategy also involves making various implementation decisions. One advantage of program transformation methodology is that it exposes such decisions for examination and review. Another is that it enables optimizations to be detected and implemented easily. Once a strategy has been discovered, it can be implemented by means of rewrite-rule transformations using the TAMPR program transformation system. The transformational approach to program reuse based on this strategy has a measure of elegance. It is also practical-the resulting Fortran program is 25 percent faster than its compiled LISP counterpart, even without extensive optimization.     

BISE Ada8086／8096交叉转换系统的设计与实现

本文给出了基于机器代码程序交叉转换的Ａｄａ交叉转换系统的设计方法和实现细节，简述了系统的基本构成和工作过程，指出了掌握代码交叉转换技术的重要意义。该系统的成功实现，为用Ａｄａ开发单片机应用软件提供了强有力的工具。     

PROTRAN: Problem solving software

PROTRAN is the name of a family of problem-solving software systems designed to provide quick and convinient access to the computational power of the IMSL Library of mathematical and statistical Fortran subroutines. This paper discusses the structure and implementation of PROTRAN using as illustration MATH/PROTRAN which provides access to the mathematical areas of the Library. PROTRAN accepts problem specifications, checks them for consistency, selects the appropriate IMSL routines and generates a Fortran program. All programming requirements such as workspace assignment and error message handling are handled automatically by PROTRAN. The generated Fortran program goes through the usual steps of compilation, linking, and execution to produce a solution to the problem. PROTRAN adds to the problem-solving power of Fortran by adding very high level problem-solving statements and it adds to the reliability of Fortran by providing extensive error checking and automating the details of using the IMSL Library.