PWCT 1.9 Art Documentation ( http://doublesvsoop.sourceforge.net )
2006-2013, Mahmoud Fayed ( firstname.lastname@example.org )
Programming Without Coding Technology (PWCT) is a visual programming languages framework to create and use general-purpose visual programming languages wherein the programmer need not write code but can visually specify every functional aspect of the program similar to flowcharts and algorithms.
PWCT is free-open source and uses Interaction by presenting a GUI between a Human language and a Programming language; so doing anything requires knowing Procedure instead of being Declarative.
PWCT include (Framework Designers to create and use general purpose visual programming languages based on new visual programming method (instead of drag-and-drop) called coding simulation method (CSM) , HarbourPWCT visual programming language, DoubleS (Super Server) programming paradigm for the HarbourPWCT visual programming language, PythonPWCT visual programming language, Supernova textual programming language developed using the HarbourPWCT visual programming language, SupernovaPWCT visual programming language and CSharpPWCT visual programming language).
 DoubleS (Super Server) Programming Paradigm is a new programming paradigm based on units that we manage and control to represent the software and this paradigm could be used in software development without directly coding to represent the complex software in a clear and visual way.
 Framework designers a collection of designers to create and/or use new visual programming languages (Packages and Components) that wraps real programming languages.
 HarbourPWCT The first visual programming language developed and used through PWCT framework designers and it is used for developing win32 applications without directly coding and uses Harbour, HarbourMiniGUI and Borland C/C++ as the embedded coding layer to produce executable applications.
 PythonPWCT another visual programming language based on Python (Components wraps the Python programming language) to clear that many other languages could be supported and you are free to use the programming language which you like in the background
 Supernova (Simple scripting programming language developed using PWCT to prove that the PWCT technology are ready for developing complex software)
 SupernovaPWCT visual programming language (Components wraps the Supernova programming language) so we can use the RPWI-Environment (including the Form Designer) to Develop applications without coding and get the generated code written in Supernova.
 CSharpPWCT visual programming language (Components wraps the C#.Net programming language).
Programming is giving instructions to computer to perform the required job, the process of programming have more than one stage from analysis and design to implementation and test.
The most common way to do programming is (writing code) which our compiler under usage can understand based on the syntax of the programming language.
To write code you need software called a Code Editor (CE), which Enable the programmer to organize his/her source code file, Modern Code Editors comes with nice features like (Auto completion, Syntax highlighting & IntelliSense) which enable the programmer to work more easier and faster.
Since coding requires from the programmer the attention and effort, a lot of researchers focus on this point, some researchers work on making coding less harmful while other researchers try to eliminate and reduce the necessary and the need of coding which we say about (Programming without coding) through Visual Programming Languages (VPLs).
There are a lot of steps towards (Programming without coding) and Visual Programming Languages, the first step was (Copy & Paste) operations where the programmer write the code one time then copy it and use it another time in another program, and this without doubt is very bad solution and seems to be the heart of problems.
The second step was the (Code Bank) where the programmer stores his common code in one place to get it quickly and still do (Copy & Paste) Operations.
The third step was the (Library) where a one or more of functions are encapsulated together and are available for use directly by the programmer after referring to the library header file in the source code and referring to the path of the library file for usage by the linker to produce executable file.
The forth step was the (Template) which is a mask of code, which can be used more than one time.
The fifth step was the (Code Generator) which uses (Templates) and get data from the programmer to generate the code automatically.
The Sixth step was the (Designers) like (Database designer, Class Designer, Form Designer, Menu Designer, Report Designer,…etc)
The seventh step was the (Wizard) which is a group of interaction pages that end up with generating designer files and source code.
In these days the (IDE and Frameworks) are used to integrate Libraries, Templates, Code Generators, Wizards and Designers together.
But still the Programmer/Developer needs to write code to complete his task (the required job).
Programming without coding technology presents general purpose visual programming language (HarbourPWCT), Framework Designers and programming paradigm (DoubleS = Super Server) for developing software applications 100% without coding by providing full isolation from the programming language syntax where the programming effort done through interaction with GUI instead of writing code by hand and the developer needs to know procedure instead of being declarative.
Since Programming without coding technology change the programming world from its heart (The Code), it's expected from this new technology to present something different replace what we use while coding.
Table 1: Coding vs. programming without coding
Goal Designer vs. Code Editor
Goal Designer is the tool of programming without coding
Inside programming without coding technology
Goal Designer is Full Replacement for Code Editor
Goal Designer can work side by side with Code Editor if this feature is required
Goal Designer manage your source code file in Modern way, each goal is group of steps, while each step contains its block of code
Using code extractor application, you can create source code file by extracting code from one goal or more.
(The idea of Goal Designer)
Goal Designer Features:-
Moving between different Goals
Create New Step
Edit Step name
Move Step Up in the steps tree
Move Step Down in the steps tree
Interaction to determine the job of the step
You can see and/or edit the step code (optional)
Copy Step or group of steps into buffer
Insert Step or group of steps from buffer to the steps tree
Interaction vs. writing code
Interaction used to determine the job of the step
The procedure of the interaction process
· Determine step
· Determine component to interact with
· Enter data required by the selected component
As a result of the interaction process
· The code will generated automatically in the (background)
· Information will generated automatically so the programmer can understand the flow of the program without the need to look at the code
The question now, what is new over the legacy code generator and wizards?
· You don't need to look at code at all
· You can modify your work without looking at code at all
· You can control the flow of the program where you can (Move steps up, move steps down, Copy & Paste steps without the need to look at the code at all)
Programming without coding technique
(Programming without coding technique)
Isolation from programming language syntax
Custom User Interface (Human Language)
Based on Programming Language Behind the scene
Use Any Programming Language Behind the scene
No Restrictions & Without Limitations
In the programming world, there is Low Level Programming Languages and High Level Programming Languages, Also in programming without coding technology which presents new Generation of visual programming languages (Visual Programming Languages based on Codimg Simulation Method) there is Low Level visual programming languages and High Level visual programming Languages
Using Coding Simulation Method (CSM) we don't need to write code, or to study the programming language syntax because we will develop the software using designers and components through interaction with the GUI instead of writing Code.
Low Level visual programming languages requires from the developer/programmer to know programming concepts, and requires that you understand the features and rules presented by the programming language under usage because the visual programming language just present a GUI (in human language) to all the features available from the textual programming language under usage in the background.
Also all Components (Transporters) available in the visual programming language which is Low Level, will be like a direct interface to features available by the programming language, so the code generated from any component (Transporter) will do a job that may not make sense in the general application, but only the developer/programmer who uses the component can understand the generated code.
High Level visual programming languages doesn't require from the developer/programmer to know the programming concepts, no need to know the rules of the textual programming language under usage in the background, because here the visual programming language that is High Level visual programming language, provides GUI (in human language) + components (Transporters) which generates the code which do the expected job which anyone can understand it because it make sense in the general application under development.
Transporter, this name because it's used for transporting the data entered to the components from the visual programming language GUI to the textual programming language source code.
Transporter differs from the wizard and code generators, its upgrade to them because transporters work together in solving the same problem which maximize the power and free the space to an infinite number of applications that we can develop which provide us with unlimited and general purpose programming environment.
Programming without coding technology architecture
(Programming without coding technology architecture)
Two Approaches for Dealing with Problems
To be a computer programmer/software developer and start your practical software development life, you need three things together (Science, Art & Technology) and here we need to pass two stages:
With respect to learning the programming, you may start with technology (pick a programming language), then you could do exercises based on what you learn (science) and applying your art (think - be creative - discover - try & error - learn new techniques).
Really after going this way of education, you will be restricted with the technology (the power of the language that you picked first) and you will start to look outside the box or you will be restricted and still face a limitation due to the technology that changes and develops over time to match the real world needs.
After time, you will be at a level of art (based on your education and your skill) and you need to study more science (to learn from others) and try new technology (to get more power).
With respect to developing a software, this will depend on the stage you are in and if you are in the education stage you will use the programming language that you know and will develop a software based on your art and your knowledge and may use:
Programmers used to mix between these two methods, but it's common to go the first way (trial & error) when they face a new problem (art plays the biggest role now) and it's common to go the second way when they face a simple problem based on their experience.
But Is This Ideal?
The answer is different from one programmer to another and depends on other factors like the project, deadline, environment ...etc.
The ideal method to develop software is to (solve the problem first, then go to implement it) and without restriction to a technology, the technology should be an option based on the problem and not a decision before the problem.
But how to take a decision about the technology when the programmer knows just one language, really the answer is simple where the programmer could learn another programming language as much as he can to win the technology challenge and take the technology as an option not a decision and if the first programming language takes years to learn then the second one may take weeks or months (based on the programming paradigm and the nature of the language and the learning curve required).
The problem here is not related to good programmers. The problem is related to new programmers.
When a user comes to learn programming, he expects a (top down) approach and this approach is difficult so many humans don't like programming and if the user used the second approach (bottom up), the results will be unexpected and we could get just a semi-programmers (I mean bad programmers).
This is just a point of view after teaching programming to new students also we could notice that most of the good programmers used the two approaches together starting from (bottom up) then (top down) or starting from (top down) then (bottom up).
To learn programming and facing these problems, you need to be patient and to be patient, you need to love programming and have fun doing it.
Then to bring programming to users, we need a plane for them:
PWCT is just an attempt to implement this idea so we could attract more users to programming.
But the question now, how could PWCT do this?
With respect to the first point (they need to love programming .... because they need to be patient), this could be done by increasing the level of interaction.
Users like games because games are easy to use and interactive where when the user does any simple action, the game responds and many things happen.
Users like browsing the web because web browsing is easy & interactive so they could spend hours using web browsers and still have fun.
PWCT doesn't let the user alone and responds to any action from the user, and the response should be big to satisfy the user.
With respect to the second point (they need to start with bottom-up approach), PWCT could provide users with ready-to-use programming system that could create programs directly without spending a lot of time studying science of programming and the quick start gives good results with beginners and the user could implement his ideas and finally get an application.
Isolate Data from Instructions
Look at the next pseudo code:
x = 1
print x on screen
for x = 1 to 10 step 1 do
print x value on screen
end of for loop
Each instruction in this pseudo code could be described using F(X) where we determine the function and the data.
The first line:
x = 1
The function ( F ) is Assignment and the Data are ( X ) and ( 1 ) .
So F(X) = Assignment (X,1)
The second line:
print x on screen
The function ( F ) is PRINT TEXT ON SCREEN and the data is ( X ).
So F(X) = PRINT TEXT ON SCREEN ( X ).
for x = 1 to 10 step 1 do
The function ( F ) is start a for loop and the data are ( 1 , 10 , 1).
So F(X) = Start a for loop ( 1 , 10 , 1 ).
end of for loop
The function ( F ) is end of for loop and the data are ( NULL ).
So F(X) = End of for loop ( NULL ).
When we write code to implement this logic, we need to pick a programming language and start writing code (related to syntax), then we need a compiler to compile this code.
Writing code when done by a human, we face a problem of (Syntax Errors) but if our code is free from Syntax errors, our compiler will accept it and will generate code written in another language (ASM for example).
The code generation done by the compiler is free of Syntax Errors and this leads to an idea.
What if all the code is generated code ? then we have no syntax errors and PWCT tries to do that and this idea is one of the most important ideas behind PWCT.
Syntax is the junction between the function ( F ) and data ( X ) and PWCT replaces this junction with managed GUI objects (Components/Transporters) that you could create and use.
Get Max. Readability & Max. Writability
When you design a text based programming language, you face this challenge.
You need to take a decision related to readability & writablity and many times, they conflict together.
PWCT is a solution to this program and we could get Max Readability because we see the instructions as Steps-Tree (Goal Designer) and the step name could be long and readable as much as we want and we could change any step name without limitations and when creating and/or modifying a step, we get interaction pages easy for use and clear its purpose.
Also with respect to writablity, we get code faster than writing it by hand and the code written by machine is at a high level of pre-designed quality depending on the component creator talent and we could create our components and determine any name we want for our component, then we use this name to get our component and use it.
GUI Based Steps Editor (Goal Designer) vs. Text based Code Editor
When we use GUI based steps editor (Goal Designer), we get the good features behind using GUI where GUI could assemble things better, make it clearer, easy to use & easy to remember.
For example, instead of using Help to know the syntax...
We could interact and use components browser:
Inside component browser, we could get components by domain and/or component name:
It's not the right time to show all the new features gained from using GUI based steps editor (Goal Designer) but we could refer to that by another example.
Where in Goal designer, we could select one step instead of selecting more than one line of code.
After selecting step, you could copy, cut & paste it.
Also we could move it up/down in the steps tree.
Points of Interest
When we have more than one tool that could be used for the same task, then we need to make a choice, but in practice I am using more than one tool and I made the choice based on the task itself because each tool comes with advantages and disadvantages.
The code editor is GREAT but it's around code and syntax while PWCT Goal Designer works around steps & interaction with GUI.
Switching from text based programming using CODE EDITOR to GUI Based programming using GOAL DESIGNER is not complex, but the hardest part is to change a tool that you are used to and you need to see the results of this change to encourage yourself to do that.
Remember that using Goal Designer, we have the code (Generated code) so using goal designer is not dangerous.
In the first days of PWCT-Goal Designer, the first problem was the performance of the goal designer itself when you deal with many steps (but this problem was solved and PWCT used practically in building business applications).
IF you want to get the power of PWCT, then you need to create your components and live using them, and when you create your components you will get the feel of using your own language that is customized to your needs.
How to get Programming without coding technology?
You can download programming without coding technology from
It's Free and Open Source.