The Future of Programming:
​SPLIT THE APP

TSPA defines a new open source programming architecture by splitting application ("apps") into three independently developed and validated "external" objects that can be located anywhere on the web and combined by users to create new and automated solutions without writing a line of code.  Calculations and data processing (Code Engines -CE) are split off from user interfaces (User Interface Frameworks - UIF), and open source hierarchical industry standard XML data file schemas are defined. This organization provides automated solutions that cannot be created any other way. TSPA has gone through three working revisions over the last six years and is being prepared for a formal release. See the Paper Trail for historical details.

TSPA defines an eXternal Object-Oriented Programming (XOOP) "soup" environment where data definitions and methods are split into two separate objects and controlled by industry and subject matter expert (SME) stakeholders. Industries define common Variable XML (VXML) data schemas and SMEs create plug-in calculation tools. TSPA provides open source I/O code to allow everyone to work together on compatible tools from small calculations to systems like Digital Twin. Experts become creators of new solutions, not simple users who have to rely on third-party software that can have limited customization and severe market constraints. After 50+ years of software development, many needed programs are not created and many markets not properly served.

Traditional "App" Programming Architecture

In a traditional app programming structure, programmers tie a custom user interface to a fixed set of calculations and data processing. They also define their own proprietary data file formats which require neutral file translators to use other apps. These translators might not exist, may not work correctly, and they slow down the work process. One paper refers to this as "data integration hell." More critically, apps with user interfaces do not allow their data processing code to be separately sequenced and automated for new tasks. This is a fundamental flaw of the interactive app programming architecture.

Traditional apps are also more costly to create because they require cooperation between both programming experts and subject experts. For a huge number of markets and application areas, this greatly limits the development of programs. When technology changed, as when DOS changed to Windows, many calculations were lost. The calculations may still be valuable, but the cost of converting them to a new technological app format was not justified. Now, with a change to web-centric app programming, good calculations are again being lost.​ TSPA breaks apps into more basic and independent programming objects.

New TSPA Programming Architecture

TSPA breaks the app into three separately developed and tested objects that can be located anywhere on the web and combined in many new and creative ways by users and SMEs. The first objects are called "Code Engines" (CE), which act like external subroutines. They are batch exe programs that read XML text files of input, do some calculations or data processing, and then write out the results into the same or different XML file. Code Engines are like Unix "filters" on steroids, but they read and write XML files containing  any program data, not just text string data. The next objects are the open source User Interface Framework (UIF) front end programs that can automatically launch one or more CEs without any custom containerization. Many different classes of UIF can be defined to allow mixing and sequencing of CEs. This goes far beyond the traditional scripting or command files of Unix filters. The future of programming will be the launching of complex CEs from many different UIFs.

​The third object specifies XML text files that can define any program variable or data structure (VXML). TSPA defines an open source hierarchy of XML schemas that can be applied to any program data or structure along with open source code for file I/O. VXML is to general programming as HTML is to web programming - one XML data file type for all. The UIF vehicle of choice is a spreadsheet program with open source macro code that handles different calculation and processing needs. Code engines can be launched in the background with input and output tied to cell locations. Users can combine CEs in many new and creative ways without writing a line of code. Code engines can be developed in any programming language, tested separately, have long lives independent of technological changes, located anywhere on the web, and be combined by users. Processing speed, fast storage, and web flexibility now make this possible, or rather, required. There is no longer any reason not to separate code even if you are writing a traditional custom UI/app. ​

TSPA is more than Open Source Software - OSS
It's Open Computer Technology - OCT
For All
Make Creators, Not Users
Move People's Cheese

FOLLOW TSPA

Leave Your Email and Get the Latest News!