Freitag, 27. März 2009


Today was the Conference I mentioned earlier. Today I got a new webcam and some more light to get a better picture. I was just at the High-Speed-Internet place when Skype started to ring and they asked for me. I got my webcam connected and we could see each other, much better than yesterday. The people on the other side of the world used a faster computer today. Everything was fine, the Workshop was scheduled to start a quarter of an hour later, and so we decided to hang up and call again.

The time in between I used to adjust my webcam, to have the right angle and direction, adjusted all the color parameters, and at the end I thought I make a joke and put my picture inside a TV frame as I found on specials.

Then we tried to get a connection again, it was not possible to convince Skype to get a picture from my webcam. The possibility to do a video setup was gone, instead of the setup there was a link to the skype shop to buy a camera. I was happy that the audio channel worked, so we had an audio conference, for which I would not have needed all the effort to get skype installed (needs more than an hour on dial-in) and got a webcam ordered. No help, no hints, nobody did know. All video stuff had disappeared. Tomorrow I will deinstall Skype.

In my opinion Skype has a great technology, it is fabulous what they did to make audio- and video-connection work over the Internet. The audio quality is much, much better then normal telephone landline connections are, sometimes it sounds like HIFI even, and the video is good, too, much better than I expected - as long as it did work. Does not work any more. Niente.

Nevertheless, the work shop was some kind of a success. I was asked how I did it, so I had to praise the team of programmers who wrote Win32FORTH and the special person who wrote ForthForm, they really did a great job. In a few weeks, I heard, they will release version 6.13 which will work fine with Windows-Vista.

Yes, praise to these guys, they wrote beautiful readable code, remember, Forth-Code is readable and understandable, even with a minimum of commenting, if it is done properly. This is part of the Forth Programming Language, contrary to other programming languages, where the same commands are written again and again and again, and you need a lot of comments, to find out what the program was intended to do. Of course you can see there are inputs, outputs, loops and subroutines, as you can see in Forth, too, but what these constructs are really doing, to know this you need a lot of comments.

Using Forth, you can write it in a way that it comments itself. Per example, if you need a program, which opens a door, in Forth you can write: Open door, and it will work, if Door and open are defined properly. Where else can you find such an easy and convincing style?

Yes, here my answer to the question how I did it. I wrote a lot about it in this blog, but the main thing (I was newbee to the Forth Source) was using the IDE, which is part of the Win32Forth environment, searching for the text on a button or a menu, and then searching down to the modules which did the special work I looked for (This kind of search is much harder to do in any other programming language).

Then I inserted my additional code for the features I liked to have, and in most cases it worked immediately, because I really carefully looked how things worked, you can say I cloned existing modules and gave some other functionality to them.

This can be done in Forth very well. I know very well with other programming languages you need a real highly skilled programmer to achieve this. I am not a really high skilled programmer. I know what a loop is and what if else then means, and meanwhile I am patient, and I am very careful. Which other programming language allows you to insert code without side-effects? As long as I upgraded the Forth only part, everything did run on first try, only if there have been direct connections to Windows involved, I had to do some debugging, because I am not a Windows programmer (remember, this is not an application program, it is programming a tool, like part of the operating system), and as long as it was inside Forth only, I did fine with the build in Forth debugger which has a lot of features.

I could not debug Windows routines, of course, because the Windows code is top secret and undisclosed to me.

Last year December we did communicate to present the visualFORTH Alpha-Version at this conference today, it gave me the drive to do my best to have a good result, and I delivered just in time - you can read this in my recent blog pages. I did not work through nights as I did in former times (more than ten years ago), I had my decent daily routine, and still, I made it to meet our schedule.

Now I will take a rest.
There are things to do: write the Installation Manual, write the Instruction Manual, and some kind of a Tutorial. There are more than 250 links for "Forth Tutorial" on Yahoo and 350 on Google. I will look for some really good ones and will have recommendations. And the next step: The visualFORTH Beta-Version.

Take care and have a good weekend!

Donnerstag, 26. März 2009


Today we prepared the Conference, which is planned to have a workshop about visualFORTH, the organizers on the other side of the Atlantic, and me myself here.

