71 |
ISSUES IN DISTRIBUTED PROGRAMMING LANGUAGES: THE EVOLUTION OF SR (CONCURRENT).Olsson, Ronald Arthur January 1986 (has links)
This dissertation examines fundamental issues that face the designers of any distributed programming language. It considers how programs are structured, how processes communicate and synchronize, and how hardware failures are represented and handled. We discuss each of these issues and argue for a particular approach based on our application domain: distributed systems (such as distributed operating systems) and distributed user applications. We conclude that a language for such applications should include the following mechanisms: dynamic modules, shared variables (within a module), dynamic processes, synchronous and asynchronous forms of message passing, rendezvous, concurrent invocation, and early reply. We then describe the current SR language, which has evolved considerably based on our experience. SR provides the above mechanisms in a way that is expressive yet simple. SR resolves the tension between expressiveness and simplicity by providing a variety of mechanisms based on only a few underlying concepts. The main language constructs are still resources and operations. Resources encapsulate processes and the variables they share; operations provide the primary mechanism for process interaction. One way in which SR has changed is that both resources and processes are now created dynamically. Another change is that all the common mechanisms for process interaction--local and remote procedure call, rendezvous, dynamic process creation, asynchronous message passing, and semaphores--are now supported by a novel integration of the mechanisms for invoking and servicing operations. Many small and several larger examples illustrate SR's mechanisms and the interplay between them; these examples also demonstrate the language's expressiveness and flexibility. We then describe our implementation of SR. The compiler, linker, and run-time support are summarized. We then focus on how the generated code and run-time support interact to provide dynamic resources and to generate and service invocations. We also describe optimizations for certain operations. Measurements of the implementation's size and cost are given. The implementation has been in use since November 1985 and is currently being improved. Finally, we justify SR's syntax and semantics and examine how its mechanisms compare to other approaches to distributed programming. We also discuss how SR balances expressiveness, simplicity, and efficiency.
|
72 |
DESIGN OF PORTABLE DIRECT EXECUTING LANGUAGES FOR INTERACTIVE SIMULATION.VAKILZADIAN, HAMID. January 1985 (has links)
DESIRE P is a general purpose continuous time simulation language suitable for interactive simulation, dynamic system study, mathematical modeling, process control analysis. It includes an interactive editor, file manipulation facilities, and graphic packages, making it a completely self-contained system. The PDP-11 version of DESIRE P handles 20 state variables, while the VAX/VMS version runs 150 or more. An interpreted job-control language serves for interactive program entry, editing and file operations, and for programming multirun simulation studies. The dynamic segment, containing differential equations in first-order form, is entered just like the job-control statments and accesses the same variables. DESIRE P is largely written in PASCAL, and most of it can be transferred to different computers, with little change. The PASCAL implementation proves that the high-level language can be used to program direct executing languages, still keeping efficiency and speed comparable to assembly language. The runtime compiler of DESIRE P generates fast and efficient code. DESIRE P can incorporate existing and new precompiled FORTRAN numerical integration algorithms.
|
73 |
Behavioural constraints, patterns and conformance : reconciling object-oriented inheritance with temporal restrictions on the ordering of methodsBuchanan, Katherine Mary January 2000 (has links)
No description available.
|
74 |
Distributed object oriented logic programmingWang, Tzone I. January 1995 (has links)
No description available.
|
75 |
Higher order strictness analysis by abstract interpretation over finite domainsFerguson, Alexander B. January 1995 (has links)
No description available.
|
76 |
A new computational model, OOGRS and its implementationLee, Jeong-Ho January 2000 (has links)
No description available.
|
77 |
Programming bulk-synchronous parallel computersMiller, R. Quentin January 1996 (has links)
No description available.
|
78 |
Implementing Overloading and Polymorphism in CforallBilson, Richard C. January 2003 (has links)
The programming language Cforall extends the C language with, among other things, overloading, parametric polymorphism, and functions that can return multiple values from a single call. This thesis presents an outline of the first implementation of the core Cforall language. An effective implementation of Cforall requires complete support for new language constructs while preserving the behaviour and efficiency of existing C programs. Analyzing the meaning of Cforall programs requires significantly more sophisticated techniques than are necessary for C programs; existing techniques for the analysis of overloading and polymorphism are adapted and extended to apply to Cforall. Three strategies for generating code for polymorphic programs are compared, using plain C as an intermediate representation. Finally, a realistic Cforall program is presented and characteristics of the generated C code are examined.
|
79 |
Constraint-based specifications for system configurationHewson, John Aubrey January 2013 (has links)
Declarative, object-oriented configuration management systems are widely used, and there is a desire to extend such systems with automated analysis and decision-making. This thesis introduces a new formulation for configuration management problems based on the tools and techniques of constraint programming, which enables automated decision-making. We present ConfSolve, an object-oriented declarative configuration language, in which logical constraints on a system can be specified. Verification, impact analysis, and the generation of valid configurations can then be performed. This is achieved via translation to the MiniZinc constraint programming language, which is in turn solved via the Gecode constraint solver. We formally define the syntax, type system, and semantics of ConfSolve, in order to provide it with a rigorous foundation. Additionally we show that our implementation outperforms previous work, which utilised an SMT solver, while adding new features such as optimisation. We next develop an extension of the ConfSolve language, which facilitates not only one-off configuration tasks, but also subsequent re-configurations in which the previous state of the system is taken into account. In a practical setting one does not wish for a re-configuration to deviate too far from the existing state, unless the benefits are substantial. Re-configuration is of crucial importance if automated configuration systems are to gain industry adoption. We present a novel approach to incorporating state-change into ConfSolve while remaining declarative and providing acceptable performance.
|
80 |
Designing graphical interface programming languages for the end userMarsden, Gary January 1998 (has links)
This thesis sets out to answer three simple questions: What tools are available for novice programmers to program GUIs? Are those tools fulfilling their role? Can anything be done to make better tools? Despite being simple questions, the answers are not so easily constructed. In answering the first question, it was necessary to examine the range of tools available and decide upon criteria which could be used to identify tools aimed specifically at the novice programmer (there being no currently agreed criteria for their identification). Having identified these tools, it was then necessary to construct a framework within which they could be sensibly compared. The answering of the second question required an investigation of what were the successful features of current tools and which features were less successful. Success or failure of given features was determined by research in both programming language design and studies of programmer satisfaction. Having discovered what should be retained and discarded from current systems, the answering of the third question required the construction of new systems through blending elements from visual languages, program editors and fourth generation languages. These final prototypes illustrate a new way of thinking about and constructing the next generation of GUI programming languages for the novice.
|
Page generated in 0.0319 seconds