Preamble

The method "Executable Pictograms" - in the form of Cognitive Equations. 
To capture (acquire) the knowledge before it is created, or otherwise, to transform patchwork of thoughts into the knowledge​

►► 
Anybody, who has the power to make things happen, is highly welcome to invest, to create a product line of new generation tools for computer programming.

Click onto and do retrieve the cognitive equations to build up a natural user interface, which helps you to rethink the problem you working out.


​• Having a wrong tool and using it in the wrong way, it's hard to fix it. Stop fixing it. Stay with really right tool - our brain. Support it.


•"Having a wrong tool and using it in the wrong way, it's hard to fix it"; That’s right Mr. Alex Knight (Silverlight MVP), I mean "Computer, software tools and effort to create better software tools". 


• When you keep thinking intensively, you catch yourself looking through the wall. That's the answer Mr. Alex: "Natural User Interface is missing". And there is a little problem. Everything we add to our plain view shall obscure our internal vision at this moment. So, there is the recipe ... 


• My recipe for creating "Natural User Interface" for computer programming: "Remove as much as possible of our view and let the work done by the right tool". Where is the computer now?...


• Where is the computer now? Unfortunately, today we have no choice, we need to pay in time and effort for using it. So, let's make it done one time only...


• So, let's make it done one time and come back to it only, when the computer appears in plain view again, to hide it.


• Put the computer in the backstage and let him assist us. Continuously increase the volume of work done, to keep the computer out of view.


•"To keep the computer out of view" means "We talk to computer our way, not the way he wants us talking".


•"Continuously increase the volume of work done" means "Add new semantics to the language of the method "Executable Pictograms".


• To add new semantics to the language of the method "Executable Pictograms" means - the notation to the Language is processible part of it ...


• ... the notation to the Language is processible part of it through the Concept like Programming.


• Is it possible to combine efficiently Imperative and Visual Paradigm together? It's possible. Through the Concept like Programming.


• I named my Method of Imperative Programming for visual paradigm - "Executable Pictograms" and implementation (instance) of it - Calculus "Executable Pictograms" (Calculus "Ex..P").

• The method "Executable Pictograms". It could become the next generation of what you think about.


