1. Lifting Platforms Beyond Calculus for
Choreographing a Cloud Revolution
Lifting Platforms Beyond Calculus
for
Total Application Optimization
Today’s mainstream programming technology cannot meet the agility requirements for timely R&D exploration. We have lifted FORTRAN beyond calculus and can use this higher platform to lift other languages like Python to automate modeling and computerization to apply a new deep-nested, massively parallel approach to multi-disciplinary design optimization of new one-of-a-kind applications.
MetaCalculus, LLC

2. A Scientific Mass-Parallel PaaS
Platform as a Service for R&D buildout …
A Scientific Mass-Parallel PaaS
MetaCalculus Python
from MetaCalculus Fortran
+ Spiritext + Spreadsheets
Diversified MetaScience
The Platform as a Service will provide virtual massively parallel cloud supercomputers end-users can program and interactively run from PCs or Android tablets. MetaCalculus provides the modeling paradigm for an R&D race build-out. This will be a renaissance of IBM’s original R&D growth of the computer industry, driven by end-user scientists and engineers, pursuing free-energy and a commercial renewal of the space program. But it will involve all software communities, first recycling most of the extant scientific software into the new mathematical regime of parallelized optimization.

3. A Sputnik Moment 1957 Brought Two Wake-up Calls
Meta Science Foundation
MetaCalculus, LLC
1957 Brought Two Wake-up Calls
Sputnik and FORTRAN
FORTRAN empowered engineers
Peer Division of Computing Labor
Engineers programmed models
Programmers produced algorithms
R&D Computerization Blossomed
IBM unexpectedly became a monopoly by introducing FORTRAN in It was initially resisted by the professional programming establishment, but generated enormous demand and application generation by appealing to engineers and scientists. They could learn FORTRAN in about 2 weeks, and became end-user programmers. In the Space program, shared R&D programming in FORTRAN became the norm, eliminating the need for requirements specifications, since the users evolved their own programs as needs dictated. Programmers and mathematicians were engaged to create solution algorithms for them to use as subroutines. So development was rapid, and R&D race timeframes could be met.

4. Software Automation Failure
But IBM aborted the mid-course correction
Software Automation Failure
10000
1000
100 10 1
0.1
0.01
$22000
$50
$10
$0.08
1957
1965
1972
1980
Daily
Computing
Cost
As computing cost fell
And labor cost rose
The burden should have shifted
From expensive labor
To cheap machines
via
Very-High-Level End-User Programming Languages
$70
$150
$200
$100
Daily
Labor
Cost
By 1962, however, solid-state performance kicked in and inverted computing economics. Companies like GE began capitalizing on it to introduce interpretive languages like BASIC with interactive time-sharing, which threatened IBM’s compiler lock-in market control. IBM retaliated with “vaporware” fighting machines, knocking GE’s threat out of the monopoly game.
By driving mighty GE out of the computer market, IBM forked the whole industry and created a moratorium on end-user very-high-level languages which threatened lease life (in 1970). We were just designing PROSE then, after four years of applying the new holon paradigm during Apollo. We entered the TS market in 1974, but we had only seven more years before the TS market infrastructure vanished with the PC cusp.
TS Market
Holon
Paradigm
PROSE
APOLLO
Instead we got PL/I, then C
A portable assembly-language surrogate
Later C++, then Java, then C#

5. Recyling Grew & R&D Computing Atrophied
Algorithmic Languages
PL/I, C, C++
Prolonged Hardware Lease Life
IT High-Cost Production via
IBM’s fork re-established the dominant slow pace of guild labor in professional programming to prolong computer lease life. Recycling of staple (mass use) software became the dominant priority, as it could amortize the prolonged labor costs. This also refocused programming on low-level machine-oriented algorithmic languages articulated for recycling and maintenance (e.g. strong typing). New R&D applications, being largely exploratory and one-of-a-kind, were not enabled by this posture, so industrial R&D automation atrophied. This was exacerbated by portable hardware languages like C, which emphasized machine address fetching (the assembly-language worldview), unnatural to engineering modeling, instead of problem-data addressing like FORTRAN. This characteristic became a guild-”gotcha”, that further discouraged end-user DIY programming. It was propagated to the successor lingua franca, C++, and was not removed until languages like Perl and Java came along, after programming labor-intensity had well passed the 100,000 multiple (in the previous chart).
IT Recycled Staple Commodity Packages
Business Week, 1980

6. Today - Modeling Gap: R&D Attrition
Software / Need Mismatch
The reason scientific computing has withered away, except in big-budget science, is that software technology is now driven by programmers who have no modeling skill, and don’t even comprehend the needs that define new modeling technologies. For 40 years, programming has been consumed with recycling and maintaining old software functionality. The whole open-source community is dedicated to this. Their main enterprise, Linux (recycling of Unix) has now been balkanized into over 200 strains. We have many languages at the same algebraic level of capability, differentiated mainly in style. Programmers without end-user guidance are mostly re-inventing wheels.
This is fractionated chaos. What happens when chaos reigns? A tipping point!
Turning this “hurd” of programmers into MetaCalculus search-engine mechanics (they are now SQL mechanics) as peer collaborators with end-user modelers (who convert science to equations) is the way to start an R&D race of end-user drivers and programmer mechanics in pursuit of free-energy invention (the polarizing goal like the Apollo challenge of going to the moon).
IT Waterfall Labor
Recycling & Maintenance
Mass staples & OS focus
Cosmetic agenda
Can’t diversify in Science
Know how to program
but not what
R&D Model Originators
Poor Modeling Tools
Ad hoc custom needs
Custom math agenda
Highly diversified Science
Know what to program but not how
R&D Stalemate (Catch 22)

7. Programming Tools Don’t Match the Need
The Market Need
Quick Programming of New Scientific Models
By End-User Scientists & Engineers
Not Programmers
Programming Tools Don’t Match the Need
So R&D Demand is Pent Up
The only way to serve the new energy invention agenda is through end-user scientific programming. The lack of mass demand in end-user programming is a totally artificial situation resulting from IBM’s fork and moritorium 40 years ago, and the consequent lack of vertical evolution toward end-user modeling. A giant leap occurred in the time-sharing era, and we are now ready to bring it back in the cloud.

8. R&D Demand Curve Narrow Opportunity Windows
decision threshold
number of projects analyzed
time to complete
Never
NOW
MetaCalculus Opens the Door
For R&D Market Growth
Insufficient time to complete application programming is the critical constraint on R&D market growth—the NOW demand constraint. It drastically restricts demand because conventional programming labor cannot even come close to satisfying the constraint.
“Agile development” is a band-aid that doesn’t come close to satisfying this need. It doesn’t even address the catch 22, because science learning curves (the diversity burden) are too steep for programmers to meet NOW timeframes. End-user scientists and engineers must drive the software. Programmers must work the engines and the software media (GUIs & languages). A peer re-alignment in the division of labor can shift everything in a sea change.
The Market potential is Huge, but
Infant mortality kills demand

