One of the biggest obstacles that impedes the productivity in software industry is the separate islands of the dynamic and the static software development environments (DSDE and SSDE). Since embedded/real-time systems require a high performance and quality that today's DSDE cannot satisfy, people use DSDE just for prototype and cannot deploy the prototype into product. They have to re-implement it and then get two separate islands which cannot be handled effectively to meet the future change. Most software engineers prefer to develop their software in their favorite SSDE to avoid programming twice: prototype first and product development afterwards. Today's technology changes so fast that they almost certain to find that this traditional method hinders them from catching up the change.
The other major obstacle in software industry is the lack of an integrated environment that can support heterogeneous computing models. The current situation is that each language or a tool provides exactly one rigid built-in model that can only be used in a narrow domain. Modern applications can be very complicated that require the cooperation of different computing models. While today's software becomes more and more complex and cooperative, more and more software development tools are invented in a limited problem domain, not addressing to the whole spectrum. As a result, software engineers are separated by different languages and tools and are unable to communicate effectively. Reuse among different application domains becomes very difficult.
Magicframe is a new software development environment aimed at removing the two obstacles mentioned above. The project is based on the programming language Transframe, which integrates the concept of the dynamic typing and the static typing system. MagicFrame will demonstrate the power of the new method to support both rapid prototyping for productive development and quality product delivery for high performance and easy maintenance, and to support heterogeneous computing models and architectural styles in an integrated environment.
MagicFrame is a two-year research project for designing and implementing the software development environment built around the Transframe language. The result is to demonstrate the power of freezing/melting system to support both rapid prototyping and high quality software product delivery, and demonstrate the power of high-level model composition to support heterogeneous computing models and architectural styles for widely diverse applications.
The environment contains the following five parts.
(1) Freeze/Melt Environment
Based on Transframe's type system, MagicFrame programming environment offers a transformable framework either freezable in dynamic programming system or meltable in static type system. The transition from prototyping to product is taken gradually by freezing more and more parts from the dynamic system into the static system. Should any change be made in a part of the static system, this part can be melted into the dynamic environment later.
The freeze/melt environment includes the following parts:
(2) Standard Library
Standard library provide a set of efficient static modules with a set of validated commonly used classes and functions, which covers:
The semantics database associated with standard library will also provided. This helps developers to design and prototype dynamic classes based on the static classes provided in the standard library.
(3) Application Framework Shelf
MagicFrame will take a great advantage of the Transframe's capability in the description of various high-level computing models. Each model is an application framework which represents a typical architectural style for a specific application domain. MagicFrame provides an application framework shelf that maintains a number of commonly used application frameworks such as multithread task, active object with communication ports, data-flow driven model, and so on.
This way, we establish a software development process named middle-out development that contains two teams: one team build the application frameworks and the other teams uses the frameworks to build applications. A user-model is a special model adapted to a specific domain. By this way, application developers will always use their own native language or model to describe what they are going to develop.
Since all user models are based in a transformable framework, the MagicFrame system can create a visual representation for the model. And since the model is native to application domain, application developers can use this visual representation to develop their application without extensive coding.
(4) Visual Design/Development Interface
Visual Design/Development Interface provides a friendly graphic user-interface for prototype design, software components manipulation, debugging, and testing. Each class has a default graphic representation, so that source code can be viewed, debugged, and edited in hypercode.
Customized graphic representation is supported so that developers can describe specific graphic representations for their own model, for example, a specific application framework for users to created a distributed client/server system in a visual design interface.
Developing application software without coding is possible only when the framework in the development tool fits into the application's architecture. For example, a data-flow chart design tool for digital signal processing system, active object frameworks for some communication systems, and multiple timing thread model for multimedia animation system.
MagicFrame provides heterogeneous frameworks. Application developers can always chose the one that fits into their application architecture. Meanwhile, all the frameworks are based on a common transformable framework in which a generic visual representation can be customized to various forms for specific architectures.
(5) Interface with Other Languages and Systems
We recognized that very large amount of useful code has been and still be produced in languages C and C++, the environment will therefore provide facilities for integrating code written in C and C++. The facility includes the support for function calls in both directions and an automatic Transframe interface generation from C/C++ head files.