The idea was to have a Conference-Call-Video-Connection tomorrow, using Skype.
This would it make possible for me to attend the Conference, and it would be possible for the attending listeners to ask questions directly.

There have been a lot of obstacles, the hardest one was to find a place in this rural area here with High Speed Internet-Connection. I was lucky to find a friend in the Computer Business who granted me to use his equipment. I ordered some Web-Cams, today the parcel arrived, and the first test could be made. After some normal problems to find out how works what we got a connection, first by audio, then by video.

It was amazing. I do not know if it was because I did see friends again after fifteen years and whom I now am sure I missed, even if it did not come to my consciousness, or because it was because of suddenly adapting a new technology I did not believe it really works.

I guess it was the first - or the second, partly, too? May be it was both. I am an Engineer used to look at things from a scientific emotionless point of view, but remember the time when the first affordable wireless phones came up, I was responsible for a project and had to be accessible all the time. I did not buy one of theses sneaky little cell phones * with everything inside to put it on the ear, but I bought a box with a real handset and a shoulder-strap, because I did not like to put the microwave onto my head to microwave my brain.
This was the first time I had this kind of emotional experience. Somehow I was proud to carry around this box so that everybody could see it (later I hided it in a briefcase, because meanwhile I was ashamed of myself), see how important I am (nowadays the bluetooth ear clips have this function).

It was great, it was fun, it was emotion to test this teleconferencing thing. I exceptional enjoyed it! I nearly could not let it go. But I had to. Midnight was approaching at the other end of the world, people got tired, and suddenly I remembered I had another appointment tonight I promised to be back for early enough.

A little, but important work I did before this test, waiting for the UPS-delivery. I made screenshots for a documentation which shall help to use the Installation-Batch I did yesterday.
Tomorrow I will put it together into a PDF, and next week, I hope, I have time to write the text documentation. I am really anxiously looking forward to our Workshop-Video-Conference on Friday.

*) By the way, seven years later in Luxembourg I worked for the son of the inventor of the cell phone!

Mittwoch, 25. März 2009


I am very happy about having finished the visualFORTH-Alpha-Version.

It took a lot of pressure from me, because I met the "shipping date", even some days earlier.
And I got an application done to demonstrate some special features of my visualFORTH.

Today's goal was the packaging. For ease of distribution everything has to be packed together - I hate installation procedures which tell you to put different things on different places.
I do not have the sources to manufacture an self-unpacking EXE, but I like to make it as easy as possible.

Since a lot of users already have their Win32Forth loaded from only a feature-patch is needed, and the simplest way to do this is to build a patch.bat and put it together with all feature folders into a zip-file named "program files".

This is the trick:
Downloading this zip-file into the root-directory C will with unzipping copy the batch-file and the feature-folders into the folder "Program Files", then select "Program Files, click on the batch file, and the "patchwork" is done by itself. I was really proud finding this out today. Microsoft did a great job making this possible.

Dienstag, 24. März 2009

Alpha-Version finished

Nearly a week it's now since my last writing here. As you can imagine, the last days of finishing a product steal away all free time which is normally available every day.

I worked hard, but I made it. I worked on the connection to the underlying Forth Operating System, and I started with a helpful program I found somewhere as a useful example, and I really had to spend more than a day on that - five days it took to bring all the right things together, including making a sample application (which needed nearly a day, because it was connected with improvements of the redirect-files).

This little example program source "FileEmit.f" by Bertrand André Jacques was really helpful.
This program was to redirect the output to a file, and I first added the redirection to a Multiline TextBox, so I could compare what is visible on the MTxtBox and what is written into the file.
This way I could find out how the output to the screen worked. It took me more than two days, to do the adaptation in the right way, it was really tricky. The computer-screen and the Textbox have - as far as I found out - different rules.

I did not know about Row/Column-Addressing of the Textbox (I should have googled it, but I did not think that way), and the screen-output uses XY-addressing for every line and for each character when typed. With a lot of tricks I got it working. When finished, I removed the redirection to a file, I did not use it any more.

