"David H. Burns" <dhb### [at] cherokeetelnet> wrote:
> > I just took it as an eyample, having been *my* long-time favorite language
> > (after BASIC).
>
> Well, I guess I'll have to admit it BASIC is my favorite language.

Not really the most modern of languages (unless you count VB/VBA, but as you say
yourself these are actually totally different beasts), and indeed one of the
most frowned-at languages (VB/VBA included in this case); I guess that's mostly
undeserved, however: The frowns should go to the people who thought it a good
idea to introduce "GOTO" as the second statement after "PRINT", thereby
inviting virtually the whole Home Computer Generation to become hobbyist
spaghetti code producers.

Normally, the first two programs would be:

  10 PRINT "Hello World!"

and

  10 PRINT "Hello World!"
  20 GOTO 10

A few years ago I did some work for an insurance company to port a few old small
SINIX-BASIC programs to VBA (something like two dozen 1000-liners) so they could
get rid of the last legacy machine that could run those programs; some of them
were really well-strucutured, well-commented and well-indented. Others were
really the worst classic spaghetti code I've ever seen in my life, and I was
more than happy that I only had to *port* them, not *fix* anything in them.

It's really a matter of programming style whether a BASIC programmer should be
despised or not. BASIC allows for a broad spectrum there. But then again, ever
since I've seen the C source code of "NetHack", I can tell that at least C
programs - even when not deliberately obfuscated - can be just as messy as any
BASIC code. And at least BASIC is not as cryptic as C.


> QuickBasic was it's highest development.

Just out of curiosity: Did they ever introduce such things as structs (records
in Pascal)? That was the thing that bothered me most about BASIC ever since I
first wanted to store a list of data tuples. Using a separate array for each
"dimension" of the tuple just didn't feel right.


> I was able to display an image and VBnet seemed to promise good image
> handling capabilities if one could only figure them out.

If graphics (or any other non-textual user interaction, for that matter) is what
you want to do, it comes as no surprise to me that you don't like modern
computer languages. The major problem, however, is not an inherent feature of
the languages themselves, but of graphical user interfaces (at least as far as
Windows is concerned; I never got to have a look at X Window or the like),
which follow an *event-driven* paradigm - i.e. *they* want to tell your program
when to do what, which is almost perfectly incompatible with the classic
application-driven paradigm. And although I guess this is exactly what you're
wrongly attributing to OOP, you're not so far off the mark: As a matter of
fact, an object in OOP can be regarded as an event-driven piece of software
(each method call constituding an event), so OOP is a very good paradigm to
model an event-driven application: All you need to do is consider your whole
application an object, too - which I admit is indeed *not* a natural way of
thinking.

(However, while the event-driven paradigm *is* an antithesis to the classic
application-driven paradigm you undoubtedly favor, OOP can be used perfectly
well for both.)

Unfortunately, modern mainstream programming environments indeed don't seem to
come with any framework to support the classic application-driven paradigm,
except for purely textual interfaces ("console application" in Microsoft terms)
or a static sequence of dialogs ("wizards").


> I have a couple of versions of Python which
> I may eventually learn to play
> with and "Borland's" free C/C++ compiler that I might use some if I
> could figure out how to do graphics
> with it. How I do run on! :)

Speaking of Borland, maybe they still come with the good old "graph" library and
the BGI graphics driver format, in which case I'd expect them to include a BGI
to interface to Windows, too.

Same goes for FreePascal. I guess I'll check that out.

C is really not a pretty language, by the way. I'd possibly still program in
Pascal, had it not been for the limitations of the compilers I had at my
disposal (16 bit "real mode" applications only, max array size of 64 kByte)
when I was introduced to C, C++ and Java. (And I'd possibly still program in
BASIC if I hadn't had to learn Pascal at school anyway, and found the language
to feature records ;)).

Post a reply to this message