What's the difference...?
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.
• 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.
Lesson learned from "Programming Conversations" a course at A9 by Alexander Stepanov and Paramjit Oberoi (guest lecturer Sean Parent)
• 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,
o 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.
o 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 consist 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 Do they perceive 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 need 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.
oo 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, cause 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.
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 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.
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”
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 savings for the nation 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 projecture 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”.
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.