That was the easy part.

The next part was to redirect the input, i.e. to use PushButtons of a form instead of the normal keys of the computer keypad to connect to the operating system.

Both parts together that means, to use a Multiline TextBox and PushButtons of a form as Console to the Forth Operating System in an easy way, so that everybody can use it.

It needed as long as the first part, it works, but switching between keyboard and pushbutton array (remember the arrays I wrote about?) has a little hurdle, because - so I guess - the operating system is waiting for an input, still after the input is switched to the PushButton-Array. The result is: a last time before the switchover is in effect a key of the keyboard has to be pressed, and then it works properly.

I found if I start a program on the normal console which emits characters regularly, the switchover works fine. But I did not find out how to get it working with starting this program by another program. It should work somehow, I am sure of that, but I am not familiar enough with the internals of the operating system.

Thing is, most of these modules which have been written in machine language at times of DOS are now calls to the Windows-System, and there I have no chance to change that.

But behold, writing this, I remember I looked for input redirecting within Windows a while ago.

This is the second time now, that writing my Blog - telling the story to you - helps me to get some insight by myself. And now I remember I tried to find out input redirection, because I liked to insert a Barcode-Reader Converter Software Module into the keyboard input stream, and I did not find out how, not even with looking up on the Internet and not with looking at all my XP-Books. Finally I was happy to find a module on the Internet which just did the Barcode-Thing.

To type single characters using the Form-Pushbuttons works perfect, but one remaining part is to write complete words by pushing a single button. Here I am the first time to have to ask the experts. A few days from now is the first hands-on workshop for the Alpha-Version of visualFORTH, and next week I will ask experts and find out if they have a solution to fix this remaining problem.

Donnerstag, 19. März 2009

Some minor improvements

Today I had some kind of a lazy day, on the other hand I have to think about preparing myself for the conference end of March.

One-Click-Turnkey was a great achievement, the Button-Array was very complex and a lot to test, it's done. Today I removed some annoying behavior, changed some menu points for better accessibility, and introduced ctrl+F to start Forth-Console, ctrl+I to start the IDE, ctrl+E to edit an object, and I am sure this will help to do some things easier - for somebody who likes shortcuts, as I do, too.

Ah, yes, and I started with the connection to the underlying Forth Operating System. Somewhere I found a little program as example, but again, the devil is in the detail.

I guess I have to spend more than a day on that. Was a little bit frustrating today,
I have to improve my working strategy.

So long!

Mittwoch, 18. März 2009

Arrays done

This was the most complex task I worked on to get a feature I liked to have and I was sure it will be needed. Now an Array of up to 4x16 Buttons (or other objects) can be easily put into a form, only a few clicks needed, every one of these starts the same program module when clicked on it.

The click-started program module gets the information which button it was by reading the value Control#, it gets back the number of the object for identification.

I thought it took me longer than a week, but looking back on my own blog, it seems to be I just started on Monday. Looks really fast that way. It's a good thing to have a blog and therefore the written knowledge what work has been done. Marvelous!

Now I need a break. The next step will be an easy to use I/O-Interface to the Win32Forth Operating System.

So long!

Dienstag, 17. März 2009

Arrays need an Index

Arrays need an Index to make them useful. I decided that if a button is clicked on, the number of this button will be put into a value which can be read by the program which is started by the Buttonclick. Sounds complicated, but I guess, this is the easiest way to do it and the easiest way to understand. Today I added this function , and the next step will be to clone the function of the first button to all other buttons of this array.

As a result this function has to be written only once, and depending on the number value of the activated button it can be executed differently or with different values. If you use a Button-Array as a numerical keypad, the number value of the button can be used just as the numerical value the button is intended to deliver. Easy, isn't it?

Today I had some other work to do, so the rest of it has to be postponed until tomorrow.

It seems to be we have springtime now: We do not have snow since two weeks and it was pleasant warm today, snowdrops are there since a week, and tulips are showing their first green tips. Squirrels are still feeding themselves on the birdseed.

Take care!

Montag, 16. März 2009

Steps forward in Button-Arrays

