Abstraction in computer programming provides a means of reducing complexity by emphasising the significant information (program behaviour) whilst suppressing the immaterial (program implementation). This aids program construction, improves reliability and maintainability, and eases the application of formal correctness proofs. The importance of data abstraction in the specification, design and implementation of large systems raises the question as to whether such methods may be applied in the context of programming languages designed before the widespread use of abstraction techniques. The program structuring facilities available in FORTRAN 77 support a form of encapsulation for simple data structures. In light of this mechanism provided by the language, state-based specification was found to be most appropriate. A specification technique incorporating object-oriented techniques is particularly suitable and allows a library of object classes to be specified and then implemented in sequential FORTRAN 77. Refinement extends the object classes so as to provide the commonly occurring generators for use in iterative constructs. Therefore, the advantages of data abstraction methods may be obtained in an early procedural language such as FORTRAN 77. Data abstraction provides data independence : a change in the representation for a particular class of objects affects only the code that implements the associated operations. This allows parallel implementations to be considered, without changes to the original specification or to any user-code. The provision of such parallel data structures is required for the migration of sequential systems onto parallel distributed memory architectures. As an illustration of this approach a general 2P2-2P (for integer P≥3) search tree utilising a pipeline of processors in a distributed memory architecture is shown to provide a means of implementing the object classes. Variations in both the number of processors allocated to the pipeline and the value of P allows the optimal search structure for a given architecture to be determined. These structures are highly efficient leading to improvements in both throughput and response time as processors are added to the array. An efficient parallel implementation of object classes is therefore achieved within the tight interface provided by abstraction.

Software mobile agents is a new distributed computing paradigm which was developed to support efficient computing over the Internet. Since its inception there has been a significant research effort to produce concrete agent-based artefacts. This phenomenon resulted in the proliferation of a large number of agent systems, mostly based on proprietary programming languages, each with its own characteristics, peculiarities and assumptions. Hence the agent technology has largely remained hidden and incomprehensible by Internet end users. Moreover the issue of interoperability and integration of agents with existing legacy software has only just started to be addressed by the agent research community in a rather ad hoc way. In this thesis we attempt to design an agent architecture which is independent of any programming language and therefore is directly suitable for Internet end users. The proposed architecture, labelled as Mobile Agent System for Internet Computing (MASIC), addresses several important contemporary issues in agent research. It defines an agent as a container of reusable components that can be copied or moved to other agents. Each agent has a symmetric I/O access control module and is also equipped with associative access collaboration facilities. Additionally every agent contains a navigator module which stores the agent's itinerary plan and provides an interface via which the agent itself or other authorised agents can dynamically adapt the plan to reflect run-time events and constraints. The agent system provides an integrated access control architecture which enables an agent to define customised access control structures that can be fully or partially shared with other agents. Existing access control structures can be combined to create new structures that represent more complex access mechanisms. Agents can discover other agents offering pertinent services via an adaptive, customisable agent discovery architecture incorporated in MASIC. This discovery architecture enables the full interaction of links with queries and supports the definition of access paths which are tightly coupled with access control and. other customised services. MASIC also provides the conceptual architecture of a message-oriented agent communication system integrated with a mobility management scheme. Finally, this thesis presents the design and implementation of a prototype graphical interface which enables the potential user of the system to create, manage and interact with agents in real time. In conclusion the research presented in this thesis aims to provide a comprehensive, language-neutral, secure, collaborative environment within which mobile agents can interact with their peers in order to perform their tasks efficiently while human operators can oversee and manage these activities through a user friendly interface. The architecture is generic in nature as it can support general-purpose, agent-based computations. Its concepts, entities and mechanisms can be fully or partially re-used to provide architectural solutions to challenges in various application domains such as Knowledge Management, the GRID and E-Commerce.

In the literature, error bound conditions have been widely used for studying the linear convergence rates of various first-order algorithms and the majority of literature focuses on how to sufficiently ensure these error bound conditions, usually posing more assumptions on the model under discussion. In this thesis, we focus on the alternating direction method of multipliers (ADMM), and show that the known error bound conditions for studying ADMM's linear convergence, can indeed be further weakened if the error bound is studied over the specific iterative sequence generated by ADMM. A so-called partial error bound condition, which is tailored for the specific ADMM's iterative scheme and weaker than known error bound conditions in the literature, is thus proposed to derive the linear convergence of ADMM. We further show that this partial error bound condition theoretically justifies the difference if the two primal variables are updated in different orders in implementing ADMM, which had been empirically observed in the literature yet no theory is known so far.