9. Optimization Modeling Paradigm
Interpretive
Languages
AD Pioneering
MC1 – Model Compiler – NASA Apollo
MC2 – MODTRAN - FORTRAN Interpreter
Optimization & Estimation Modeling with Fixed Algorithms
MC3 – SLANG - Macro Language
Added System Dynamics Algorithm Differentiation
MC4 – SLANG/CUE
Modular/Relocatable Programs & Algorithms
MC5 – PROSE - Commercial Batch Processing
CDC Cyber, IBM 370, Univac 1100 Service Bureaus
MC6 – TSPROSE - Commercial Interactive
CDC Cyber Systems (Cybernet, United Computing Systems)
Stabilization of Meta Calculus Paradigm
16-bit Hiatus – Automatic differentiation infeasible on segmented memories
MC7 – Fortran Calculus 77 – DOS PC (protected mode) Version 1990
MC8A – SyCal, Synthetic Calculus Fortran 77 (coded – not tested)
MC7B – MC-Fortran 95 Dialects: FC2, MetaCalc, MetaFor (+Spiritext) 2010
MC9 – (Parallel Meta Calculus - TBD)
MOB Search (MetaCalculus Optimization Broadcasting)
MetaCalculus evolved the highest level of software expression, capitalizing on nested algorithmic differentiation to achieve a new holon modeling paradigm for optimization. It evolved four generations at TRW and NASA. In 1973, the first commercial language, PROSE (MC5) was introduced, and the sixth generation was introduced in MC5 and MC6 were marketed nationally to engineering users in Fortune 500 firms. The demise of the time-sharing market in the early 1980s interrupted its growth and the 16-bit mini-micro machines caused a hiatus, as interpretive automatic differentiation-based optimization was not practical on these puny machines.
In , non-interpretive MC7 (Fortran Calculus) was developed to satisfy DuPont’s requirements to port PROSE software to PC, Vax, and Cray machines. Subsequently MC7 was re-engineered into a new MC8 multi-language API for Windows NT machines. This development was shelved in 1995 due to uncertainties in Windows platforms and lack of funds.
Compiled
Languages

10. MetaCalculus is Escalation
Fortran
Calculus
FORTRAN
Optimal Design & Control
VERSUS
Math
Under
The Hood
Math in
The code
25 Statements
Escalation is raising expression to a higher and simpler metaphoric paradigm in which the one who knows and creates the science is in the driver seat, and all of the detail is under the hood. This is what a spreadsheet does and it is what SQL does. Users do not have to know how the search-engines work in order to define search queries.
Holon modeling self-organizes problems in the most natural way, like DNA. It is not something we invented. It is something we discovered. MetaCalculus is an ontological paradigm—a fact shown to us by systems philosopher, Arthur Koestler, who coined the term “holon”, and integral philospher Ken Wilber, who used it to describe his “Theory of Everything”. Thus it is a natural escalation paradigm for all mathematical modeling—it is not arbitrary. All mathematical languages will eventually incorporate it.
Holon Modeling
Paradigm
Higher and Simpler
Problem Expression
125 Statements
BTW, How would you approach this problem in Python?

11. Holon Modeling in TS Era
Optimization Holon
Correlation Holon
The 1975 R/D Magazine article “Computing in Calculus”, explained the modeling paradigm, without using the philosophy term “holon”. This limited PR is what helped us expand from Control Data Cybernet service to several other time-sharing vendors. CDC’s Minneapolis staff sat on their hands, so we broke their exclusive when they reneged on announcing PROSE in January 1974 with their new line of Cyber70 machines (part of our strategic deal and critical to our PR strategy). This is probably why nobody remembers either PROSE or Control Data.
15 years later, the academic mathematicians, who started a publishing movement, based on our semantics (automatic differentiation), missed the point of a modeling paradigm shift. We had leapfrogged them to holon modeling, which moved their work under the hood. They are Matlab’s boutique market—not an R&D modeling market, like FORTRAN unleashed in They are tool makers, not science modelers.
Simulation Holon

12. PROSE Met NOW Modeling Needs
MetaCalculus Time-Sharing History
Optimization Rapid Prototyping
Hughes Aircraft - Satellite Antenna Design Optimization - 3 weeks
FORTRAN estimate = 6 months
R&D Associates - Maximum Likelihood Estimation hours - Mentored
FORTRAN estimate = 1 week
Rockwell International - Space Telescope Optics - 2 days - Mentored
Tektronix - Electron Trajectory Optimization - 3 Weeks - Mentored
Ford Aerospace - Laser System Design - 3 days
Wyle Laboratories - Noise Abatement Optimization - 1 day
TRW - Optical Systems Optimization - 3 weeks
6 months FORTRAN effort unsuccessful
Sierracin Magnedyne - AC Motor Design Optimization - 1 day – Mentored
Goodyear - Radial Tire Design – 1 hour - Mentored
6 month FORTRAN effort unsuccessful
Bechtel Corp. - Steam Power Electric Network - 3 Weeks - Mentored
PROSE proved how MetaCalculus can revive R&D productivity. Using it, scientists could express their prototype models directly and automatically connect powerful search engines to seek optimum solutions. Then they could experiment with the output response of the searches, gaining insight to adapt and evolve the models, without exceeding their meager R&D budgets, not encumbered with the prohibitive cost of supporting mathematicians and programmers. PROSE introduced a peer process of extreme modeling, whereby scientists with modeling knowledge, assisted by mentor mechanics with expertise in PROSE solution engines, jump-started new applications in time to meet proposal deadlines, for example.
This peer division of labor is what we can now spread to the whole industry with a new PaaS approach.
PROSE proved how MetaCalculus can revive R&D productivity. Using it, scientists could express their prototype models directly and automatically connect powerful search engines to seek optimum solutions. Then they could experiment with the output response of the searches, gaining insight to adapt and evolve the models, without exceeding their meager R&D budgets, not encumbered with the prohibitive cost of supporting mathematicians and programmers. PROSE introduced a peer process of extreme modeling, whereby scientists with modeling knowledge, assisted by mentor mechanics with expertise in PROSE solution engines, jump-started new applications in time to meet proposal deadlines, for example.
This peer division of labor is what we can now spread to the whole industry with a new PaaS approach.
Optimization Re-Engineering