• The method "Executable Pictograms" basically is the content of the calculus, in its most general sense 
(different from that in mathematics: Non-standard calculus [Infinitesimal Calculus {hyperreal numbers}], Standard calculus [Fundamental theorem of calculus 
<https://en.wikipedia.org/wiki/Fundamental_theorem_of_calculus> {differential calculus <https://en.wikipedia.org/wiki/Differential_calculus> , integral calculus}], Calculi [Computer Science, Software Engineering]) 
for programming, which is designated to become one of many an academic discipline.


• The method "Executable Pictograms" is designated to empower the lay down of the foundation for creation of human brain - computer interface through introducing the new concept of language graphical design for computer programming, as new method of imperative programming for visual programming paradigm, where “Executable Pictograms” stands for: a language, when ”Human Comprehension” is meant and - a conformation/confirmation (of choices and a set of visual points of interest to traverse among the options to provide additional details), when computer input through interaction is meant.


• In common parlance, having the idiom of the Method "Executable Pictograms" in mind, it is correct to say that, Method "Executable Pictograms" is a tool for computer assisted, high definition, multidimensional thinking, which resembles calculus for computer programming.


We are introducing adaptive ontology Calculus χπ of programming and do programming semantics of the Calculus of Core Pictograms rather than the user’s problem domain and addressing them with pictograms in two-, three-dimensional way, to resemble programs for user’s problem domain. We are replacing legacy programming language, with pictographic language for Calculus "Ex..P" and employ his adaptive ontology Calculus χπ of programming. We see problems through formulas, equalities, equations and system of equations, still remaining with imperative and concurrent thinking. We cover over elements of the rest of basic programming concepts: functional, logic. And retain the capability of object-oriented, generic and intentional presentation of the calculations. And we call it - visual programming paradigm.


The concept:

• Domain expert proceeds from one point, creating another one in hypertext frame, containing possibly graphic information as well, transforming his knowledge to the point, where knowledge frames delivered by the "Executable Pictograms" finish the specification, explaining to him, what he wants to accomplish using a computer.

• At this point he has a multidimensional frame on very intelligible three-dimensional (two-dimensional projection is possible) graphic structure to start with rethinking the problem he works out.

• This structure is processible and, by default, computable after all data passports are reviewed (interaction among the passports resembling interaction that among the Cells of the Microsoft EXCEL).

• This structure is contained of terminal pictograms of Visual (stands for "paradigm") Language for Calculus "Ex..P", implementing method "Executable Pictograms".


        We are dedicated redefine software development, introducing the framework (software development “methodology”) for software development, based on adaptive ontology, eliminating a Coding.


     This framework is called Calculus for Programming and based on implementation of the new (and only one of this kind in the industry) method of imperative programming for visual paradigm – Executable Pictograms.

     This framework intended to be delivered as a standard feature (in the form of Computing platform), enhancing group productivity tools by utilizing functionality of the specification-designing, presentation, design development and implementation in the ontology based, holistic way as an interactive WYSIWYG blueprint. This blueprint is delivered in the form of 3D interactive graphics with hypertext (plain 2D presentation of the document is optional). 

     The implementation of the adaptive ontology used, is called Calculus χπ.

      • Having a wrong tool and using it in the wrong way, it's hard to fix it. Instead, we prefer to have a visual language for calculus and visual calculus for programming. It’s how we rediscover a Programming, leaving the Coding in the past.

     Here we are talking about the software development. As of today, there is no any other theory or methodology supporting the use of ontology in the process of software development, eliminating Coding. Presentation of the process of development is supported by 3D graphics and a hypertext according to the methodology. We have a bunch of applications for modeling, e.g. UML. They cover needs for ontology, with the set of Frames, to collect data about the problem, to create a program, which is coded or/and synthesized in this case. All of them imply the use of coding, i.e. a calculus for coding is used. There is no specification, design and development of the frames (in the case of UML, we are not designing nor developing the frames by itself, we are just using them), which imply the use of the process of ontology designing, presentation, development and her adaptation, which we call Calculus for Programming. Contrary, the calculus for programming is employed in our methodology of the software development. Somebody can say, “Growing use of ontology”, in reality it means the growing use of only a word “Ontology”. And nobody knows (but us) how “to eat it” (to integrate with it) and what the difference among the Programming and Coding is. Calculus for programming, defining a programming, which is derived and accumulated from a process of designing and developing of the ontology for specification of many problems and algorithms of calculations to solve them. And Calculus for Coding is derived from coding by itself, adding different layers of abstraction, thus creating different “programming” (i.e., in reality, coding) languages. Each time, when we are reasoning over code, we derive each time, the calculus for programming, to construct mentally a specification, of what it is created, to reason about it, thus reasoning about it become extremely obscured. And this is fundamentally wrong. Programming means we construct, present, design and develop a specification of a problem, embracing Calculus for Programming, based on adaptable ontology. We are constructing, presenting, designing and developing an interactive WYSIWYG 3D blueprint for every problem, which we solve on the computer in the environment of the group of developers and domain experts. And this is our Code (knowledge Code – enriched in this way by natural language), which could very conveniently serve as input for AI, to process the knowledge or to be applied to bring in a knowledge about computing to the Quantum Computer, or just serve as an interactive 3D blueprint, in the case we want to comprehend and contemplate the whole picture.

     Our concept is confirmed as a foundation for the billions of a billion-dollar computer and Internet of Things industry.

It’s a:

• Global educational platform of Calculus for Programming 
• The platform for globally used SaaS (Software as a Service). 
• SaaS embedded into the hardware of the new architecture computers and IoT. 
• SaaS as a part of Quantum computing infrastructure.
• New computer architecture with denied access to the code to the public (access granted to the manufactures only). 

My WEB is the commercial presentation of the concept. To create a feeling of what it is all about, providing examples.​


 That's mean two things:

o The first one. Ever since the programming was born in the middle of the eighteen hundred (1843, Ada Lovelace), there was no of today’s wise developed computers, so there was no concept possible to employ computer assistance in the concept of programming and thus, bad thing happened, "computer programming" became "a calculus for coding" only and remain in such a quality as of today.

o And the second one. To fix it, we should invent a calculus for programming and transform a “programming” into one of the academic disciplines, i.e. we consider a Programming by itself as an academic presumptive discipline about the knowledge capturing (acquiring) before it is created. And Calculus “Ex..P” for programming is a knowledge frame to support it, i.e. to capture (acquire) the knowledge before it is created, or otherwise, to transform patchwork of thoughts into the knowledge.

 • If we consider the agenda of computer programming as an academic discipline in despite of paradigm -: "... you, to say for a computer, what to do...", then a calculus for programming agenda will be considered as -: "... you, to learn about and then choose from, what the computer will do for you... ". Such an agenda of the calculus for programming implies to have a conformation for every choice you made. This conformation is provided for you by the handler of all information - WYSIWYG CASE tool and carried out to you interactively as a graphic illustration in free editable by you, within the frame provided, form. This form is called Executable Pictogram representing the blueprint of the specification, design and implementation on the computer of the system created. And, thus, the subject “to learn about” will be the theory of the programming, as an academic discipline, “Calculus for Programming”.

 • Resemblance to the Object Process Methodology (OPM) by Dov Dori as a part of the adaptive ontology Calculus χπ of Calculus for programming, χπ-Graph and hypertext with graphics is a medium to reflect the user's problem domain with the precision desired.


How does it sound in philosophical meaning?

In philosophical notation, the method “Executable Pictograms” (“Ex..P”) for specification, design and implementation of the systems is emergent phenomena, where integrative level - Executable Pictogram emerges from the cognitive interaction of human brain and the system of “core” pictograms of Calculus in the problem domain environment. For the problem domain, considered as computer programming, system of “core” pictograms is used for implementing semantics of computer programming and is called - System of Core Pictograms (“Core..P”) of Calculus “Ex..P”. “Core..P” employs the Set of Executable Pictograms - the conformation/confirmation of intentions of Calculus χπ, as building blocks of the domain specific blueprint for/of specification, design and implementation of the systems.
  Formulas (abstractions) of the Calculus Ex..P are designated to expand every expression, descending it to the Code (executable) level. By design the process of descending it to the Code (executable) level is used for a mental perception and cognition (study) by the reader of the abstraction hierarchy to understand the calculation semantics reading the blueprint of the Calculus “Core” Pictograms. The transformation, performed by the system (WYSIWYG CASE tool) in order to calculate/produce a result, do not based on the “process of descending”. The only part of the blueprint of the Calculus “Core” Pictograms - the System of Core Pictograms is designated to perform transformations and calculate the results. By design the information necessary for these transformations and calculations is collected (wrapped in) and delivered through abstractions in the blueprint of the Calculus “Core” Pictograms, when they (abstractions) are used by hand to assemble pictograms to create a domain specific program of transformations (to generate a structure of calculations) and calculations to produce a result. The receiver of the information, delivered by the “Abstractions”, is the “Core..P”.
     Then phenomenon taking shape of, accordingly, Pictogram resembles a method in Object-Oriented Programming, a Program resembles Object, and a Project resembles Class. Presence of a Skeleton and a Core, and altered presence of a notions of an index (enabled by an attachment of the Operational String to the Pictogram) and the parameter of the process in the Calculus χπ makes the difference between the notions, resembling each other accordingly.

• The set of resemblances with Intentional Programming (Intentional Software) is:

Notation »»► Intentional Tree;

Process ► Executable Pictogram ► Disposition of Executions »»► Domain Schema;

Process ► Executable Pictogram ► Multidimensional Set-Tree »»► Intentional Tree implementation;

Process ► Executable Pictogram ► Multidimensional Set-List »»► Intentional Tree implementation;

Instance ► Project ► Program »»► Intentional Program;

And "Calculus χπ" for programming »»► system of intentions projected from the code of imperative calculations (System of Core Pictograms) by WYSIWYG CASE tool, which employs the Set of Executable Pictograms.

• "Calculus χπ" of programming – by design is a system of intentions (intended to be applicable to resemble components of intentional programming) projected from the code of imperative calculations (System of Core Pictograms) by WYSIWYG CASE tool, which employs the Set of Executable Pictograms.

Calculus χπ considered as an Adaptive Ontology of calculus, in his general sense (we call it “calculus "Ex..p" for programming” or “calculus for programming”), for specification, design and computer programming of the systems.

• An Executable Pictogram is a Pictogram of the Calculus χπ representing in a formal way a Top Level of an abstraction, which contains Zero (Code) Level and the Middle Levels in between, constructed from the symbols, so called Pictogram’s Building Blocks (ideograms). The Code Level is computable (executable) and the rest - processible (in addition to features “executable and processible” - divide by zero is processible, but not executable /calculable/).

• An Executable Pictogram - is a graphic symbol or set of graphic symbols enclosed in the hypertext frame with anchor points of hyperlinks representing Nodes, Correspondences (correspondence - an instance of corresponding) and any derivative of the syntax for a Pictogram in the Calculus of Core Pictograms. An instance of every anchor point is called a Passport. It is used for information on process behavior (e.g. In the case of non-referenced field in use, default values or type handling method to store).


• Quite different user friendly environment (Intentional programming, Literate) could be created to support method "Executable Pictograms".


• The method "Executable Pictograms" is intended to support and boost cognitive capabilities of the user's brain.


• The method "Executable Pictograms" support manipulations on cognitive images, that features PC–Human Brain Direct Interface for programming.


• PC–Human Brain Direct Interface for programming could one day find himself among "Natural User Interfaces" meant by Bill Gates.


• The method "Executable Pictograms" is a result of intuitive many years of exploration of the system specialized pictograms, intentions and equivalent to them data structures to feed in automatic processes, implementing software product and representing the semantics of the solution to the user's problem have been specified, designed and programmed following this theoretic setup.

• Method "Executable Pictograms" implies that user put together PC given ideas and evaluates specification PC generated.


• The idiom of the method "Executable Pictograms": "Do think more, write-assemble less. Anything is written-assembled always correct; specification and result produced. Are they done?"


• Let’s clear some viewpoints on the relationship among the notions: complexity, simplicity and calculus for programming.

Check this out now! There Mr. Charles Simonyi ("Intentional Software") is talking about "Executable Pictograms" with the only difference, where, what he's calling "doodle", I call it - "Calculus for programming", and what he's calling "... few boxes or a few arrows... but it’s the data structures I maintain that are the key", I call it - "Executable pictograms", and finally, where, what he's calling "... I keep them in my mind throughout the entire process", I call it - "programming with pictograms under supervision of user interface in cloud":

INTERVIEWER: When you shift gears and actually start programming, what do you do first?

SIMONYI: The first step in programming is imagining. Just making it crystal clear in my mind what is going to happen. In this initial stage, I use paper and pencil. I just doodle, I don’t write code. I might draw a few boxes or a few arrows, but it’s just mostly doodles, because the real picture is in my mind. I like to imagine the structures that are being maintained, the structures that represent the reality I want to code.

Once I have the structure fairly firm and clear in my mind, then I write the code. I sit down at my terminal–or with a piece of paper in the old days–and write it. It’s fairly easy. I just write the different transformations and I know what the results should be. The code for the most part writes itself, but it’s the data structures I maintain that are the key. They come first and I keep them in my mind throughout the entire process. (Programmers At Work. Charles Simonyi– 1986. By Susan M. Lammers.)

  Here Mr. Bill Gates talks about "simplicity" in the context implying, you to inventing the calculus for programming each time, when you creating a program (coding); and answer, why “you have to really love the program and concentrate on keeping it simple, to an incredible degree (which I call “Calculus for Programming)”:

INTERVIEWER: What do you consider the most difficult part of computer programming?

GATES: The hardest part is deciding what the algorithms are, and then simplifying them as much as you can. It’s difficult to get things down to their simplest forms. You have to simulate in your mind how the program’s going to work, and you have to have a complete grasp of how the various pieces of the program work together. The finest pieces of software are those where one individual has a complete sense of exactly how the program works. To have that, you have to really love the program and concentrate on keeping it simple, to an incredible degree.


  Later, Mr. Charles Simonyi in reference to the witticism "Anything you can do, I can do meta", has his vision of the user's domain developed into an intentional programming concept (The Death Of Computer Languages, The Birth of Intentional Programming. Charles Simonyi. September 1995. Technical Report MSR-TR-95-52). Which is as a result of "complexity" vs. "simplicity" advocacy in regard with developments of intentional programming concept.  

Charles: ... Mathematics is leading the way with the discovery of very complex fundamental objects. The traditional name for a class of these objects, “simple groups,” ironically reflects the old belief that “fundamental” is equal to “simple.” Well, maybe it isn’t. In computers we may not get anywhere with real artificial intelligence, user interfaces, languages, and so on by harping on simplicity. (Programmers At Work. February 29, 2008. Charles Simonyi 2008/1986. By Susan M. Lammers.)

  Here is my take on it all. Calculus for programming is designated to become a discipline of making in order complexity, thus transforming it into quantity. To put it differently, the complexity of the user’s domain will make an impact on the semantics of the calculus of Core Pictograms, leaving the complexity of the projection of the final product represented in Executable Pictograms not intact.

  Our brain tends to simplify everything we perceive. Then our thinking kicks in. That's why simple things should have simple solutions in order to proceed. For a human being, there is nothing more simple than a picture (picture is worth a thousand of words). That's why a picture should be that micro command of the human intellect to process. If you do acquire the knowledge, compressed into pictures, and add it to this type of scenario you shall have the starting point where I'm, after more than 30 years slow journey along this path. I call it, Calculus "Executable Pictograms" for Programming. So, honestly, there is nothing new here. First, you learn, and then you create a picture; learn again to change it repeatedly, until you unable to add anything more to the picture created. That's my philosophy of computer programming, and here you have samples of it.

  All WEB site examples are nothing about "what you can see", it's all about "what you cannot see". What you see is the delineation of a sculpture of virtual reality, recreated adding to this picture: hyperlinks; options to choose from, created through computer analyze/assistance; and calculus for programming, based on the method of imperative programming for visual paradigm. You should perceive me as a filmmaker. If you ask him, "show me the movie?", what he can answer you, so neither me. Your take, on all you have, lays on your quick wits, unless you reinvent the missing. Keeping human comprehension and examples in mind, this sculpture has: his two-three-dimensional picture; hyperlinks - another one dimension; calculus "Executable Pictograms" for programming - one more dimension; and a computer analyzes/assistance, enforcing calculus of Core Pictograms, where interactive computer input is meant - the final dimension. So, there is a very important part missing - a tool called "Computer Aided Pictographic Design of computer Programs" (CAPDP) - the hyperspace (Integrated Development Environment) created from above mentioned dimensions.

CAPDP is a WYSIWYG CASE tool for the programming embracing features:

• to provide a system of expectations (ontology of intentions - calculus for programming) empowering you to say something where you don't know what to say;
• to prevent you saying nothing, where you should say something;
• to prevent it happen - where you say something do not match what you think about (Due to enforced system of expectations – a context of Executable Pictograms).


Lesson learned from "Programming Conversations" a course at A9 by Alexander Stepanov and Paramjit Oberoi (guest lecturer Sean Parent)
http://www.stepanovpapers.com/#Programming_Conversations​

• How many of calculus (for programming), we have, if we consider programming as a discipline (a branch of knowledge or teaching) in science?

• Does an expert programmer's goal (guest lecturer Sean Parent), following his mind setup - "calculus for programming" (:

o no Raw Loops;
o no Raw Synchronization Primitives;
o no Raw Pointers),

means, that language used with these unwanted above constructs, are not the calculus' (for programming) language? If so, following this implicit, above definition of calculus for programming, do we need to invent calculus each time we are rewriting code to make it better?

• The purpose we are rewriting compilable source code, I mean, projecting it implicitly into calculus for programming is:

o to make code more readable (resembling a specification);
o to make code more suitable for reasoning about him;
o to make code more efficient by processing time.

And we could have it all in one, by making the non-compilable (for eyes only) code as a projection of the "calculus for programming" explicitly, produced by the CAPDP CASE tool, through the interactive process, resembling intentional programming.

Does it make possible to reduce the need of rewriting code to only goal, to find, the better way of saying what we want to achieve through programming?

• "You should recognize the fundamental algorithms and data structures" - sad Paramjit Oberoi (during the lecture accompanied by Alexander Stepanov and guest lecturer Sean Parent):

o does it mean they are not the part of his calculus for programming?
o what his calculus consists of, when he's writing and drawing something on the board, and briefing on the algorithm, before he commits to construct or overview the source code?
o does it mean the data structure coming first in his mind and an algorithm, built around this structure, then follow it?
o are they perceived and represented as separate entities? 
o what happens if his calculus consists of data structures, which represent the algorithm, by itself and he can switch between algorithms by adding or removing something out of the data structure displayed?
o how this shall affect his programming technics and reasoning?
o does the algorithm represented in this way is the source code?
o what now he'll be drawing on the board, if his calculus is graphical in nature?
o does he needs something else to draw, if everybody has the same calculus in their minds?
o is it the only mistake he can make in this way is to say/assemble something not matching what he thinks about, if every structure is not drawn, but provided, while traversing through the options, by the CASE tool as a drawing, is processible and computable, and assembled by hand?

• Should we have a different calculus for each different domain to represent problems and solutions in these domains? Probable Charles Simonyi would say, yes, if we ignore the capability for domain knowledge experts' literacy (calculus) in programming. 

• Should the implemented set of fundamental algorithms (for instance - STL) have GUI for each of her elements to visualize the relationship among input-output and a process of calculations;

• What does the remark "nobody knows what the elements of STL do" means missing?

• How the feature WYSYWIG is related to the calculus for programming?

• How we know "What You Get" if WYSYWIG feature is in place for programming and we don't have a calculus for programming?

• Should losses of the software engineering can get significantly reduced if we answer all of the such questions?

• Alexander Stepanov stated "... the programming is fundamentally unsafe activity, it requires you to think...", "... you should know fundamental algorithms' and data structures' primitives..." (I prefer to alter the meaning of the data structures and put them first) and he stated also - the form to specify the problem and the solution is an English prose.

o "... the programming is fundamentally unsafe activity; it requires you to think...":

- should we invent each time the knowledge in attempts to make it safer or to apply the knowledge as an element of calculus before programming?

o "... you should know fundamental algorithms' and data structures' primitives...":

- should this knowledge to stay detached from the process of programming as two different things or to make the data structures to become a programming by mounting algorithms onto them - which is the concept of the calculus for programming?!

o " the form to specify the problem and the solution is an English prose ":

- should the English prose stay one dimensional or become a hypertext? And what if we add the graphics to the same level with the symbols to enter them and access hypertext feature?

• What else questions we can raise to seek answers to support a programming becoming a discipline in science?

• What's the difference between traditional/modern imperative programming and the method Executable Pictograms in term of Relationship?

o The relationship between Data Structures, algorithm and calculus for programming in the modern, traditional imperative programming.

  oo Data Structures are created to optimize execution performance and expressiveness of the source code.
  oo Data Structures are created and tailored to fit an algorithm.
  oo Data Structures are wrapped with other constructs into algorithm representation in programming language.
  oo Calculus for programming becomes an implicitly represented feature of the source code derived as a set of recognizable and generalizable parts of code structure.

o The relationship between Data Structures, algorithm, calculus for programming and altered notion of the Data Structure in the method Executable Pictograms of the imperative programming for visual paradigm.

   Data Structure (Executable Pictogram) are assembled/created to represent an algorithm and source code.

  oo Execution performance and expressiveness of the source code is optimized and embedded into the engine of the WYSIWYG CASE tool for the programming (specification, design and implementation) named as "Computer Aided Pictographic Design of Computer Programs" (CAPDP) - the multidimensional hyper space.
  oo Calculus for programming is applied explicitly to assemble a Data Structures.
  oo Calculus for programming is applied to specify a problem, an algorithm for solution to, is derived from, as well.
  oo Internal, same kind of, Data Structures (the Engine) is created to represent semantics of the Calculus for Programming itself and the projections for interaction with and display an Executable Pictogram, and the lowest level of the abstraction for the reference/feedback to the code generated.
  oo This kind of projections represents visual-interactive UI of the WYSIWYG IDE CAPDP which employs an Adaptive ontology - Calculus χπ, where Object Process Methodology by Dov Dori is adapted, to match the graphical design of the Calculus "Executable Pictograms", and contained as very important part of it, to glue things together and make sense of everything presented with Executable pictogram. The Engine is programmable and expandable, implementing low level adaptability of the ontology Calculus χπ.
  oo Templates facility (templets) of the Executable Pictograms is implementing high level adaptability of the ontology Calculus χπ.

• Difference among Calculus for Programming and Calculus for Coding in term of relationship with programming and why Alexander Stepanov thinks - programming is "Fundamentally Unsafe"?

o What the program does? It works, as it's coded and not necessarily as programmed (and usually it works as wasn't programmed)?