A new week again. First tests of the visualFORTH Alpha-Version have been done by our Alpha-Tester, and first experiences have been made. As usual, things happen which never happened when I was working with it, but I could immediately make an update. It is so easy, if the files to update are in the same Folder structure than all files of the Application, then with a simple copy-paste action all Files find their right place. I appreciate that Microsoft has done a great work to accomplish this. It is real great for updating, patching, and synchronizing. If these Update-Patches are done in chronological order, everything will be okay. And so it was.

Today I worked on Button-Arrays. I solved the problem of crashes when the array was more than 4x6 - I had to recognize that I used local variable definitions on places they do not belong.

After removing the obsolete dangerous definitions, it worked without crash. Some corrections I had to make depending on the size of the array, and I decided to stop working on this and to restrict arrays to a maximum size of 4x16, I think this is enough for the Beta-Version, range extensions will follow later.

The next step will be to make it possible to do the same action with each Array-Button, and delivering the Array-Button Number to the executing program.

Up to now I extracted the number, works fine, and tomorrow the remaining part will follow. Then I have to look for packaging.

See ya!

Freitag, 13. März 2009

Alpha delivered

It was some stress, really, to get the Alpha-Version ready until Wednesday, but I did know, it will be ready. So it was, and my first tester unpacked it, installed it, and, voila! It works.
Now I am waiting for the first testresults, and meanwhile I work on the update-version.
So far, so good!

Mittwoch, 11. März 2009

I made it!

I made it!
There is a FORTH-Society Meeting in about two weeks, and the goal is to present this new tool at this meeting. For this meeting the Beta-Version should be ready, and today the Alpha-Version should have been ready.

I promised to have it ready today, so there is enough time for the people who present this new tool to get acquainted with it.

After a lot of tests I got it ready. I made it! "Normal" people cannot imagine what a gorgeous feeling it is to have completed a software project, even if it is only part of it. I am pretty sure you know this joy when a software does what it should do, even if it is only a little or marginal part of a bigger project. So say a praise with me! A praise with me will help you with your next project, because I know how hard it is to get software development ready just in time!

Over all the years I have learned to meet endlines better and better. I worked self-employed, and when a customer came to me asking me if I can develop a special software for him, and I was sure I could, I got the order and started. My imagination was bright and I got a lot of ideas what I could put into this software to amaze my customer about what he got without asking for it. But I did behold this as my secret, never told it to the customer.

When the time came to have the ordered software ready, I abandoned a part of my imagination, and the more pressing the end date was, the more I abandoned, until there was only the part left over the customer wanted. It was great to have all these great ideas, but it was greater that - with the help of this special imagination - delivery was just in time.

It not always worked precisely, but it worked better and better. Remember to have a walk when you got stuck with a problem! Enjoy the fresh air - if you are lucky to work for a company which allows you to take in some oxygen from outside. If you have to stick in your cubicle, then you have no chance to get a solution easier and faster. You have to work overtime, and may be on the weekend to get it done. But, don't worry, if your company is paying overtime, then it does not make sense to solve a problem fast. Working to fast is not socially accepted, you will draw the anger from your colleagues, if not from the managers, too. This is one of the reasons that I preferred to work self-employed.

When I had my first job as engineer, I was ready with my work at noon. Not to bother my Boss I decided to do a walk to other departments, preferable to the library, and before finishing the workday, I helped my colleague to solve his problem he was sitting at the whole day (his vision was to be a physician, but his father had a Telecommunication Business, so he was ordered to study Communication Technology. He was seldom happy in his life, drinks helped him to deal better with his feelings, and he died in a young age with a liver disease).

Oh, I forget the main thing:
I really made it, and the email with the Alpha-Version of visualFORTH is on the Net now.

Dienstag, 10. März 2009

The Solution: DOS-Batchfile

Yes, believe it or not, the solution is the oldfashioned but well working Batch-File.

But, as it is with difficult problems, the devil is in the detail, as they say.
This day was a real hard day, a lot of tests to be done to find out how it works.
Don't forget, this is not a normal programming session, this is programming a tool, or let's say, some kind of system programming.

