The Future of Programming
​SPLIT THE APP
Make Creators, Not Users

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. Short Version.

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 PLM 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. That 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 external subroutines called "Code Engines" (CE). 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 (interactive or batch) that can automatically launch one or more CEs without any custom containerization. Many different classes of UIF, like game engines, textbook frameworks, and 2D/3D design programs and optimizers, can be defined to allow mixing and sequencing of CEs from anyone. This goes far beyond the traditional scripting and command files of Unix filters. The future of programming will be the launching of complex CEs from common UIFs.

​The third object specifies XML text files (VXML) that can contain any program variable or data structure. 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 for all program data.

One UIF offered by TSPA is a spreadsheet that handles general calculation and analysis needs. Code engines are launched in the background and it looks like the calculations are done in the spreadsheet. 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, protected, have long lives independent of technological changes, and located anywhere on the web.

​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 as part of the World Wide Web.
The Web and TSPA framework are free, but the TSPA components (PEX, UIF, CE, VXML) you add may be fee or free - public or private.
The interstate highway and exits are free, but you can build hotels, libraries, or private companies at the exits.
The products may be open to the user public (UIF readers) or available for others (SMEs) to build combined products.
Cars are sold to the public that are built with components (CEs) that come from other factories using common transport.

 
In the picture above, the free Interstate Highway System is the World Wide Web and the traffic control and roads at the exits are the open source software (OSS) tools. TSPA breaks the traditional app into three parts: the User Interface Framework (UIF) "readers", the calculation Code Engines (CE), and the data in common container (VXML) "data boxes" that are plug compatible with all components. Components are created independently by the appropriate stakeholders: computer scientists, subject matter experts, and industry groups that work towards unified data definitions. Components can be reused for many purposes automatically.  They can be written in any programming language, protected, immune to changes in technology or any other component, and uploaded to the web for monetization by the creators for use by all. TSPA's VXML data boxes will change Web programming just like the intermodal container system changed the world economy. Ford's 2017 Fiesta was assembled in Mexico with a Brazilian engine and a Mexican transmission and then sold at car dealers across America.

It's time to break apart the monolithic app cathedral to build a bazaar of digital components for content experts and users. The creation of an app needs more than just agility of computer science centric ideas. It needs plug-compatible base component objects created independently by all stakeholders. It needs external structural collaboration and agility, not side-by-side human interaction agility of computer scientists in each company. TSPA provides that open framework structure for all.

Now that more than half the population in the world has access to this web highway, that's a huge market of users and creators who need to be disconnected technologically and financially from the traditional top-down monolithic app process controlled by computer specialists. The TSPA split greatly lowers the cost of programming and opens up a vast new world of plug-compatible components and computer solutions by and for all.


​
Tweet-Level Explanations (Multi-Tweet Learning):

Something has to give. Traditional Apps don't fit a client-server Web model. How do programmers write for SaaS?

Why do calculations need to be tied to user interfaces? Why is everyone STILL defining their own data structures and file formats?

Split the App. Use plug-in building blocks so we all play in the same Web development sandbox. Users become creators and take back control.

User interfaces live In browsers. Calculations and data live on the Web and are contributed and connected by all.

Build all digital systems from the bottom-up with plug-compatible external Web components.

Eliminate Data Integration Hell. Automate and connect legacy data and files with new data definitions.

Make PLM, Digital Twin, MDE/MDO, IoT more external, automated, collaborative, realistic, and affordable.

Shipping containers changed the world economy. TSPA COTS containers will do the same for the digital economy.

Split data definitions from file formats. Split Methods from Data. Define external class definitions. Unify Data.

VXML data containers are to general programming as HTML is to web programming - one file for all. Why hasn't this happened already?

The computer technology world consists of more than programmers and "users." Hello Subject Matter Experts!

​Don't turn everyone into programmers. Eliminate unnecessary programming.

​Most people on Earth are connected to the Web. They are more than just users or programmers.

Programming is too complex and costly. Eliminate programming bottlenecks. Open new markets.

Content experts are creators and drivers of new digital products. They've been treated as users or told to learn how to program.

Agility is not created by working side-by-side faster. Agility is created by working apart faster. Structural Collaboration.

Collaborative web development of complex systems with a "gig economy" will become more common or necessary.

OSS is for Programmers. TSPA is for Programmers AND Subject Matter Experts AND Users. Create without programming.

Build Open Computer Technology (OCT) plug-in components for all creators.

Organize Open Data Definition (ODD) Communities to standardize common data in each VXML Data Box. 

OCT = TSPA + OSS + ODD  : Computer technology is NOT just about programmers and OSS. Empower ALL stakeholders.

Define common external Version Control and DevOps methods for all players in the global digital economy. Git/GitHub is just the start!

Change programming from a vocational skills career crapshoot to one that is more transferrable over time, technology, and companies.

Encapsulate learning curves, knowledge, and skills.

Expand from Full Stack to Full Web Programming with plug-in calculation and data components located anywhere on the Web.

​Divide and collaborate. Conquer costs. Automate tasks. Unify data. Make creators, not users. Open new markets. Win-Win-Win.

New Digital Web Definitions:

WWW = Interstate Highway System
OSS = Roads and traffic control at the exits - Civil Engineering
TSPA = Split of apps into plug-compatible components that fit this highway
   UIF = Stores (readers) at the exits - Computer Scientists in browsers
   CE = Manufacturing companies (calculations) at any exit - Subject Matter Experts in any programming language
   VXML = Variable XML files for any data - Horizontal, Vertical and Longitudinal Industries
          These plug-compatible data box "containers" will be used to unify the new digital economy
   PEX = System unification that connects processing and data spread over the Web - PLM, IoT, Digital Twin, PIDO, …

OSS will end up focusing on the free infrastructure and maintaining the Web - Win-Win
Programming will be driven by SMEs combining plug-compatible calculations and unified data containers
OSS will be separated from components that are free, but not open source
COOPETITION - Systems will be built by plugging together (free/fee) components from many with no programming.

​Burma-Shave Explanation:
Why does
Programming
Make you nap?
Be productive.
Split the App.

​TSPA

---

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!