o What is enabling us to program? Thinking and reasoning about the problem with the help of specification writings and mental/physical pictures/graphics.

o What is enabling us to code? Programming language and/or UI of the CASE tool.

o Sometimes code is represented in the program text, sometimes the code is generated from the program text, represented in graphics. In both cases the code tells us, what the program does.

o The same code can have different presentations and same presentation can produce different code, because it could depend on the context, the presentation is wrapped in. So, no difference where we are in those relationships, the presentation means code, which tells us, what the program does.

o I call the knowledge, which tells us, what the program does - the Calculus for Programming.

o It is not the Calculus of programming, because no Calculus means there is no programming. And Calculus for programming is derived from the program. That's mean - from the code. So, there should be the Calculus for Coding, which tell us, how the code should be arranged in order to tell us, what the program does.

o The same Calculus for Coding, in general, produces different code, thus - different Calculus for programming. So, to read the program, we should read the calculus for programming the first. That's mean it can't be scaled and reused. Calculus for Programming is a derived feature.

o So, we can't think in terms of Calculus for programming and are forced to replace it with Calculus for Coding. That's why the programming is "Fundamentally Unsafe", which is stated by Alexander Stepanov.

o And it's very important to make it safe. There are so many studies attempting to quantify the cost of software failures. They don’t agree on percentages, but they generally agree that the number is at least 50 to 80-billion-dollar range annually.
http://www.galorath.com/wp/software-project-failure-costs-billions-better-estimation-planning-can-help.php

