Home | About us

Re: why xbase++


1999-11-29 16:13

Bill -

This is from the introduction of my training materials:

Have you ever heard someone say “He’s so far behind he’s ahead”? There’s a
lot of truth to this statement, and many of us have been in a situation more
than once in our lives where we found out that we became much better
positioned simply by staying off the bandwagon.
If you are finding yourself in the uneviable position of having to develop a
strategy for migrating an existing Clipper applications to windows, then you
probably have been down this road before and have been burned by one or more
experiences with other Windows languages.
By now, many programmers have decided that they must move on to Windows and
that there is no place for Clipper or Xbase in their strategy. These
choices were made because the available Xbase-language Windows products just
did not deliver on their promises. This was caused mostly by the fact that
the new emerging techology, Windows, was a constantly moving target. Most
of the development efforts had to deal not only with a significant technical
paradigm shift, but also a shift in a political climate that forced
developers to migrate applications before the languages, operating systems
and users were ready to make the migration.
Like I said before, many of you have already travelled this road and have
experimented with, or developed applications using other Xbase-syntax,
and/or non-Xbase-Syntax Windows languages. I am not suggesting that in any
way, this was a bad choice. I have spent sufficient time with other Windows
language to come to the realization that Windows applications can be
developed by travelling many different paths. What I am offering, however,
is another perspective; one that frees us to open our minds to look at the
future from a different view. Many of us have been so busy and so worried
about constantly moving forward that we have forgotten how we got here in
the first place, by the use of an enduring and powerful language - Clipper.
So you may be thinking “What is he talking about? Clipper is Dead!”. In
the sense of a product, this may be true, but in the sense of a language, it
is far from true. Let’s imagine that Chinese is packaged into a product
named “Visual-Chinese” and this product includes a set of design-tools for
creating quick-Chinese documents that can be easily integrated into our
marketing documents. Soon we would find our business opened up to a new
market of 1 billion people. The product becomes instantly successful and
everyone love its and uses it - until, years later, when we find that our
marketing documents are not delivering any sales. Why? Because the
language had to be cut and trimmed to fit into the limitations of the
software environment. It becomes ambiguous, arrogant and unwanted by the
very people who inspired its development, so it dies and Visual-Chinese gets
thrown away like every other Visual tool. Does this mean that the Chinese
language dies with the product? No. Chinese is a language that will
endure. It has lots of users; it is robust, and it is mature.
The key word is “language”. Development strategies should be built around
the choice of a proper language, not just a product. Clipper is a language
that endures. It cannot die. It has widespread use around the world and
there are hundreds of thousands of Clipper legacy applications still doing
mission-critical work. Unfortunately, because the word “Clipper” is owned
by another software developer, and because that developer has essentially
abandoned the Clipper, it cannot endure under the name Clipper, so it must
endure under another name: that name is “Xbase”.
Clipper was undoubtely the best custodian of the Xbase language from 1987 to
1996. Clipper introduced the Xbase compiler, the open-architecture concept
of the extend system, code blocks, locals, statics, multi-dimensional
arrays, the RDD layer, the preprocessor, and language extensions. Clipper
was the first Xbase custodian to give Xbase respectability as a true
programming language.
Xbase++ is the newest player in the game of Xbase. Alaska Software has been
in the enviable position of being allowed to sit back and watch what others
are doing to the Xbase language. They had no stake in it so they were not
required to play the game. It kind of reminds me of an old “BC” cartoon in
which two ants are sitting on an ant-hill looking down on several
pre-historic cavemen as they clubbed each other senseless. One ant says to
the other “If we had the bomb we could intervene”. Sometimes it takes a
bomb to stop the madness.
Now Alaska Software has the bomb! - And they are ready to intervene.
In my opinion, Xbase++ will become the Xbase custodian for the next
generation of Xbase. Why? Here’s a small list:
1. They chose to support compatability with the most widely accepted version
of Clipper, version 5.2e. They listened to the Clipper developers and
insured that Xbase++ is 100% compatible with their existing Clipper code and
the Clipper preprocessor.
2. They chose to make Xbase++ platform independent, so it can be used with
Windows, OS/2, Linux, AS/400, etc.
3. They designed it like Clipper, so Clipper developers can use the same
tools they have been using for years, including their favorite editor, their
favorite linker, and their favorite third-party libraries.
4. They have embraced the third-party community and have encouraged them to
migrate their products to Xbase++.
5. They added an event model and a complete set of easy-to-use GUI classes
titled “Xbase-Parts” that makes it easy to design GUI dialogs and also to
migrate existing Clipper applications to full-GUI Windows applications.
6. They added a full, state-of-the-art, object-oriented language that
adheres to all of the modern OOPS standards.
7. They added a DBE (database engine) layer, based on CORBA technology, that
exploits a powerful database architecture.
8. They added stable multi-threading, making it simple to offload
time-consuming operations to a host system or separate thread.
9. They added persistence to all data types, including code-blocks and
objects.
10. They added memory management systems that have eliminated the problems
that have persistently dogged other Xbase dialects.


