Development Systems 

Update/Extend License                Download/Install

All development systems are fully interoperable and may be packaged in any number of ways.  Three comprehensive, fully interoperable development systems are currently available.

SoftBuilder represents a new category of software -- programmable middleware -- that both speeds development and increases software reliability and maintainability.  Flexsys provides an ideal compliment by supporting legacy systems, including XML development in our patented visual Flexform environment. AutoBuilder is our latest package, and is based on recently patented methods that both automate key development processes and guarantee that software will operate correctly exactly as specified.  Click here for more details.

Scandura Development systems are currently only available under license to commercialization partners and for academic R&D.  

Please see Partners for information on how to become a corporate partner.  Please see Opportunities if you are an Academic and wish to use Scandura Development Systems for instructional purposes and/or R&D.

 

Developing distributed systems in the standard way is a complex business. Building and connecting components one-by-one only to find that existing links no longer work is both frustrating and expensive.  In contrast, Scandura development systems make it possible to build and test such systems locally on one machine.  New components can be inserted and distributed via simple plug and play.  Even new  messaging infrastructures (ranging from simple file transfer and ftp to IBM's MQSeries) can be plugged in  -- without further testing.  

You owe it to yourself and to your company to compare what we are offering with well-known alternatives such as: BEA, Commerce One, Tibco, Vitria, WebMethods.  Remember the rationalization "No one ever got fired for buying from XXX."  When word gets out, that may well be converted to "Anyone overlooking this opportunity should be fired!" *

Development System Products

SoftBuilder: SoftBuilder represents a new category of software -- programmable middleware.  It is a unique, fully extensible system that both speeds development and increases software reliability and maintainability. It allows business analysts and designers to create and maintain dynamic models of distributed interacting systems. Special support is provided for simulating interactions within and between business enterprises, but it can equally well be used to quickly develop any software system -- distributed or otherwise. Both automated and manual interactions between independent event handlers (e.g., humans, communication software) and applications are supported. Models may combine human simulation with executable components at any and all levels of abstraction. Simulation enables designers to test system logic long before implementation. Tested models, in turn, may be implemented using off-the-shelf components, applications and messaging infrastructures. Details below:

Flexsys: Flexsys provides an ideal compliment by supporting legacy systems, including XML development in our patented visual Flexform environment. Flexsys' components automate many reengineering and conversion solutions and Flexsys' meta-components facilitate the construction of custom tools -- for example, for automatically converting between competing XML standards. Such tools make it possible to cost-effectively automate a wide variety of general-purpose and application-specific solutions.

AutoBuilder: AutoBuilder is our latest package, and is based on recently patented methods that both automate key development processes and guarantee that software will operate correctly exactly as specified. This package is undergoing advance alpha testing and is available only to a select number of individuals around the world.  Click below to learn more about our unique fully integrated product line and our partners.  Then contact us.  Becoming a partner will open opportunities that will stretch your imagination.

Overview of Technical Capabilities

Scandura’s products are based on a unique, universally applicable and easily programmable software "bus" that enables true "plug and play" integration. When plugged into this unique software bus, existing components, applications and messaging infrastructures automatically interoperate and components can easily be replaced with improved versions, as they become available.

When building a B2B (or other distributed) system, custom components can easily be added using a refreshingly simple and highly intuitive interface coupled with a powerful, highly secure but equally simple development language. This language is fully extensible, based on abstract syntax trees, (ASTs) and increases both predictability and software development/integration productivity by a factor of ten during development.

These technologies can be integrated with a wide range of complementary tools, providing a robust suite of software development and integration solutions while ensuring customers that their investment will remain easily adaptable and never become obsolete. Dramatically increased predictability also make it possible for a partner to offer a wide range of software services in a highly cost-effective manner.

Whereas existing software development and integration technologies are highly complex and can only be used effectively by software specialists, Scandura's technologies automate development and integration utilizing fully extensible and unusually easy to use technologies. They are based on Abstract Syntax Trees (ASTs) with semantic attributes, plus an easy to learn high level design language that is optimally designed for manipulating ASTs. ASTs provide a completely general and precise way to represent concepts, data and processes in the real world. Three patents protect key elements of Scandura’s technology and a fourth is pending.

The Technologies: A Closer Look

Scandura technologies define a new category of software called "programmable middleware". These technologies include three categories of fully interoperable components:

Development Environment

The development components dramatically simplify the construction of distributed interacting systems, both within and between enterprises over the Internet. Rather than competing in the integration market, these components avoid uncertainties resulting from competing standards by rising above the battle through the use of ASTs and Scandura’s high-level design (HLD) language.

The integration of independently developed messaging infrastructures, applications and components can be accomplished in a small fraction of the time it normally takes using standard development languages and techniques. For example, one can create dynamic (i.e., executable) models of complex supply chain scenarios in a few hours (even minutes). Once tested, these models can be implemented and distributed over intranets and the Internet in a systematic step-by-step fashion -- literally by selecting names of available replacement components and messaging infrastructures. Rather than constructing distributed systems before testing as is normally done, implementation consists of simply plugging executable components into tested models.

Unlike most integration frameworks, Scandura's development environment is completely general, and can accommodate any kind of interacting system and/or messaging infrastructure. It supports both non-real time and real time communications, and logic can easily be shared between system components.

Arbitrary processing logic is easily specified in ASTs using the high-level design language in a patented visual environment, which supports hierarchical development and maintenance. New components, including event-driven components (called event handlers) can easily be constructed. Event handlers include optional interfaces and arbitrary processing logic. They can send information to and receive from other event handlers. The environment automates key steps in constructing interfaces.

Other components provide an ideal complement by supporting legacy systems written in or using essentially any data format or source code language for which a well-defined grammar exists. These components use patented technologies to construct custom systems, which automatically reverse engineer arbitrary textual data (including source code) into ASTs, where they can more easily be manipulated. Conversely, they are used to construct custom generators, which generate text, tagged data or source code from ASTs. For example, they greatly simplify the construction of automated converters between arbitrary XML formats or programming languages.

Additional components, currently under advanced development, promise even more. An unusually comprehensive patent published August 14, 2001 protects these components. They automate many of the above development tasks while GUARANTEEING that systems perform exactly as specified. For example, these components will automatically construct hierarchies of equivalent designs, making it possible for domain experts (as well as programmers) to quickly develop and maintain internally consistent code. 

Guaranteed correctness has never before been possible and represents an important breakthrough with almost unlimited potential. These components are fully compatible with the others and will be ready for commercialization and gradual introduction in the upcoming months.

Integration Environment

The integration environment consists of a powerful adapter generator and a run-time generator.

The adapter generator provides three essential services:

The run-time generator creates run-time versions (DLLs) for any high-level design component or group of components. Similarly, third party messaging infrastructures (e.g., ftp, IBM's MQSeries) can be substituted for defaults. Run-time components may include arbitrary logic -- everything from automated data converters to higher order processes for constructing entirely new processes.

In addition to supporting the integration of newly developed and/or wrapped components (for which adapters have been created), the Scandura's Integration Environment also serves as a "snap on" to existing components or even to entire existing (distributed) systems. This "snap on" feature, using bypass links, makes it possible to easily add new components to an existing system (e.g., to further automate an enterprise and/or inter-enterprise wide system). While similar integrations can be done using other development and integration tools, considerably more effort would be required.

While the Development Environment makes heavy use of Windows (95/98/millennia and NT/2000) GUIs, the run time Integration Environment is largely platform independent and may easily be adapted for use with Unix and other operating systems.

Pre-built Components

The Scandura's technologies include a broad array of powerful, pre-built high level design components which also interact with the other high level design tools available from other leading software development tool vendors. A patented visual design and editing environment, which makes software designs largely transparent, is an integral part of the system, used in both data (e.g., XML) modeling and coding in high level design and 3GL (e.g., C/C++ and Java) languages.

Not only is all external development and maintenance done in this visual environment but the entire system itself, from top to bottom, was developed and is maintained entirely in this form. Experience indicates that Scandura saves approximately 25% on new C/C++ development and at least 50% on on-going maintenance. High-level design development is faster by a factor of at least ten.

Also included are a wide variety of pre-built reverse engineering, generation and default conversion components for XML as well as most common programming languages (e.g., C/C++, Java, Pascal, Fortran and COBOL). The default conversion components can easily be customized to automatically perform essentially any desired transformation. Competing XML formats, for example, become a non-issue in this context.

Also available are a series of distributed supply chain scenarios, designed by the advanced technology program (ATP) consortium and implemented as above. These scenarios can be converted into working systems by supplementing them with selected components.

Productization to Date

Scandura's technologies have been field-tested and commercialized on complex real world projects and as part of a large advanced technology program. They have been used successfully to model, test, implement and deploy supply chain scenarios at IBM, Boeing and TRW.

Other development components have been used successfully on large reengineering and conversion projects. These range from automatically converting between rival XML formats to automatically converting over 600K lines of highly optimized VAX Pascal code into C/C++ on Unix.

Because ALL components are fully interoperable, they can be offered in any combination either as software tools and/or to provide high profit margin services. Scandura has developed several easily modified packages, including Softbuilder and Flexsys, along with a fully integrated and operational system for monitoring usage and linking that information with a comprehensive database. This system makes it possible to monitor component usage over the Internet in a secure environment (and, e.g., to bill accordingly).

Softbuilder

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.

Flexsys

Flexsys provides an ideal complement to SoftBuilder by supporting legacy systems. Flexsys' components automate many reengineering and conversion solutions and Flexsys' meta-components facilitate the construction of custom tools. Such tools make it possible to cost-effectively automate a wide variety of general-purpose and application-specific solutions -- for example, by passing data (e.g., XML) or code (e.g., Java) between applications and extracting business logic in legacy applications.

In addition to a wide variety of code generation, reverse engineering and conversion components, Flexsys includes patented meta-components that automate the construction of new and customized reengineering and conversion components.

In effect, Flexsys is an unique software tool factory which greatly facilitates, even automates the construction of custom tools for automating a wide variety of reengineering, conversion and E-commerce solutions: Solutions ranging from finding and fixing mundane Y2K and Euro-conversion problems to integrating legacy applications over the Internet (e.g., via XML), extracting business rules and web enabling legacy applications.  

Flexsys is the first system of its kind.  It is designed for use by software service providers and others responsible for maintaining large software systems, whether they be local, on Intranets or on the Internet.  The software can be written in any language that has a well defined grammar.  In addition to empowering users, support is currently available for many dialects of C, C++, FORTRAN, COBOL, Pascal, Ada.  Recent additions are Java and XML.  These extensions are all fully interoperable and make it possible to automatically import arbitrary source code into Flexsys unique Abstract Syntax Tree (ASTs with semantic attributes) repository.  

Once in ASTs, patent pending processes can be used to easily create patterns and high level design code to automatically detect and modify arbitrarily complex code structures.  In addition, code can be viewed and easily modified manually in our patented AST-based Flexform environment.  Documenting and maintaining source code as visual Flexforms has been shown to make code 25-50% easier to understand, document and/or modify.

Flexsys consists of an easily extensible set of interoperable components and meta-components.  Many of these components are written in the C/C++ language for optimal speed.  Others are written in Flexsys' High Level Design (library) and/or SLANG languages for ease of development and maintenance.  HLD provides the full power of a language designed for use in manipulating arbitrary ASTs (which can be used to model essentially any structure, real world or otherwise).  SLANG is a very fast functional language for processing textual statements in ASTs.  Collectively, they combine ease of use with the power and efficiency necessary for automating essentially any reengineering and/or conversion tasks.

Whether written in C/C++ or HLD all Flexsys components are fully interoperable HLD components in their own right.  Both high and low level Flexsys components can be freely assembled to achieve arbitrarily complex goals based solely on semantic requirements.  Moreover, new components can easily be added to accomplish unforeseen tasks.  In addition to the HLD and SLANG languages, this is greatly facilitated by Flexsys' meta-components.  The are components that automate many of the task involved in supporting new languages or for creating custom converters to meet application specific needs.

As a corporate member of an IBM-led government project, Scandura also shares rights to ALL software developed with government funds. Among others, these include a Virtual Situation Room enabling media rich and secure communication over the web, and an automated negotiation server based on a sophisticated rule system.

Components Included in Each Available Product Package

 FlexSoftTutor: Softtutor and Flextutor.

 Tutors w/ auto: Softtutor, Flextutor, Autotutor.

 Visual Developer (not available): Flextutor, Visual Flexform Pseudo-Code Designer and Code Generator (with XML, C/C++, Java supported; Pascal, Ada, Fortran and COBOL available as is).

 SoftBuilder: Softtutor, Visual HLD Flexform Designer, Invert Hierarchy, Update Repository, HLD Interpreter/Simulator, Visual HLD Debugger, Create Distributed System, HLD Adapter Generator, HLD-C Generator,  Tool Checker.

 Flexsys: All components in Visual Developer plus Reverse Engineer, Language Translator, Assorted Analysis Tools, Language Meta-Tools which Automate the Creation of Custom Generation, Reverse Engineering and Conversion Tools.

SoftBuilder with Flexsys: Softbuilder and Flexsys. 

AutoBuilder (not available): All components in SoftBuilder plus Autotutor and AutoBuilder (which insure fully consistent hierarchical development and guaranteed correctness with respect to specifications.  Is fully compatible with but dramatically extends SoftBuilder.

 Scan: Includes ALL components in SoftBuilder, Flexsys and AutoBuilder.

 Local License Server: Allows use of Scandura Development systems behind a firewall.  Available only under special license.