o Alexander Stepanov stated "I use usually 10% of the C++". Does it mean he has derived his Calculus for programming from 10% of the Calculus for Coding and the rest probably could be used to decrease the efficiency of his code? But what about expressiveness of the program presentation and support of mental pictures/graphics?

o We introduce the way to make the programming safe as a Method of Imperative Programming "Executable Pictograms" for Visual Paradigm. We use a Calculus for Programming explicitly to think, reason and construct the program.

o So, coming back, to where we started, we should design the Calculus for Programming from mental/physical pictures/graphics and find the center among the Calculus for programming and the Code.

o And at the center is the WYSIWYG CASE tool, which projects both things. One - towards a user and another, accordingly, towards computer.

o We prefer to use the knowledge of the foundation of Imperative Programming as Calculus for programming and make it in mental/physical pictures/graphics, were a facility of templates (templetes) in the Calculus for Programming designated to represent and support mental pictures/graphics explicitly.

o The graphical nature of the Calculus for Programming represent and support mental pictures/graphics explicitly and implicitly. So, it's safe to say, it is possible to think in Calculus for Programming, to scale it, to reuse it and to share it among the users. And thus a program shall do, what we think of.

• Conclusions

o Calculus for the traditional/modern imperative programming is a result, derived feature of coding. It helps implicitly to understand and read the code, thus it's not scalable and reusable for different problem domains.