13. Meta Calculus Extended Languages
MetaCalculus Holon Paradigm
Modeling Holon Alphabet Op
Meta Calculus Extended Languages
Holon Templates Language Add-Plug Ins Co
Languages: Si
Meta Calculus is a holon modeling paradigm that generates software to solve nested matrix-inverse problems, generally for applications involving design optimization, scientific method correlation, and systems simulation. It is a three-element solution calculus that extends high-level languages to a much higher level of implicit matrix expression, by adding metaphoric operators that command hidden matrix-solution tools. These tools are dynamically interfaced to user-defined models via a calculus matrix engine harness, which performs automatic differentiation of the models and differential-geometry coordinate transformations to recursively nest and de-nest iterative search engine and simulation processes.
The modeling paradigm achieves unprecedented simplification at a very high altitude of abstraction because the three matrix-solving tool-operators are true conceptual building blocks of hierarchic mathematical matrix systems, but hide the mechanics of their solution processes.
This is the mature legacy of PROSE that scientists used before the PC era, to personally program sophisticated applications which middleman programmers could not even conceptualize in the lower-altitude framework of algorithmic languages.
We will now review the calculus of variations problem again to examine its semantics.
Calculus Matrix
Engine Harness
SYSTEMS OPTIMIZATION
Find … to Maximize
System:
API
SYSTEMS CORRELATION
Find … to Match
Nested Automatic
Differentiation
SYSTEMS SIMULATION
Initiate …
Integrate
Engines:
Interchangeable Solution Engines

14. Metaphoric (Non-Algorithmic) Template Modeling
Optimal Design & Control Application
Visible Source Code
This optimal design and control application is a simple but sophisticated mathematical example involving all three solver classes. It is an optimization problem containing a two-point boundary value simulation.
The inner boundary value simulation must find the initial condition of a coupled set of differential equations to match a terminal point boundary condition. This is an iterative inverse problem, and so is the outer optimization problem. Thus we have nested inverse problems, in which the inner one solves a set of simultaneous differential equations. Both perform automatic differentiation of its respective model to compute the gradient and higher derivatives of the function being searched for the solution condition.
This involves the recursive nesting of the two differentiation coordinate systems. As the inner solution is found by iteratively searching its coordinates until the solution condition is matched, its differential results must be transformed for use by the outer optimization solver in its search for the optimum condition. This requires an iterative differential geometry coordinate system transformation, which is part of the search-engine harness.
(non-algorithmic)
Find A in TWOPT
to Minimize OBJ
OPTDES
Find Y
in TRAJ
to Match Y 1
TWOPT
Integrate DIFF
TRAJ
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
Optimization
Solver
TWOPT
Find Y
in TRAJ
to Match Y 1
TRAJ
Integrate DIFF
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
AD Arithmetic A
AD Arithmetic
Y0
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
TRAJ
Integrate DIFF
Simulation
Solver
Correlation
Solver
Differential Coordinate System Inheritance
Holistic: Simultaneous Equations

15. Actual Program in TSPROSE language (1975)
Find A in TWOPT
to Minimize OBJ
OPTDES
Find Y
in TRAJ
to Match Y 1
TWOPT
Integrate DIFF
TRAJ
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
FortranCalculus Spiritext Version
Problem .optdes
interact
find a in .twopt to minimize obj
end
Default optimization solver: hera
This is the actual source code of the example in the time-sharing version of PROSE. The Meta Calculus statements are colored black to distinguish them from the more familiar language syntax, and the solver engine names are color coded to denote their membership in the solver classes. Note the absence of I/O statements, except for the INTERACT statement, which communicates with a terminal. Standard reports were generated by the default optimization and correlation solvers, employed in this example. So the user did not have to waste time in programming I/O while experimenting to get results.
Note also the absence of any loops or IF statements, even though the solution is iterative at three nested levels.
Model .twopt
find y0 in .traj to match y1
obj = z/2+a**2
end
Default correlation solver: ajax
Model .traj
y=y0, x=1, z=0, t=0, t1=1
initiate athena for .diff
equations zdot/z, xdot/x, ydot/y
of t step dt to t1
integrate .diff
end
Model .diff
zdot=x**2+y**2
xdot=-a*x+y
ydot=x+a*y
end

