A TESTAMENT TO
THE OPPORTUNITY OF
META SCIENCE
This is the common testament of a group of R&D scientists and engineers who have unique experience with a high-productivity software technology known as meta calculus, which is ready to render an economic leap in science and technology productivity. We believe that the computer industry is at a key turning point. Labor-intensive algorithmic software technology has been operating in diminishing returns for about 40 years, while prohibitive labor costs have repressed computer demand in R&D. This economically outmoded technology has exhausted its momentum, and will give way to a new era of metaphoric programming, congruent with end-user modeling expression rather than computation technique. This shift to metaphoric software design is long overdue, and will eventually lead to universal programming fluency in all market sectors.
We believe that the convergence of meta calculus with other software technologies and the open-source software (OSS) movement will trigger a series of higher-productivity build-out waves to usher in the era of metaphoric programming. The first wave will be the rapid re-evolution of scientific software via optimization re-engineering of legacy simulation code by simple recompilation in compatible meta-calculus languages. Following waves will build-out higher, more specialized application generators and pre-built tools to be collectively known as meta science. These higher metaphoric tools will directly address pent-up end-user needs in R&D that cannot be economically enabled by algorithmic software technology. These new waves will unleash and extend the growth of Linux into the domain of end-user scientific programming. This will be a renaissance of the demand-pull that originally built the computer industry.
The details backing up this testament are discussed in a yet to be published book, entitled Catch++, Software Overspecialization and the Metaphoric Programming Agenda, by Joseph Thames, the leader of the group.
Jacob Beutel, PhD Physics
Phil Brubaker, BS Math
Charles Crummer, PhD Physics
James McDonough, PhD – Professor of Engineering and Mathematics
Daniel Mickish, PhD Physics
Frank Pfeiffer, MS Math
Dillon Scofield, PhD Physics (Adjunct Professor)
Joseph Thames, MSME
The Opportunity
The computer industry is poised for a turnaround because of convergence of available technologies and cultural forces that can leverage a second stage of the phenomenal growth of Linux into the R&D end-user application domain. Three proven technologies of metaphoric optimization programming, metaphoric I/O programming, and collaborative web-document generation are ready for combination with other open-source compiler technologies for parallel processing. The integration of these four technologies into a “web-casual” metaphoric extension of Linux can potentially co-opt the open source movement to achieve the same kind of quantum leap that IBM used to trigger original industry growth with the shift from machine coding to algorithmic programming.
The key word is “casual”, meaning “part-time” programming. Metaphoric programming is “templative” and semantic intensive. Programming is made super simple and metaphorically abstract both in higher math and with visual I/O templates (forms and formats) that self-generate the semantic tools comprising the bulk of the software, leaving only the “essence”—the science modeling to be defined, and this is vastly simplified. The idea is to have the computer do the detailed work of generating algorithms, and that this is masked from the user by the metaphors of the programming language.
Yes, for end-user scientists and engineers, whose main work is science, not software. This is a class of end-users who are not daunted by programming. They just don’t have time for it. And they can’t afford middlemen to do it for them. They were the original programmers that built the industry with their computing needs in languages that are simple by today’s standards. The problem today is that programming has become overspecialized and cosmetic focused, requiring total dedication to its craft, leaving no time for the substance of application science. Contrary to popular belief, this is devolution not evolution. The computer industry long ago abandoned the needs of R&D application development, and devolved into an industrialized commodity cul-de-sac of overspecialization, which has exhausted its population-limited staple demand and is imploding due to foreign-labor arbitrage. The industry can’t continue in the direction it is going, but must back its way out to a simpler programming technology in order to leap ahead, and the infinite demand potential of R&D is once again the route to computer prosperity, like it was in the Apollo era.
Yes, it is a web-portal programming environment we call “WebLinux”, combining highly simplified website scripting with metaphoric language I/O which hides the client-server interaction. The user experience is that of programming a meta-calculus “web meta-computer” that is functionally indistinguishable from the user’s PC—the web is the computer, and the user generates elaborate websites by defining simplified program I/O metaphors. The metaphoric extension has the dual nature of traditional (shell) scripting, and (compiler-language) application programming, only in this case both are metaphorically leveraged, and this leverage augments the leverage of meta calculus.
Yes, the script layer is a extension of the popular LAMPM (Linux-Apache-Mod-Perl-Mason) web-scripting environment. A new kernel API of mason components is added to the environment. These components are employed as “pipe-fitting wrappers” to application programs running on the server. In essence they dynamically fit I/O “front-end” pipes between the server application programs and the web, and “back-end” pipes between the application programs and databases (or database servers). These kernel components are the hidden “solvers” of the Masonik (Mason inter-process kernel) script layer that handle the complex and often daunting inter-process communication that even skilled programmers avoid. This IPC barrier has been a deterrent to growth of application programming via the web. Now scientists and engineers will be able to do it casually.
Would you consider Amazon.com a primitive website? It is one of many developed with Mason. Actually, the metaphoric I/O added to all of the meta-calculus languages provides further leverage in this regard. This is another technology that was a precursor to Visual Basic, which originated on IBM’s original portable computers, the 5100 series. It separated programming into syntax (verbal) and context (visual), and made them independent (orthogonal) but both highly simplified, because their connections were abstract—ganged like CGI forms (holistic) instead of individually formatted read/write statements (reductionistic). This naturally led to templating of both syntax and context. The I/O process took on the nature of mathematical mapping (syntax verbs) through interchangeable transforms (visual context).
Now the visual context transforms are web-page layouts and hypermedia, which can use standards built-in to the languages (like solvers), or can augment them by Masonik web scripting—independent of the application programs. The result will be the same rich web experience, but with the advantage of rapid application development by casual programming.
The most important is the creative commitment of developers and end-users based on identity with a cause. This is the cultural lever that has resulted in the incredible success of Linux. The second key element is a design baseline for collaboration—a proven external architecture specification (e.g. language and tools interface). The third is history of usage and demonstrable user leverage that will draw volunteers and funding to motivate implementation and create immediate user demand. Fourth is an idea signifying that the endeavor is the key to the future and has a potential for sustained growth build-out that is logically understood as need fulfilling and is easily predictable. Fifth is the bleak alternative of an imploding labor market caused by foreign outsourcing of IT jobs. This displaced labor can be re-employed in this new agenda, and the current overspecialization of this labor can only be ameliorated and transmuted by this agenda.
Yes, Eric Hoffer studied the motivations of mass movements, and identified the most important three as: discontent with the status quo, a sense of power derived from the cause, and belief that the endeavor is the key to the future. These motivations induce people to commit their lives to a cause. The discontent of the open-source movement stems from history of the monopoly domination of the computer industry, so its key element is a form of common resistance, especially led by the heroic figures of Richard Stallman and Linus Torvalds. The sense of power is a natural side effect of overcoming programming challenges, which is a kind of creative addiction. In our case similar motivations prevail. Here an important element of the sense of power is the quantum-leap provided by optimization re-engineering.
The engagement of all of Hoffer’s motivations is the primary purpose of the book, Catch++ -- Software Overspecialization and the Metaphoric Programming Agenda.
There are five in this case. The first baseline is meta calculus, which has been in limited but broad use for more than thirty years. It is a mathematical macro extension to the popular languages (a wrapper of added commands) and a common mathematical tool architecture (API, virtual machine, and tool library) that together extend these algorithmic languages to achieve metaphoric leverage. (See some examples)
The second baseline is a pair of standard GNU/Bison based compiler designs for the two most popular scientific languages, Fortran and C, providing for both mono-processing and an easy transition to cluster parallel processing, to which the meta-calculus extensions can be easily added. The extension of this compiler infrastructure to object-oriented languages is also straightforward, as each of the current object-oriented languages have a similar structure based on GNU/Bison.
The third baseline is the syntax/context metaphoric data-mapping I/O system (Metaset/MetaBasic) originally developed and marketed on the IBM 5110/5120 computers in 1979 through 1981 when IBM phased out this line of computers. It is the basis for a similar design, called “Metaphorio”, with the syntax verbs applied to visual web-context this time.
The fourth baseline is the Masonik kernel extension to the industry standard Linux-Apache-ModPerl-Mason web-scripting environment.
The fifth baseline is an emerging popular motif of collaborative web-code that can potentially replace both peer-reviewed scientific publication and software maintenance practice at the same time. Web-code unifies program code and a new form of in-situ documentation. It will logically lead to web-based integrated development environments with version control methods to maintain developing code and documentation in lockstep.
This is the history of the meta-calculus language PROSE and its successor, Fortran Calculus, discussed below and in the Appendix. Also the Metaset/MetaBasic system was sold to small manufacturers for development of applications on the IBM 5100 series machines. Both of these “experiments” demonstrated the primary economics of metaphoric programming—the massive reduction of programming labor and the consequent unleashing of application software development from the choking effect of this labor cost and of the necessary education of middlemen to perform the labor—itself a major deterrent to new application development, particularly in R&D where the labor was iterated in continual prototyping, leading to exponential cost growth.
PROSE triggered a ground swell of interest in its basic calculus-arithmetic process, automatic differentiation (AD), a breakthrough means of guiding calculus-based search tools for optimization. AD arithmetic has become a popular academic movement, and many popular products such as Mathematica, Maple, and Matlab have adopted it, but none have yet linked this breakthrough with the second breakthrough which gave PROSE its metaphoric power of “super simplification” in mathematical composition—subroutine-like holonic nesting. And none have adopted the baseline of the common languages in order to enable optimization re-engineering by the simple means of recompilation. This is the trigger for a new round of re-evolutionary market growth that will proliferate metaphoric programming.
Examples of limited metaphoric programming media are ordinary spreadsheet tools. Lotus 123 and Excel are examples of metaphoric media for low-level math—limited to simple algebraic equations. The GUI framework of the spreadsheet is a metaphor of the way forecasting used to be done with butcher paper. Thus metaphoric programming is the kind of programming that matches the users’ original view of a problem—congruent with the user thought process.
Meta calculus provides a platform for optimization re-engineering of simulation software. Thus it logically leads to a re-evolution of myriad legacy applications in a semi-automatic fashion. But this is just the first stage of the metaphoric programming build-out agenda—the exodus of software engineers from the imploding labor market of foreign-outsourced IT. Object-oriented programming and the growth-leverage potential of pre-built re-usable components will quickly motivate a componentization retooling of a wealth of legacy scientific code—a build-out of standard engineering modeling-tool libraries. This componentization will lead to higher-order metaphoric programming media for highly diversified rapid-prototyping of new optimization applications—a post-industrial fanning-out of non-staple application production. This modeling-tool build-out will result in multiple higher plateaus of metaphoric program design, which in the aggregate will be called meta science.
Meta Science
Meta science is an idea of media for modeling science in the metaphors of science—the concepts in which scientists themselves describe their thoughts. The intent is to build-out a collection of metaphoric software generation tools, primarily languages and GUI wizards for scientific and engineering end-users. These application synthesis tools will be the post-industrial (beyond industrial diversification) CAD, CAM, and computer-embedded control (CEC) production systems of a new era. This will be seen as the new era of market diversification or fanning out, that could not be achieved with labor-intensive industrial-style algorithmic software methods.
The base level of meta science is a convergence of three sub-technologies—meta calculus, web-code and meta engineering componentization. Meta calculus provides the general-purpose foundation for a quantum leap from algorithmic to metaphoric programming. Web-code will rapidly popularize meta calculus. And meta-engineering will become the knowledge-base of diversified meta-science proliferation
Meta calculus (AKA synthetic calculus) is a higher-order mathematical extension of conventional programming languages. Its level of transparency (user level) is that of optimization and the scientific method. It is a higher-order alphabet of combination like DNA. Only in this case the elements of the alphabet are problem-statement metaphors corresponding to three natural classes of numerical solution—simulation (Integrate…), correlation (Find…to match), and optimization (Find…to maximize). Simulation is a process of prediction that forecasts the behavior of a simultaneous equations model (usually involving differential equations to be integrated). Correlation and optimization are search-engine processes (inverse problems) that repeatedly forecast simulations while searching the input parameters of the models that meet required conditions. In correlation the condition is matching constraints of some kind, like particular constants or curves. In optimization the condition is an a maximum or a minimum.
Thinking in terms of a spreadsheet, simulation corresponds to computing from the top-line to the bottom line in a single pass (although some of the spreadsheet formulas are differential equations that must be integrated by hidden numerical algorithms); whereas correlation and optimization correspond to finding the top line that meets conditions on the bottom line, by iterating the top-to-bottom simulations until the bottom-line conditions are met.
In meta calculus, these metaphoric classes may be combined by subroutine-like holonic nesting to simply address all forms of mathematical equations systems non-algorithmically. This is like having an optimizing spreadsheet where one of the lines of the spreadsheet invokes another optimizing or correlating spreadsheet. And this nesting can have any level of depth. These kind of spreadsheets may be thought of has “holons” (whole/parts ala Arthur Koestler or Ken Wilber). Imagine a series of bottom-tabbed spreadsheets, where the hidden sheets are optimizing, correlating, or simulating sub-holons (parts) of the visible optimizing holon (the top spreadsheet).
Thus meta calculus is a holonic modeling paradigm that end-users program what to solve without having to specify how. They merely choose tools (particular search-engines or numerical integrators) for each problem-statement metaphor (each holon).
At the arithmetic level, meta calculus is based upon automatic differentiation (AD), that evaluates the partial derivatives of the output of models with respect to their input parameters. These derivatives provide the guidance for optimizing search engines. To enable the subroutine-like nesting, AD-generated derivative arrays are transformed to propagate the differentiation of nested search problems (correlation and optimization). The important thing is that the user doesn’t have to be aware of any of these complex mechanics. Scientific modeling in meta calculus is transparent to solution mechanics.
Yes, exactly—a paradigm congruent with higher scientific thought. Meta calculus metaphorically prescribes searches of mathematical surfaces, like SQL does for databases, only the surfaces are dynamically generated by simulation. It is a form of general-purpose metaphoric programming that directly addresses scientific-method level (correlation) applications and higher applications of optimization. But it is just the beginning of the metaphoric paradigm for the higher mathematics of optimization. There is vast potential for specialized higher-order metaphoric media to be built upon meta calculus. This is the regime of meta science—a realm of fast application development.
Yes, web-code is an extension of code compilation that generates annotated code web-documents that can be browsed to follow the flow of the code and has multiple levels of documentation for collaboration of all of the code stakeholders—designers, user-peer support people, and managers. These documentation levels include tooltip-implemented footnotes and popups, both permanent and temporary email-connected collaborative notes etc. Each code statement has links to online manuals and links to web forms that can be filled in by user-collaborators.
Web-code will do for collaborative software development what the web did for the Internet—unify it into a common medium of understanding and collaborative communication which transcends the differences in the code languages.
Yes, like class tool algorithms of meta calculus, meta engineering is a collection of pre-built modeling components programmed in meta calculus, that can be selected from a library. The key idea is that meta engineering components are automatically differentiated, making them building blocks of optimizable model systems. This includes the notion of higher-order modeling alphabets (like DNA or meta calculus but with more numerous elements) combinable into engineering problem classes like CAD and CAM problem regimes (e.g. components like ASIC-chip models and servomotor models).
Yes. Meta calculus augmented by web-code will be the basic level of meta science. Together they can cause a profound shift in scientific collaboration and publication. Since meta calculus is actually a mathematics of inductive numerical solution, as opposed to deductive symbolic derivation, science need no longer be reduced to tedious algebraic deduction (e.g. formal analytical derivations and proofs), as the primary means of explanation, but can use numerical or graphical demonstration via the web as the method of exposition, and peer review can directly interact with the models and solvers being used—substituting different solvers as a means of validation—via web-code collaboration.
As mentioned above, the first phase will be optimization re-engineering (ORE)—a semi-automatic process of recompiling old simulation models in meta-calculus languages. Jargon-wise, this will be called ORE mining. It will not need object-oriented methods, since most of the legacy code will not be available in object-oriented languages, but mostly in Fortran, Basic, and C. So the first meta-calculus languages will be extension of these legacy languages.
Meta engineering is the second phase and will take a few years to completely build out. It will not really start until meta-calculus versions of the object-oriented languages are available. We expect university engineering departments to be the main developers of meta engineering components and component-configuration (design) alphabets. These components will logically evolve from applications that have already been ORE mined. Meta engineering will then be appropriately called ORE recasting or ORE refining. It will employ a lot of graduate engineering and science students.
There are potentially two super classes of higher media, math application templates (MATs) which are purely mathematical (without pre-built engineering), e.g. spreadsheets; and problem-oriented optimization (POO) APIs and wizards, which have pre-built meta-engineering component libraries as knowledge bases which are used to construct models.
An example MAT, developed in the meta-calculus language PROSE by Jim McDonough, was a template called EPOC (Economic Planning via Optimal Control), which was applied to timber resource planning by Simpson Timber and the Western Timber Association. Jim designed it as an alternative to dynamic programming, which was limited in problem size by what its originator Richard Bellman called the “curse of dimensionality”. EPOC did not have this limit and could handle a very large number of state and decision variables.
POO wizards will be the new post-industrial form of CAD, CAM and CEC tools. POO refining will be a relatively painless way of helping software engineers re-train in application science. Whereas ORE mining will require only technician skills (recompilation and benchmarking without understanding the embedded science), developing meta-engineering component alphabets will require that the technicians understand how the rudiments of the embedded science naturally combine (e.g. the affinity of chemical elements). Multiple alphabet prototypes in each problem class will have to be evolved for refinement. Graphical wizards for combining these alphabets to construct programs will also be part of this evolution. A simplified example is the tools (rudiments) of a paint program or photo rendering package, but in this case the icons will be metaphors of scientific processes (e.g. turbine stages, ASIC chips, etc.)
The R&D Market
The market that IT couldn’t reach—highly diversified non-staple and custom applications in R&D. The IT build-out has only involved staple commodities, because only staples group together enough common users (economy of scale) to amortize and recoup the enormous costs of algorithmic programming methods. Carr is right about the IT build-out. Commodity recycling has been the IT agenda for the last 40 years. Recycling and graphical rendering of old applications enabled IT to get fat in a zero-sum loop of market turnover that saturated the industry staple demand before 1990. Unfortunately, the markets for staple business commodities saturate because their ultimate demand level is essentially proportional to the size of the population.
The IT middleman programming process has always been hampered by what used to be called the “waterfall”. Imagine a series of flowchart boxes arranged like a waterfall. The top box is user requirements, the next cascade is software design, the third cascade is programming, and the final cascade is testing. The hardest part has always been the top box, because the user seldom really understands the problem. This is particularly true in R&D, because its purpose is to explore and evolve applications. Without benefit of user programming (which eliminates the two middle cascades), if the user requirement specifications were half baked, the user wouldn’t find out until he started using the software (the final testing box). Then as he tried to change requirements, he would have to repeat the labor of the second and third cascades. This recycling through the cascades is what is known as prototyping. As programming became more labor intensive, this is where the cost got bloated.
After the first three generations of computing, a lot of staple applications (those having thousands or later millions of users) already had gone through this painful process. So IT was able to eliminate the top box, and use the old programs as perfect specifications. So this became the recycling agenda. No prototyping was required, because the original design had gone through all that. As the computer companies wanted to sell more computers, they were able to change the computer designs very quickly and then recycle the old applications by merely porting the old applications to the new machines, or in later years, merely changing the user interfaces. So IT focused on changing the graphical user interfaces (GUIs) of the old programs to make them look new. As fewer and fewer applications really were new, the industry reached a state like the fashion industry, where it was just turning over old demand without substantively changing the art. It became a zero-sum game of replacing something that otherwise couldn’t wear out. Sure there were improvements, otherwise people wouldn’t buy at all.
In the decade from 1980 to 1990, the raw price of computing dropped by a factor of 100. But demand did not respond in kind. It doubled in the first five years but only rose 20 percent in the second five years. And this was the Reagan era, during which there was more military spending and more foreign investment in the US than ever before. This was when the Nobel economist, Robert Solow, made the often quoted remark that has since been called the IT productivity paradox: “You see computers everywhere but in the productivity statistics”. Andy Rappoport, in a 1991 Harvard Business Review article said: “Computers are too powerful for the uses to which they are being put”.
Infinite, both in diversity and fidelity. Scientific markets didn’t saturate from lack of need. They saturated quite early because of excessive programming labor cost and inability of IT to meet time-to-market (TTM) constraints. In R&D applications, which are processes of continual prototyping and evolution of models, IT middlemen programming causes inverse leverage (iterating the middle cascades), which leads to exponential growth in prototyping cost and intolerable TTM. This is what started suppressing scientific markets 40 years ago. It coincided with a strategic economic inversion in the computer industry. Computers became cheaper per capita than programming labor in about 1965. Algorithmic programming had reached its point of diminishing returns. The industry needed a mid-course correction that did not happen. It needed to shift from algorithmic programming to metaphoric programming to compensate for labor-time cost overload.
Yes, the R&D markets, which had originated with end-user programming in Fortran and Basic, atrophied because IT middlemen took over programming technology and kept end-user programming at bay by making programming more esoteric, requiring full-time dedication to master. Instead of developing metaphoric programming media for end-users, they endlessly articulated algorithmic programming media (Algol -> PL/I -> C -> C++ -> Java -> C#), making programming more and more labor specialized and labor intensive. In the recycling of commodities this could be sustained due to economies of scale. But in R&D, programming-time cost overload, plus inverse leverage of iterated labor in prototyping, suppressed demand and left big-science R&D, such as the space program, in a marginal state due to exorbitant software costs.
Yes, historically end-user programming has been the major driver of industry demand-pull. The industry was originally bootstrapped by end-user programming in Fortran, making IBM a monopoly in about three years, and led to the prosperity that took us to the moon. Later end-user programming in Basic triggered the growth of the time-sharing market, and spreadsheets sustained the growth of the early PC markets. Meta calculus is an end-user paradigm that directly addresses pent-up needs long suppressed by the IT agenda—needs for extremely rapid prototyping of new applications, and optimization to achieve the highest scientific quality. The overwhelming problem is that these needs cannot be economically addressed via algorithmic programming.
We strongly advocate this technological agenda because it has been proven. This advocacy is based on our direct experience of the leverage of meta calculus during the time-sharing era, using the first commercial meta-calculus language, PROSE.
A few application programmers did—ones that related to application problems at the level of the scientific method. Some even became totally dedicated to it, subsequently programming in nothing but PROSE. But IT empires often perceived PROSE as a threat to their dominion. DATAMATION had quoted cases where “practically unsolvable problems thrown at PROSE were solved in a matter of hours”. This timeframe did not fit the IT norm for application development, because it could not support middleman programmers. What “unsolvable” meant was that such problems were unsolvable by algorithmic programming in any reasonable amount of time. So many IT managers overtly or covertly suppressed PROSE to protect their programming staffs. Wherever PROSE was adopted by end-users, they no-longer requested support from IT, because they no-longer needed programming help. Also PROSE was an interpretive virtual machine, which programmers regarded as slow, so they tended to reject PROSE out of hand. They generally rejected Basic for the same reason.
PROSE was not portable. It was developed before Unix. About 25% of its code was assembly language, and it was implemented on proprietary operating systems that did not survive the time-sharing market. As the time-sharing vendors went out of business, PROSE’s direct access to end-users was vastly curtailed, and IT procurers tended to bar its entry into their controlled end-user domains. It continued to be used on old machines for almost a decade, but at exorbitant prices. The infrastructure plunge of micro-computing in the 1980s made meta-calculus infeasible for more than a decade.
We are now at a turning point. IT is in crisis, as the world is now realizing. It is collapsing under the weight of its own labor, and the boardroom solution of labor arbitrage outsourcing is sending IT jobs to the third world. Staple market saturation has exhausted the need for middleman programming which in spite of decades of methodological attempts (CASE, OOP, etc.) to mitigate the gross inefficiency of the waterfall production approach, have never come close to the economic efficiency of end-user programming in metaphoric languages. This is especially true in R&D, where the evolution of the user’s model is the dominant source of software design uncertainty, and the inverse leverage of middleman labor iteration exponentially magnifies cost. Carr’s analysis of IT is actually quite conservative. Except for the administration of networks, the era of IT has already ended, and has no traction to return.
IT technicians have overspecialized in algorithmic technique. They cannot supply the diversified application-domain knowledge needed for non-staple and custom application development. This is why IT couldn’t create demand-pull in the R&D market. This essential knowledge can only come from diversified end-users. And end-users cannot afford the protracted cost and time of middleman programming. Metaphoric programming does not require today’s esoteric software-engineering skills, because it is tailored to be congruent with the problem-originators (end-users) “problem-view”, not the software-engineer’s “technique and maintenance view”. That is why it is called metaphoric. Most of the worlds software engineers will have to re-train in application knowledge if they are to continue as developers. They have no alternative. Those early adopters who embrace the meta-science agenda will be the primary winners in the new era.
Yes, in essence the industry is ready for a reboot—a renaissance of the value proposition and the demand-pull that originally built the industry. Only this time, we will not be starting from scratch. We don’t have to create all of the scientific models of the last 50 years. We don’t even have to re-create them. All we have to do is recompile them in meta calculus. The computer will do most of the work.
Yes. It will be the replacement of software-engineering employment in the IT staple-commodity recycling agenda—not with commodities, per se, but simulation models. They will be recycled from simulation to optimization. That is how the re-evolution will begin. This time the software engineers will be as important in creating demand-pull as the end-users. They will have plenty of easily justified work to do as the whole industrial system opens up to post-industrial diversification. Moreover, they will flesh-out the object-oriented apparatus that will be used for the meta-engineering build-out—compilers (OSS) and mathematical tools (AD).
Mobilizing the OSSAD Mass Movement
OSSAD will be the mass movement that will build the object-oriented meta-science foundation apparatus or infrastructure. OSSAD will be the aggregation of the open-source software (OSS) movement who will build-out the web-code-augmented meta-calculus compilers, and the automatic differentiation (AD) arithmetic movement who will build the mathematical tools and adapt them for distributed and parallel processing.
The interface between OSS and AD already exists in the form of the current meta-calculus APIs (MC7 and MC8). MC7 is the Fortran Calculus (FC) API, which has been operational on DOS since 1990, and is now operational on Linux. It was the resurrection of PROSE in a new form—a native-code compiler instead of an interpretive virtual-machine compiler. Unfortunately, including the dynamic PROSE features in a static (F77) format within a single language made FC neither fish nor fowl, but a hybrid. The redesign, MC8, was therefore intended to support multiple languages. The development of MC8 compilers is the first step in the mobilization of OSSAD. Very fortunately, this task has been vastly simplified by OSS compiler work associated with parallel processing, done in Russia based on prior work in the US—the Distributed Virtual Machine (DVM) System of compilers that convert mono-computer source code to cluster-computer source code.
The DVM system is a great leap forward for meta calculus, not only for conventional monoprocessing, but for multiprocessing as well. By adapting the existing DVM Fortran and C compilers for meta-calculus (mating them to MC8), we will also have the prototypes for MC9 (intrinsic-thread AD parallelism) and MC10 (extrinsic-thread AD parallelism), as discussed in an NSF proposal we prepared in 2003. The DVM compilers are source-to-source compilers, where the input source is the user source (potentially with comment-embedded distribution commands) and the output source is distributed source (if distribution commands are processed). Meta-calculus adaptation will make this a two stage process. In the first stage the meta-calculus source is converted into AD-overloaded source, and in the second stage, the AD-overloaded source is converted into distributed AD-overloaded source for parallelization. Thus the second-stage source is a design substrate for parallel process design.
This simplifies a hand-off from the existing MC software team, Thames and Robinson, who are now the only ones who understand the internal design of meta calculus, to a new OSS team. Due to the advanced state of this current design (eighth generation of a technology that was marketed for 8 years in the mainframe era), and the advanced state of the supporting DVM system, a fully functional MC8-9-10 meta-science platform can be produced with relatively modest funding. A dual language system thus made available to OSS can serve to flesh-out a whole spate of meta-science extensions to conventional languages. This will jump-start the research and marketing build-out of a higher plateau of metaphoric application development that will extend GNU/Linux to make working scientists and engineers—engaged in casual programming—the primary application developers, and once again the drivers of computer demand pull.
Yes—meta science. Joseph Thames was also the architect and primary developer of EvoScope, a web-code generator for C. EvoScope is based on GNU/Bison, as are the DVM compilers. Actually, the DVM System uses Bison for parsing, and Sage++, a C++ code-generator toolkit for backend code-generation. EvoScope uses C-embedded Perl as a back-end code generator. It would be a relatively minor effort for Joseph to adapt one of the DVM compilers to MC8 and implement its metacybernetics webcode generator at the same time. With assistance from another programmer who worked on EvoScope, they could adapt both DVM compilers at the same time. The result would be two new meta-science language products, MetaFor-DVM and MetaC-DVM, that compile to native machine code on mono or cluster machines. This is about a 2 man-year effort. Then the OSS experts can use these as target languages for OOP versions of meta science languages, MetaC++, MetaJava, MetaPerl, and MetaPython.
In order to mobilize and co-opt the OSSAD movements, a non-profit approach is required. The intellectual property of the infrastructure must be held in common, like open source. However, there must be compensation for creative work and for property contributions. We propose a non-profit foundation like the Apache Software Foundation, but the use of its infrastructure software must generate revenue. So the Meta Science Foundation (MSF) will be a non-profit software-service wholesaler, that will charge build fees to commercial users for first-time use of new builds (compilation and linking). For-profit resellers may mark up these fees for commercial sales. To achieve the benefits of open-source, the source code must be available to all foundation members, and membership must not be restricted.
No. The MSF would be prevented by law from competing with for-profit firms. Its fees would be the same for all, and would be minimized by non-profit regulation. It would not engage in advertising. Neither would it be a support service organization. That function would also be a for-profit or volunteer function. Its sole purpose would be development and maintenance of common meta-science infrastructure.
However, it will indirectly serve as a market promotion vehicle. It will serve as a technology vortex to draw in the participation of the OSSAD movements, and thereby spark widespread interest in the Catch++ book, which presents the vision for an industry re-evolution. We believe this articulated vision will displace the naïve vision of artificial intelligence (AI) that has sustained computer research for decades to little avail, motivating DARPA and the Japanese computer industry to commit enormous resources to techniques that have far less value than meta science. We believe that when the true economics of computing delineated in the Catch++ book are fully understood, meta science will take the place of AI as the driving motive of computer science.
It can be, but we want to accelerate the transformation by providing stronger rewards for creative work. We propose a labor-based bootstrap currency that can reward technical talent in the way that venture capital rewards entrepreneurial talent.
We propose the use of IOUs which accrue value with time like bonds. We propose to call them barter bonds or BBs. They will be exchanged for volunteer labor and later redeemed for cash, or exchanged for services and products and later redeemed by labor. By having time-accrual value (interest) they will become tradable in new “BB markets”.
Yes, that is one of the motives. There are other reward mechanisms we want to implement as well. There is much latent intrinsic value in “proto-software” that goes unrewarded when aggregated into broad tools or operating systems like Windows. We want to establish a new software pricing system, like telecom pricing, that fairly distributes reward for original creativity. This is use-based pricing tagged to the value of change—the software build events. Charges will be levied for individual resources (tools) incorporated in software builds (compilation and linking).
Tools will be individually priced, and use-royalties paid to their developers. Thus tools and proto-software will become market valued in accordance with their utility. This mechanism will also provide vital feedback to developers as to what kinds of tools are valued by users. This will shift development incentives more toward user-satisfaction than the self-satisfaction that is currently stronger in the OSS movement.
Yes, that is the idea. Like it or not, software—being of negligible marginal cost—is an economic driver of natural monopolies and economic centralization. Our intent is to create a natural monopoly optimized for the common good—not for privileged gain. Competition is vital, but it is non-destructive competition for increased value. The new value pricing system, which will be the foundation of the new meta-science market system, will provide the mechanism for this constructive competition. All derivative meta science CAD, CAM, and CEC products will create revenue for the MSF, and the MSF will plow that revenue back into meta-science technology, or disperse it to other worthy causes.
Meta Science Marketing
A for-profit service and consulting alliance will spring up around the MSF, in the same manner that choreographers such as Red Hat and Suse sprang up around Linux. But this alliance will be non-staple application focused, whereas the current Linux choreographers are staple focused, like IT in general. It will be a collaborative franchising alliance of meta-science and web-code outsourcing. The inner tier will be computer-utility leasing, network management, and software contracting franchisor brand firms. The outer tier will be a very large matrix of independent software consulting firms supplying temporary outsourcing talent on a highly multiplexed part-time basis.
Unix has traditionally been marketed via the VAR franchising approach, because it has the most rapid growth potential and can be partially self financed. Also the nature of software contract outsourcing combined with R&D engineering services lends itself to the program-office/matrix approach of the aerospace industry, adapted to the web-VPN Internet capability of immediate point-to-point consulting. PROSE consulting via mentored application spawning was successful in the rudimentary networking of 30-cps teletypes. This plan is an advanced evolution of that approach.
Yes. This is also a variation of the headhunter-agency role of software outsourcing, but adapted more toward the systems engineering support for R&D one-of-a-kind problem-solving in a market that is initially highly horizontal, but with the prospect for potentially very many pockets of vertical opportunity for development of MATs and POO wizards. In addition, the inner tier serves as the administrative support to the outer tier—computer-utility leasing, network administration, sales, and customer support.
Yes. It is a matrix of independent consultant franchisees dispersed across the globe. There can potentially be millions of small businesses in this model. Each is a node in the global franchise network and would lease its hardware from the computer utilities, which would be configured and administered in cookie-cutter fashion with all of the tools needed by the consultants as part of their franchise package. Many of the consultants will be engineering and science students, as well as university faculty. Their consulting roles will be part-time and highly multiplexed.
Yes, because meta science will dramatically shorten application development times through mentoring, a way of enhancing the leverage of meta science through skill synergy. Mentoring implements an incredibly short “spawning” sales cycle, originated in marketing PROSE, which exploits the complimentary skills of mentors (languages and tools) and customers (scientific models) to bypass both learning curves. Turnkey modeling contracts will also utilize science and engineering graduate students, because they are simultaneously the world’s best and most underpaid modelers. Modeling skill tends to atrophy in industry.
Of course, and most will be members and work for the MSF as well. In a sense everybody in the alliance network will work for everybody, and BBs will be an alternate means of compensation to convert potential value into current value. Most work will be highly multiplexed temporary work performed offsite and web remote. Network connections will ebb and flow via instant VPN extranets controlled by project managers in the brand franchisor firms. Essentially all computers will be leased as franchisee packages from the computer utility brand firms, who will also administer them like “thin clients” for interoperability.
EvoScope, the current product of MetacyberNet, was designed for software maintenance contracting, primarily for legacy code maintenance (projected to be a $300 billion market), which would lead to evolutionary (incremental) upgrading of legacy code as a more conservative re-engineering approach instead of re-building from scratch with new technologies like Java and C#. The customer often has been held hostage by the IT agenda of these newer algorithmic languages, required to take high financial risks which can be avoided in the former approach. In the aftermath of the Internet bubble customers are less likely to take such “bet the future” risks. MetacyberNet, a brand franchisor will focus in the business and mission-critical software arenas, and can support many of the franchisees in a synergistic way while they are multiplexed in such functions as meta-science mentoring. EvoScope also has a role in optimization re-engineering and vertical-application prospecting.
This is the location of old models in legacy engineering code that potentially have joint-venture market potential as POO wizards. Generally this kind of code is non-staple (medium and low demand density), in that it does not have the vast economies of scale that have previously resulted in CAD products, but with low-cost optimization re-engineering can be profitably remarketed, or donated to the MSF for incorporation into the meta engineering libraries.
Rapid optimization prototyping leveraged by a broad knowledge base of pre-built meta engineering components will dramatically reduce the cost of product development to the extent that anything beyond ad-hoc, one-of-a-kind applications can be profitably distributed even at very low demand densities. Moreover, service companies will specialize in “proto software” marketing, whereby common core software functionality that is too usage-diversified to be distributed as products, can be rapidly tailored to individual client needs at low cost. Most business software fits this common core functionality character due the common functionality of business.
In the engineering design arena this economic flow might be thought of a post-industrial CAD or CAD diffusion (proliferation) into design areas that have much lower economies of scale. This economic activity will enhance the shift from mechanistic conglomerate concentration to organic global diffusion that will characterize the post-industrial era. Low demand-density vertical application products can achieve high profitability without prohibitive pricing due to the global village effect of the Internet, and the fanning out of world industry to minimize the energy of value distribution—the “shape of things to come”.
Pricing and Revenue
That is generally the case, because the indirect competition from commodity software in the business PC domain has depressed prices for software in general. A part of this is an economic anomaly. The immense economies of scale in PC software and PC hardware, coupled with the displacement of value perception from purchase decision, has decoupled pricing from utility in the computer industry. Scientific products, which do not have the high demand density of commodities, have to be priced much higher to recoup their production costs.
The typical buyer is an IT purchasing agent, whose only perception of value comes from price competition in the market, which is dramatically influenced by the mass-production prices of commodities. In today’s saturated computer market, computers themselves cost less than $500. Any software package costing more than $1000 would give the purchasing agent apoplexy. The poor engineer who tried to justify such a purchase would encounter formidable resistance to overcome, particularly since the purchasing agent reports to a completely different management line usually.
No, actually it is very bad business. Particularly if the engineer could solve a problem with the new tool in one tenth the time he would spend without it. He may save his company the equivalent of nine-tenths of his salary for a year, in just that one application. If his burdened salary is $100,000/year, he just saved the company $90,000. This does not even count the other benefits like winning a contract because it only took 20 working days to solve the problem rather than 200, and he was able to put the results in the winning proposal.
Generally an engineer would receive a reward or a bonus if he could demonstrate savings or increased company income by 50% of his salary. In this case the utility for the single use of the tool might well be worth $25,000 in the above scenario, or far more where it was instrumental in winning a new contract.
Pricing needs to reflect value to the end-user. The best method is use-based pricing like the telecom industry. In R&D where evolution of software in prototyping is heavy, the best reflection of value is a charge for build events, like compilation and linking, that is a small fraction of the worth of that event to the user.
Well, look at the above case, where the value is $25,000 for 20 days of using the tool. If there were an average of 20 compilations a day for that period, each compilation would be worth $62.50. But lets say to establish a norm price for all usage, going overboard to be fair we only charge $5.00 per compilation as a wholesale price for the use of MetaBas say. And looking down the road about three years where there are one million users employing MetaBas in the world, the yearly income for this product would be $250 million to the MSF. For all eight languages and meta-engineering libraries during this same year income is estimated at $10.25 billion. In all of these cases the estimated value to the client companies would be in excess of $100 billion—just on the basis of cost savings, not opportunity value like winning contracts.
Revenue is harder to estimate because it will include much more than markup of the MSF prices. A substantial part of the revenue will be for consulting, mentoring, and outsourced software development. It is safe to say that it will be an order of magnitude higher than the MSF, perhaps as high as $200 billion per year.
Yes, this could be conservative when you consider that this is an alliance with up to perhaps thirty brand franchisor companies, and a very large matrix of small consulting firms, potentially millions globally. So this is a crude estimate of the size of a substantial portion of the world R&D expenditures after three years of the same or higher rates of growth that were seen following the introduction of Fortran in 1957. By comparison the R&D expenditures in the US alone were in excess of $250 billion in 2000, following five years with growth rates in excess of 20% per year.
Yes, and this would derive from an extension of MSF pricing. This is revenue to pay part-time mentors for assisting (jump-starting) new users who would often not be programmers. Mentoring is evangelistic sales support that spawns new applications by having a mentor show a client how to setup the client's model in meta calculus. It leverages problem-solution success and reduced time to solution, because it exploits the synergy of the mentor's knowledge of the tool and the client's knowledge of his problem to bypass both learning curves. Since immediate value is demonstrated, this charge is easily justified to the client organization as value in creating a new application plus defrayed learning cost. It is a one-time charge because the client seldom needs mentoring after the initial success.
This is a brand reseller charge, where the reseller contracts the mentor labor out to the franchisee consulting matrix. Also this charge is marked up by the reseller. Mentoring charges would be engaged through special mentor accounts for new users that they would use while mentors were assisting them.
Mentoring is an extremely potent tool for sales acquisition that co-opts standard tools like advertising. It stimulates word-of-mouth evangelism. It creates a brand-consultative bond with the client that is relatively invulnerable to price competition. By reminding the customer of the value derived by the brand service, it also justifies value pricing as opposed to cost pricing.
For usage of the end-user languages MetaBas and MetaCalc, including mentoring charges the usage revenue assuming a 300% markup over MSF rates would yield $3.94 billion in revenue in the third year, of which $813 million would be mentoring charges.
Competition
Matlab, Mathcad, Mathematica, and Maple are the most popular. All have significant installed bases that will have to be accommodated.
The fundamental strategy is co-optive. Our goal is to gain cooperative hegemony over these perceived competitors and have them adopt meta science. This is where the OSSAD co-option strategy comes into play. There are two fundamental weaknesses of these current products that render them as future sideshows rather than as competing main events. They are hampered by the fact that they are non-holonic (reductionistic) math workbenches or tool kits, and are base-language incompatible.
Yes, in contrast to PROSE, Mathematica and Maple were designed, like Macsyma before them, to automate the pre-computer reductionistic paradigm of symbolic manipulation. In terms of calculus, for example, one of their main early usages was deriving derivative formulas before automatic differentiation trumped this card. In essence this is a mathematical mechanics focus—designing how to solve rather than what to solve—an algorithmic focus. Whereas PROSE completely hid calculus under the hood, leaving only algebraic (not algebra) modeling like Fortran or Basic as the only skill required, these tools immerse the user in the world-view of the numerical analyst, which is what many of their users are.
Within these reductionistic frameworks, which were already in existence before the Breckenridge AD symposium in 1991, they have incorporated AD as an afterthought. Holonic nesting, like PROSE, requires a complete departure from the symbolic paradigm of Mathematica and Maple, and though Matlab and Mathcad or not symbolic oriented, they retain the reductionistic flavor and are non-holonic tool kits. None of these products can transmute complexity into simplicity in the subtle holonic way that meta-calculus does.
This is an important vulnerability that eliminates these languages for optimization re-engineering by the simple act of re-compilation—which is the way meta calculus will capture the OSS mass movement in the first phase of the meta-science build-out. OSS software engineers don’t need to understand the simulation models or the math of optimization in order to convert old simulation code to optimization code. All they need to understand are the legacy languages, Fortran and C, and their meta-calculus counterparts, MetaFor and MetaC. They will validate the conversion by comparing test cases from the old to the new. This induction of OSS into meta calculus will subsequently lead to the capture of OOP.
Actually, it will be the degenerate form of meta science that captures OOP. The extension of MetaFor and MetaC with web-code (EvoScope technology) generation—the second release of these DVM-based compilers. Web-code will greatly enhance the collaborative exchange of ORE mining and will accumulate annotated websites depicting the historical processes of optimization re-engineering for easy learning by OSS members following in their footsteps. Web-code histories will become like fantastically rich email chains made more efficient by tooltip notes and popups, links to context-sensitive online manuals and wiki-notes by commenters, all hidden behind the unobtrusive link symbols which eliminate syntax noise.
Isn’t it obvious? All these OSS folks are steeped in OOP—a lot more than in the engineering and math of the ORE-mined legacy code. They are going to be repulsed by a lot of this old legacy code, especially with all this collaborative peer pressure looking over their shoulders. They are going to want to re-organize it—to say the least. The strong-typing crowd are going to want to supercede MetaC with MetaC++ or MetaJava. The weak-typing crowd are going to want to replace MetaFor (and MetaBas) with MetaPerl or MetaPython. Even before they start collaborating in the meta-engineering build-out (ORE recasting) that fleshes out meta science, they are going to flesh-out the meta-science OOP languages.
Yes, with these new OOP languages, the meta-science juggernaut will shift into the second gear of re-evolution, and the intensity of collaborative exchange via web-code begins to blur somewhat. New collaborative special-interest groups (SIGs) dedicated to various application domains (e.g. engineering and science sub-disciplines) will spring up all over the world, mainly in universities. Through these SIGs, problem-oriented optimization (POO) API alphabets will begin to emerge.
Yes, in this rampant re-evolution, POO metaphors in GUI wizards will begin to appear and evolve. Since being based on meta calculus and OOP, these POO wizards will be holonic.
Yes. This is where we begin to glimpse something like the Star Trek mode of programming, far away on the horizon—the foreseeable future that the old AI crowd used to prognosticate about.
They become sideshows and then they will go the way of languages like APL. Along the way their installed bases will get re-engineered into meta science. But the symbolic math sideshow will still have a major part to play in the advancement of meta science into the grand-challenge domains of partial-differential equations (PDEs) and cluster computing.
PDEs and Cluster Computing
Symbolic math is really a higher form of compilation—symbol solving. It is a way of converting one symbol system into another—translation. The whole pre-computer fields of mathematical analysis and symbolic logic fit into this scenario. It is reductionistic. But as most numerical analysts will tell you, the way to solve PDEs by computer is to reduce them to ODEs, or to algebraic equations with finite-element or finite-difference approximations. The way to do this metaphorically is to use systems like Maple or Macsyma to transform the abstract PDE formulations into meta-calculus programs.
Yes, PDEs impose higher structure that naturally decomposes into independent processes that can be parallelized. Thus a part of the symbolic transformation can be dedicated to this parallel process decomposition.
Yes, the DVM System compilers are cluster decomposers. They convert a mono-processing source program into a cluster of decomposed source programs for parallel processing on multiprocessor machines. The decomposition process is programmed by commands imbedded in the comment fields of the mono-source. These commands tell the DVM compilers how to convert mono-source into multi-source.
Yes. As we said previously, MetaFor-DVM and MetaC-DVM add a meta-calculus translation stage on top of the decomposition stage, which converts meta-calculus source into overloaded Fortran and C source. PDE translation will add another stage to translate PDE source (probably internal syntax generated by POO wizards) into meta-calculus source.
Mostly, yes. This puts the engineering above the math, which is the practical way of things. Programs like NASTRAN, ANSYS, SINDA, etc. are really engineering programs, even though they solve PDE systems. Engineers usually relate problems in terms of application descriptions, not math descriptions.
Yes, this is where the OSS and AD movements really coalesce. The decomposition programming for PDE reduction, POO wizard development, meta-calculus cluster decomposition, etc. will be where the build-out growth in R&D will occur in the next decade.
APPENDIX A – User Stories
I was introduced to PROSE in 1975 by Dan Mickish and Dillon Schofield, my research colleagues in the Imaging Systems Department of the Dupont Experimental Station in Wilmington Delaware. Dillon and Dan had developed a model in PROSE that became part of an X-ray system design that we later turned into a Dupont medical product. Joe Thames later assisted me in completing this product, and developed the successor to PROSE, Fortran Calculus, at the same time. This was in 1989-90.
I met Joe in person in 1985, when Dan Mickish and I visited him at the Aerospace Corporation, where he was a project manager in the Air Force Shuttle program office. After leaving PROSE, Inc. in 1979 as the time-sharing market was starting to close down, he and a computer designer were attempting to develop an advanced computer that could support digital calculus (the PROSE engine) at the micro-code/hardware level. They had both joined the Aerospace corporation in 1980, intending to use it as an incubator to build this computer, and then spin-off a microcomputer company to fabricate and sell these advanced machines. During the next five years they built the Aerospace Research Computer (ARC), and were reducing its basic CPU to a RISC chip that would power an add-in board coprocessor for PCs. This was the way they intended to re-introduce PROSE technology to the marketplace. They called this chip a WISC for “writable instruction set computer”. In essence it was a “blank-slate” CPU that could emulate any other computer, including a “digital-calculus metacomputer”, which was the primary intent. They were then planning to spin-off a startup micro-computer company with one of the Aerospace executives as the CEO.
Later, my colleagues and I assisted them in their attempts to raise capital on Wall Street for this startup, meeting with representatives of the Venture Capital firm, Petersen Jacobs and Ramo. Simon Ramo had been their initial contact, and a colleague of Ramo’s, Richard D. DeLauer, former DoD undersecretary of Research and Engineering under Reagan, became a board member of the new startup, at Joe’s urging. DeLauer had been a sponsor of Joe’s team at TRW during the Apollo program, who developed predecessors to PROSE.
Unfortunately, the new company ran into fabrication problems with the new chips that cut their projected performance in half. They were to be marketed as add-in boards that would give mainframe power to PC-AT machines. Joe’s team developed a Fortran compiler/interpreter for these boards, and I purchased one of the new boards for my work at Dupont. Because of the lower than expected benchmark performance (about 10-times faster than 16-bit Fortran on the new Intel 386 chip), the CEO of the new company decided to abandon scientific languages marketing.
As this decision cancelled the purpose for which these machines had been designed in the first place, Joe was faced with a choice of giving up his career dream, or leaving the company. He chose to leave the company to continue pursuing synthetic calculus, and Richard DeLauer chose to leave the company board for the same reason. It was during this time that I assisted Joe to make the next step. This was 1988.
Joe had been thinking about how to get around the AD performance issue, and worked out a way to create a native-code compiler for a new meta-calculus language. During this time, I had several PROSE programs that I was using to design the new X-ray system, and I needed to have them converted to the Dupont Cray YMP, as the only remaining vendor of PROSE charged enormous fees. Joe agreed to a contract to convert these programs. It was understood that he would develop the new language compiler and API for this purpose, but would do so on his own capital.
During 1988-1990, Joe developed the next generation synthetic-calculus language, Fortran Calculus (FC), and converted the X-ray system design programs from PROSE to FC. He implemented FC on the Dupont Cray and Vax machines, and also implemented it on DOS machines. I found the DOS version sufficient for my needs. The X-ray system design subsequently went into production as a new Dupont medical X-ray product, Ultravision, later advertised on TV.
I was a sales support engineer for United Computing Systems (UCS), a Control-Data based time-sharing and remote-services vendor located in Kansas City, when they began introducing PROSE in 1975. I introduced PROSE to many companies in the bay area, and worked with PROSE, Inc (out of Los Angeles) over teletypes, to mentor users in prototyping new optimization applications. Mentoring was a quick way of jump-starting new users, some of whom were not even programmers. They generally didn’t know much about how to optimize their equation models, but wanted to do so. We were more successful in jump-starting new applications this way than appealing to optimization experts, who usually exhibited NIH resistance. Thus PROSE was easier to sell horizontally to non-experts than vertically to experts in the beginning.
In 1979, I joined Memorex with another PROSE colleague, Frank Pfeiffer, who had previously founded the PROSE user group. We were instrumental in persuading Memorex to acquire PROSE on an Amdahl mainframe. PROSE was then vended for IBM and Amdahl mainframes by Sun Information Services, a Philadelphia subsidiary of Sun Oil Company. I used PROSE at Memorex to optimize a matched filter design for disk drives. The design time was reduced from 12 weeks to 1 week and the filter design was optimal.
Later, while working for Lockheed Missiles and Space in Sunnyvale (1986-91), after testing MACSYMA for several months on a project to see how it compared to PROSE, I was instrumental in procuring the Vax version of Fortran Calculus from Joe’s third startup company Digital Calculus Corporation. I also bought a DOS PC version which I have been using ever since.
In the 1990’s, I created several science/engineering applications (e.g. curvFit, Match-n-Freq, ODEcalc, etc.) to show the power and simplicity of Fortran Calculus. For more information, visit http://digitalcalculus.com/demos/
I first worked with Joe at the Aerospace Corporation in the early 1980’s where a colleague, Phil Young, a mathematician and software engineer in the IT division where I was a section head, adopted PROSE totally. Once Phil started programming in PROSE he would never program in anything else. In those years we had PROSE installed on both CDC and IBM mainframes at Aerospace.
I was one of the reviewers of Joe’s 1983 paper on Metacybernetics, his software theory of evolution that later became the basis for web-code. This paper described the concept of a “metacomputer” that was to be a virtual machine implemented in the context of the Aerospace Research Computer (ARC). The ARC was called the “metacomputer host”. This theory postulated the evolution of metacomputers using generative tools like compiler-compilers (i.e. metacompilers). In the 1980’s this concept was a little far out for the computer architecture symposium where Joe was chairing a session, so he was advised not to publish it then.
Later, of course, with the invention of the web, the notion of metacomputers became commonplace, as that is precisely what the HTML-CGI protocol became, a metacomputer instruction-set architecture for client-server metacomputers. In 2000, Joe used elements of his Metacybernetics theory to create EvoScope, the web-code generator, and co-founded a fourth startup company, MetacyberNet, to develop and market it. His partners took this company into fetal mode in 2003, and continued EvoScope development by outsourcing to programmers in India.
In 1992 and 1993, I worked with Joe at Digital Calculus Corporation in Los Angeles while trying to raise venture capital, but the downturn of the defense industry and the rash of downsizing that characterized that time, offered little chance of success.
I began working as a staff mathematician for PROSE Inc with Joe and Michael Robinson in 1973, while I was starting work on my PhD at UCLA. I had previously been a fluid dynamics engineer at Douglas Aircraft in Santa Monica and had considerable experience in numerical mathematics. Most of my work was using PROSE itself to solve very sophisticated mathematics problems, including the use of PROSE to develop advanced solver algorithms, including a PROSE version of the generalized reduced gradient (GRG) algorithm.
The most significant development was a higher order mathematical application template for optimal control modeling. This was called EPOC for Economic Planning via Optimal Control. The opportunity for this development was a project by the Western Timber Association in San Francisco and Simpson Timber Company in Seattle. Simpson had developed a specialized optimal control approach for use in managing forests, but was in dispute with the US Forest service who used linear programming to model forests. The Western Timber Association wanted us to validate the Simpson model with a completely different approach. We subsequently used EPOC to solve two separate models, one to validate Simpson’s model, and another for more general regional management of timber production and distribution. Both of these models were presented at forestry symposia.
Joe and I later worked together at the Aerospace Corporation, where PROSE was used for orbital transfer problems. I later became a UCLA faculty member, and then later took a position at the University of Kentucky, where I am now professor of mechanical engineering and mathematics. Much of my work is associated with turbulence and chaotic flow regimes, and I have extensive experience in parallel processing.
In early 2003 I collaborated with Joe and Dillon Scofield on a proposal to the National Science Foundation. The intent was to extend meta calculus for parallel processing in order to solve an important application in quantum dynamics associated with high temperature superconductors.
I first encountered PROSE in a 1975 article in R/D magazine by Joe Thames. He gave an example of an optimal design and control problem that involved nested optimization, correlation, and simulation. I knew from my own experience that this was not possible, so I decided to attend a seminar about PROSE. Then I started using PROSE and I found out that it was possible. I then realized that under the hood, the PROSE language had a very sophisticated mathematical engine, which essentially took all of the work out of user programming.
At this time, my colleague, Dillon Scofield had been trying to develop an optimization application for a month or so. When I got back from the seminar I asked him for the formulation of his model, because I wanted to try PROSE on it. Within 3 days we had a solution.
I consider PROSE to be the most powerful scientific language ever developed because it not only allowed simulation but also optimization. These processes could be easily combined by subroutine-like-nesting to address high-order inverse problems of most any complexity. PROSE programming was essentially algebraic, like Fortran or Basic, and usually non-algorithmic because almost every conceivable sophisticated calculus-level solver was already provided and easily called within the program.
PROSE allowed me to solve commercially important problems
that I would not have attempted otherwise.
My most important accomplishments using PROSE were the development of a
new generation of medical X-ray intensifying screens, optimizing the chemical
replenishment of a commercial graphic arts film development system, developing
a measurement system for organic and inorganic integrated optics, and the
re-definition of neural networks in terms of conventional optimization algorithms.
I was an application programmer at Northrop when I first encountered PROSE in 1974. I used it to rapidly develop a number of applications for engineers in a support role.
Later in 1978, when I was at Bechtel Power, I started the PROSE user group and came into contact with PROSE users from all over the US. All of us knew that PROSE was a great leap forward beyond Fortran and Basic. But unfortunately, PROSE’s infrastructure, mainly Control Data machines would soon vanish from the scene.
As PROSE became popular in the late 1970s, academic interest in its internal mechanics began to emerge. The PROSE literature called this “digital calculus”. Digital calculus is actually a composite of two fundamental techniques, but interest soon fixated on the calculus arithmetic part, which came to be called automatic differentiation (AD).
In 1979 we held a one-day symposium on PROSE at the Rand Corporation, which was one of the sites of the IBM 370 version of PROSE. Much of the interest of this symposium was on the idea of building calculus-based hardware, because the computation intensity of calculus arithmetic in software could conceptually be vastly speeded up by building hardware for this purpose. As the mainframe time-sharing era was starting to wane at this point, and everyone saw desktop machines on the horizon, hardware enhancement looked like the best way to sustain end-user programming on desktop machines. Joe Thames focused his attention on this for the next nine years.
In 1979, PROSE Inc developed a crippled version of PROSE for Oak Ridge National Labs (ORNL) for use in sensitivity analysis of nuclear codes. It was called GRESS (Gradient Enhanced Software System), which had a limited version of AD. ORNL distributed GRESS to academia and this stimulated further interest in AD.
In the late 1980s as the interest in AD was growing, I wrote a couple of articles about optimization and AD in PROSE for the ACM special interest publication on mathematical programming, the SIGMAP journal.
Later (1990) I was contacted by Andreas Griewank of Argonne Labs, who was interested in putting together a SIAM symposium on AD and inviting participants from all over the world. About 60 people who had been prominent researchers in the group were invited. This became the famous Breckenridge symposium, that started a watershed of interest in AD.
Joe Thames is a visionary computer scientist who has devoted a substantial part of his career to the development and commercialization of automatic derivative based scientific and engineering software. For those who may not be familiar with the revolution his work represents consider the following tale.
A colleague of mine, Dan Mickish, attended a meeting where one of Joe’s commercial versions of automatic differentiation software was highlighted. Dan was intrigued. I remained back at the research lab working on an optimization problem involving an industrial process related to the coating of photographic film. I had been able to formulate the problem in terms of a minimum time principle. After about a month’s work, I had a working numerical solution and was graphing the results from tabulated data generated from my program. On return from the meeting, my colleague asked for the mathematical formulation of the problem. Using Joe’s software the problem was solved in three days! Not only was this an eye opener to me as a theoretical physicist, in this instance it proved an important proof of the result. The story does not end here. We were unable to patent the result because we found that a competitor had spent some ten man years using a cut and try method to get what we could now show, using Joe’s software, was a sub-optimum result. But this, in the view of the DuPont patent liaison, was enough to have had the idea of a mathematical optimization of the process already disclosed.
In my present capacity I have seen the field of computational chemistry, for which two Nobel prizes have recently been awarded, seriously delayed in its development because of the lack of easily used automatic differentiation software. The negative impact is through the present necessity to hand code automatic differentiation to implement Newton’s method for the optimization methods needed. This problem is further exacerbated by the necessity that the implementation of automatic differentiation languages be extended to cluster computing. The main idea is that easy-to-use tools, which include automatic differentiation, should be in the hands of the formulators of the problems. The implementation should be left to the professionals such as Joe Thames.
The reader may be aware that there are several engineering/scientific software packages that can now do automatic differentiation. Those that I have experience with include Maple and Mathematica. Neither of these have the power to solve problems that Joe’s software such as PROSE from as early as the 1970’s had, because they are not holonic. They do, however, have relatively good graphics and a faithful following of users.
In early 2003, Joe, Jim McDonough, and I collaborated on the NSF proposal to apply parallel meta calculus to differential geometric manifolds of quantum dynamical models. In this proposal we postulated an adaptation substrate for tuning AD methods and algorithms and holonic nesting for parallel processing. This was before we knew anything about the DVM System compilers, which essentially provide ready made infrastructure for us to adapt meta calculus for parallelization.
I have recently acquired a 24-processor AMD 64-bit Opteron cluster machine for quantum chemistry applications. It will be shortly augmented by 8 more processors giving 16 dual 64-bit processors, 64 GB main memory and 4TB disk. We intend to install MC7 on this system soon, and plan to use this system to test the MC8-9-10 DVM systems as they are developed.
Through his recent work, Joe has shown that he continues to carry the torch for those of us who need efficient high-level computational tools. My hope and others like me is that his work gain development support and be extended to parallel, cluster computing.
Super Simplification in Metaphoric Programming
The dynamic units of program structure created by the Find metaphors of meta calculus are examples of holons (whole/parts), a term coined by Arthur Koestler and his major contribution to General Systems Theory. It has been popularized more recently in Ken Wilber’s Integral Philosophy, particularly in his Brief History of Everything.[1]
A meta calculus holon is the dynamic synthesis of a formula modeling unit (a subroutine model of an elemental problem, such as a system of simultaneous nonlinear equations) and a numerical solution algorithm (a solver). This model/solver holon is synthesized by the execution of a metaphor (e.g. Find). Associated with this holon is a differentiation context in which the technique of automatic differentiation (AD) is applied to the formulas of the model to produce the partial derivative matrix (e.g. Jacobian or Hessian) used by the solver—a search engine—to sense the differential changes in the model parameters. This enables the solver to follow the path of steepest ascent or descent of the multidimensional surface represented by the model formulas, in order to iteratively find the holon solution.
But if the model happens to contain another Find metaphor, something truly magical happens that escapes notice of the user—a super simplification occurs. The nested Find metaphor creates a nested holon and a new AD context—a new elemental problem. The derivatives of the outer holon are saved at this point, so the derivatives of the nested holon can be computed by AD and the nested holon’s solver can find its solution. (See some examples)
Once the nested solution is found, its final derivatives are saved in preparation for a differential-geometry coordinate transformation that transforms the inner holon derivatives into outer holon derivatives, so that the outer process of automatic differentiation can continue. This coordinate transformation requires multiple AD passes through the inner holon’s model.
The net effect is that the outer holon’s derivatives are propagated through the inner holon’s solution process. The overall effect—the super simplification which escapes the user’s consciousness—is that the two solvers (outer and inner) are being merged into a single holonic solver by the simple act of nesting the Find metaphors.
The metaphoric leverage only becomes apparent when one considers what it would require to build such a solver in an algorithmic language. To design such a composite algorithm at the algorithmic programming level would challenge the most sophisticated software engineer or numerical mathematician. Yet the metaphoric programmer is unaware that he or she is automatically creating such a solver. This automatic aggregation of algorithms into higher holonic algorithms is infinitely nestable. This is the holonic ontology of meta calculus—all of the nested holon algorithms are the parts of the outer holon algorithm, which is the whole. Yet these parts are integral to the whole, by virtue of the “dynamic glue” of the recursive coordinate transformation. They are never manifested externally. Nobody ever sees them.
This phenomenon of super simplification is so subtle that those of us who used PROSE for more than a decade, simply took it for granted. It actually worked to our detriment in the promotion of PROSE. Before we imbedded this holonic apparatus in the semantics of a language, people were impressed by the complexity of these algorithmic engines—they could see them and be impressed because they were part of the visible code. But once they were hidden in the semantics and given infinite regress which was the feature of PROSE that transcended its meta-calculus predecessors, the language didn’t look sophisticated. Some who had used the early Rand language, JOSS—the precursor to BASIC, said that PROSE was simpler to use. It had some high-level metaphors—Find…to maximize, Find…to match, Initiate…Integrate. But these metaphors were somewhat like the metaphors that later appeared in SQL.
In SQL however, holonic nesting of database searches was still quite complex because it was included in the SELECT metaphor itself, making the design of database searches somewhat a specialty of its own, requiring considerable skill and thought. In meta calculus, however, holonic nesting is dispersed into the nested models where it appears as a natural description of the model itself. Thus the complexity goes un-noticed. It is transmuted into natural simplicity that is overlooked by the user.
You see this same super simplification in the use of spreadsheets. People flocked to spreadsheets because of their metaphoric naturalness of expression—their ontology. It was so natural that users didn’t regard it as programming at all.
We suspect that this metaphoric transmutation of complexity into simplicity is an ontological source of holonic leverage of metaphoric programming over algorithmic programming. Finding the right metaphoric structure emerges in the evolution of software languages, as it did in the evolutionary development of PROSE. It is somewhat like the principle of diagonalizing a matrix into its eigenvectors and eigenvalues. We have seen similar effects in other languages that miraculously simplify programming. This principle of ascending leverage of holonic expression may be the key to upward progress in man-machine communication eventually leading to the “Star Trek” mode of programming. This ascending leverage may not have much to do with artificial intelligence as AI is now conceived, although some AI techniques may prove useful. To date AI methods have not been employed in any of the cases where this ascending leverage has been observed.