o Calculus for an imperative programming of the method Executable Pictograms for visual paradigm is a tool/environment to think, to construct and to reason about the algorithm of the solution for the problem, thus it's scalable over different problem domains. Its ontology is adaptable (expandable and adjustable).


The lesson learned from Mr. Sanford B. Klausner theory called “Cubicon” 
Talks by Sandy Klausner (https://speakerdeck.com/corecubist).

There is my vision for “change”.

Where is the power of your theory Cubicon?
Answer: “The machine only has the access to the Code; The public access to the Code is restricted by the hardware and replaced with the M2M communication”.

Where is the weakness of your theory Cubicon?
- You do not have a Calculus for Programming employed. Instead, you have the Calculus for Coding only.

The goal is “A Computer architecture, which exclude public access to the code”:
• Computer processor, embracing the theory Cubicon and employing WYSIWYG CASE tool CAPDP, only has the access to the code, which is exchanged among the hardware in the way of the M2M (machine to machine) communication. CAPDP stands for "Computer Aided Pictographic Design of Computer Programs" – the part of a hyperspace (Integrated Development Environment);
• The only option for the public to choose from, are our intentions, delivered by the hardware;
• Public transparency of the intentions in the software “a must”;

The result: “No hackers, no software viruses, no software piracy, no software failures”. Annual average of savings for the nation willl be 50 billion of dollars (no software failures), where the additional software security (anti-virus, anti-identity theft) cost has not counted in.

Calculus for Programming definition through its features and the difference with Calculus for Coding:

• The same behavior (in the sense “to be explained”) could have many representations;
• The representation could have no behavior (it's about representation of itself design);
• The representation could have levels (ontology, Executable Pictogram, Calculus χπ, χπ-graph);
• The representation does not provide access to machine code (and his abstraction - legacy programming language);
• The representation can be explained (illustrated) by machine code (legacy programming language);
• There is no fixed structure of the iterations in the calculations (the structure of iterations by itself is calculated);
• There is no legacy presentation of the indexed variable in the expression of the string of mathematical calculations and the content (of the data) transformations (because there is no fixed structure of the iterations in the calculations;
• There is a form of representation of the access to the index.
• The representation of the data structure can be explained by the algorithm presented in the form of the machine code (legacy programming language);
• The representation is the only form to present the specification of the problem.
• The representation has free visual expression in the frame provided as a set of options to choose from combinable by a simple set (constrains) of graphical rules and restrictions.
• There are no legacy programming mistakes (no direct access to machine code or/and legacy programming language). The only type of the mistake could occur, where the specification of the problem does not specify the problem we intended to specify (specification not finished yet or specification is done for another problem).
• The difference among the Calculus for Programming and Calculus for Coding embraced by the way the another level of abstraction is added to the code (legacy programming language) and the access to the lowest level code or/and legacy programming language is granted or denied;
• Calculus for Programming and Calculus for Coding by itself represent knowledge set about different types and the direction of the projection of the code (legacy programming language). The projection is directed towards the Calculus for Programming and Calculus for Coding to project thus the code (legacy programming language).
• Calculus for Programming must be one of the many disciplines in the science. It’s designated to teach “how to programming”.



• The idiom of method "Executable Pictograms" follows paradigms: Intentional programming (Language Oriented), Literate, Imperative and Visual.


• Method "Executable Pictograms" is a foundation for "processible" and "computable (executable)". This foundation designated ...


• This foundation designated ... to be seen and used to rethink the problem you solve. Computer code is generated and stays out of plain view.


• Intentional programming (software) is a pretty good balance of "The way we want to talk to" and "Computer wants us talking". And ...


• And ... the method "Executable Pictograms" is a significant shift of this balance towards "The way we want to talk to".


• Basically, the method "Executable Pictograms" lay down a "calculus for programming".


• The method "Executable Pictograms" implemented in new Visual (is meant "paradigm") Programming Language and Notation to represent multidimensional her semantics.


• It's all about the new kind of Meta-Link Flowchart, assembled from a fixed set of pictograms, each of which consist of ideograms, and each of which enriched with text strings as identifiers, sequence of operations and comments.


• The new, net like Flowchart ("Meta-link Flowchart") is not a data flow neither process flow nor status representation.


• The new, net like Flowchart ("Meta-link Flowchart") is more formal, two-or three-dimensional graphically designed formula like, very universal and simple.


• "Executable Pictograms" - the Method of Imperative Programming for visual paradigm -effectively defies “Deutsch Limit” (L. Peter Deutsch.).


• The method "Executable Pictograms" makes even "GoTo ..." looking "good". Now it unable to make a confusion in the logic of any algorithm.


• Cognitive perspective of the method "Executable Pictograms" do graphically incarnate “GoTo”, as a marker consisting of one symbol named “Go back to the entity started to continue”.



Let’s take a look into Bill Gates' prediction on the future of the Software and Computer relationship:


INTERVIEWER: Do you think there will ever be a radical change in the way people go about programming, or in the way computers operate?

GATES: …. Software tools are getting so much better. It is possible that we will eventually be able to take just specifications and a description of what the machine is efficient at, and then have some super high-level compiler do a lot of the work that programmers do now…”

Susan Lammers. 
https://programmersatwork.wordpress.com/bill-gates-1986/.


We’ll follow a little bit different approach. Instead, “… to take… a description of what the machine is efficient at…” we just will pursue to build the computer, which is efficient at editing Calculus “Core Pictograms” and projecting them into intentions (Calculus χπ) to transform a patchwork of thoughts into knowledge about the problem and solution. 

That means total IT industry transformation, saving billions of dollars in losses for the nation. According to National Institute of Standards and Technology (NIST) software defects cost nearly $60 Billion annually. Some sources provide worldwide costs of IT failure at $3 trillion. This sad story told by numbers in loss over decades gives us the credible proof: “We can’t simply substitute “Programing” with “Coding”. We should invent it”.


What's the difference between UML CASE tool and the WYSIWYG CASE tool CAPDP (the project of the Executable Pictograms, LLC) by the terms of the definitions?


• The UML CASE tool is the software application with the interface integrating the problem specification and the generation of the computer code to solve the problem. The knowledge about a programming is captured in the calculus for coding theory and implemented as one of the legacy programming languages.

• The WYSIWYG CASE tool CAPDP is the software application with the interface embracing the “Calculus for Programming” theory as the code (Calculus χπ), replacing legacy computer code, to capture in the holistic way the knowledge about a programming, and the knowledge about the problem and the solution. The part of this code, designated to capture the knowledge about the programming, is called “Calculus Executable Pictograms”, which employ the set of Core Pictograms in the problem domain environment. The knowledge captured is projected as the blueprint for each of the solutions to the problems. There is no legacy computer code (programming languages) accessible through the interface. Instead, there is the code Calculus χπ implementing the theory. That’s why we call the theory
“Calculus for programming. Calculus χπ” – the new foundational concept for the new computer architecture, restricting (for the public - the end user) the access to the legacy computer code.

Flag Counter

Classmates

Frequently Asked Questions (FAQ) by the contributors


​Hi, there! 
     The scientific research near the forty years in the making “to save for nation billions of dollars annually” is seeking for contribution. We’ll be able to capture knowledge before it is created, i.e. to transform the patchwork of our thoughts into the knowledge.


      We are dedicated redefine software development, introducing the framework (software development “methodology”) for software development, eliminating a Coding.

 This framework is called Calculus for Programming and based on implementation of the new (and only one of this kind in the industry) method of imperative programming for visual paradigm – Executable Pictograms.

     This framework intended to be delivered as a standard feature (in the form of Computing platform), enhancing group productivity tools by utilizing functionality of the specification-designing, presentation, design development and implementation in the ontology based, holistic way as an interactive WYSIWYG blueprint. This blueprint is delivered in the form of 3D interactive graphics with hypertext (plain 2D presentation of the document is optional). 

     The implementation of the adaptive ontology used, is called Calculus χπ.

     • Having a wrong tool and using it in the wrong way, it's hard to fix it. Instead, we prefer to have a visual language for calculus and visual calculus for programming. It’s how we rediscover a Programming, leaving the Coding in the past.

     Here we are talking about the software development. As of today, there is no any other theory or methodology supporting the use of ontology in the process of software development, eliminating Coding. Presentation of the process of development is supported by 3D graphics and a hypertext according to the methodology. We have a bunch of applications for modeling, e.g. UML. They cover needs for ontology, with the set of Frames, to collect data about the problem, to create a program, which is coded or/and synthesized in this case. All of them imply the use of coding, i.e. a calculus for coding is used. There is no specification, design and development of the frames (in the case of UML, we are not designing nor developing the frames by itself, we are just using them), which imply the use of the process of ontology designing, presentation, development and her adaptation, which we call Calculus for Programming. Contrary, the calculus for programming is employed in our methodology of the software development. Somebody can say, “Growing use of ontology”, in reality it means the growing use of only a word “Ontology”. And nobody knows (but us) how “to eat it” (to integrate with it) and what the difference among the Programming and Coding is. Calculus for programming, defining a programming, which is derived and accumulated from a process of designing and developing of the ontology for specification of many problems and algorithms of calculations to solve them. And Calculus for Coding is derived from coding by itself, adding different layers of abstraction, thus creating different “programming” (i.e., in reality, coding) languages. Each time, when we are reasoning over code, we derive each time, the calculus for programming, to construct mentally a specification, of what it is created, to reason about it, thus reasoning about it become extremely obscured. And this is fundamentally wrong. Programming means we construct, present, design and develop a specification of a problem, embracing Calculus for Programming, based on adaptable ontology. We are constructing, presenting, designing and developing an interactive WYSIWYG 3D blueprint for every problem, which we solve on the computer in the environment of the group of developers and domain experts. And this is our Code (knowledge Code – enriched in this way by natural language), which could very conveniently serve as input for AI, to process the knowledge or to be applied to bring in a knowledge about computing to the Quantum Computer, or just serve as an interactive 3D blueprint, in the case we want to comprehend and contemplate the whole picture.

     Our concept is confirmed as a foundation for the billions of a billion-dollar computer and Internet of Things industry. It’s a global educational platform, globally used SaaS (quantum Computing), 

       Our WEB is the commercial presentation of the concept. To create a feeling of what it is all about, providing examples. 
My science in desperate need of some attention to continue R&D and come up with something more substantial for your organization.

     Now we are ready to say: - “Programming is not the same as Coding”.  Use an E-mail to address your questions or 
"Contact Us" by the form on the right                                    rstrei@aol.com

     Our company is on the mission to raise a fund to conduct R&D on intense and wide spared scale. To achieve the ultimate goals of creating:

Global educational platform of Calculus for Programming 
The platform for globally used SaaS (Software as a Service). 
SaaS embedded into the hardware of the new architecture computers and IoT. 
SaaS as a part of Quantum computing infrastructure.
New computer architecture with denied access to the code to the public (access granted to the manufactures only). 

     To make a wire transfer or simple contributions, go online:
http://www.executablepictograms.com/To-contribute.html 

or

for the examples of the 2D blueprint printout (Version 3), follow the link:
http://www.executablepictograms.com/MoreDefinitionsExamplesV3.html

     Then, for the detailed presentation of the 2D blueprint printout, click on the little icons at the top of the page. One of them could be reached, following the link (big enough picture, to test your equipment for performance productivity):
http://www.executablepictograms.com/Programming_as_an_academic_discipline.jpg

Investments, instead of contributions, could be considered a meaningful amount at a wide range of money, ranging from 
$70 000 annually to 5 billion for a decade, if the hardware production tools will be deployed.

FAQ 1:

"Describe what you will use the money for":


• The money will be used for fundamental research leading to a theoretical foundation, named “Calculus for programming. Calculus χπ”, for specification, design and systems engineering in a generic domain-independent fashion, using, the type of computer software so called WYSIWYG CASE, as the tool.

• The money will be used to introduce the theory “Calculus for programming. Calculus χπ” to the experts of different domains.

• The money will be used to introduce this foundational theory to the academic society and promulgate it.

• The money will be used to expand R&D of the method “Executable Pictograms” of imperative programming for visual programming (not coding) paradigm. (The concept implemented before 1974 as a complementary technique to enhance reading data structures on the paper blueprint of the project, developed since 1977 in Lithuania and continued as of today in the USA, what has led to this foundational theory “Calculus for programming. Calculus χπ”, separating two notions in computer science – Programming and Coding.)

• The money will be used by company “Executable Pictograms, LLC” to keep research a flow and, if it not objected by the contributor, to finance the contract with the “Intentional Software Corporation” to build a prototype of a WYSIWYG CASE tool, as a workbench, embracing the foundational concept Calculus χπ. (I am the founder, CEO/CTO of the company “Executable Pictograms, LLC” and the author of the theory “Calculus for programming. Calculus χπ”). 

• The money will be used to publish theoretical results and develop an educational platform to achieve literacy in systems engineering (by using a computer) across every educational juncture (e.g., elementary, secondary, and postsecondary levels [College/University]). 

FAQ 2:

What unique things would separate you from other applicants applying for this money?


The theory “Calculus for programming. Calculus χπ” is the only theory as of today for programming, which allows capture effectively domain specific knowledge before it’s created and reasoning as to knowledge blueprint independently of the computer code. (We consider a Programming by itself as an academic presumptive discipline about the knowledge capturing (acquiring) before it is created. And Calculus “Ex..P” for programming is a knowledge frame to support it, i.e. to capture (acquire) the knowledge before it is created, or otherwise, to transform patchwork of thoughts into the knowledge). This is a perfect match to Intentional Programming, introduced by Charles Simonyi, to use as an implementation platform. Altogether they will be used as the foundation of a new computer architecture for faultless specification, design and systems engineering in a generic domain-independent fashion, embracing concept based on the restriction of the direct public access to the machine code. Thus creating a very beneficial digital environment, where identity theft, hacking and software piracy are limited by hardware architecture and naturally secured by corporations’ multibillion dollar manufacturing investments to make access to machine code granted only to IoT hardware infrastructure through M2M communication.​

Let’s take a look into Bill Gates' prediction on the future of the Software and Computer relationship:



INTERVIEWER: Do you think there will ever be a radical change in the way people go about programming, or in the way computers operate?

GATES: … . Software tools are getting so much better. It is possible that we will eventually be able to take just specifications and a description of what the machine is efficient at, and then have some super high-level compiler do a lot of the work that programmers do now…”

Susan Lammers. 
https://programmersatwork.wordpress.com/bill-gates-1986/.


​We’ll follow a little bit different approach. Instead, “… to take… a description of what the machine is efficient at…” we just will pursue to build the computer, which is efficient at editing Calculus “Core Pictograms” and projecting them into intentions (Calculus χπ) to transform a patchwork of thoughts into knowledge about the problem and solution. 



That means total IT industry transformation, saving billions of dollars in losses for the nation. According to National Institute of Standards and Technology (NIST) software defects cost nearly $60 Billion annually. Some sources provide worldwide costs of IT failure at $3 trillion. This sad story told by numbers in loss over decades gives us the credible proof: “We can’t simply substitute “Programing” with “Coding”. We should invent it”.


What's the difference between UML CASE tool and the WYSIWYG CASE tool CAPDP (the project of the Executable Pictograms, LLC) by the terms of the definitions?

• The UML CASE tool is the software application with the interface integrating the problem specification on the fixed knowledge frames and the generation of the computer code to solve the problem. The knowledge about a programming is captured in the calculus for coding theory and implemented as one of the legacy programming languages.

• The WYSIWYG CASE tool CAPDP is the software application with the interface embracing the “Calculus for Programming” theory as the knowledge design code (Calculus χπ), replacing legacy computer code, to capture in the holistic way the knowledge about a programming, and the knowledge (before it’s created) about the problem and the solution. The part of this code, designated to capture the knowledge about the programming, is called Calculus “Core Pictograms”, which employ the set of Core Pictograms in the problem domain environment. The knowledge captured is projected as the blueprint for each of the solutions to the problems. There is no legacy computer code (programming languages) accessible through the interface. Instead, there is the code Calculus χπ implementing the theory. That’s why we call the theory “Calculus for programming. Calculus χπ” – the new foundational concept for the new computer architecture, restricting (for the public - the end user) the access to the legacy computer code.



FAQ 3:

• Show the difference among the Programming and Coding.

Illustrate what does the notions “Calculus for programming”, “Calculus χπ” and Calculus “Core Pictograms” mean.