16. Another Program with Same Template Wing Design Optimization (1976)
Find A in TWOPT
to Minimize OBJ
OPTDES
Find Y
in TRAJ
to Match Y 1
TWOPT
Integrate DIFF
TRAJ
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
FortranCalculus Spiritext Version
Global all
Problem .wing
execute .setup
find eis,alpha in .flex by thor
under .tcon
with bounds delei,delalp
with lowers ieu,alphau
holding weight
matching altotl
to maximize winglift
tabulate xs,y
end
This is the essential part of the source code of another application having the same design pattern. This is a wing design optimization program that solves for the flexural rigidity vector and wing-section length vector that maximizes the lift of a cantilevered wing while holding a weight constraint greater than zero and matching a wing length constraint.
Note the under phrases in the find statements and the initiate statements. These phrases call a special type of user subroutines (not shown in the slide) which are known as solver controllers. These controllers are portals that pass option values to the library solver engines (thor, ajax, and athena), in this case. This is the way solution mechanics tune the engines, when necessary. It is how traditional programmers adapt the engines as peer assistants to end-user modelers, when numeric instabilities emerge and the iterative engines don’t converge.
Model .flex
find dy0 in .beamivp by ajax
under .icon
to match ypa
for k=1 to nei do
eiavg=eiavg+alpha(k)*eis(k)
repeat
winglift=integral(force,0,x,4)/
eiavg
weight=wtmax-eiavg
altotl=arrasum(alpha)-1
rowprint eiavg,winglift,
weight,altotl
tabulate eis,alpha
end
Controllers
Model .beamivp
x=0, y=0, dy0dx=dy0, xf=h, y(1)=y0
initiate athena under .acon
for .beamode equations
d2y0dx2/dy0dx, dy0dx/y0
of x step h to xf
for i=2 to,npts do
integrate .beamode
y(I)=y0, xf=xf+h
repeat
ypa=dy0dx-dy1dx
end
Model .beamode
sum=0
for j=1 to nei do
if(x ge sum and x lt
(alpha(j)+sum*wl) then
goto ode
endif
sum=sum+alpha(j)
repeat
dy2dx2=-integral(force,0,x,4)/
ei*(1+dy0dx**2)**1.5
end

17. Hidden Mashup Intelligence: Automatic Poly-Algorithm Synthesis
Similar to spreadsheet modeling, users are generally unaware of the sophistication of the metaphoric program synthesis they are achieving with simple nesting of Find statements in their ad-hoc models. Under the hood they are dynamically assembling hybrid poly-algorithm search-engines, in which the hidden solver and user’s model for each holon subassembly, and the differential geometry coordinate system transform (which recursively nests the holons), are its assembled composite parts.
By metaphorically automating this wrapping of ad-hoc model components in hidden solution assemblies, this three-element template alphabet spans the full spectrum of applied mathematics. Yet the embedded models are simple formula procedures like spreadsheets, and the solvers are interchangeable engines. Thus the program code is merely a hierarchy of simple algebraic problem definitions, relating outputs in terms of inputs, in templates that connect solution matrices to the solution engines.
With this metaphoric simplicity of problem description and interchangeable engines, modeling becomes a process of experimenting with canned solvers. Once a solution is found by a set of solvers, it can be easily validated by substituting different solvers, and comparing results.
Programmers become solver mechanics by experimenting while porting legacy simulation applications into optimization applications—a major new business that automatically shifts the software division of labor into a higher-productivity posture.
OPTDES
Find A in TWOPT
to Minimize OBJ
AD Arithmetic A
TWOPT
Automatically Synthesized Hybrid Algorithm
Find Y
in TRAJ
AD Arithmetic
Y0
Optimization
to Match Y 1
Solver
TRAJ
Integrate DIFF
Correlation
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
Similar to spreadsheet modeling, users are generally unaware of the sophistication of the metaphoric program synthesis they are achieving with simple nesting of Find statements in their ad-hoc models. Under the hood they are dynamically synthesizing hybrid search-engine poly-algorithm systems, in which the solver and user’s model for each holon component, and the differential geometry coordinate system transform, which recursively nests the holons, are its hidden composite parts.
By metaphorically enabling such automatic synthesis, this simplified three-element alphabet spans the full spectrum of applied mathematics. Yet the embedded models are non-algorithmic algebraic description, and the solvers are interchangeable engines. Thus the program code is merely a hierarchy of simple algebraic problem statements defining outputs in terms of inputs, linked by commands that aggregate the inputs and outputs into solution matrices processed by the solution engines.
With this metaphoric synergy of simplified problem description and interchangeable solution engines, prototyping becomes a process of experimenting with canned solvers. Once a solution is found by a set of solvers, it can be easily validated by substituting different solvers, and comparing results.
Programmers become solver mechanics by experimenting while porting legacy simulation applications into optimization applications—a major new business that automatically shifts the software division of labor into a higher-productivity posture.
Holonic Algorithm Components
Solver
Simulation
Solver
Differential Geometry Coordinate System Transformation Algorithm

18. Mashup Template Patterns
FortranCalulus Spiritext
FortranCalulus Spiritext
The three-element alphabet of matrix-solving tool operators gives rise to generic composite templates of matrix-inverse problems, as shown here, each outlining a broad class of science and engineering application motifs.
These design pattern archetypes, like the design patterns of object-oriented programming, unify and simplify the higher-order expression of problems. There are relatively few patterns, because the number of permutations of a three-element alphabet are limited. This enables quick recognition of how to assemble new application programs, self-organized by the form of the equations in the scientists’ models. This in turn gives rise to a high-leverage division of labor based on mentoring of design patterns by programmers, as tutors to scientists who learn to address their problems and articulate them by interchanging tools and tuning their solution progress by solver-control options.
FortranCalulus Spiritext

19. TAO – Stack-Fan Optimization
Holon Modeling Today …
TAO – Stack-Fan Optimization
Total Application Optimization – Practical MDO
Optimization Model Stacking (holon searching)
Maximize Profit
Minimize Cost
Maximize Performance
Minimize Weight …
Parallel Fan – MOB Searching
Many search engines, each from grid of start points
Global search results in output database
Each holon nest multiplies iterations.
Too expensive in TS era.
Now practical in Cloud for everyone.
Plenty of computer power.
The big shift today is deep nesting of constrained optimization and automatically parallelized searching. We couldn’t afford this in the TS era due to the cost of computer time. We didn’t have multi-core GPUs then.
Today holon modeling can lead to affordable automatic supercomputing for every inventor, student, researcher, and manufacturer. TAO is a branded method we can use to blitz the OEMs into backing our alliance. All it will take is one of them: Amazon, or HP, or Google, or Oracle, or Apple, or Microsoft. Then the race will be on.
MDO (multidisciplanary design optimization) can now be afforded by all organizations—operations of the organizations themselves will be optimized on many levels, as well as the products they design and manufacture. So MDO will become the gold-rush—spurred by the free-energy genie. With the FORTRAN skills of baby boomers, now freed from the constraints of their former employment to become our VAR marketing executives, this revolutionary potential is unprecedented in history.

20. MOB: Embarrassingly Parallel
Unconstrained Optimization
Constrained Optimization
MOB (MetaCalculus Optimization Broadcast) searching takes away the computer performance issue even if each level of nested disciplinary optimization is made up of nested mashup template patterns involving optimization of differential equations, like the wing-design problem previously shown. With today’s many-core GPUs, there is hardly any conceivable limit as to what can be optimized simultaneously.
Moreover, MOB searching is a global optimization strategy. All of the extrema in a defined hyperspace can be found in a single MOB run. A MOB PaaS infrastructure can implement a variety of platform strategies, public clouds like AWS, collections of cooperating private clouds in VPNs, even distributed internetworked PCs.
MOB provides the compute power to search very high fidelity models that typify large simulation codes. Thus world dynamics models, ecosystem and economic-system simulation models will be routinely converted to optimizataion. Simulation was the 20th Century solution method. With MOB, optimization will become the 21st century solution method.

21. SOURCE CODE DESCRIPTION & ANNOTATION SOURCE CODE IN PREFORMATTED HTML
MetaScience Web Portal
Holon Modeling Paradigm
SYSTEMS SIMULATION
SYSTEMS CORRELATION
SYSTEMS OPTIMIZATION
MetaFor
NAD Semantics
Metaphoric Solution Tools
Language:
Tools:
Engine:
Kernel
Nested Algorithmic
Differentiation
Our web portals add the important new technology of dynamic documentation called “Spiritext” which flashes an explanatory web of information to the reader of the source code. This is a background “sub-hypertext” which follows the stream of attention of the reader via mouse-pointer tracking, and enables her to navigate to online context-sensitive documentation connected anywhere via the web. It allows her to insert notes to collaborators with reverse links to her messages added to the source text. “Spiritexting” can become as popular among researchers as phone texting is today.
These web portals will be the public cloud PaaSs we use to introduce the new services. The major growth of our partnership will be in small public-cloud PaaS venues adminstrated by Stackato (i.e. local ISPs). These public clouds will be the collaborative venues where new application-specific media are evolved by our VARs.
MENU
EXECUTIVE SYNOPSIS
SOURCE CODE DESCRIPTION & ANNOTATION
SOURCE CODE IN PREFORMATTED HTML
ELEMENT 1
ELEMENT 2
ELEMENT n
...
Collab
Notes
Spiritext

22. MetaScience VAR Culture Choreography
Diversified Open Source Development
PaaS Cloud Marketing
Master VAR
IDE Composers Run Browsers
Meta Calculus Corp.
Core Technology
Development
MSF
Meta Science
Foundation
Cloud OEM Partners
MCC
Webinar Recruiting
This is our vision profile of the MetaScience Alliance in its “final” steady state form, illustrating the two cloud portals, both revenue producing, but one being non-profit (the Open Cloud Service supporting open-source communities) which will primarily offer bleeding-edge MetaCalculus service with free self help forums, and the other being for-profit (The Enterprise Service) which will offer stable MetaScience dialects with Spiritext Wiki tiered support from Cloud OEM partners, backed by the Master VAR, the VAR Matrix, and by MCC. It is not intended that there be a rigid tier hierarchy of support, but rather a support marketplace where contributions are metered and participation is rewarded after the fact, like restaurant tipping, based on customer preferences.
The Master VAR is the webinar-based recruiting and VAR education agent, as well as the market maker and contracting agency of the VAR matrix, adopting a role similar to program offices in aerospace companies who manage projects performed by the matrix. This matrix is not to be exclusive to any of the major partners, as collaboration is intended to trump competition in this alliance.
Open Cloud Service
MC8
Enterprise Service
MS7
Spiritext
R&D Domains VAR Matrix

23. MetaScience VAR Culture Buildout OS Extension Modeling Platform
Core languages: MC-Spirit-Fortran (3 Dialects)
Extension Languages (e.g. MC-Spirit Python)
GAEMY Wrapper Translator Publisher Development
IDE & Output Interpreters
EverGlade escalated GUI Composers
MIDUS Tablet Menu IDE
Spreadsheets & MOB drill-down Browsers
Domain Diversified Modeling Interfaces
VAR Modeling languages: Spirit-Python variants
GAEMY escalated Wrapper Translator-Publisher Developments
VAR GUIs (Pallet-Modeling)
EverGlade Escalated Visual Modelers
VAR Investment & Co-investment projects
We envision enlisting a VAR culture to help us build out a modeling platform terrace above today’s operating systems, to enable end-user scientists and engineers to rekindle R&D application development. Its core languages will be three dialects of Spiritext-augmented MetaCalculus Fortran. Extension languages will include Spiritext-augmented MetaCaculus Python and other dynamic dialects developed using our GAEMY escalator. IDEs will be both GUI-pallet based composers produced by VARs using our EverGlade escalator and Google’s GWT for the web; and rolling command-line IDEs for tablet-finger mode based on our current MIDUS menu IDE. Output interpreters will be both spreadsheet based and MOB drill-down browsers developed with EverGlade/GWT with webkit or mozembed XML/HTML5/JavasScript implemented hypertext.
We expect this mathematically-generic base to proliferate into a great host of domain-diversified modeling interfaces produced by members of our VAR culture, financed as co-investment projects with funding from within and outside the culture.

24. VAR Licensed Assets/Tools: 7 Pillars of MetaScience Culture
Fortran Source Core Assets
Build Tools and Scaffolding
MC Kernel Library
NAD Arithmetic Infrastructure
MC Solver Libraries
Optimizers, Correlators, Simulators, Utilities
MC Language Translators
FortranCalculus 2 (F77-like)
MetaCalc (PROSE/BASIC like)
MetaFor (F95-like)
MIDUS Console Menus PaaS
Asset Build & Test System
Spiritext Wiki Publisher
Webcode Site Generator for all languages
GAEMY Translator Escalator
MS (upper) Languages Evolver
Spiritext Parsers Evolver
EverGlade GUI Escalator
Gtk2 GUI Evolvers
Aligned with GWT for Web GUI
Having experienced the leverage of PROSE in re-awakening R&D agility with time-sharing, I knew that remote computing would emerge again one day, and I set out to prepare for the opportunity when it came again. I knew that I could only cope with the scientific diversity by providing escalator tools for others (VARs) to use to build the new ecosystem infrastructure.
Knowing that documentation was the software Achilles heel, I first built Spiritext in 2001 to resolve that problem. Next I tackled the language and GUI media evolution problem—both handicapped by the same vertical-evolution flaw I had encountered in Yacc—the half-baked “compiler-compiler” of Unix.
Now I have the MetaCalculus FORTRAN assets, and four more scaffolding systems which our VARs can use for the MetaScience Multi-PaaS buildout.

25. VAR Recruiting & Training
MetaCalculus Mechanic Training 101:
Coders become MC Solver Mechanics
ORE Mining of Legacy Simulation Code - Metamorphosis
MetaCalculus Mentor Training 102:
Solver Mechanics become Evangelist/Mentors
ORP EXTREME MODELING Collaboration
MetaCalculus Sales Training 103:
MetaScience Multi-PaaS Buildout Training 104: – 7 Pillars
Language Design – GAEMY, Spiritext, MIDUS
MetaCalculus Python (App-Generic Pylon)
Pylon Fan (App-Specific Dialects)
GUI Design – EverGlade & GWT
GUIDUS from MIDUS
App-Specific Composer Icon Pallets
During the last 30 years of OOP and the data-search 4GL (SQL), I have seen a precursor of what is to come, as SQL, originally focused on end-users, was taken over by professional programmers, who became SQL mechanics. But like the FORTRAN build-out which preceded it, the SQL buildout had to build up from nothing, so its has taken decades. It could not be merely recycled like GNU compilers and Linux, which is why the technician skills of Stallman & Torvalds, as the guild’s pied pipers, were sufficient to challenge Microsoft and give Google the keys to the kingdom—for free.
But this MetaScience Multi-PaaS buildout will be a blitz. Programmers can become MetaCalculus engine mechanics practically overnight—by recycling again. But this time it is recycling plus escalation—simulation to OPTIMIZATION. MetaCalculus is thereby an autocatalyst to create an army of R&D catalysts (evangelist-mentors) as end-user modeling peers.
It will be simply another recycling buildout using the 7 MetaCalculus pillars farmed out like tractors to our VAR community, who will evangelize these peers in collaboratively spawning newly modeled design applications, and producing new application-specific media (languages and GUIs) from the ORE mined and recast modeling components accumulated over time.
During the last 30 years of OOP and the search 4GL (SQL), I have seen a precursor of what is to come, as SQL, originally focused on end-users, was taken over by professional programmers, who became SQL mechanics. But like the FORTRAN build-out which preceded it, the SQL buildout had to build up from nothing, so its has taken decades. It could not be merely recycled like GNU compilers and Linux, which is why the technician skills of Stallman & Torvalds, as the guild’s pied pipers, were sufficient to challenge Microsoft and give Google the keys to the kingdom—for free.
But this MetaScience Multi-PaaS buildout will be a blitz. Programmers can become MetaCalculus engine mechanics practically overnight—by recycling again. But this time it is recycling plus escalation—simulation to OPTIMIZATION. MetaCalculus is thereby an autocatalyst, and it creates an army of R&D catalysts (evangelist-mentors) as end-user modeling peers.
It will be simply another recycling buildout using the 7 MetaCalculus pillars farmed out like tractors to our VAR community, who will evangelize these peers in collaboratively spawning newly modeled design applications, and producing new application-specific media (languages and GUIs) from the ORE mined and recast modeling components accumulated over time.
ORE mined and recast modeling component
libraries

26. Optimization Re-Engineering
ORE
Code Mining VAR Mechanic Training 101
Optimization Re-Engineering
Mentor-consulting can be quickly learned by programmers as interns by porting legacy simulation programs to MetaCalculus-Fortran and applying the optimization solvers to convert the old code to new optimization applications. This way they learn to apply the library solution engines, qualifying themselves to support new customer modelers as “solution mechanics”, helping them rapidly prototype new concept optimization programs from their original science models. Thus optimization re-engineering is a means of shifting IT programmers back into the organic peer driver/mechanic division of labor that characterized the original Fortran era of the Space race.
They will pick up some science in this process, but that is not necessary or even important except for use as fodder for learning the engine behaviors under a taxonomy of the “mathematical loading” of certain types of equations. What the equations mean is not their concern, but rather that of their end-user partners.
There is another major benefit that is a by-product of ORE mining—the “purification” of software by separation of modeling science formulas from algorithmic code. This is an automatic separation of concerns (SOC)—Dijkstra’s well-known principle of software architecture. It accumulates modeling formulations as purified science expression for further refining and aggregation into modeling alphabets via text search and other forms of software archeology.
SUBROUTINE DESIGN
FUNCTION PUMP
Fortran
MODEL DESIGN
FMODEL PUMP
MetaFor
FIND x,y,z to maximize f
OPTIMIZATION
CompSci Intern Role
Automatic
Differentiation
Simulation Program Optimization Program

27. Service with Economy of Scale
VAR Mentor Training 102
ORP
EXTREME
MODELING
Optimization Rapid Prototyping
Part-time Support
Application Spawning
“Mechanic”
Knows:
Equation types
Solver Engines
“Driver”
Knows:
Equation meaning
in science
Mentor consulting is a leveraged method of horizontal marketing, easily mastered by programmers as repurposed part-time evangelists. It leverages complementary skills of mentor and client (race mechanic and driver) in a brief transaction to frame equations in a prototype design pattern. The engineer-scientist client provides problem knowledge, while the mentor-mechanic shows how to apply MetaCalculus design patterns and solution engines. Thus there is no learning-curve delay to block R&D growth.
This is an extreme form of extreme programming, which squares its cost-time reduction. Mentoring sales-acquisition can be broadly outsourced, as a rapid-fire spawning process with economy of scale. The mentor’s brief encounter jump-starts the end-user into programming his own model. This part-time mentoring of end-users will augment the normal creative work of programmers in media building (next slide)
Bypassing both
learning curves
Service with Economy of Scale

28. FORTRAN/C/Perl /Python/SQLSource
MetaScience Domain VAR Language Terrace Design Stack
Domain
Modeling
Languages
Specific
GAEMY Compiler Mechanics 1
Modeling Component Library Domain Alphabet Dialects of Base MC Languages
Wrapper
Translator
Publishers
MIDUS Solution Engine Mechanics 2
The MetaScience buildout by the Domain VARs will be like a diversification fan-out into the various R&D application domains. This “design stack” represents the rich division of labor that will evolve internally to the “escalation language PaaS terrace” above and below (in libraries) the current crop of compute-bound languages like Fortran and C, in concert with I/O bound scripting glue languages like Perl and Python, and database languages like SQL.
Tier 1 involves compiler mechanics applying the GAEMY escalator to produce wrapper translator-publishers for domain-specific dialects of the base languages MC-Pylon and MC-Fortran (MetaFor—one of three current dialects). Tier 2 involves programmers catalyzed by ORE mining to become solution-engine mechanics & end-user evangelists, who focus on TAO objective nesting and MOB searching (multiple solvers/grids) for assisting end-user clients in solving R&D models. Tier 3 involves Spiritext Wiki Mechanics (in coordination with Tier 1 mechanics) to enhance the wiki-side of Spiritext, including lockstep (code & documentation) version control and tablet portal “Spiritexting Collobaration”. Tier 4 will involve numerical mathematicians who build search and prediction algorithms in Fortran.
TAO Parallel PaaS Strategies
MetaFor Source
MC7
MetaFor Source
MS8
MetaFor IL
Compiler
FORTRAN/C/Perl /Python/SQLSource
Spiritext Wiki Mechanics 3
Spiritext
WebCode
Compiler
Wiki Sites
Driver/Mechanic Collaboration Strategies
MIDUS Numerical Engine Builders R
New Solver
Engines 4
F95
Compiler
MC Kernel &
Engine Library
Binary Code

29. Value Priced Service with Economy of Scale
Consultative Selling 103
ORP
HIGH
MARGIN
Optimization Rapid Prototyping
Part-time Support
Application Spawning
This chart is critical to understanding the key difference between selling to IT buyers and selling to R&D engineers. IT selling is low margin vending. The IT buyer can’t judge the value you are selling, only the R&D end-user can. R&D business is high margin because we are selling solutions into a race condition, to assist the client in a winning situation---a winning proposal, first into the market, a vastly superior product, etc. This is consultative selling, where service price is based upon the situational value of winning---not on price competition in the market.
As the master VAR, this is the value proposition and sales training you will be providing to VARs---how to consult with a peer modeler, who the VAR mentor as solution provider (solver engine “mechanic”) is helping to solve a sophisticated time-critical problem. She may even be a modeling consultant who also happens to know the MetaCalculus engines. This is why we seek VARs who are highly diversified application-domain specialists.
MetaCalculus is the attractor to you as service agent, who screens opportunities, negotiates service prices, and assigns VARs to the opportunities. You are the program office for the global VAR matrix you recruited with your webinars.
“Mechanic”
Knows:
Equation types
Solver Engines
“Driver”
Knows:
Equation meaning
in science
No Vending
Price Competition
Value Priced Service with Economy of Scale

30. MetaCalculus Contains
GUI Terrace Starter Kit …
MetaCalculus Contains
Simulation
Solver
DIFF
X = f(A,X,Y,Z)
Y = f(A,X,Y,Z)
Z = f(A,X,Y,Z)
Integrate DIFF
TRAJ
System Dynamics
Jay Forrester’s legacy in K-12* education is now OUR MANDATE
MetaCalculus in Middle School via GUIs
Can leap 7 grade levels in math modeling
From Algebra to the Calculus of Variations
Forrester’s GUI motif in Stella, Vensim, and Powersim GUIs are our PaaS springboards. His major legacy has been a GUI motif for the posing of dynamic feedback models of differential equations systems, without the user having prior knowledge of differential and integral calculus. This motif provides an alternative and far simpler mode of introducing these esoteric math concepts in an application framework long before the students have the mathematical maturity these subjects require in their standard pedagogy founded upon hundreds of years of traditional teaching methods—overloaded with mathematical formalism.
The SD GUI motif is the key to engaging the open-source community and the current SD modeling crowd to join the MetaScience buildout, using EverGlade. Domain diversification is not required initially, since these motifs are totally generic math. But they will create a starter kit for a diversified multitude of domain-specific GUI motifs, like NASA’s FDS (spaceflight operations), Berkeley’s SPICE (circuit design), or Syntha’s Syntha 2000 (turbine power-plant modeling).
The Promise of System Dynamics Modeling in K-12 Education, D.M. Fisher & P.J. Potash *

31. MetaCalculus Umbrella GUI for SD
SD Survived R&D attrition due to its Modeling GUI:
MetaCalculus Umbrella Icon Alphabet is
System Optimization Semantics – SOS
System Correlation Semantics – SCS
System Dynamics Semantics – SDS
SD Motif can be subsumed in MC GUI
To pave the way to MetaScience Modeling
Like Forrester’s legacy, the vast potential of MetaCalculus is its capability to advance human understanding of mathematics and science the way automotive machines like cars advance the physical power as human extensions—by placing most of the motive force and intelligence under the hood, and simplifying its use.
Driving automobiles is vastly simplified, as is the operation of all kinds of machines, including advanced aircraft, by coupling the intuitive and autonomic symbiosis of man and machine, bypassing the formal mathematics used for navigation and control. Jay Forrester has led the way, which MetaCalculus can follow.

32. MetaScience Domain VAR GUI Terrace Design
SOS
SCS
SDS
MC Composer GUI
STELLA/VENSIM
Translator
SD to MC
Translator
By producing the combined MetaCalculus and System Dynamics graphical modeling motif we can engage a mass movement of SD modelers among Forrester’s followers as VARs to teach the higher math of MC as the upper optimization and correlation terraces above SD. This includes three major SD purveyors who can become part of our Alliance Choreography Group. This will add to other VARs specializing in building the GUI media using our escalator scaffolding tools for evolving GUI and modeling language specialization into diversified application domains.
SD Motif
Modeling GUI
EverGlade/GWT GUI MC Patterns Starter Kit

33. Engineering Education
Using Spreadsheet for Output Comprehension
FIND Output morphed into spreadsheet
To show iterations of
Independent parameters
Constraints
Objective Function
Rows Match Model Lines
Name in column 1
Formula in column 2
These slides illustrate how Optimization Re-Engineering (ORE) mining is a mere porting process of converting old simulation code into a new language platform which contains libraries of search engines. It can be learned by programmers in trial application like SQL servers to quickly develop skill as evangelist mechanics (like DBAs) in solution mathematics to be peer partners with modeling scientists and engineers who are the subject-matter specialists.
This leads to super agile “extreme modeling” which can meet the narrow opportunity windows (NOW) to release R&D demand pull, and establish the new peer division of labor of code sharing between end-users and professional programmers. H
Historical PROSE Application:
AC Motor Design Optimization
Re-Engineered from BASIC
Simulation into PROSE optimization
(in just a few hours)

34. AC Motor Output Spreadsheet
FIND Output morphed into spreadsheet
Iteration Output …
Unknown independent parameters
Constraints
R&D demand pull can be further accelerated by this integration with familiar spreadsheet tools where they are second-to-none in data display and manipulation with ad-hoc graphical charting.
The synergy is more leveraged because the spreadsheets are generated, from the output of GUI modeling tools, rather than constructed laboriously by hand, which falls victim to the notorious weakness of the spreadsheet medium—its lack of “evolvability” with the help of version-control systems.
Objective Function (efficiency)

35. Design Model Output … Rows Match Model Lines Name in column 1
Formula in column 2
Iteration Output in remaining columns …
This slide illustrates the advantage of spreadsheets as “data flow” display media and emerges a new pedagogical mode of experiencing “calculus flow undercurrent” sensed via Newton’s “fluxions” conveying the differential sensitivity of dependent-variable dimensional-streams to the independent-parameter dimensional-streams they depend upon, sampled via cell notes.
This exploits intuitive comprehension via numeric induction rather than the symbolic deduction of standard math pedagogy. It engages students’ epiphanic intuitive resonance (right-brain phenomenon) that is normally unavailable in math cognition based on formal algebra. I believe this is the key to engaging the excitement of children long before they have experienced the mental gymnastics necessary to comprehend calculus via the traditional formal route.
Inducting differential calculus
from under the hood
Using cell notes for
Objective Function (efficiency)
Constraints

36. Educational Model Base Build-out
AC motor problem was new paradigm example
Optimization Re-Engineering (ORE) mining
Can transform education/research agenda
ORE mining can train students as mentors
Porting old simulation code and applying solvers
Learning solvers by applying them to many models
No need to learn the modeled science
New “Extreme Modeling” Collaboration Paradigm
like PROSE mentor and AC motor design engineer.
Complementary Differences – New Division of Labor
Our intention is to once again engage the “pied piper” strange-attractor viral phenomenon that built the open-source software community, to pursue education and R&D venues rather than re-invention of operating-systems, standard-functionality languages, integrated development environments, and content-management/web-application frameworks—IT staples limited by the inbred experience of the programming professions. We have enough of these tools and we are wasting vital resources to continue building more of them.
The infusion of the modeling skills of science end-users in collaboration with professional software developers is a vital diversification influence that has been severely lacking in computer technology during the last 40 years of hardware reign. Balkanization into redundant software strains has become a Babel syndrome of chaos generation. It is time to change the agenda.
MetaCalculus provides the means of unifying the diversity by merely shifting the labor by Dijkstra’s proven architecture principle of separation of concerns—modeling to scientists and engineers, programming to programmers in shared synergy coding.

37. Fodder for ORE Mining - NASA FDS
On Orbit Graph Generators
FDS was a “proto-MetaScience” CAD medium of “canned engineering” synthesis tools, which was designed as a serious game for relatively un-educated technicians to design shuttle missions without having the ability to understand the underlying engineering. Other such serious games, like SPICE (circuit design) and Syntha (turbine power-plant design) were example proto-MetaScience media.
They were all simulation systems without overall design optimization. Yet their canned engineering content is very amenable to optimization synthesis via MetaCalculus. Thus they are excellent candidates for ORE mining and TAO supercomputing, to both catalyze the MetaScience buildout and establish the new collaboration agenda between computer science and engineering departments of universities.
Shuttle CAD System for Mission Design
Hundreds of FORTRAN programs
Historical Model Base to Train New Engineers

38. Learner Centered Learning
MMPOG
Massively Multi-Player Online Games
Persistent world simulation (e.g. Atriarch )
Mimic world problem-solving in game contexts
Physics, Economics, Ecology, Political Science
System Dynamics, Data Assimilation, Optimal Control
Nurture world building gamer communities
Teach K-12 MetaScience in game context
Disintermediate classrooms into learning labs
Both of my sons are software engineers at the top of their professions. One of them, Christopher, with his wife Serafina—a highly competent market maker in the gaming community—produced the Atriarch MMPOG which simulates a small alien planet. I have always lamented that MetaCalculus was not available for use in their business when it was started in the mid 1990s.
Yet this could still be done to create a phoenix-like rise of an FDS-based “Migration to Mars” collaborative game to play out something like Kim Stanley Robinson’s Mars Trilogy (Red Mars, Blue Mars, Green Mars). My sons are ideally positioned to become VARs in this kind of pursuit.
We would never have made it to the moon without ET help, if kids like me, nourished by science fiction, had not dreamed about it, decades before.

39. Now we introduce what I believe will be the great unifier of software technology. My former partners did not share my vision that it would be leveraged by MetaCalculus. They saw it as a maintenance tool and as an aid to IDEs, but ceased financing maintenance of the ten patent disclosures after sinking almost $200,000 in them (179 claims). So the patents were never granted. But now they are in the public domain, so the open-source community is free to build this technology into the paramount education media of the future.
I am especially enthusiastic about the pedagogical power of Spiritext for teaching MetaCalculus, and as an R&D collaboration medium for “tablet texting”. It is especially important to dynamically document the diversified proliferation of the MetaScience buildout, as a channel to transmigrate the prolific open-source community into R&D.
Now we introduce what I believe will be the great unifier of software technology, which my former partners could not appreciate would be leveraged by MetaCalculus (they were investors in PROSE), but failed to see the synergy. They saw Spiritext as a maintenance tool and as an aid to IDEs, but they refused to finance maintenance of the Spiritext patent disclosures after sinking almost $200,000 in them (179 claims). So the patents were never granted.
They did not credit the pedagogical power of Spiritext for teaching MetaCalculus, or as an R&D collaboration medium. Of course they did not know about the potential MetaScience buildout, or how it could transmigrate the open-source community into R&D.

40. Spiritext Tranpublished Features
Footnote annotating a variable
mouse over
Navigation
PROSE and SQL started the quantum leap to semantic-intensive languages. SQL led to the next buildout of GUIs for data modeling, like MS Access. Oracle and Sybase produced SQL imbedded in C/C++ and database-resident languages like PL/SQL and Transact-SQL.
It is for these semantic-intensive, and macro-extended languages (e.g. second-generation C applications like Apache2 with 10+level macros) for which Spiritext was conceived. In situ dynamic documentation is essential for rapid comprehension by multiple software asset stakeholders (programmers, software managers, and user peers) of applications written in such media.
Footnote annotating HOLDING phrase of FIND template
mouse over

41. More Tranpublished Features
But rapid comprehension of semantic-intensive applications in media, where the software bulk is under the hood, just scratches the surface of Spiritext potential. As shown here, multiple-engine choice software like MetaCalculus (unlike SQL servers) requires quick access to information about how to apply different engines, especially in this early buildout period while programmer mechanics are learning to automate their MOB combinations for exploring and mentoring end-users in TAO supercomputing.

42. Spiritext Wiki Footnote Entry
Now we move from developer-produced to user-produced documentation—the wikiside. This JavaScript part of our original Spiritext medium was designed and developed by my other son, Steve. As he is also a Perl expert with super regex skills, he developed a Spiritext style-optimizer using “meta-regexes” (regex-defining-regexes), that transforms my simple framed webpages (shown here) into much more stylish division-based websites.

43. Wiki Application Specific Footnotes
My simple Spiritext frame-based style uses lower-case Greek letters for footnote triggers. Steve’s style optimizer morphs this simple style into much richer division-based pages. It is actually a mega-regex scanner that is a stylesheet-driven Spiritext transformer that can be meta-programmed for different styles.
My simple Spiritext frame-based style uses lower-case Greek letters for footnote triggers. Steve’s style optimizer morphs this simple style into much richer division-based pages. It is actually a mega-regex scanner that is a stylesheet-driven Spiritext transformer that can be meta-programmed for different styles.

44. Spiritext Wiki Collab-Note Entry
When you consider that Spiritext—as rapid comprehension natural meta-language about programming-language code—can be dynamically translated, so that it appears in different dialects to each correspondent, and can be immediately communicated via IRC, it removes all barriers to global collaboration.
The top world specialists in a given mathematical or science modeling domain can be called upon to comment on a specific problem or approach by adding collab-notes. of applications written in such media.
6/20/2007

45. PROSE Also Produced DIVERSIFIED
PROSE (MC5,6) HISTORY
PROSE Also Produced DIVERSIFIED
One-of-a-Kind
CAD
Tektronix - CRT Design
National Steel & Shipbuilding - Tanker Design
Watkins-Johnson - Travelling Wave Tube Design
GTE - Telephone System Provisional Planning
Hughes - Antenna Design Beam Synthesis
DuPont - Advanced X-ray System Design
Goodyear - Radial Tire Design
Sierracin Magnedyne - AC Motor Design
Bechtel Power - Steam Power Electric Network Design
Everyone knows the power of CAD. It is why we have such cheap and powerful computers. They have been designed using CAD for nearly 40 years. But so far, CAD has been limited to mass-application arenas. Using quick CAD for one-of-a-kind designs is unheard of, because it usually costs more to program the CAD tool than to create the design by hand. But that wasn’t the case with PROSE in the 1970s. Major companies used PROSE to build specialized CAD systems in highly diverse application areas. Meta Calculus produces such low cost CAD that it is practical even for single designs. Low cost prototyping of highly diversified ad-hoc CAD applications will become a fundamental economic driver of new prosperity, dramatically boosting new invention and lower production cost across the board, not just in mass-demand markets.
New CAD Niches Opened

46. VAR To Boost Diversified Design & Manufacturing.
CAD Diffusion
Vertical Market VAR Niches
Post-industrial CAD
Do it yourself CAD
New problems
New technology
High evolution
Rapid prototyping
Quick time-to-market
Invention CAD
Invention byproducts
Cottage industry growth
Mfg. Process Design
Commodities
Custom
DEMAND DENSITY
Meta Calculus enables the rapid prototyping of new CAD applications in vertical-market niches. This is the critical capability needed to re-establish the U.S. manufacturing base. Meta Calculus can open thousands of new vertical market CAD niches spread through the economy, leading to new flexible CAM feeding the “Star Trek replication” technology of 3D printing. A new surge of diversified invention will result, as new-concept computer use becomes more cost effective and prevalent.
Now with the free-energy genie out of the bottle, everyone now sees the brass ring of the carousel and everyone is going to reach for it. MetaCalculus is the CAD/CAM builder and optimizer for this R&D race that will finally realize Alvin Toffler’s dream of a Post Industrial manufacturing era. Writing about the logical implications of FORTRAN and BASIC in the 1960’s before IBM forked software back to guild dominance, his predictions were delayed for a half century.
Engineer Entrepreneur Role

47. Sputnik Moment II 1957 Brought Two Wake-up Calls
Meta Science Foundation
MetaCalculus, LLC
1957 Brought Two Wake-up Calls
Sputnik and FORTRAN (US’s “Sputnik”)
FORTRAN empowered engineers
And took us to the moon
MetaFor can be a Renaissance
A shift back to R&D growth
To escalate the free-energy revolution
We believe that the turning point opportunity is here now. We can do what Fortran did to advance scientific computing, and usher in a computer industry renaissance.
By eliminating time-sharing market infrastructure, the PC cusp buried adolescent PROSE, just when the enormous power of MetaCalculus was emerging. As an interpretive platform in an age of limited hardware performance, it was shunned by professional programmers, as they opted for native-hardware speed even if development cost soared.
Now, when everybody is seeking “agile” relief, its native-compilation performance will regain their allegiance as it demonstrates both higher performance and higher abstraction than any other software technology. Now it is the means of bringing software businesses back from the depressed subsistence in the no-man’s land of the bipolar staple-software hegemony, which was the gift of five decades of monopoly domination and the desparate “kamikaze” resistance of the open-source movement. We can build a new free-energy, science end-user-driven software ecosystem that rewards everybody.