Graduate Student, Computer Science
Software Engineer
Thesis Title: DynamiTE: A 21st Century Framework for Concurrent Component-Based Design
|
Mike Stannett
|
About
Recent changes in the direction of computer hardware development have created an impasse in the domain of software engineering. Over the past few years, new microprocessors have not seen the same increase in clock speed that has prevailed over previous decades. Instead, the use of multiple `cores' has become common, due largely to physical limitations which prevent the individual elements of a single processor core becoming any smaller. As a result, the performance benefits of these new processors arise not from being able to execute a single task faster than before, but from the parallel execution of many such tasks.
However, this leads to a problem. The existing dominant methods for designing software systems are inherently sequential. Current imperative and object-oriented programming languages are still founded on the principles of early computational models, such as the Turing machine. These take an idealised view of events where they always occur sequentially and in isolation. Programs are thus still effectively written as a sequence of reads and writes to a form of memory. The problem with this approach is that it runs into major issues when the execution of other programs may cause changes to memory outside the remit of the program. Imagine Turing's model but with multiple heads, each running separate programs yet still sharing the same tape -- what happens if more than one head writes to the same area of the tape?
Our research advocates a move towards systems where the focus is on interaction between minimal sequential subsystems. Rather than building huge monolithic structures, the same result can be achieved using a number of smaller components, running in parallel. Such a strategy has been suggested in varying forms over the years, but due to the perceived future evolution of the microprocessor, this is now an essential requirement, rather than a design ideal or optimisation. We also provide a formal grounding for such designs, based on academic research which has been largely overlooked in the industrial sector. Security also forms an inherent part of both the design and formal model by allowing restrictions to be imposed on the communication between individual components.
What we propose here is a compromise; we introduce a new framework, DynamiTE with a task-oriented design methodology, which retains as many familiar ideas as possible. Unlike existing efforts, we avoid introducing a completely new programming language. Instead, we build on top of an existing one (Java) which is already familiar to many software developers and which uses constructs with which they are already familiar. In doing so, we remove a huge barrier to adoption; the implementation of the framework is no longer some mysterious mass of code written in an obscure functional language, but a Java library like any other which developers may even be able to contribute to with time.