Nevertheless, all modules are written and all tests are done to get the One-Click Pushbutton EXE-File Generation. The solution is the Batch-File, I know it will work, but a Batch-file has it's own unique features which have to be served in the right way. The Batch solution is nearly done, some Troubleshooting, and then I have got it.

Now I have to go the last mile to get it done.
More tomorrow!

Montag, 9. März 2009

Pushbutton done for One-Click EXE-File

Sunday is over, a new week began. It did not look well for my One-Click EXE-File Generation. Together with visualFORTH, which is based on ForthForm, a Forth Console, like a virtual Terminal to the virtual Forth system, which is connected to visualFORTH, can be opened to receive output from the visualFORTH and to send commands to the visualFORTH.

Example: values and variables of the visualFORTH may be changed from this console, or a visualFORTH program under development may send text to this console. I used it several times, especially for debugging purposes. To debug, I simple type: "debug module", and when I start a program under development, this program stops when this "module" starts within this program, and I am able to go through this "module" step by step, until this module is done. Then the remaining program proceeds.

I used this console to load the sourcecode file for the Form-Project, which is generated by one click only, and it only had a working result when no Form was opened, would be a really odd thing: First you create the Form for your project, then compile and save the loadable sourcecode by a pushbutton click, then close visualFORTH, open again, and generate an EXE-file with one mouseclick again. With this method I could pretend it is a one-click turnkey generation, but, really odd. May be I could do these steps - switching off the system and restarting - per program.

I proceeded to the next point without finishing: I tried to change the picture on the menu pushbutton I choose to convert to the One-Click EXE-File Generation pushbutton. I found out how to do this, but after recompiling the system the result was that the BMP file used seems to have the possibility to generate transparent colors as I know from GIF files. Another odd story. Never have seen this before. That was the second hurdle. I decided for now not to change this pushbutton Icon-Picture, may be later, I have to ask how to do this. Then I discovered that it was not possible for me to control enabling and disabling for this menu pushbutton.

After three frustrating experiences a break was needed. Breaks are always good when stuck in program development. The best is to do an outside walk in this wonderful wake up springtime nature. I discovered long ago that after a walk the solution suddenly is there. My theory is that while walking, the brain, which is floating in the brain fluid (the Liquor cerebrospinalis), through this increased relative motion receives more nutrients and works better. And another theory I have: If you do not annoy your brain with thinking, the brain is able to work much better. The brain only needs an order what to achieve, and then, let it go! Works by itself.

The break gave me a great inside: why not start a new virtual console, just used only for the EXE-file generation, and after this it has to be closed anyway. Suddenly I did not need to change the enabling procedure of the menu pushbutton, because it was just right. This pushbutton I needed showed up enabled when a form was opened.

The procedure for development of a new form is as follows: on the pulldown form menu select "New" (or "Open" if you did something before), or use the keyboard <ctrl>+N to open the form. With some clicks position some controls onto the form, with a right mouseclick open the "Properties+" popup, change the captions if needed, and type in the commands which you like to be executed with this pushbuttons. These commands should be defined in a file. Generally with Forth it is possible that everything you can do with keyboard typing, can be automatically run by Forth: you simply type it into a file, and load this file with "fload" from console.
Then click the "Test" menu pushbutton, to see if it works as intended. Make changes if needed.

When the test is finished, and everything works fine, click the "Turnkey" menu pushbutton, and, voilà, the EXE-file is done.

Recognizing this is the way to do it, I started working again, now more relaxed, and now the work is done for today. The "Turnkey" pushbutton is done, it compiles a sourcecode with everything what is needed to generate an EXE-file. For security I added a message "Generating EXE-File" and the possibility to cancel. It is not needed, but I thought "better safe than sorry", to avoid the situation where you click on a button, nothing happens, and the system freezes and you do not know what is going on. But when writing this, I just had the idea instead of using a message box - which needs another click to proceed - I should write a message on the status line. Yes, it is good to explain how things are working to somebody to get better ideas. Thanks for listening!

Today's work is done, tomorrow I do the last steps to finish the turnkey process.
Take care!

