Introduction
I am going to talk about the ideas and technology behind PWCT (http://doublesvsoop.sourceforge.net).
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:
- Learn Programming Basics (Education)
- Start Software Development (Get Practical Experience)
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:
- Trial and Error method
- Solve the problem first, then go to implement it
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 depend 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:
- They need to love programming .... because they need to be patient
- They need to start with bottom-up approach
- They need to switch to top-down approach
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.
With respect to the third point (they need to switch to top-down approach).
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 used more than one tool and I made the choice based on the task itself because each tool comes with advantages and disadvantages.
Visual Studio code editor is GREAT but it's around code and syntax while PWCT goal designer is a SIMPLE TOOL but 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.
History
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.
