First Language Learned

What was the first programming language you learned? How do you believe that this has affected you? (BrainDamage)

Add your anecdote and update the tally, please. REMEMBER: THIS ONLY A SURVEY! Be honest. Don't hedge by saying, "My first RealProgrammingLanguage was..." If you typed it in, keyed it in, punched it in, toggled it in, you programmed in it.

Tally so far:
  Algol60 :2
  APL [AplLanguage]: 3
  Assembly [AssemblyLanguage]: 4
  BASIC [BasicLanguage]: 90
  Binary (well, coding in Hex): 1
  Calculator: 2
  C [CeeLanguage]: 3
  C++ [CeePlusPlus]: 3
  COBOL: 1
  FORTRAN [FortranLanguage]: 11
  HyperTalk: 1
  Hypo: 1
  IITRAN [IitranLanguage]: 1
  Java [JavaLanguage]: 2
  JavaScript: 3
  LISP [LispLanguage]: 4
  Logo [LogoLanguage]: 9
  Pascal [PascalLanguage]: 4
  Perl [PerlLanguage]: 1
  PHP [PHP: Hypertext Preprocessor]: 1
  PILOT [PilotLanguage?]: 1
  Python [PythonLanguage]: 3 (I imagine there will be more...)
  Roo: 1
  SinclairZxEightyOne Basic: 1
  SmallTalk: 1
  Snobol: 1
  SOAP: 1
  Turtle [TurtleLanguage?]: 2

