response 1 of 49:

Jan 26 04:42 UTC 2007

Fortran 4 in 1968, forgot it all.   Does anyone still use it?

response 3 of 49:

Jan 26 04:59 UTC 2007

Here's my response from M-Net: (Note that when I say, ``this item is nearly
20 years old...'' I'm referring to the item on M-Net.)

This item is now 20 years old.  I honestly can't remember the order I learned
languages in; I suppose it went something like this:

Logo (in grade school)
Basic (on the Macintosh, but not seriously, and I honestly don't remember any)
C++
C
FORTRAN 77
Pascal
Perl
sh/ksh/csh (all at roughly the same time)
awk
Tcl (and Tk and expect)
Macro-32 (Under VAX/VMS)
VMS DCL (Command procedures, baby! $DECK is your friend!)

Yes!  I really `learned' C++ before C!  No, I'm not kidding!  And yes!
I really learned FORTRAN before Pascal!  That was so I could convert bits
of a monopulse radar simulation originally written in FORTRAN IV into
C!

Then it gets fuzzy.  In no particular order:

Scheme and LISP 
Prolog
Python
Java
Ruby
SQL
SML
Ada-95
MC68k assembler
SPARC assembler
Smalltalk

All of these to lesser or greater extents.  Ruby and Python and Java well.
SML okay.  SQL well.  Prolog and Ada not so well.  At some point I picked up
a bit of C# and many ``little languages'' (would someone consider regular
expressions a ``language''?  How about troff and TeX?  Sed?).  Many of these
've forgotten; I surprised myself by successfully writing a Pascal program
the other night.  I surprised myself by successfully writing a FORTRAN
program a few months ago.  Maybe it's time to finally dust off the Alpha and
install VMS on it and get it into colo....

response 5 of 49:

Jan 26 08:12 UTC 2007

How did people learn Perl?  I think my first exposure was the Perl 4.036 man
page....

response 7 of 49:

Jan 26 13:24 UTC 2007

BASIC on a Commodore VIC-20
C++
C
Rexx
PHP
SQL
Perl
VB

I also learned C++ before C, and the reason for this was my first
programming class was an Intro to Programming class at the college and
it used C++.

As for Perl, I learned by trying to figure out some of the perl code
that a previous employee had implemented. I'd have to say it was pretty
obscure and hard to follow.

response 9 of 49:

Jan 26 17:42 UTC 2007

REXX was also popular with OS/2 and Amiga users.

response 11 of 49:

Jan 26 19:01 UTC 2007

Basic/BASICA/GWBasic (Just having fun in our PC clone, used in
highschool to write codes to approximate numerical integration to pass
Calculus, pissed off the instructor by using bad programming practices
and stupid variable names (I always used the name of the principle as an
accumulator, and the variable cheese as an iteration variable))
Bourne Shell (taught myself with tutorials, and more in Jr College)
Korn Shell (taught myself with tutorials, and more in Jr College)
AWK (learned in Jr college)
Matlab (first year EE)
C (second year EE)
JAVA (switched from EE to Information Systems)
Tcl + TK (self taught for a project at work, and needed a really easy
way to do a scripted language that offered a motif-like gui; project was
no-go after a couple of weeks because the director of ops and I got into
a pissing fight and he obviously outranks me)
Javascript (self taught, then needed to use it for web development
class) C# (web dev class)

response 13 of 49:

Jan 26 19:36 UTC 2007

html is a programming language?

response 15 of 49:

Jan 26 20:19 UTC 2007

"flat" html without JavaScript or css etc. is probably nothing more than
"formatting markup tags".  But these days, except for the most basic web
pages, there is at least *some* kind of JavaScript or "programming language
type stuff" included.

response 17 of 49:

Jan 26 20:36 UTC 2007

(I almost typed, ``rexpond'' to fronttalk for this!)

REXX on the mainframe was something else.  What it was, I'm not sure; I
didn't particularly care for it.  But I was intrigued by some aspects of the
environment: in particular, it was a *really* powerful scripting system that
let you integrate disparate parts of the system.  For instance, you could
address the text editor (XEDIT) and use it to drive user interfaces that
were frontends to REXX scripts.  Similarly with other applications (like
mail).  I thought that was pretty cool; you still can't easily do that under
Unix (and probably, you never will be able to).  But the language itself was
sort of goofy, I thought.  And the mainframe was Not where I wanted to spend
all my time: too constricting.

At one point, though, it did inspire me enough that I wanted to see a
general purpose `text editor filesystem' for Plan 9 that could be scripted
from the shell, or used by a front-end like sam or acme.  The response was
that that was essentially what acme was, but the difference is that acme is
married to the user interface, whereas in the mainframe world, XEDIT was
not.  But that would make interacting with *files* a lot more convenient
than using `here' documents and shell expansion (as opposed to text streams,
which are still undeniably useful).

Here's a REXX story: When I was a sysadmin at an academic department at Penn
State, we used to charge for computer time, disk usage, and printing on our
centralized servers.  Yeah, clearly these were the Bad Old Days(TM).  Now
days?  Yeah, right.  It'd be cheaper over six months to buy a PC and install
Linux on it and do it yourself.  Anyway, four generations of sysadmins
before me, the department set up the account system: they would use the
standard Unix tools to do accounting; quot, sa, ac, pac, etc.  Then some
homegrown software written in Perl that would suck in all the data, merge it
together, and generate reports that we could send to research groups
informing them of how much they owed the systems group.  The guy who got
hired before my immediate predecessor, however, had a mainframe background
and access to the campus VM system (by then an ES/9000: the 3090 had been
retired).  He didn't want to mess with the Perl stuff, so instead he
reimplemented it in REXX on the mainframe.  He'd run scripts to dump the
accounting information into plain text files, which he would then FTP to the
mainframe where he'd login and run his REXX programs (they had a sort of
nice, mainframish menu interface and everything).  He'd do a run, print off
the reports on the nearest mainframe line printer, and put them in people's
mailboxes.  Weird, but it worked.

The next guy who came in didn't do accounting at all; he was in way over his
head, and quite confused.  He just couldn't figure out how to get it all to
work.  A real nice guy, but not a knowledable professional.

By the time I came in, accounting hadn't been run in three years.  I managed
to contact the author of the REXX stuff (he had since moved to a different
organization within the university, so was still around), and got a copy of
his code.  The Perl code was, by then, hopelessly out of date.  I didn't
have access to the mainframe, though, so I downloaded a REXX interpreter for
Unix and got it running on our Sun's.  I modified the CMS specific parts of
his programs to run under Unix, and managed to start accounting back up.
The first time we generated reports, we realized that computing was owed
somewhere around US$11,000 in back usage charges.  Needless to say, people
weren't too thrilled to get these bills in their mailboxes, and shortly
thereafter, we decided to stop charging for usage and instead making the
computing budget be part of the department's overhead costs.

response 19 of 49:

Jan 26 20:41 UTC 2007

Regarding #16; I think we have a web item, and there is certainly a web
conference.  Those questions would really be more appropriate there.

response 21 of 49:

Jan 26 23:24 UTC 2007

(CGI stands for `Common Gateway Interface' and is a method for getting
interactive behavior out of web pages.  CGI programs can be written in
a variety of languages.  The web item, item #34, would be the place to
discuss it, however.)

response 23 of 49:

Jan 27 18:43 UTC 2007

Re: #11. ARexx (the Amiga dialect of REXX) was really cool. Though I never
actualy used it myself, Commodore shipped it by default with the OS, and
extended it so that it became a complete general-purpose scripting language
with Amiga extensions. Pretty soon every Amiga program worth its salt had an
"ARexx port" that programmers could use to combine GUI programs in much the
same way Unix cli users write pipes, coming up with new and inventive ways
to use those programs.

The Amiga was somethign else.