94 research outputs found
The computerization of programming: Ada (R) lessons learned
One of the largest systems yet written in Ada has been constructed. This system is the Intermetrics Ada compiler. Many lessons have been learned during the implementation of this Ada compiler. Some of these lessons, concentrating on those lessons relevant to large system implementations are described. The characteristics of the Ada compiler implementation project at Intermetrics are also described. Some specific experiences during the implementation are pointed out
A pascal compiler for PDP 11 minicomputers
In this paper the development of a cross-compiler running on the central computing facility is described. The compiler transforms PASCAL source code into object code for the PDP 11 family. The arguments for higher level languages on minicomputers and the choice made for PASCAL are discussed. It is shown that only a minor effort in terms of manpower is required if such a development is based on an existing compiler that is suited to the purpose of adaptation. Even without large amounts of optimization the code produced is both compact and efficient. Some attention is paid to requirements that should be fulfilled in portable compilers. The paper ends with a discussion of some strong points and weak points of the PDP 11 architecture
A study of systems implementation languages for the POCCNET system
The results are presented of a study of systems implementation languages for the Payload Operations Control Center Network (POCCNET). Criteria are developed for evaluating the languages, and fifteen existing languages are evaluated on the basis of these criteria
Efficient Dispatch of Multi-object Polymorphic Call Sites in Contextual Role-Oriented Programming Languages
Adaptive software becomes more and more important as computing is increasingly context-dependent. Runtime adaptability can be achieved by dynamically selecting and applying context-specific code. Role-oriented programming has been proposed as a paradigm to enable runtime adaptive software by design. Roles change the objects’ behavior at runtime, thus adapting the software to a given context. The cost of adaptivity is however a high runtime overhead stemming from executing compositions of behavior-modifying code. It has been shown that the overhead can be reduced by optimizing dispatch plans at runtime when contexts do not change, but no method exists to reduce the overhead in cases with high context variability. This paper presents a novel approach to implement polymorphic role dispatch, taking advantage of run-time information to effectively guard abstractions and enable reuse even in the presence of variable contexts. The concept of polymorphic inline caches is extended to role invocations. We evaluate the implementation with a benchmark for role-oriented programming languages achieving a geometric mean speedup of 4.0× (3.8× up to 4.5×) with static contexts, and close to no overhead in the case of varying contexts over the current implementation of contextual roles in Object Team
Fault tolerance distributed computing
Issued as Funds expenditure reports [nos. 1-4], Quarterly progress reports [nos. 1-3], and Final report, Project no. G-36-63
First International Conference on Ada (R) Programming Language Applications for the NASA Space Station, volume 2
Topics discussed include: reusability; mission critical issues; run time; expert systems; language issues; life cycle issues; software tools; and computers for Ada
Production of optimised machine-code for high-level languages using machine-independent intermediate codes
The aim of this work was to investigate the problems
associated with using machine-independent intermediate
codes in the translation from a high-level language into
machine code, with emphasis on minimising code size and
providing good run-time diagnostic capabilities.
The main result was a machine-independent intermediate
code, I-code, which has been used successfully to develop
optimising and diagnostic compilers for the IMP77 language
on a large number of different computer systems. In
addition, the work has been used to lay the foundations
for a project to develop an intermediate code for portable
SIMULA compilers.
The major conclusions of the research were that
carefully designed machine-independent intermediate codes
can be used to generate viable optimising and diagnostic
compilers, and that the commonality introduced into
different code generators processing the code for
different machines simplifies the tasks of creating new
compilers and maintaining old ones
Research on reliable distributed computing
Issued as Quarterly funds expenditure reports [nos. 1-4], Quarterly progress reports [nos. 1-4], Final report and Appendix, Project no. G-36-62
- …