How about LanguageLearningPaths??

  [1] calculator > 8080 assembly (in hex) > Pilot > BASIC > FORTRAN > PDP-11 Assembly > DG Nova Assembly > Algol > Pascal > Apple ][ Basic > 6502 Assembly > 80x86 Assembly > C > AWK > HyperCard > C++ > 6811 Assembly > PIC xx Assembly > PICK BASIC > SQL > VB > Javascript > Perl > TCL > Python > Ruby > XSLT > sh > PHP
  [1] calculator > BASIC > AnalogComputer? > FORTRAN > Algol > z80 assembly > Forth > CPL > TurboPascal > VMS DCL > C > sh > awk > perl > html > lex > ...
  [1] BASIC > DHTML (HTML/CSS/JavaScript) > PHP > C++
  [1] BASIC > HTML & CSS > PHP > Javascript > C > Python
  [1] BASIC > (HTML/JavaScript) > Java > C
  [1] BASIC > VB > HTML & CSS > Javascript > sh > PHP
  [1] BASIC > HTML > VB > sh > Perl > PHP > Java
  [1] BASIC > Pascal > Perl > Java
  [1] BASIC > Pascal > C > C++ > Java > ... (various 'scripting' languages)
  [1] BASIC > JavaScript > CSharp > Smalltalk > Scheme
  [2] BASIC > Assembly > C > ...
  [1] BASIC > Assembly > Logo > Pascal > Lisp > C > C++ > Java > Perl
  [1] BASIC > Assembly > (Pascal & C concurrently) > C++ > Forth > REXX > Smalltalk > Oberon-2 > J > Haskell > (Lisp-family & Java concurrently) > (more that I've since forgotten about) > Java
  [1] BASIC > C/C++ > sh > Assembly > Java > C# > VB .NET
  [1] BASIC > C > ...  > Lisp > ...
  [1] BASIC > C > Logo > Lisp > ... > Java > ...
  [1] BASIC > C > FORTRAN > Perl > Python > Smalltalk > Java
  [1] BASIC > FORTRAN > Assembly > AM2901 microcode > PL/I > COBOL > RPG > C > *nix shell > C++ > Tcl/Tk > VHDL > Perl
  [1] BASIC > Pascal > C > Assembly > C++ > Java > Python
  [1] BASIC > Pascal > C > Assembly > Objective-C/C++/Smalltalk > Visual Basic > Perl/C > JavaScript > Java
  [1] BASIC > Pascal/Assembly > C/ARexx > Fortran77 > Perl/Awk/Bash > PHP > C++/Java > Haskell > Objective-C > Smalltalk
  [3] BASIC > Assembly > Pascal/Modula II > C > ...
  [1] BASIC > Assembly > ... > C++ > Java > Tcl > Python > Haskell
  [1] BASIC > VbClassic > VB .NET
  [ ] BASIC > Java > C > C++ > Assembly
  [ ] BASIC > HyperCard/SuperCard (1994) > HTML/PerlLanguage/CommonGatewayInterface (1995) > JavaScript/PHP (1996) > RealBasic/AppleScript (1998) > C/C++ > JavaLanguage > PythonLanguage (2003) > BooLanguage/CsharpLanguage (2004) (I'm finally back to something that is as good as HyperCard)
  [1] BASIC > HyperCard > Pascal (for HyperCard external functions) > C++ (since Apple moved away from Pascal) > ... > Python
  [1] BASIC > LOGO > C > Perl > C++ > Scheme
  [1] C++ > C > Shell Scripting > PHP > Java > Ruby > Perl
  [1] C++ > PHP > Shell Scripting > C > Objective-C > Lua > AVR Assembly > JavaScript > CoffeeScript > Java > Ruby > [Python]
  [ ] Pascal >
  [1] Snobol and Pascal > LISP, C and Algol68 > COBOL > FORTRAN > ... > IoLanguage
  [ ] Logo > BASIC > Assembly > Pascal > Ada > LPC > Inform > VBA > Python
  [1] Logo > BASIC > C, Excel, VbClassic > Java, C++ > ...
  [1] Fortran > Algol > BASIC > Pascal > C > ...
  [1] Fortran > BASIC > C > Lisp > ...
  [1] Fortran > IBM 1620 Asm > Lisp > Symbal > AED > COBOL ... 
  [1] Java > Lisp > Python > C > Everything else
  [1] LOGO > BASIC > Perl > Bits of PHP/ASP/other crud > Python > XSLT... although everything after Perl feels like backsliding.
  [1] LOGO > BASIC > Pascal > C > C++ > Java > Perl > PHP
  [1] LOGO > BASIC > Pascal > C > C++ > Java > Perl > PHP > Ruby
  [1] JavaScript > Pascal > C > Java > Bash
  [ ] Java > Python > C/C++ > Assembly
  [1] MS Batch > JavaScript (though more as "Dynamic Web pages woo!"; I was 7) > Python > sh/bash/zsh > CommonLisp > Java > Prolog > Scheme >... (hopefully Haskell or Ruby next) 
  [1] BASIC > C > AppleScript > JavaScript > PerlLanguage > PhpLanguage > RealBasic > ObjectiveCee > PythonLanguage > EmacsLisp
  [ ] TI83 language > C++ > CommonLisp > Javascript > LabView > R (in the middle of learning R)
  [ ] (Q)BASIC > VbClassic > C > InformLanguage > Perl > PHP > JavaScript > Python > Java > Ruby > (Scala and Scheme)
  [1] Algol60 (some Fortran and Lisp) > [CORAL-66, Z80-assembler] > Pascal > [C, 68000-assembler] > C++ > [Perl, Python, Scheme]

My first was BASIC, nothing unusual. I'd say that mainly it's affected me in all the ways predicted in BasicConsideredHarmful. -- DanielKnapp

BASIC on the Apple II, which predisposed me in a lot of ways:

(1) I have no patience for compilers (which is why I love the SmalltalkLanguage and VisualAge for Java)

(2) Reflection is no problem to me. (Heck, you had to use PokeAndPeek to do anything on those boxes! I was shocked to learn that people wrote code that was not self-modifying.)

-- KyleBrown

I always find discussions like [those on WhyWeHateLisp] interesting because I was one of the abnormal few whose first language was Lisp. I actually find it quite hard to deal with C for solving most problems, even so-called trivial ones, although I'll use C where I find it fits best (inside Unix, and when writing a small tool with a focused purpose, or when writing a small library with a focused purpose, and only for a certain domain of problems that I can WinBig? by using C and leveraging Unix). I hate C for general systems stuff. Who else comes from "non-standard" programming backgrounds (a friend of mine recently confided to me that his first language was APL, and he's definitely warped like myself, only different)? -- DanMoniz

Strictly speaking, my first language was BASIC, which I tinkered with on a Tandy 1000TX when I was around 12. I didn't manage to get infected by the programming bug, so I never got farther than tinkering around with tiny programs. My first real programming experience was taking CS 61A, the introductory programming course at CalBerkeley, which covers the first four chapters of StructureAndInterpretationOfComputerPrograms. So unlike many other students, who had been corrupted by Pascal or C++ in high school AP computer science, I had to the opportunity to be blinded by the light of Lisp. CommonLisp is still my LanguageOfChoice, although I do most of my day-to-day programming in Java. -- JosephDale

DartmouthBasic on a PDP/11, then BASIC on CP/M, then AppleSoft Basic (the last Microsoft product I really liked), some 6502 machine code (couldn't afford an assembler, so I had to type things like "60 ED FD"), a little Logo (which we all hated, because you had to declare your variables before using them!), then (believe it or not) Forth, in the form of PaulLutus?'s GraForth?.

GraForth? was a beautiful language: easy to understand (once you got the hang of ReversePolishNotation), easy to write structured code in, and yet very close to the machine: words would get compiled down, as I recall, and the code would be put on the stack; the word itself would simply be a JSR to the entry point for the compiled code.

Less than a year later, the academics got hold of me, and I learned to love Pascal (which I used commercially as late as 1995). Halfway through college, I learned C from K&R's book and a helpful 16-year-old named Explorer Bob (he'd programmed TinyMUD).

But the languages that really shaped me in the beginning were BASIC and Forth. -- GeorgePaci

My first language was BASIC on a Commodore Pet (at the tender age of 5 or so). While not much older, I also learnt LOGO. The first language I actually sat down and studied, though, was Pascal (the MacPascal? editor was my first exposure to a syntax-aware editor, and still one of the better ones I've seen). -- RobertWatkins.

My first language was IITRAN, a simple PL/I-like language for students. See "The IITRAN Programming Language", R. Dewar et al, CACM 12(10):569-575 (Oct 1969). My second was FORTRAN, a step down. My third was Snobol4, an awesome three steps up. I learned all of these on my own in one year (1967) without the trauma of late nights and slow turn-around experienced by those taking computer classes. -- WardCunningham

Hmm. BasicLanguage first, originally on the CommodorePet, later on the CommodoreVicTwenty and CommodoreSixtyFour. Then LogoLanguage, also on the 64. My first language in school was BASIC again, this time on a TrashEighty. Somewhere around this time, I was learning 6502 AssemblyLanguage. PascalLanguage (TurboPascal), 68K assembly, and C in college. Later SasLanguage? (during my dark days at BigBlue), and now a mix of C and C++. (Not in the same programs, of course. ;-) One of these days I'll take up Java. -- MikeSmith

SinclairZxEightyOne BasicLanguage, SinclairSpectrum BasicLanguage, BbcBasic, 6502 AssemblyLanguage, GwBasic, 8086 AssemblyLanguage, CeeLanguage, RevelationBasic, VisualBasic, JavaLanguage - is that a UkPerspective??

Quite possibly. I learnt SinclairZxEightyOne BasicLanguage, BbcBasic, LogoLanguage, AmstradCpc BasicLanguage, Z80 AssemblyLanguage (hand-assembled on paper) and 6502 AssemblyLanguage all while at JuniorSchool?, then TurboPascal and 8086 AssemblyLanguage st SecondarySchool? (with a first attempt at learning CeeLanguage and CeePlusPlus), and then CeeLanguage and CeePlusPlus (properly) at university. I have since learnt other languages, including JavaLanguage, VisualBasic and LispLanguage. All my programming skills are self-taught from books and websites, although I often made use of the computers and compilers at school/university. I think that early exposure to AssemblyLanguage is really quite useful, since it shows you how computers really work. -- AnthonyWilliams

[SinclairZxEightyOne BasicLanguage was also the first language in which I did any heavy-duty programming (such as it was), though I had formerly played with TRS-80 BASIC. Then I learned hand-assembled Z-80 machine code, and did a bit of hybrid stuff (BASIC & machine code together). I did a little Z-80 assembly, too, as well as a ZX-81 hardware interface project, before getting a CommodoreVicTwenty, and then a CommodoreSixtyFour. So I used CBM BASIC and 6502 assembly. I had to learn PascalLanguage for Comp-Sci in High School. Going from free-form BASIC to structured Pascal was refreshing and freeing, as I could finally do some of the things I always wanted but never had the means to. At my first full-time software job, between stretching Lotus 1-2-3 macros and dBASE III scripts to their limits, I learned CeeLanguage - on the first Unix box I ever had access to - as well as a little shell programming. Unfortunately, I didn't get much of a chance to use it, but by that time, it was JustAnotherProgrammingLanguage. I went to school to learn EE -- they forced me to learn FortranLanguage - and on my first co-op migrated to EmbeddedSystems work using C and 6800 assembly. Somewhere in there I picked up a little ForthLanguage and PostScript, though I never did any serious hacking with either. Learning ObjectOriented principles was as freeing as learning StructuredProgramming. And so I learned CeePlusPlus, PerlLanguage, JavaLanguage, and so forth. -- TimKing]

SinclairZxEighty BasicLanguage, SinclairZxEightyOne BasicLanguage, Fortran (on a CdcCyber no less), Pascal, CeeLanguage, ShellScript?, PerlLanguage, CeePlusPlus, JavaLanguage, with some VB/VBA, LispLanguage on the way. -- MatthewFarwell

My first was 8080 assembler, followed by Pascal, BASIC, FORTH and C. This was 1977-1981. In school I took FORTRAN and punched my assignments because for some reason there was never a line at the card reader :-) -- DavidBrantley

BASIC - on a teletype. It corrupted my mind. And to think I could have learned PL/I first; it could have saved me. ;-> -- JeffGrigg

When I was a teenager, I saw guys programming in BASIC, but they didn't get any chicks. I waited until I was 20 and started programming in C. I was able to marry in seven years.

I was 9 years old when I first learned programming with Apple ][ BASIC. After a year, I learned 6502 Machine and Assembly language. And then I moved to C and Turbo Pascal, where I had a great difficulty changing my programming style into StructuredProgramming. As I became freshman in university, I studied OOP such as C++ and Java, where I had difficulty as well, moving into another paradigm. Anyway, despite of BASIC being my first language, I wasn't, hopefully, mentally mutilated beyond hope of regeneration(as EwDijkstra said in QuotesOnProgramDevelopment) after all.

Thinking about the best language to learn first, IMHO, it would be nice if the language and the environment has some sort of interaction as in Interactive Interpreted languages - such as PythonLanguage, RubyLanguage, SmalltalkLanguage, and so on. Lexically and syntactically neat and clean with consistency is very important in order to form a good mind frame and good habit, I suppose. In this vein, I don't think hybrid programming language is a good choice if he/she were to learn more languages in the future.

-- JuneKim

My first language was Atari BASIC. It had a lot of nice features like automatic syntax-checking and built-in graphics commands. If one were so inclined, one could write an entire graphical program without one POKE, though it wouldn't have any sprites. I seemed to take to structured programming a little better, probably because I was weaned off the GOTO/GOSUB/FOR-NEXT tar pit by Turbo BASIC, which had all the control structures one needed: WHILE/WEND, REPEAT/UNTIL, and even multi-line IF/THEN/ELSE, and named procedures. It had some advanced commands to provide other ways to alter memory than singular POKEs and PEEKs, often eliminating the need for in-line machine language routines that did the same thing in more inefficient and obfuscated ways. It was also three times faster than Atari BASIC, and almost completely backwards-compatible. There was even a compiler to make programs even faster. It gave me a greater appreciation for C when I finally learned it. -- NickBensema

I started with Spectrum Basic when I was about 7 or 8 but I was saved by C64 Basic. It was such a horrible and crude language that learning 6502 Assembler was the only sane course of action. Imagine a language with line numbers which forced you to use goto because you didn't have subroutines or functions. Then make it really, really slow. Then provide no abstraction of the underlying hardware so that doing anything with sound or graphics involved setting bits in registers on chips. You haven't lived till you've written Basic programs with a memory map by your side. After that kind of beginning everything else looks good by comparison. -- AdewaleOshineye

Obligatory link to CommodoreBasic provided here. It did have subroutines and functions, but in some ways it's worse than described above. -- NickBensema

This is going to sound like a MontyPython sketch but when I first learned to program we used to envy people who had 128k of ram and floppy disk drives.

Started with 8080 & Z80 assembly. This was a "near miss" - I almost started with BASIC. One of my most enlightening moments was the day I examined the assembler and C output in CodeView together and realized, "oh, is that all they're doing!" Truly liberating: I realized there is no magic in the abstractions of higher level languages - it all comes down to assembly. The shrouds of mystery became gossamer.

Assembly gave me the grounding in "GoodTightCode" and what's really going on in the box; ForthLanguage opened the vistas of abstraction and iterative incremental coding with factoring and discrete component modelling, and C introduced me to structure and modularity. I was able to combine the lessons of Forth and C in creating 10 very successful years of FoxPro development. Depending on the task of the moment, I can use any of these languages as PseudoCode.

If a programmer really wants a solid foundation, there is no substitute for assembly. In terms of simple productivity, I've never matched FoxPro. If I had it to do over, I'd have spent more time with Forth. -- GarryHamilton

I 'borrowed' OhPascal? from a college roommate. -- SeanOleary

Good ol' GFA-Basic on the Good ol' Atari 1040ST. Fast, compilable, structured, excellent support for all things low level (no peek or poke for me :), and a surprisingly well translated manual (from German)... come to think of it, I rather miss that language. -- WilliamUnderwood

I think I can up the strangeness ante somewhat. I was tempted to write qbasic, as that is what I first truly programmed in. But it wouldn't do the fact justice, that I told my teacher I knew how to program BASIC, without ever touching qbasic before in my life, and proved so by finishing all her tests successfully in the first session. The truth is that several years earlier, before I ever thought of programming a friend of my father's, who was an engineer introduced me to visual basic 1.0. I did my first VB without a single line of code. It was a slide show of images simply advancing on the press of a "next" button. I never grokked programming at the time and didn't do anything else either. But it let me jump right into qbasic, pretending I was master programmer extraordinaire. Then soon the switch of Pascal (not without writing a qbasic game that the whole school played in breaks for top scores). And I'm still at it (Delphi now). The truth is, I did object-oriented programming from the beginning; it seemed natural, even though my teacher had no clue about it. OK, my programs were 70% assembly, but that was graphics stuff. Today I write in my own languages, the compilers and interpreters still written in basically Pascal. I can't see what's wrong with it ;)

I was first exposed to APL on punchcards but can't claim any real proficiency at it. Commodore BASIC followed along with 6502 (actually 6510) and 68000 AssemblyLanguage. Then a long time passed. When I came back at it I became passable with javascript and learned enough Perl to realize that Perl sucks. :) PeterHansen introduced me to Python which is my LanguageOfChoice now. -- AndyPierce

FORTRAN on HollerithPunchCards. In high school, we had a card punch machine in the corner of the class room and our teacher would carry our decks of cards to the university to run twice a week. A couple of days after submitting our jobs, we would get pages of white and green striped computer paper back reporting either success or cryptic error codes that referred to equally cryptic 4 or 5 word explanations. Still, it was pretty cool when a job finally ran. -- WayneMack

A punch machine? You were lucky, we had to use a heavy pencil on mark-sense cards. But at least we got ours back the next day from the other high school that actually had the computer. We got one "field trip" there during the term where we got to use their punch machine and uninterrupted access to see what it was like to get your program run in what seemed like real time! -- MarkTilley

In high school (1976) I wrote a short program in APL. My first programming course in college (1977) used a combination of LISP and PL/1; the next year I took a structured programming course taught using Algol. When I bought my first PC, I used Pascal (1985). Maybe this weird start is the reason I have always been more interested in the programming process, rather than the language. -- StanSilver

Basic on a PDP 11/34 at my high school. I suspect it was harmful in the traditional manner. But I do not code for food nowadays. KenMegill

Basic on a friend's Atari 800XL. I was further subjected in school and it took me a good 5 years before I could get out of that state via perl and then through to Ada95, C, Scheme and greener pastures. Not being a programmer and finding myself to be a natural SysVNazi, I became a system administrator.

My first language was GW-BASIC on an 8088 PC. For reference, I was born in 1976. -- BrentNewhall

I first wrote code when I was 6 in Basic, but I mostly just copied the text out of magazines. I didn't really know what they meant, though I could fix typos.

The first actual language I understood was HyperCard, and that was when I was ~12. -- anon DidYouPostThis

This one mirrors my experience pretty well actually. Except I had classroom instruction in Commodore Basic - and later Turing and even a bit of C. While I did some pretty amazing things with HyperCard and HyperTalk (with some help from ResEdit), I didn't really learn what I think of as "real programming" until university. -- KarlKnechtel

Atari Pilot (with turtle graphics). It's one of the few languages I used that I can't remember one whit of. -- RandyBrown?

10 T: Hello, world!

American English, but from the context of the page I see that it should really be named FirstProgrammingLanguageLearned?. That was Microsoft's Extended Color Basic on the TRS-80 Color Computer. Mmmm, upper case. -- EricHodges

The first programming language I learned was AutoLisp. Never learned BASIC; too young I suppose. -- KyleWakefield

My first one (when I was about 12) was a kind of 4 bit mnemonic assembly language, that was featured by an electronic experimentation kit. you could put some resistors, leds etc. on lego-like pieces together, connect them with each other and with the 4 in- and outputs of the 4-bit microprocessor component, program it and have some fun. - Said 'language' was entered with a hex-number-pad and a display consisting of six 7-segment leds.

But that was of course just the beginning, I moved on to basic, C, ..., *; today I cannot count the languages (or rather language concepts) learnt or read of (among them quite few advanced ones).

-- GunnarZarncke

I honestly can't remember if it was FORTRAN IV on an IBM 1130, or BASIC on a PDP-8E in the mid-70s. I spent a few years floundering around in those languages (although I *did* give a talk about expressing clarity and intent in code using BASIC for my examples in 1981!). Luckily before I could turn completely to the "Dark Side", I was introduced to Pascal, and soon after (around 1983) a Pascal dialect with "Units" so I could at least practice rudimentary information-hiding. -- GeoffSobering

I worked as a web content editor at a floundering Internet startup in 2000 when they told me I needed to learn to develop web applications if I wanted to have a job. They used PerlLanguage, so I dove in and taught myself. Most of my time is now spent in JavaLanguage, but I very much enjoy RubyLanguage and still have a special place in my heart for PerlLanguage. -- DaveHoover

Like several others here, I learned BASIC on the CommodoreSixtyFour, but I didn't really learn how to program until we started using the ComalLanguage. It was available for the 64 on both cartridge and disk (I didn't realize it until much later, but I also learned Logo at this time too, since the Commodore Comal version had a built-in Logo implementation). Then I learned Pascal on the CommodorePet, followed by C on the CommodoreSixtyFour. These were my first languages. -- BillCaputo

I no longer remember the order in which I learned my first programming languages. I'm fairly sure that, in some order, they were: BASIC (on a CommodorePet), FORTRAN IV (learned from a big thick manual; I never actually used it), and some variety of Lisp. I'm 32 years old. I'm not sure what effect my early programming language learning had on me; I can hardly go back and try learning a different set and seeing what changes... -- GarethMcCaughan

Haven't seen this one yet... I taught myself to program (around 1990, age 10) in TI-BASIC on a Texas Instruments TI-40 console that plugged into our TV and used solid-state cartridges for software. Unfortunately it had no hard drive, and I never bothered with the system for hooking up a cassette recorder to save data, so power-off was the end of my code. I wrote a fairly large Adventure-type game, among smaller projects, all written out in pencil on notebook paper and typed in afresh each coding session. Nobody ever told me about subroutines, so I didn't use them (I don't even know if TI-BASIC had them) - it was all a mess of GOTOs. I suppose there's no worse way to learn programming concepts: at least it taught me to type fast, and to be economical with lines of code (not necessarily a good lesson). Soon graduated to a Zenith PC (MS-DOS 3.1) and was lost in the wonders of QBasic and Nibbles-hacking (4-player TurboNibbles? with blinking and shifting walls!!). Since learned CeeLanguage, CeePlusPlus, PerlLanguage and PhpLanguage (the only language I've been paid to write in, sadly). Played around a bit uninspiredly with JavaLanguage and SchemeLanguage, but PythonLanguage seems to be a good fit. -- CarlMeyer

FORTRAN, 1401 Assembler - don't worry, I've kept current. -- RobertField

My first language was QBX - Quick Basic eXtended, for Dos 3. I think BASIC is really quite a decent first language.

BASIC on a PDP, via a teletype. But this was a high school course of little consequence. In college, PL/C (the "student" version of IBM's PL/I), alongside assembly language on the same mainframe, followed very rapidly by PDP assembly, Pascal, and LISP. The first language I did programming-for-hire in was FORTRAN, then Scheme and VAX Pascal. I didn't learn C until relatively late, and replaced it as quickly as was feasible with C++. -- DanMuller

Applesoft BASIC, then Commodore BASIC, then 6502 machine language on each. I can't call it assembly, because I didn't have an assembler - all I had was a 6502 opcode list and a memory map/syscall list for each machine. Next step was C; my initial reaction was "How in the world can you program this without knowing the addresses to which it gets compiled?". But I got better. -- TimLesher

QBasic and Visual Basic. I never got over it; I simply cannot stand languages that insist on bracketing the conditional in if statements or end lines with semicolons (not that, say, Haskell is bad with its optional semicolons if you have two statements on the one line, just that Java, C etc. are bad with the you-end-a-thingy-with-a-semicolonitis). -- Tristan McLeay?.

My first language real programming language was FORTRAN on a 9/36-bit UNIVAC 1180 mainframe. A few years before, in 1970, we used an Olivetti Programma 1000 at school. But this machine was little more than a 5-register calculator programmable in a kind of assembler (a 8-digit display, 60 pound weight at the bargain price of about 8.000 $). -- HelmutLeitner

I also learned on an Olivetti Programma in highschool around 1974-5. IIRC, it was called a Programma 101. Its display was a paper tape, just like a cash register. Programs could be stored on some sort of magnetic card. I remember writing a program to calculate PrimeNumbers; it ran all weekend until the numbers got too large. Later I learned BASIC on a Sinclair ZX-80, followed by TI Basic, Coleco Adam Basic and Amiga Basic. -- JohnWebber

BASIC (old style with 10,20,30, goto, gosub...) on a SinclairZxEighty hooked up to a B&W television monitor which jiggled every time you pressed a key. Wonderful design for the time: white was about 8 inches square, 2 inches thick at the top that tapered to a thin blue or black touch sensitive keyboard, looked like a spaceship. This was back in the late 70s and it was small compared to a modern laptop. Was a lot of fun. I was in high school but joined a university computer club in their electronics dept they had radio shack and South West Technical Product PCs (green screen - before the days of apple and IBM PCs I think Apple's Lisa was just coming out) rows of BYTE magazines had hours of fun playing tic-tac-toe, star trek, d-ship all of which had the BASIC code to fool around with. Even tried writing our own version of Pac-Man and Space Invaders on the radio Shacks when those games came out on Atari and the Arcades.

HP 110 programmable calculator. (see also: ProgrammableCalculators)

Concise expression of solution was essential. Also, since the only output was numbers, I learned that symbolic representation was the basis of EVERYTHING. -- BobBockholt

It would also be interesting to know the last language ever programmed in? ;-) -- RobKamp

Lisp, of course. Those who master Lisp transcend into a higher state of being.

Technically, I was taught Basic as a kid on my Victor computer, but I never wrote anything of my own volition with it. I followed exercises, never saw the usefulness. The first time I saw a cut-n-paste JavaScript make something happen on a browser, I knew I had to learn it. I followed a few tutorials, but otherwise taught myself JavaScript. It was all down hill from there. My boss wanted me to learn Perl. I learned it. Job change. My boss wanted me to learn VBScript. I learned it. Continue for a couple more jobs and many more languages and here I am. -- LaraKramer

PILOT up there is ATARI PILOT; I don't remember it being like what's at the RetrocomputingMuseum, but it has been years ago. It did have turtle graphics, I remember. -- RandyBrown?

My earliest programming memory: using LogoLanguage at the age of 9 or so in primary school on a ResearchMachines Nimbus (would have been around '89). After that came BasicLanguage on BbcMicro machines in my secondary school from 11-12, and then VisualBasic when I was about 13 for a little while, a break, then again as part of an A-Level I was taking (16-18). Didn't like it at all. Started dabbling with PerlLanguage (naive CGI scripts) at 20 or so. Started liking programming again. Fiddled around on and off with it as part of being a professional webmonkey for the next couple of years. Got hired to do it professionally at 23. Learnt more in the next 6 months than all my previous time with it put together. Still hacking Perl now, and loving it. Never did get around to learning a "proper" language, though. -- EarleMartin

BASIC (I was born in 77). When I was 6-7, I typed BASIC programs into my sister's TI-99/4A. Even though my understanding was limited, I suspect it primed me for logical thinking. When I was 11 I got a TI of my own and obsessively read the manual cover to cover and so TI Basic was my first language.

I graduated to an HP-86 PC which had a beautiful procedural BASIC, floppy drives, a printer, and eventually, a huge 0.96 megabyte hard drive. The HP had a faux-vector graphics library which forced me to learn trig and geometry.

I needed more power to make a MarioBrothers? clone, so I started getting up at 4:30 in the morning to program GWBasic on the family's 8086 PC before school.

When I was 13, I discovered the book OhPascal? and that was my first "true" programming language. I think I might have had trouble with this jump if it were not for three things: 1) I had learned assembly on the HP, so pointers seemed logical to me. 2) I had already learned structured programming from HP BASIC. and 3) Borland TurboPascal had an IDE that just made it easy. Editing, Compiling, Debugging, and online help all in one package. For many years I thought Pascal the perfect language and C/c++ ugly.

OO programming did not come easily to me. Borland TurboPascal had OO features, but I figured you had to be stupid to use something like that when procedural programming was more logical. I mostly made games with TP, and after about five years my programs started to become so complex and had menu-driven GUI's that I evolved into using OO techniques by accident without using the OO language syntax.

Though I used C++, I was 22 or so before I was fully able to grok OO programming. VB and Java helped with this. -- MichaelMcHenry

My daughter, born in 96, is now 7. I wonder what her FirstTimeLanguage will be? She plays Hangman on my 24-year-old TI-99/4A, and DungeonSiege? on her own Pentium III PC.

I can't imagine a small child learning Java or C#, it should be an interactive interpreted language. I'm tempted to show her how to use MacromediaDirector, but it's far too complicated and too many things can not work. Logo is just not interesting. I'm most tempted to show her how to type in simple programs to the TI. -- MichaelMcHenry

When I was still too young to be let on a computer, I learned Turtle(LOGO) on the Big Trak - -- LayneThomas

Basic. And what's worse, VAX Basic. Somewhat bizarrely, my second language was TurboProlog?. My dad's firm was all spooked about the Japanese FifthGeneration stuff so they gave him a free compiler. After hacking at that and the VAX at my high school for a few years, I picked up some just plain goddamn bizarre programming habits.

AtariBasic, followed by 6502 assembly language. -- KrisJohnson

SpectrumBasic? on a 48k ZX Spectrum as an eight year old. And then picked it up again quite a few years later with QuickBasic bundled with DOS 5. -- ThomasDavidBaker?

Does editing an executable with a hex editor count as using a programming language? Only if you modified the machine code, and didn't just edit strings.

English. I remember it was quite fun learning to program the parental units (not to mention my kid sister). 10 say "twuck"; 20 say "truck"; 30 get some Trix (sugar cereal); 40 goto 20; 50 rem or were they programming me?

Seriously, I think it was some Basic variant on my grade school's teletype machine when I was 11. The next year, a friend of my parents' came to live with us, bringing his Dr. Dobbs ("Running Light without OverByte?") collection and his IMSAI, upon which I learned more Basic, 8080 assembly, and Lisp. (He was the kind of guy who wrote his own Lisp from scratch, and hacked the GameOfLife with video display in TTL.) I was learning Applesoft Basic, 6502 assembly, and Pascal at school at roughly the same time. Later, when I had my own PC-XT, I wrote my first useful programs in TurboPascal. As today, most of the real effort of programming was learning the damn libraries and system calls rather than the language itself. I encountered C on the Unix mainframes at college, and it's been all downhill from there. -- IanOsgood

Who was this Lisp-from-scratch Life-in-TTL guy?

Gail Marshall. He went on to found an industrial frame grabber company, ImageNation (which provided my first contract programming job, making TIFF libraries for it and researching the emerging JPEG standard.) He was a RealComputerHobbyist?. He also wrote his own graphics libraries and hacked an Olivetti daisy-wheel typewriter into a printer! -- IanOsgood

So there I was with a 5" floppy, trying to make this so called game work by typing the file name in at the prompt. It didn't. After a few phone conversations, I opened the executable in a hex editor, switched some numbers here and there and voila. My next language was Logo/Turtle, Basic, Assembly, QBasic, C, C++, Java, Ruby, Small Talk and then Self. With a few side trips into Perl/Python, Scheme/Lisp, ML, and others of that sort (college made me do it... Go figure).

Definitely Basic since GWBasic and QBasic were free and readily accessible on my DOS 3.3. Helped me learned some really simple concepts about programming. -- ChaoKuoLin

Well, we started with MS QBasic at school, but we had some kind of interpreter programme before, called Roo. In it you had to program a kangaroo to draw a picture with its tail. Worse than aforementioned Turtle/Logo. Had only Jump, Walk, Turn (left) and If See Border, While Not See Border.

SOAP stands for the (IBM 650) Symbolic Optimizing Assmbler Program. I used it in 1959. The 650 stored data on a rotating magnetic drum, containing 2000 words (40 bands of 50 words each, I think)! While you were executing an instruction, the drum was turning, so every instruction had an extra field containing the address of its successor instruction. If the successor was too close (turnwise) to the one you were executing, you missed a revolution, and your program would be really slow; too far, and the instruction unit had to wait for the drum to come around! That's why you needed an optimizing assembler! It also meant it was impossible to backtrack to find a problem! Bell Labs built a neat interpreter for this machine called BLIS, and I have had a soft spot for interpreters ever since! -- PaulMorrison

Like so many other people, I started with BASIC. I was five years old at the time, and my dad was going back to college to get a degree in information systems. We had an Apple IIgs at home (I can still remember, to this day, what the store looked like that we purchased it from, despite having only been 4 at the time), and I was watching dad, and I wanted to do what he was doing. So he pulled out a 5.25" floppy, formatted it, copied on PRODOS and BASIC.SYSTEM, and gave me the manuals. I twiddled with Pascal some (got started with that the same way -- asked my dad. It was TML Pascal, and I never did figure out how to use its much-touted graphics capabilities) but I never really learned enough to make use of the language. Lack of GOTO confused me at the time. QBasic on a 386 following that, then Visual Basic 2.0 on a 486 following that, upgrading to 3 and 6 in later years. Somewhere in there I learned some 6502/6510 assembler. C++ in high school, mIRC scripting (hey, that's some powerful stuff), TI-BASIC and Z80 assembler (for a TI-86) on my own after that, and last year I added Scheme to my list of languages. While we're sharing anecdotes, I've got a couple. I had to take a BASIC course in high school as a prerequisite to the C++ class. (They let me skip the Intro to BASIC class, but Structured Programming in BASIC was still required.) I went in knowing more about BASIC than my teacher did. She had to pull out the language reference to look up some of the keywords I used. (Tell me, just WHAT is wrong with using DEFSTR?) And then, well, let's just say that technically I don't know Java. I've never studied it. AP exams got me out of taking Intro to Programming in college, and they taught Java in that class. Yet when I took Graphical User Interfaces, our assignments were in Java -- and I got them turned in. It's amazing what you can fake with the right knowledge of C++, eh? -- CodaHighland

Oh yeah, one more anecdote while I'm thinking about it. I booted up my old Apple IIgs a few years ago. It's still in perfect condition, though some of the floppy disks have suffered from age. I caught myself writing in Applesoft BASIC using structured programming and a few aspects of object-oriented, using arrays with and constants for array indices to simulate structures. -- CodaHighland

Basic on a 4K Tandy TrashEighty at the age of 19 (28 years ago). A buddy got a contract (our first) to do a mailing list application. The client handed us a TRS-80, a printer, some cassette tapes (!), and a couple cables. We handed him back a working mailing list generator about a week later.

Why is it written above that BasicLanguage is not a RealProgrammingLanguage? It may not be a good programming language, but it's a "real" language in that you can get productive work done in it.

Plus, the sheer number of Wikizens who cut their teeth on BASIC ought to disprove some of the rather nasty things that EwDijkstra had to say about it... Esdgar was a brilliant fellow, but one who enjoyed inflammatory rhetoric a bit too much.

My first language (I actually forgot that I learned it first...) was QBASIC. This was because it was built into Win 3.1(?). Indeed, while this was my first language, I was not really interested in a computer career so much as 'it was just cool' that I could control the computer. I made a neat lil calculator. I was 12. I didn't _truly_ program again until first year university, when I learnt Java. I did included HTML/JavaScript in my learning path because I learnt them for fun, but I wouldn't really count them as programming languages. -- SusanRoy

First, I learned Integer Basic and Applesoft Basic on Apple II computers by hitting Ctrl+C on computers at the computer stores, and playing with the code. Subsequently, I did more playing with Apple IIs at the local library, and learned 6502 Assembly, so I could write better graphics and sound programs. Later, on an Atari ST, 68020 Assembly, Modula II, Pascal, then C. Later, on PCs, C and C++. When I got actual jobs programming, it was desktp DBMS languages - Paradox PAL, FoxPro, Access/VBA, then VB. Of course, occasional bash, bits of Perl, etc., along the way. Now trying to escape from VB into Java, C# and Hybrid Functional stuff ASAP.

-- Steve Jorgensen

My first language was Compass, an AssemblyLanguage for Control Data's Cyber 3300. It ran in a 64 bit operating system called Master - "Multiple Access Shared Time Executive Routine" -- PeterLynch

First, Integer BASIC on Apple ][ computer, typing in games from magazines. Two-letter variables -- ick. The hardware could only display uppercase letters. (The first word processor I used - AppleWriter?, I think - used inverse video to represent uppercase letters, normal white-on-black to represent lowercase letters). Since then, many assembly languages. Still learning more programming languages. One of these days I'll get around to Lisp. -- DavidCary

I was started on the path with a programming class on Logo at the local science center. About fifteen years ago we got our first computer - an Apple ][gs - and I taught myself Integer BASIC. The first non-trivial program I wrote was a Logo-like interpreter because we couldn't afford to buy the program. Later on I read a book on C from the local library yet couldn't try any of the programs since we couldn't afford a C compiler or linker.

Nine years ago we purchased a PC with a modem and CD-ROM drive, and I read about C++ and Java on the internet. It was amazing to me that we could actually compile programs for free. In the last four years, I've read enough to understand some Perl, Python, Lisp, XSLT, VB, among others. But I still often think in Logo. :-p

I think that everyone should start with Logo. It teaches the concepts of command, paramaters, functions, loops, and recursion in a way almost anyone can understand. There is hardly any grammar to learn and it isn't complicated to read (unlike C or Lisp). Other courses tend to focus more on the syntax and libraries (esp. those on C++ or Java) of a language. Even BASIC is too complicated for a beginner with no experience programming, I think.

-- JimmyCerra

First learned BBC basic on a BBC micro at primary school (4 - 11 years old) my first computer was an AcornArchimedes so continued with BBC basic but learnt C as well. In high school, I learnt Pascal and VbClassic; at university, Fortran and C++. Now can add tcl, vhdl and a bit of lisp to the list as well as having relearnt c++ (as it is quite a different beast now to what it was back when I first learnt it). I don't think starting with bbc basic has particularly coloured my programming, for the simple reason that I learnt so very little when I was playing with it -- JamesKeogh

In (rough) order.. Basic on the Atari 600, LOGO, Apple ][ Basic. Then into "real" programming, with Visual FoxPro(!) as the first real stuff I ever did. Perl, HTML/JavaScrip?, C, C++, Python. A few other languages like VB Classic, Delphi thrown in, some other web development stuff (MacromediaColdFusion is what I get paid for...), but Python and C++ are my current loves.

Basic on Apple 2 was the first one, in my 13th year.

Then Lisp, before Pascal, C++, Prolog and so on..

Programming Lisp during my high school was quite nerd. I can remember one time, I said to my mathematical teacher, who was a little bit into computer programming, how nice and beautiful was a lisp program. Something pure and near perfect.

The guy looked at me, like desperating for such a nerditude... -- BernardNotarianni

I learned Logo on Commodore 64s back in the third grade. In retrospect, that was wonderful experience: It had me thinking about recursion and subfunctions starting really early on. Ten years later, in introductory CS at university, recursion came pretty naturally to me, which I attribute to that early experience.

After graduating grade school, my family bought a CompaqPortable on which we installed one of the contemporary PC versions of Logo. I don't know why, but it was never quite the same as Commodore Logo. After trying that for a while, I switched to QuickBasic 4.0, and ended up like so many others, using TurboPascal 6.0. TurboPascal was my first real introduction to things like pointers and compiled software. To this day, I miss TurboPascal's quick compilation speed and intelligent module system.

In college, I spent most of my time (aside from a few intro courses taught in Pascal) in C++ (BorlandCeePlusPlus? 4.0), and later CommonLisp and Tcl/Tk with IncrTcl?. The CeePlusPlus experience was mainly valuable in learning how to clean up the messes I made out of inheritance structures and exceptions. Once I got that down, moving to plain, ordinary, C in a professional environment was a breath of fresh air. To this day, CommonLisp, SchemeLanguage, and CeeLanguage are the languages that stuck with me and that I still use. -- MikeSchaeffer

My first language was CeePlusPlus. I don't count my few "programs" written for the TI-85 calculator since they only consisted of single simple functions. My university used CeePlusPlus as a first language when I was a student. At least they got away from PascalLanguage. -- WillGray

The first language I wrote code in was COBOL. I never did much in it because I was about 8/9 and the column-oriented syntax was really hard to use on windows. After that I learnt lots of languages but the first one I did useful stuff in was SqueakSmalltalk, which I had a lot of fun with (I was 10). My current language I use a lot is perl I generally find it pretty easy to pick up the basics of languages, but FunctionalProgrammingLanguages really scare me and I find them really hard to grasp through online tutorials, especially as most things to do with them seem to require a degree in mathematics. Lisp I find amazingly simple though. (For the record I'm 12 now) - April 7 2005 "tombom"
Binary->Turtle->HEX->Assembly->BASIC->C++->QBASIC->C->Java->Modula3->Perl->Ruby->Python->Smalltalk->Lisp_>Scheme->ML->Self->Java->C++ (yes, I learned some languages more than once. After experiencing new languages, I became a different programmer, and had to start from scratch and re-learn the old ones from a new point of view)
The first language I ever used was Turbo Pascal, but at age 4 I didn't have the slightest clue what I was doing. That was followed by, in no particular order and thoroughly mixed with each other, Visual Basic, Turbo C++, QBASIC and Prolog.

In the last 5 years or so, I've moved on to (again, not in any kind of sequence): Java, Python (my current favorite), Haskell, Scheme, Javascript, and a tiny bit of tinkering with a few others like Ruby, Smalltalk and Scheme. I also picked up some of Common Lisp years ago from reading my parents' copies of The Little Lisper and Essential Lisp, but to this day I have never actually tried programming in it.

I also do some PHP, but I firmly refuse to classify it as a programming language (it wants to be Perl when it grows up - need I say more?)
BASIC was my first language, at the tender age of 4. I later learned Z-80 machine language (maybe 6 years old or so?), then 6502 as I progressed from the TRS-80 to the CommodoreSixtyFour. Later, I upgraded to a CommodoreAmiga?, which used the 68000 processor, where I stuck with assembly language until I could afford a C compiler. I only switched to C, by the way, because it was "cool." I was immensely productive with plain assembly language. I, to this day, still posit that C is no more productive than plain assembly. (C++ and other OO-languages, however, are demonstrably higher level and more convenient to use.)

At the same time, I was going to Mohawk Valley Community College, taking Pascal courses. Worst. Experience. Ever. (Funny, because I love Oberon.) Pascal has had a significantly negative impact on my coding; I claim that it set me back to the stone ages of programming. BASIC was positively superior to Pascal, in my experience.

From there I moved into REXX programming (since AmigaOS 2.04 came with ARexx standard), and into other programming languages, like Lisps, Haskell, Forth, etc. (in no particular order).

As far as impact on me? BASIC had zero impact on my ability to program. When I was working for a small code-monkey shop back in Utica, NY, we had to deliver a dentistry application using VisualBASIC 3. I found myself unable to implement certain control constructs in it easily, so I resorted to implementing a simple "virtual machine", where I had an array of integer "registers" (DIM I%(15) or so), floating point "registers" (DIM F(15)), etc. I also had used arrays for lots of other tasks, and had maintained "pointers" (indices) into these arrays. The result was working code. Yes, I programmed in a virtual assembly language, implemented in BASIC. It worked, it was pretty fast, and we got paid. Good times! (Unbeknownst to me, I had inadvertently re-invented the stack-base virtual machine, as each type of array had its own "base pointer," allowing me Forth-like control constructs.)

Today, I prefer to code in Forth, which also usually lacks higher-level data structuring capabilities out of the box. While I enjoy its structured programming capabilities, I still use the ColumnMajor? database approach towards representing collections of objects that I search through often, and arrays of RowMajor? structures for things which are not searched through frequently.

I've found that periodically resizing arrays is not that expensive in terms of runtime as well, especially if you grow your array by an amount that is a function of what is already in use (e.g., Fibonacci growth), and of how often it grows (the longer it's been since it grew, the less likely you'll be adding mega quantities of data to the structure, so you can cut back on the growth rate).

-- SamuelFalvo?

See the CapArray algorithm/pattern for a way to grow in chunks. This way heap isn't fragmented and memory isn't allocated continually

"Pascal has had a significantly negative impact on my coding; I claim that it set me back to the stone ages of programming. BASIC was positively superior to Pascal, in my experience."

Having looked back on both my own old line-numbered BASIC and TurboPascal programs, I find this hard to fathom. Could you expand on this? -- IanOsgood

FortranLanguage was the first programming language I learned. IBM 360 AssemblyLanguage (BAL) was the first language I used.

After exposure to 'text formatting' by using someone else's code and my pencil-marked data cards (he was doing 'picture'; I was creating statistic summaries for a weekly recreational sports league of which I was the scorekeeper), and an open high school period after dropping a required course by an instructor I often butted heads with, I headed for the high school introductory Data Processing course, which taught a wonderfully simple ML called Hypo; when I find a concrete reference, I'll add a HypoLanguage? page. Not an Assembler of any sort, 'twas all in opcodes and operands. Gave me the right frame of mind to handle everything else that's been tossed my way in the subsequent 32 years....even BASIC!

The first language I "used" was C, for a programming course at school. But considering that I learned nothing and dropped out of the class, I don't believe that counts. You can call me a Lisp acolyte.
To be quite honest it was so long ago I am not entirely sure. I remember being taken to visit a computer in Brighton and writing a program on a form, I think it was Algol. That would be before 1965 when I went to university. There I wrote programs in Fortran II for the IBM 1620. That would be in 1967. Paper tape. When I started work in 1969 we used punch cards to submit programs in Fortran. We also had an early interactive system with Basic. -- JohnFletcher
In 1981-82, I learned a little bit of BASIC on an ancient PRIME minicomputer, typing in programs from the classic 101 Computer Games on black and white terminals in my high school. Great fun, at the time. I then didn't have a computer to use until three years later, by which time the school had a room full of (already dated) Apple IIe computers, which gave me a chance to actually understand what I'd been typing in the first time through. I didn't really become a Serious Programmer until In encountered Pascal and eventually C in college, and even then it remained more of a hobby until the 1990s. - JayOsako
For me first was LogoLanguage (ObjectLogo?, on the Mac.) I might or might not have keyed in some BASIC on a TI-99/4a before that, I'm not sure. Sometimes I would type in one of the more complicated examples from a Logo book and it wouldn't work. Only later I realized this had probably been a problem of ObjectLogo? using LexicalScope where most Logos used DynamicScope. Then HyperCard came out, around 1988 or so, and would become my playground. I'm surprised there aren't more votes for HyperTalk here.

Another big influence was RoboWar?, a game where you programmed virtual robots that would try to move around on screen and kill each other. The game used a sort of stack machine assembler, like Forth without any introspection, and as a leveling mechanism each robot only could execute a fixed number of opcodes per time step. There was an annual RoboWar? tournament, all entries to be included in the next release of RoboWar? so people could see how the winners ticked and evolve their strategy. One of my Hypercard creations was a utility to translate infix math formulas into postfix, to help me write Robocode. I think it actually was trying to be a recursive-descent parser, though I didn't know that at the time.

There was the fallow period when HyperCard was clearly dying, but I couldn't clear the hurdles involved in learning "real programming" -- I got a Pascal IDE and a book about Mac programming but never made anything of it. I did do some CrudScreen type applications for people using FileMakerPro and AppleScript.

College led me through C, C++, Java, Lisp, MATLAB, a couple of assemblers. I didn't really grok Lisp until several years after I'd used it for an algorithms class. (This was about the time I looked back at Logo and realized that it was basically Lisp.)

Sometimes I wonder why things have to be so hard, when making HyperCard do things was so easy when I was only 7? - PeterMeilstrup
I started with Turbo C++ in school. Shifted to Turbo Pascal from there, then Delphi, C++ Builder, and Modula-3. Now, some C# and Java for work, lots and lots of Oxygene (a modern Object Pascal derivative for .NET).
Self taught BASIC, then (Turbo) Pascal at the High school and first year University and Fortran 95 later at the University (and later many others).


View edit of August 8, 2014 or FindPage with title or text search