PowerBasic, worth the investment ?
You can purchase PowerBasic from an authorized vendor Component Source.
http://www.componentsource.com/features/powerbasic/index.html
If you are interested in my software tool, EZGUI 5.0 Professional, you will need the PowerBasic for Windows compiler:
http://www.componentsource.com/products/powerbasic-compiler-windows/index.html
So is PowerBasic worth the cost ?
Absolutely ! Why can I say this ?
You have to understand what the PowerBasic for Windows compiler is. It is a native code Windows compiler fully capable of accessing the WIN32 API’s directly. While PowerBasic does have some GUI commands in the language, you don’t have to use them. You can write applications using the WIN32 API alone which provides you with an extensive array of features. This means that as a developer you are not dependent upon updates to the compiler to get more features. The possibilities with a native code compiler are almost limitless. Is that really true ?
EZGUI was built using native code
In all fairness, while the PowerBasic Windows compiler has an acceptable GUI command set, EZGUI 5.0 Professional is years ahead of anything in the compiler as far as GUI features. While native coders using PowerBasic may struggle with the basics, EZGUI users have access to many of the more advanced features in Windows and also a number of proprietary features built into EZGUI itself. So which compiler did I use to write EZGUI 5.0 Pro ?
Actually EZGUI 5.0 was started using Powerbasic 6.1, which is four generations back from the current PowerBasic 10 compiler. I have a number of different versions of PowerBasic on my computer (running two separate license paths) and I prefered the older 6.1 version because it created a smaller DLL for my runtimes. I actually maxed out the 6.1 compiler. My source code was too much for it (the older compilers were a bit more limited in the size of apps it could compile), so I decided to move ahead a few generations of compilers to finish EZGUI 5.0. I skipped 7.0 (I don’t have 7.0) and 8.0 and went straight to the 9.0 version which can handle huge programs compared to the old 6.1 compiler. I also have the version 10 compiler which I use for testing. So EZGUI is developed using an older generation of the PowerBasic compiler and I don’t see any limitations with that compiler for many years to come.
Because I am a native coder, PowerBasic is almost unlimited for me. True I don’t have 64 bit compiling yet, but that won’t be a requirement for software for a good number of years yet. Compiling to 32 bit native Windows EXEs has plenty of life left in it. What I like about the compiler is that its core feature set provides me with so many options for coding. Now some programmers aren’t good with low level stuff and if they depend largely upon high level engines, then maybe the PowerBasic compiler may seem limiting to them and the future of the company could be an issue. But for low level programmers like myself, it is not an issue. I can write whatever I need using the low level WIN32 API and even API’s like OpenGL.
If I can develop something like EZGUI 5.0 Professional using even an older version of PowerBasic, then I can honestly say that the compilers have a long life span of usage for capable programmers. The PowerBasic compilers are “rock solid” too and not prone to a lot of bugs. True no software is perfect, but the PowerBasic compilers I have used have demonstrated that they are pretty sound and reliable. I trust them and have confidence in them. My customers know that I am stickler for reliable software myself and can ill afford bugs in my own software, so I can honestly say that PowerBasic compilers have gained my trust over the years.
EZGUI pushes the limits of the PowerBasic compilers
Now my customers have the best of both worlds. They too use the PowerBasic compilers which are reliable and do most of what they need for the non-GUI stuff and they use my EZGUI to push the limits of the PowerBasic compiler so they can build more advanced user interfaces. EZGUI has been pushing the limit of GUI design far beyond what ever Powerbasic alone can do. I was build a drag and drop designer long before PowerBasic even had a GUI command set or their PB Forms designer. When PowerBasic began to add GUI commands and print commands, I was already building drag and drop engines (build your own WYSIWYG style apps), custom controls, DIB engines (low level pixel manipulation) and even a 2D sprite engine for animation. Today PowerBasic’s built in GUI command set only supports the basic controls, while EZGUI has a number of advanced custom controls already built in, such as my Canvas control (with 2D sprite engine), advanced graphics (image rotation, image filters, alphablending), MCI control (for easy multimedia), splitterbar control, turtle graphics control (vector graphics), glCanvas control (with OpenGL based 3D scripting language), masked edit control, files listbox control and property listbox control. EZGUI has an ownerdraw engine for customizing controls too.
Now I should point out that EZGUI itself was written using PowerBasic, but the difference is that I am an experienced WIN32 API programmer with over fourteen years experience in developing GUI engines. So if you are willing to learn how to tap into the WIN32 API, then PowerBasic compilers are almost unlimited in what they can do for you. If you need an easier way to build user interfaces, then the combination of PowerBasic and EZGUI 5.0 Professional also can provide you with years of use in software development with almost unlimited possibilities. I should point out that EZGUI was designed so one could expand upon it using the WIN32 API. Rather than a closed “black box”, EZGUI was designed so one could expand it. For example EZGUI has commands for making hooks into core engines of the runtime, such as the Forms engine window procedure, subclassing, superclassing and more. An experience WIN32 API programmer can easily superclass existing EZGUI controls to build upon them. EZGUI provides access to API resources it uses directly, such as fonts, brushes, icons, bitmaps and cursors. So rather than be limited, EZGUI, like PowerBasic, was designed so you can expand upon it.
PowerBasic’s low level features are where the real power is
In building EZGUI 5.0, one thing that really made a difference when coding using PowerBasic was its low level feature set. For example, PowerBasic’s advanced data types allow all sorts of ways to solve problems. One favorite feature is the ability to define an array of types (structures) via a memory address. In EZGUI’s glCanvas control I use PowerBasic variable length strings (OLE strings) to store data, but overlay an array of types (structures) into the string memory space, so it works like a different data type. PowerBasic has an excellent array of data types with a powerful string engine, Quad Integers (8 byte integers), extend floating point and more. Another favorite feature in PowerBasic are pointers. I use pointers a great deal in EZGUI. It allows me fast access to pixel data, string data and more. You can do things with pointers that just can’t be done any other way.
Powerbasic also produces very fast running and very small (in size and memory usage) executables. It allows you to create industry standard DLL’s (dynamic link libraries) too. You can call functions/procedures via code pointers too, which allows dynamic calls. This is a very powerful feature in the compiler. You have pointers to data. You have pointers to code. You have pointers, to pointers, to pointers (redirection) too.
The price is right
While some independent programming languages found on the web may be low priced, most industry standard professional programming languages are not cheap. The Embarcadero compilers are in the thousands of dollars. Microsoft’s Visual Studio (Pro) is not inexpensive either. The PowerBasic compiler at $199 is very reasonable for a quality, professional level, native code compiler. Combined with my EZGUI 5.0 Professional it is still quite affordable for a professional programmer. So if you are interested in a powerful combination of programming tools, then PowerBasic for Windows and EZGUI 5.0 Professional make a powerful tool set. To make things even better, EZGUI 5.0 Pro is current on sale for half the price (only $129 see: http://cwsof.com ), so that is a real deal.
Many places for support in using PowerBasic.
The community of PowerBasic programmers is of a good size (in the many thousands) and among them are many very experienced WIN32 programmers. Surely, they will be around for awhile and provide help in learning how to get more from the compiler. My own forums (for EZGUI and PowerBasic users at: http://cwsof.com/forums/index.php ) will be one source of information. Some of the more advanced PowerBasic programmers hand out at Jose Roca’s forums ( http://www.jose.it-berater.org/smfforum/index.php ). Paul Squires excellent FireFly Visual Designer is well supported with their own forums ( http://planetsquires.com/ ).
Some other third party developers with tools for PowerBasic programmers:
Some in the PB community already have their own web sites with excellent resources, like this one: http://www.garybeene.com/power/