P.S. While adding links to my story, I discovered there is a One-Click Patent.
First I was concerned I should withdraw my One-Click claim, but then I calmed down.

The One-Click Patent, filed by Jeffrey P. Bezos, is about "A method and system for placing an order to purchase an item via the Internet", and my One-Click Turnkey operation is not for placing an order via the Internet. But be careful, when developing a form for purchase via the Internet! Apple Inc. and Barnes & Noble took a license from Amazon.

May be that's why other people call my method a Single-Click operation!

Samstag, 7. März 2009

One-Click Turnkey / Exe-File Generation

Forth is the basis of visualFORTH, Forth makes it possible, that I am able to finish visualFORTH.
Forth is not only an Operating System and a Programming Language, it is a Database System, too, to better describe it, it is a Knowledge System.
This Database / Knowledge System is very humble called a Vocabulary, residing in a Dictionary.
This Vocabulary holds all Forth Commands, called Words.
These Words are Modules of incremental programming, and these Words together make the whole Program, Modules of a structured Program, and each Forth Word / Module may be used as a single separate Program, for testing purposes or for diversity.

This Vocabulary - there may be even several Vocabularies, each for a special context - has all the knowledge needed to generate a Turnkey-Version, a ready to use Version the user of the completed program finally gets. So a "Wizard" to magically put together an Exe-File is not needed, even if it looks like this process is done by a Wizard. It only needs some "magic" Words to generate. The building of an Exe-File shows the advantage of a program with graphical control elements: while with textual programming several words, depending on the context, would be necessary, with the use of graphical control elements all the needed program modules are at hand inside, because the context is given by the graphical Form.
A One-Click Turnkey / Exe-File Generation is possible.

Today I worked on this One-Click Turnkey / Exe-File Generation, looking up the "magic words" and trying to find out how to do it. Even if all the needed knowledge is inside, with textual programming the programmer has to have knowledge what to use, and it is possible to find it by searching the source. With visualFORTH this knowledge is not needed anymore, it is build in.
So I found these "magic words" and laid down the foundation for a One-Click Turnkey / Exe-File Generation.
Now I have to add a new pushbutton to the Tool-Menu, the Turnkey pushbutton.
Have a nice Weekend!

Freitag, 6. März 2009

All Beta-Version Features done now

Today I finished the last feature I liked to have in the visualFORTH Beta-Version,
it is the automatic generation of a Button-Array.

As you can see from my Profile, I was embedded microprocessor system developer my whole engineering life. That's why a button array is so important to me.

My first big microprocessor project was a keyboard with 250 illuminated keys,
each lamp was switched by an TRIAC, and each key was wired separately, because the customer liked to have it this way for maintenance (later I convinced other customers that a matrix wiring works as well and saves a lot of cabling). At that time a whole 19" Rack with one microprocessor board, 11 pcb's with 24 TRIAC's each, and 5 boards with 50 digital inputs each, all Euro-Format 4" x 6". There have been another boards, one with TTL-PROMs to store the program (I did not like MOS memories, because they needed three different voltages at that time), a decoder board to control the 16 interface boards, one board with a little CMOS memory, and one time- and date-board, using some CMOS-counters to be able to have the right time after a power outage.
This was really tricky. A 32kHz quartz crystal oscillator controlled the time, the frequency was divided to get minute-pulses, and these minute-pulses went into a counter. The second part of this timer-unit read the counter until it was empty, so when power came back, the time was running very fast until the current time was there again - some electro-mechanical master clock systems did the same.

The microprocessor did not only recognize the pressing of a key, storing that information, switching the TRIAC's at zero-crossing, but there was also a printer for documentation and a remote keypad connected with a proprietary serial interface. In theory I did know, that, using a Round Robin for Multitasking, everything will work simultaneously, but when we had a first test, I was totally surprised, that it really worked as intended. With this project I learned structural and incremental programming, because the only storage I had for my program was a tape recorder. So I had to write a little part of the program, test if it works, burn it into the bipolar PROM, and do the next programming step. Making a mistake would have been fatal, because there was no insert or copy/paste! This way I learned to program very careful und structured, and I used flowcharts for planning.
As I mentioned, it was my first big project.

