DynamiTE - Summary

This group is not part of the GNU Project.

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.

Registration Date: Wed 18 Feb 2009 04:02:43 AM UTC
License: GNU Affero General Public License v3 or later
Development Status: 3 - Alpha