Why Xbase?
Many of us wonder why Xbase has not been given more respectability as a
“mainstream” language. If Xbase is so good, why are Borland and Microsoft
phasing it out of their future products? I was watching a television
program the other day about an analysis of automobile technology over the
years. We often assume that the best technology is what endures over time
and that it eventually rises to the top. This may be true in an ideal
world, but in a capitalist society, it is usually market dog-fights that
determine dominance. In this analysis, it was determined that steam
technology could have produced cars just as good as internal combustion
technology, but Henry Ford chose the latter.
Microsoft has chosen Basic, not because it is better, but because they own
it. Borland chose Pascal, not because it is better, but becaused they own
it.
Over the past 10 years, the success of the Xbase products has been due to
the high degree of abstraction of the Xbase language, which makes it vastly
simpler to access and use operating system functions and resources. In
addition, Xbase is more than just a specialized programming language, a
database navigation language, or a user interface language - instead, it
combines all of these roles, harmoniously integrating them with one another.
Xbase offers dynamic data types and is generally described as being highly
“tolerant”. Taken together, these benefits have persuaded a steadily
growing community of users and developers to rely upon it as a choice for
implementing mission-critical and commercial PC-desktop applications. In
fact, world-wide, more than one-third of all DOS-based commercial
applications now in use were written in Xbase, with Clipper accounting for
the major share.
Why Xbase++?
Clipper programmers have tried just about everything to migrate their
applications to Windows, but the available languages have failed to make
this anything other than an expensive and painful process with clumsy
results. I have started migrating applications windows several times and on
each occasion have realized I was wasting my time, until now. My experience
with Xbase++ is unlike any other product I have tried. Xbase++ gave me a
place to start that was comfortable and familiar. It allowed me to compile
a small program, link it, and run it just like in Clipper. I was not
required to learn an IDE, a Resource Kit, a Windows-API, a new editor, a
respository, new functions, new classes, or new commands. What I did need
to learn was a new compiler, named XPP.EXE and a new linker, named
ALINK.EXE. The compiler is compatible with CLIPPER.EXE so that was really a
no-brainer, and ALINK.EXE was basically a piece of cake too, because in
Xbase++, there are no complicated linking strategies as required by Clipper.
In a few minutes, I had a small Xbase++ program running. In a few hours, I
had a large Xbase++ program running, and in a few days, I had several of my
products compiled and running as 32-bit applications.
So is this the Holy Grail? Is this the Magic Wand? In a way it is, and in
another way it isn’t. Xbase++ doesn’t take a DOS text-based application and
convert it to a Windows GUI-based application. It does, however, take a DOS
text-based application and convert it to a 32-bit text-based application
running as a true Windows application. Of course, this isn’t the final
result that we want for our 32-bit Windows applications, but it is a major
step, because until now, nothing could accomplish this feat.
Migrating large Clipper applications requires that we meet certain
objectives before continuing to the next level. Many Clipper applications
have dependency on some third party library or maybe even a library of your
own C routines. Xbase++ allows us to deal with these issues and resolve
them before needing to write any GUI migration code at all. I had to deal
with this when evaluating a strategy for migrating a major application. The
Clipper version of this application has about 20 “C” functions and 10 “ASM”
functions that are key to its functionality. The most important of these is
an interactive preprocessor that works with a dot-prompt interpreter.
Xbase++ has an extend system that is nearly identical to Clipper, so it
required making only a few modifications to the parameter passing logic in
my original C code and it was ready to compile with any 32-bit C compiler.
I was able to test this conversion without writing a single GUI dialogue. I
just compiled, linked and ran the new application.
Every other language would require converting all screen output code from
text-based to GUI-based before I could run the application. Even a Other
Xbase-compatible languages do not let us start from this vantage point
because they cannot handle the text-based IO requirements of the Clipper
application. My application had hundreds of dialog screens, menus and
browses that all write text-based screens. If I had used any other language
but Xbase++, my data-entry screens, dialogus, menus, and browses would have
to be re-written before I could turn the application over to the users. It
could take years to migrate 10 years of Clipper code into a useful program.
Xbase++, on the other hand, allows me to migrate the application in steps:
1. Recompile the existing application in Xbase++ and run it as a 32-bit
Windows application.
2. Give priority to the portions of the application that need to be
converted to GUI and start converting the application in little pieces.
Dialogues that need to be GUI will look and run just like other 32-bit
Windows applications, whereas dialogues that can wait because they may be
used less often, will look and feel just like 32-bit text based
applications. Both GUI and text-based code can be combined in the same
application.
3. Add new features to the application that take advantage of the operating
system and the new language extensions, like file pick dialogues, the print
manager, the TCP/IP Winsock interface, etc.