This was the beginning of the microprocessor era. Later we used video-boards and Monitors, and I wrote my own database system, everything in assembler, until I got my RSC-Forth from Rockwell.

Nowadays, with GUI's, the keypad is on the screen, and instead of a real button a mouse is used to click or push the button. In former times manufacturing of a keyboard was a lot of work, with each illuminated key separately mounted.

What is the computer and the software good for? It should make our lives easier.
So I decided that a keypad-generator, or let us say a feature to generate an array of pushbuttons with a minimum of mouse clicks, is a must for visualFORTH's Beta-Version, coming soon.

I just did some research and read in a tutorial for the standard GUI-programming language "Now copy and paste this button 12 times" - with visualFORTH it is much easier:

Open the Properties Popup with a right mouse click, set the intended number of rows and columns, click on the PushButton symbol (or RadioButton or CheckButton or BitmapButton or any of these objects), click on the area where you like to have the array of objects, use the mouse to draw a frame which sets the array area, and click on "To Box" on the Properties Popup - and there they are, your buttons, well aligned in rows and columns as intended.

If you are missing features on your GUI-software, please let me know. I will do my best to add it to visualFORTH.

Donnerstag, 5. März 2009

What's behind?

Why visualFORTH? What's behind?
With the creation of visualFORTH I am standing on the shoulders of Giants, as there is as the most important person Charles Moore, who invented and developed FORTH nearly fifty years ago, remarkable, and unbelievable, that FORTH still exists and is used by a now again growing number of people, who do not like to be restricted by a "normal" mainstream programming language, who like to have their full freedom in programming, are weary of typing redundant text again and again and are weary of programming "workarounds" to get their job done.

FORTH is totally different to other programming languages. Typing FORTH programs is reduced to the essentials of logic the program really needs, and every FORTH programmer is encouraged to write his programs in plain English language - and even more, he can use his native language not only for comments, but to name FORTH commands, because FORTH is extensible, plainly spoken, FORTH is built on adding commands, until the goal is reached and the program is done. Even Chinese people discovered FORTH and are working on a version with Chinese characters.

FORTH did run first on a IBM 1130 and then on Digital-Equipment PDP-Minicomputers, and because of it's easy portability and small footprint it was for a long time the first operating system (FORTH is not only a programming language, it is a operating system, too) on new microprocessors - I myself started in 1984 with RSC-FORTH on Rockwell's little R65F11 computer board. Not many people know that the IEEE 1275-1994 Standard Open-Boot-PROM, inside Sun-Solaris-Workstations, and used by IBM, too, is a true FORTH Operating System.

When IBM conquered the microcomputer market nearly thirty years ago, Laxen and Perry transferred FORTH, then named F83, to MS-DOS, and with the advent of MS-Windows Tom Zimmer started Win32Forth, which then was my standard FORTH system to work with for test and development. Laxen, Perry, and Tom Zimmer are the other giants on whose shoulders visualFORTH stands, and of course, now most important, all the people on the's Win32FORTH-Project, they are great FORTH- and MS-Windows-Programmers, and their work made visualFORTH possible. Special thanks to Ezra Boyce, who developed ForthForm, an evolutionary remake of Michael Hillerström's DiaEdit, his "Graphical Dialog Editor for Win32Forth".

With visualFORTH now, based on Win32Forth's ForthForm, it is possible to use the full power of FORTH to generate Graphical User Interface programs running on your MS-Windows PC, without having any knowledge of MS-Windows-Programming. MS-Windows-Programming is complex and complicated, and programming in FORTH needs only an introduction of a few hours, there are tutorials on the WEB, and the best one to start with is "Starting Forth" by Leo Brodie (another giant). And visualFORTH is really easy to use. A tutorial will be available soon.

Mittwoch, 4. März 2009

Coming soon...

Since a while I am working on a software project, named visualFORTH.
To my knowledge some people would enjoy to work with this new
effective kind of generating Forms on their personal computer.
It is planned to have the first official release in April.
If you are interested, please let me know.