SoftBuilder - Development Systems
SoftBuilder - Development Systems
Update/Extend
License
Download/Install
SoftBuilder
Repository,
Languages and Meta-Components
SoftBuilder
Components
Overview: The SoftBuilder environment helps analysts and designers to easily create and maintain dynamic models of arbitrary systems. Special support is provided for simulating interactions both within and between business enterprises (i.e., e-business). Automated and manual interactions between independent event handlers (e.g., humans as well as event-driven servers) and applications are supported. Designers can create e-business models, for example, which combine human simulation with executable components. Simulation enables designers to test system logic long before implementation. Tested models, in turn, may be implemented automatically by plugging in off-the-shelf components and applications.
SoftBuilder includes a patented display environment, making it easier to understand and maintain program logic. It also includes a unique interpreter allowing designers to create, execute and debug High Level Design (HLD) models in a visual environment at any and all levels of abstraction (patent pending). Other SoftBuilder components provide automated support for implementing HLD models. Existing components can automatically be converted into HLD components, GUI and other application shells can reference HLD components and net-based applications can replace HLD event handlers used in simulation models.
Thumbnail descriptions of SoftBuilder's HLD Repository, Languages, Components and Meta-Components are given below. SoftBuilder runs on PC's running Windows95/98/NT.
HLD Flexform Repository: The HLD Flexform repository consists of linked ASTs with semantic attributes that directly support real world semantics. This repository provides an ideal environment for representing arbitrary data structures, operations on those data structures and groupings of these data structures (e.g., libraries, objects, units, systems, sets of systems, etc.). It can be accessed and manipulated directly via a visual environment which supports contextual viewing and editing at any and all levels of abstraction (U.S. Patent 5,262,761). The HLD Flexform repository is an HLD version of the Flexform repository. It supports the dynamically extensible, semantics-based HLD language. All levels of the Flexform repository can easily be accessed from other tools via a simple HLD interface.
High Level Design (HLD) Language: The HLD language is a powerful, easy to use language that is ideally suited for manipulating the Flexform repository, at any level of abstraction, from individual characters to high level semantic relationships between Flexforms and elements thereof. The HLD language makes it possible to quickly create custom components for performing essentially any definable reengineering task. Not only can the HLD be used to gather information implicit in any Flexform repository, but it can be used to modify the repository automatically. Among other things, the HLD can be used to create mini-procedures, which work in conjunction with SLANG (see below), to convert from one language or operating system to another. Mini-procedures operate at the parser token, statement, before and after module, and before and after system levels. Mini-procedures and Semantic Postprocessors are used where it is necessary to manipulate information in a broad semantic context. Source is available for several language conversions.
HLD Component Generator: This component automates the process of integrating third party components into SoftBuilder. Given a component written in or callable from C/C++ (e.g., Visual BASIC), along with basic type conversion information, the HLD Component Generator converts that component into HLD. HLD Component Generator makes direct use of the following SoftBuilder components which can be used individually.
Semantic Wrapper / Semantic Integrator: These two meta-components (available as separate dynamically loaded libraries) make it possible to wrap software components from essentially any source, including legacy code, in a semantic wrapper. The semantic wrapper enables these components to interact with other wrapped components. Core components serve as semantic "glue" which makes it possible for software components from arbitrary sources, once wrapped, to interoperate based on semantic considerations without regard to interface issues, global variables and the like. The wrapping process has been largely automated. Generate Semantic Library automatically integrates wrapped components so it can be dynamically l9aded with any other set of semantically wrapped components (e.g., core semantic library).
HLD -> C Generator: This meta-component generates full C code ready for the compiler from high level designs (HLD) implemented in terms of semantically wrapped software components.
HLD Designer: The HLD Designer is used to create and modify Flexforms which represent HLD AST's in SoftBuilder's semantics-based repository. The user can choose from a variety of visual representations, ranging from the instantaneous text based editing (often preferred by those at home with traditional text editors) to GUI Flexforms (including simulated 3-D). The latter are fully event driven, among other things making it possible to simultaneously view and edit as many Flexforms as desired . SoftBuilder's modular AST repository directly and fully reflects underlying system semantics. The repository includes relationships between modules (e.g., structure charts) and compilation files (units), and the modules themselves -- at all abstraction levels. Based on patented display technology (U.S. Patent 5,262,761, 1993), Flexforms may be expanded directly in context, as well as in separate windows. High level system overviews and individual modules may be linked, viewed and edited in a highly interactive, uniform visual environment. Switching between high level overviews and individual modules is instantaneous.
Interpreter: The Interpreter can interpret arbitrary HLD programs. These HLD programs may reference virtual (made up) components as well as components in any given set of HLD libraries. Virtual and executable components fully interoperate. High level virtual as well as executable functions and procedures may be intermixed in developing HLD components. Indeed, HLD applications can be simulated dynamically at any specified level of abstraction. The Interpreter comes with a core HLD library that is ideally suited for manipulating Flexform ASTs. Particularly notable is the HLD SIM library, making it possible to dynamically model and test interacting systems, with a focus on e-commerce and e-business.
All Flexsys and other SoftBuilder components (including the Interpreter itself) also are available to the Interpreter. Even the Interpreter is available to itself.
Third party components can easily be made available to the Interpreter (e.g., graphics and multi-media). The Interpreter comes with a powerful and easy to use debugger, which enables the user to intermix executable and manual (to be simulated) operations at will. This makes it easy to develop and prove systems incrementally at any combination of top-down and/or bottom-up programming and design.
Update System Repository: A major problem in using traditional software tools is that designs and code quickly get out of sync. Carefully constructed designs go for naught once programmers start changing the underlying code. In Flexsys, this problem is avoided because all system changes, including the lowest level code (not just system designs), are made directly in the Flexform repository. Update System Repository automatically updates system designs to reflect changes in individual module Flexforms. The addition of a subroutine parameter, for example, or a call on a new subroutine, will automatically be reflected in the associated system call hierarchy (structure chart) and unit (file) hierarchies.
Invert Hierarchy: Inverts any given hierarchy Flexform (e.g., produces a uses hierarchy from a call hierarchy).
HLD Checker: Statically checks HLD applications for common mistakes prior to execution.