No description available.

Scientists are trending towards usage of high-level programming languages such as Python. The convenience of these languages often have a performance cost. As the amount of data being processed increases this can make using these languages unfeasible. Parallelism is a means to achieve better performance, but many users are unaware of it, or find it difficult to work with. This thesis presents ParForPy, a means for loop-parallelization to to simplify usage of parallelism in Python for users. Discussion is included for determining when parallelism matches well with the problem. Results are given that indicate that ParForPy is both capable of improving program execution time and perceived to be a simpler construct to understand than other techniques for parallelism in Python.

This thesis investigates nondeterminism in functional programming languages. To establish a precise understanding of nondeterministic language properties, Sondergaard and Sestoft's analysis and definitions of functional language properties are adopted as are the characterizations of weak and strong nondeterminism. This groundwork is followed by a denotational semantic description of a nondeterministic language (suggested by Sondergaard and Sestoft). In this manner, a precise characterization of the effects of strong nondeterminism is developed. Methods used to hide nondeterminism to in order to overcome or sidestep the problem of strong nondeterminism in pure functional languages are defined. These different techniques ensure that functional languages remain pure but also include some of the advantages of nondeterminism. Lastly, this discussion of nondeterminism is applied to the area of functional parallel language implementation to indicate that the related problem and the possible solutions are not purely academic. This application gives rise to an interesting discussion on optimization of list parallelism. This technique relies on the ability to decide when a bag may be used instead of a list.

Static analysis is the name given to a number of compile time analysis techniques used to automatically generate information which can lead to improvements in the execution performance of function languages. This thesis provides an introduction to these techniques and their implementation. The abstract interpretation framework is an example of a technique used to extract information from a program by providing the program with an alternate semantics and evaluating this program over a non-standard domain. The elements of this domain represent certain properties of interest. This framework is examined in detail, as well as various extensions and variants of it. The use of binary logical relations and program logics as alternative formulations of the framework , and partial equivalence relations as an extension to it, are also looked at. The projection analysis framework determines how much of a sub-expression can be evaluated by examining the context in which the expression is to be evaluated, and provides an elegant method for finding particular types of information from data structures. This is also examined. The most costly operation in implementing an analysis is the computation of fixed points. Methods developed to make this process more efficient are looked at. This leads to the final chapter which highlights the dependencies and relationships between the different frameworks and their mathematical disciplines. / KMBT_223

Many functional programming languages rely on the elimination of 'impure' features: assignment to variables, exceptions and even input/output. But some of these are genuinely useful, and it is of real interest to establish how they can be reintroducted in a controlled way. This dissertation looks in detail at one example of this: the addition to a functional language of dynamically generated names. Names are created fresh, they can be compared with each other and passed around, but that is all. As a very basic example of state, they capture the graduation between private and public, local and global, by their interaction with higher-order functions. The vehicle for this study is the nu-calculus, an extension of the simply-typed lambdacalculus. The nu-calculus is equivalent to a certain fragment of Standard ML, omitting side-effects, exceptions, datatypes and recursion. Even without all these features, the interaction of name creation with higher-order functions can be complex and subtle. Various operational and denotational methods for reasoning about the nu-calculus are developed. These include a computational metalanguage in the style of Moggi, which distinguishes in the type system between values and computations. This leads to categorical models that use a strong monad, and examples are devised based on functor categories. The idea of logical relations is used to derive powerful reasoning methods that capture some of the distinction between private and public names. These techniques are shown to be complete for establishing contextual equivalence between first-order expressions; they are also used to construct a correspondingly abstract categorical model. All the work with the nu-calculus extends cleanly to Reduced ML, a larger language that introduces integer references: mutable storage cells that are dynamically allocated. It turns out that the step up is quite simple, and both the computational metalanguage and the sample categorical models can be reused.

No description available.

In order to utilize parallel computers, four approaches, broadly speaking, to the provision of parallel software have been followed: (1) automatic production of parallel code by parallelizing—compilers which act on sequential programs written in existing languages; (2) "add on" features to existing languages that enable the programmer to make use of the parallel computer—these are specific to each machine; (3) full-blown parallel languages—these could be completely new languages, but usually they are derived from existing languages; (4) the provision of tools to aid the programmer in the detection of inherent parallelism in a given algorithm and in the design and implementation of parallel programs.