Square Pegs and Round Holes
Most Windows programmers will tell you that you cannot take a standard
Clipper application with @SAY..GETS, Menu Prompts, etc, and convert it to a
Windows GUI program without a major change in the architecture and the
functionality of the program. They claim that a text-based, modal design
has too little in common with GUI-based, event-driven, non-modal design.
They will tell you that it like trying to fit a square peg into a round
hole. For years, I believed this because it made sense. I, like everyone
else, wrote my Windows applications with a different structure than my
Clipper applications. They were built around an event model rather than a
procedural model and the code was tightly-bound rather than loosely-bound to
the functional model. This always leaves me with an uneasy feeling because
it forces me to write applications that are less modular and are platform
specific.
Xbase++ has taught me that GUI applications can be built with the same
functionality and structure as Clipper applications without losing its
platform independence. I learned this when I was developing a system to
convert my hundreds of @SAY..GET dialogues to GUI dialogues. The event
model supported by “Xbase Parts” allowed me to develop a new dialogue system
that works with a “Get-List”, similar to Clipper, and then pass the GetList
array to a GUI reader function similar to the ReadModal() function in
Clipper. This abstraction of the functional design of a dialog from the
code implementation of the dialogue allows for architectures in which
Clipper @SAY..GETS and menus can be easily migrated to GUI.
The Torch has been Passed
Alaska Software likes to exploit their slogan “The Next Generation of Xbase”
on their marketing documentation, their website, and even the product - but
it isn’t just a slogan. It truthfully states what the product is and where
it fits into the Xbase story. It also defines Xbase++ as not just a 32-bit
compiler for Clipper but a product that helps us move beyond Clipper, beyond
DOS, and beyond Windows.
The only thing that is common between Xbase++ and Clipper is the
compatability of the language, otherwise, Xbase++ is an entirely new
programming language that is created by an entirely new company who is
un-encumbered by an old user-base, by old loyalties, or by an old marketing
strategy. Alaska enjoys the freedom to move forward with a vision of “a
perfect world” that the other Xbase custodians could not realize. The
other Xbase dialects were all acquired by large companies who had already
established their language strategy and bought the products not for their
technology but for their user-base.

Bill Reese wrote in message ...
>Folks,
>
>Can someone clue me in on why I might want to choose xBase++ as our new dev
>database software?





 






Post Date :

1999-11-29 16:13


Author :



Groups

Other Messages