Slashdot Mirror
Slashdot Asks: What Was Your First Programming Language? (stanforddaily.com)
This question was inspired by news that Stanford's computer science professor Eric Roberts will try JavaScript instead of Java in a new version of the college's introductory computer programming course. The Stanford Daily reports:
When Roberts came to Stanford in 1990, CS106A was still taught in Pascal, a programming language he described as not "clean." The department adopted the C language in 1992. When Java came out in 1995, the computer science faculty was excited to transition to the new language. Roberts wrote the textbooks, worked with other faculty members to restructure the course and assignments and introduced Java at Stanford in 2002... "Java had stabilized," Roberts said. "It was clear that many universities were going in that direction. It's 2017 now, and Java is showing its age." According to Roberts, Java was intended early on as "the language of the Internet". But now, more than a decade after the transition to Java, Javascript has taken its place as a web language.
In 2014 Python and Java were the two most commonly-taught languages at America's top universities, according to an analysis published by the Communications of the ACM. And Java still remains the most-commonly taught language in a university setting, according to a poll by the Special Interest Group on Computer Science Education. In a spreadsheet compiling the results, "Python appears 60 times, C++ 54 times, Java 84 times, and JavaScript 28 times," writes a computing professor at the Georgia Institute of Technology, adding "if Java is dying (or "showing its age"...) it's going out as the reigning champ."
I'm guessing Slashdot's readers have their own opinions about this, so share your educational experiences in the comments. What was your first programming language?
In 2014 Python and Java were the two most commonly-taught languages at America's top universities, according to an analysis published by the Communications of the ACM. And Java still remains the most-commonly taught language in a university setting, according to a poll by the Special Interest Group on Computer Science Education. In a spreadsheet compiling the results, "Python appears 60 times, C++ 54 times, Java 84 times, and JavaScript 28 times," writes a computing professor at the Georgia Institute of Technology, adding "if Java is dying (or "showing its age"...) it's going out as the reigning champ."
I'm guessing Slashdot's readers have their own opinions about this, so share your educational experiences in the comments. What was your first programming language?
Needed it for an engineering course. My first actual programming course used PL/I
20 GOTO 10
Like many from my era... It took years to undo the damage!
Had a TRS80 model 1
On punch cards
Of course.
And the binary sequence to boot the thing up. Well, that wasn't really programming. It just inputting the same thing every time we needed to boot.
Tape drives, paper tape, punched cards, etc.... Back before computers were appliances found in everyone's home or pockets.
WE were geeks! And those of us who were into sci-fi read books!
It's banana pudding day and I got to get to my walker.
Not sure that language has a name, though.
Slashdot, fix the reply notifications... You won't get away with it...
I have only used Rust. The other languages excluded me.
;D
That's the first programing language for any human.
Think of it as a complex AI-like programing process...
I also picked up Pascal and C shortly thereafter. C stuck, Pascal didn't. I seem to remember learning COBOL and PL/I at some point, along with a bit of fortran.
I've learned so many languages over the years, that I've lost count. Right now I have active projects going in C, HTML5/Javascript, and Python. It's gotten to the point where another language isn't a big deal: it's more about learning libraries than the language itself.
Java ranks near the top of my list in languages I prefer not to program in if I can avoid it.
It's hard to ignore it when it's embedded in the computer boot ROM
On a vic20 and C64.
JavaScript, then PHP, SQL, then python, then C++
True millennial
Atari BASIC, then Modula-2.
Still lives today. In its pure form it's fast as hell
As a 6 year old I started to teach myself BASIC on a Sharp MZ-80A. Many years later I learned Pascal at school.
Fortran 4 written in neat block capitals on Fortran coding sheets. There weren't enough card punch machines to go round.
First computer was an RCA VIP, January 1977 (the TRS-80 and Apple ][ hadn't been introduced yet). To program the VIP, you flipped the RUN/RESET switch up while holding the 'C' key on the hex heypad, then '0' to write memory, then the four-digit address, then entered your hex codes. You had better have written your program out on paper ahead of time. Clear screen was 00E0. After awhile you could read programs just by looking at the hexdump. A lost art.
Sinclair Basic on a zx80
I started (but didn't finish - ended up switching to a mathematics degree) a mechatronics engineering degree. The progression at my uni went assembly, C, Java, Python, C++, and now I'm working full-time as a C++ developer.
Having an interpreter appear automatically when you press ctrl-C while playing a game is pretty nice. Too bad that things are less accessible that way today.
Avantgarde Hebrew science fiction
Sinclair ZX Spectrum BASIC, specifically. Self-taught from the book that came with every Spectrum.
Later came Pascal (in college), then after a semester of Pascal they switched to C, skipping the basics of C to go straight into second-semester concepts. That spoiled programming for me for a long time.
These days it's XSLT, Windows cmd, Autohotkey and the occasional bit of Python in a mostly non-programming job.
I still have the deck of cards... A simple system usage reporting program for NCR's B3 operating system. 1978.
My first language was Fortran on an IBM 1620. I rapidly switched to assembly language since the computers in those days had such limited speed and memory that assembler was usually crucial for performance. But the issue raised is what SHOULD be the first language taught. For years I've advocated Kernighan and Ritchie as the book to learn C for this reason: the examples all show efficient code. It is not subtly teaching bad practice by showing loops that are overly complicated inside because the variable were set up wrong, etc.
I like Python better than C these days but I'm not aware of a similar introductory text. I love Dive Into, but it is not an introductory text.
When I grew up the C64 had Basic built into the CLI, so that was the obvious way to start experimenting. But when I later moved over to x86 architecture things started to get a bit messy. I had a short fling with QuickBasic, but quickly needed something more advanced and moved to TurboPascal for a while. Needing more speed I then overcompensated going full x86 asm, which was fun and very helpful for my later career in terms of experience and understanding the hardware. But not very productive, so C/C++ became the middle ground. And there I have stayed since.
On a Sharp PC 1500A.
VB6, then PHP, then Delphi 7, then Java, then C#, then C++
Born in the 90ties, don't judge.
BASIC was first. Closely followed by Pascal and Machine Language (I didn't have an assembler so I coded my Apple //e in raw hexadecimal). I enjoyed learning all 3 of those.
After that was COBOL which I absolutely hated.
C for servers and tools, c++ for web applications (using libwt).
I would use C alone if there were a web framework for it.
Sent as ripples into the electromagnetic field. No single photon has been harmed in the process.
Started learning with SmartBASIC on an Adam/Coleco. Moved up to Apple's Basic on the Apple IIGS, then Apple Assembler.
When I got a PC, I did some BASIC, then moved on to PASCAL (and took some formal PASCAL classes in high-school), then C++ in college. Learned Perl along the way. Picked up Java at my first job out of college. My second job out of college I learned ActionScript. Now days I do mostly Java and C++.
I really hope they continue to teach a typeful language. Learning things like memory management, threading, etc. are all important in CS classes. These are the things that will make a developer much more rounded -- instead of chasing the latest hot language.
30 goto 20
20 goto 40
50 goto 30
60 print "HELLO BASIC, OLD FRIEND!"
Huh. Why doesn't my program work?
In all seriousness, I started with BASIC at home and later did a bit with it in middle school. High school was Pascal based, and my university started with C. (There were many languages in between, but since the summary is focusing on schooling ...)
I still remember the frustration.
Many thanks to a progressive Dutch primary education system.
Human Rights, Article 12: Freedom from Interference with Privacy, Family, Home and Correspondence
LOGO. Grade school, I think fourth or fifth grade. Version horribly translated in my language.
My first program:
Hell Segmentation fault
Trust
BASIC - '84
LOGO - '85
Pascal - '91ish
C, and many others - 92ish
65C816 assembly - '93
Pascal in AP comp sci - '95
When I was a kid I had exposure to Basic and LOGO and a few other things but the first real programming I actually did would have been in Pascal (Turbo Pascal 6 if I remember correctly). These days most of my coding is in C and C++.
The most obscure thing I have ever programmed in would probably be assembly language for the 65816 CPU (an enhanced 16 bit version of the famous 6502 CPU). The main claim to fame for the 65816 was as the CPU in the Apple IIGS and also the CPU in the Super Nintendo (SNES ROM hacking is where I learned 65816 ASM)
There are two separate questions with different answers brought up here:
For me:
It's psychosomatic. You need a lobotomy. I'll get a saw.
I toyed around with a little Applescript on the family's computer when I was a kid, but the first real programming language I was introduced to was QBasic in a computer class in 7th grade.
I wrote my first code at high school in about 1976 in Fortran.
There were no computers at school so the code was written by shading in little ovals on each of a stack of cards using a soft pencil. The cards were sent to a college that had a mainframe. The cards were read and used to generate a stack of punched cards that were returned the next day. You then inspected the cards to see if they correctly coded what you wanted them to code. If not the card was "edited" by covering incorrect holes with tape and punching new ones with a hand held punch. The cards were then sent back overnight to be re-read, and this time an attempt at compilation and execution was made. If you were lucky you got a printout from a line printer with the result of your code. If you were unlucky there was a syntax error and the cards had to be re-edited. Running "Hello World" could take several days with each step of the process requiring sending the cards to the college and getting the results back the next day.
The first languages which I used to write properly-speaking programs were C and C++, when studying mechanical engineering at the university. Theoretically, I firstly used Basic in high school, but what we were doing back then cannot be called programming. My career as a programmer started some years later working as a mechanical engineer and with Fortran.
Custom Solvers 2.0 = Alvaro Carballo Garcia = varocarbas.
Focal-11 loaded from paper tape was my first home programming language. But before that I had shredded 80 column cards coding Fortran IV on the Watfour IBM 360 environment.
https://en.wikipedia.org/wiki/... But I quickly switched to Basic as that was the language in all the magazines.
.. of course. Such a clean and slick language, that made fumbling with the PCs-hardware very easy.
I use it till today to talk to the ISA/TTL Bus on DOS.
Locomotive Software BASIC
Z80 assembler
Then I turned 11 and went to a school with these weird RM Nimbus things that could do
GWBASIC then QBASIC
MS Word 2 macro language
Visual Basic
Then I went to college that had TurboC++ and genuine 286 and 386's and learned x86 real mode assembler :D
C That says it all had to add this nonsens because of posting filter
nix is very simple, but it takes a genius to understand the simplicity. (Dennis Ritchie) ~
A great thing to be able to type all commands with a simple keypress and more than enough computing power for reasonable computing needs. But I quickly evolved to Commodore Plus4 Basic, very similar C64 Basic except that all system-internal Peeks and Pokes were different. After that, TurboPascal, Prolog, CommonLisp, etc.
On a Heathkit H-89 I built with my Dad. He paid $150 for the extra 8K of memory to get 64K so my programs had some memory. Good memories...
It must show my age. First language 6502 assembly. Second language 8080/Z80 assembly.
My second computer was A500 and I was keen to learn how to make games; short text-based adventure games resulted.
I started with 6800 machine code as I was using a Motorola D2 copy I had build and it had hex key pad for input and 6 digit 7seg LED display for output, so it was not like you could use something fancy like an assembler.
I first learn BASIC on a TRS-80 clone, then moved to my own ZX81 clone, where I started programming Z-80 assembly. After a few years, I upgraded to a MSX computer, where I learned Pascal and C. The most important thing I learned was algorithms and data structures. BASIC in those three platforms are so different, that, unless you understood the algorithms, porting programs was not straight forward.
The Bell Floating Point interpreter for the IBM 650 in the basement of Encina Hall at Stanford, 1958. A three-address code (A op B goes to C), the manual was printed on the back of the coding form. As a night operator, one night I ran all the assigned jubs and then wrote a program to calulate a Fibonacci sequence and nver looked back.
On punch cards. We had to post them from our country school to a data center in the nearest town (Invercargill) who would run them and post the output back. Turn around for bug fixes was a week.
This would probably directly related to the first language. Or rather - when (which year) did you write the first line of code?
Which language is appropriate to learn the basics? It depends on what the basics are.
- Java and other high level languages are horrible for learning, because it includes solutions for nearly every software problem. This makes it nearly impossible to learn the whole language (with all its standard packages), on the other hand the learning experience doesn't provide much basic knowledge
- On the other extreme end C (or any for for native assembly) have too many quirks distracting from the basics CS topics, and lack higher language constructs
There's no middle-ground. Maybe the correct option for education purposes is to use some high level language, and prohibit use of standard libraries (possibly except interface definitions). At least as long as the purpose of education is to create an understanding of what's going on below, and not to create worker drones who can put some pieces of software together without understanding what they are doing.
FORTRAN was offered only to engineering students; everyone else took PL/1
Geology - it's not rocket science; it's rock science
The other languages are for pussies.
8080 ASM But of course I only wrote software on paper as it would be several years before I could get a machine to actually, you know, run it.
Summer school course at Wellesley Middle School. A Teletype connection to BBN in Cambridge. I would have been 15.
Basic, then Pascal. This was in last centuries 90s
Fortran II on an IBM 6020, puched cards; then IBM 7044 also punched cards. On microcomputers, Altair 8800, I used
8080 Assembler, Z80 Assembler, Altair Mits BASIC (by Bill Gates), then dBase II under cp/m 1.4 and 2.2. Those
were the days, noisy machines, teletypes, chain printers (scary!), and *lots* of blinking lights: incandescents too,
not LED's like later. Today I use mostly Bash Scripting with extensions for hardware manipulation.
A quick comment on BASIC. The disadvantage of Basic is sphagetti code due to GOTO's. The Advantage of
Basic is that it *has* GOTO statements. If you want to try some real sphagetti code, try 8080 assembler! But
both *can* be elegant.
MSX Basic Version 1.0
Copyright 1983 by Microsoft
CRT terminals were still in the future. Later; FORTRAN, PDP-11 machine code, Forth, and various flavors of assembly language. It was really a big deal when Turbo Pascal was released.
09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0
I fist learned various flavors of BASIC on a TRS MC-10, then TRS CoCo, Apple ][+ and ][e. I was very proficient with various interactions of MacroWorks, (Super, Ultra) by Beagle Bros. within AppleWorks and HyperText in HyperCard on my Mac SE/30. Then Fortran on the university mainframe, Pascal on the PC, C on the AT&T Unix PC. My formal education stopped there. I still play, but 25 years later don't program for a living, but would love to pick up Swift when it's a but more implemented.
I learned programming at university using the FORTRAN language, picked up Basic on my own later when one of the engineering profs bought a Data General Nova on his own dime so we'd get some "minicomputer" experience. But my first job required assembly programming on a military Univac 1218. I loved that thing (then), because it was so computery: every register was displayed on the front panel and you could set/clear the bits by pushing the light button, and when it ran, they all flashed. Very very cool. Programmed the thing with punched cards. The assembler was multipass, dumping the cards off to 9-inch reels of mag tape (also very computery) and making the passes through that. So the whole experience was this blinking, tape spinning, card reading, huge printer printing experience and DEAR GOD IT WAS BEAUTIFUL. It was like I had stepped into a '50s era scifi movie and it was all in my control, mwaaaaahahahaha. So, you know, just your average day in paradise for an engineering newbie.
8080/z80 assembler, like all the kool kids in 1978....
It simply refuses to die.. even when it's dead.
John_Chalisque
Apple Soft Basic, only messed around with INTEGER Basic to 'patch' some games. ... still on an Apple ][, never relly understood that types basically were completely ignored, error messsages were a pain in the ass. But I learned about the tool chain you need(ed) for 'real programming'. ... ... never seriously used it and have forgotten everything. :) as I e.g. did P/L1 and COBOL in Y2k reengineering, but never learned enough of them to write a program from scratch.
6502 assembly and Sweet 16
Atztec C
Pascal, then Modula 2
Then around 1988, 'better C' (wrote some GUI stuff in C for OpenView connecting some Prolog programs to each other)
Quickly later I switched from Pascal on Macs to a subset of C++ (Think C, later bought by Symantec) and to CFront based C++ on Suns.
Around that time I worked mainly in Unix, with various shells and Perl. On the Mac I learned 68k assembly, because I always thought I could make the Think C virtual message dispatch faster
Because of study requirements I learned Prolog and Lisp and SQL.
Later SPARC and PowerPC assembly
Then Acorn Risc basic on my Archimedes, and ARM assembly (that opcode set I really like, and ofc. 68k is such a nice architecture)
On PC I switched to Borland and Symantec C++, on Macs I sticked to Think C/Symantec C++, on Unix I mainly was working on scripts.
Meanwhile my 'private' programming is mainly Groovy and a bit Scala. My professional programming is usually Java.
I guess I forgot plenty of languages
Of course I did lots with HyperCard / AppleScript.
For beginners I think Groovy and Python are excellent languages. Java I would probably only teach with stuff like Blue/J. And: there is still 'Free Pascal'. Pascal is probably the best language for teaching that ever was invented!
When I have a bit free time I will start learning Swift and make some small Apps, that I have ideling in my mind since quite some time.
Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
I started to teach myself programming in high school around 1992. The used computer I got from a university student came with the TopSpeed Modula-2 environment, so I started using that. It was really nice, and gave good foundation for programming.
https://en.wikipedia.org/wiki/Modula-2
Fortran IV, followed by Algol, then Basic, then Assembly. By that time I realized I wasn't cut out to be a programmer and went on to better things.
Comal 80 in the 80's
on a PDP-11
My UID is prime!
ZX Basic (on a Spectrum) and then straight to Fortran at University
Should have been C or assembly. They way I was taught, which is how I think it should be taught, you start with transistors and work your way up. Logic gates, circuits, integrated circuits, assembly, compilers, high-level languages. C lets you see how the language is integrating to the hardware below it. You have registers, heap memory and a stack, interrupts, pointer arithmetic. Python et al are all just theory. C is reality. From there, you can move up to learning high-level things.
I'm not saying C is the best language. I'm saying it's the best first language.
It came on the Amstrad CPC, and you needed to type commands like run"monty just to run your games. Magazines had type-ins and 'pokes' and so on.Back then there was nowhere to hide from the need to at least know how to type 10 print "hello"... 20 goto 10... run.
John_Chalisque
Filling out bubble cards for an IBM 1160 - ca. 1977. Program printouts came back two days later.
Teacher was a drunk the administration couldn't fire, most kids used the class to a) socialize or b) make pictures out of different letters. I remember a particularly impressive Corvette logo.
My proudest achievement was figuring out how to program multiplication/division as repeated addition/subtraction. All by myself, just using the manual.
Mimetics Inc. Twitter
Yep. It was the PC before PCs were an option. Many a program was re-typed into its volatile memory.
Then Fortran IV, Fairchild F8 Assembler, Data General Basic, ICL 1904 Assembler, M6800 Assembler, Algol 68. I was spared COBOL, thank the deities.
I think it was Compute! magazine that had BASIC program source code printed in their issues. I could hardly wait for the next issue to come in so I could write each line of code verbatim to see what the program did. Of course my father was with me and encouraged me; I even remember him pointing out bugs with a red highlighter in the magazine.
And then I'd proceed to randomly change and delete code just to see what would happen next :)
6502 on the C64 followed by 68000 on the Amiga and Atari ST. Cracking games and the demo scene. First high level language was Pascal followed by C and Modula 2. Later C on Macintosh (MPW) & c++ on NeXTStep along with Objective-C. Now I'm doing C++ on Linux.
My 1st language was assembler in the 80's Sinclair ZX line (mainly ZX Spectrum 48k). Back on the time, i used count t-states (cpu cycles) and manual optimize assembler code. Good times prior internet and even modems where we exchanged assembler routines via normal post mail letters.. like heavy letters every 4 weeks or so, side by side with "almost girl friend" flirt letter.. oh good times when coming home after school wondering for new mail responses :D
Anyway, back to topic i was lucky to start down bottom with assembler and then kept going up in abstraction.. i would risk suggesting its a good best practice no matter how fast is hardware or how much elasticity exists in parallel processing of data like with hadoop... in the end deep bottom everything still relies in pretty simple and basic constructs. Good Day everyone.
Basic. Dartmouth Basic. (At school on an interactive terminal to a Prime 300 IIRC)
Fortran (At school. On punch cards fed to some IBM mainframe in the basement.)
Intel 8080 assembler (At school, IMSAI 8080 running MP/M)
Fortran (At work, PDP-11 running RSX-11M)
Macro-11 (At work, PDP-11
Pascal (At Work, in service class)
At some point I heard about C and got "The C programming Language" and started to learn that. I've used that for more projects in the ensuing 30+ years than anything else. Along the way I also learned/used Java, C++, and I'm now learning Go. I've scripted with sh/bash, Rexx, Perl, Python. I've dabbled with a few others like Rust, TCP, PHP and probably others I've forgotten.
Changed my major to CS in 1974; my first CS class (BYU), we started with a IBM 360 pseudo-machine code (on punched cards) and then moved on to actual 360 assembly (also on punched cards). Later in the semester, we had to buy a FORTRAN text (which I still have), teach ourselves FORTRAN, and pass a proficiency test. (My professor for that class was Dr Alan Ashton, who would end up being on of the co-authors of Word Perfect. Great teacher.)
At the same time, I started working part time for a computer-assisted translation research project on campus that was using PL/1; my first task was doing data entry of Spanish vocabulary, but I bought a text on PL/1 and started teaching myself.
I'd actually had some brief exposure to BASIC a few years earlier, but not enough to claim it was my first language.
Bruce F. Webster (brucefwebster.com)
Growing up near the college, they had free accounts. My High School had a teletype & modem.
Later, my school got Commodore CBM/PET systems.
We also had a SuperPet. It had APL, Interpreted Pascal which I tried. It had Fortran, Cobol and 6809 Basic which I didn't try.
I had an Apple ][+ and did lots of Basic, some assembly and Apple Pascal with the built in Bugger. Simply recompiling would sometimes clear up errors.
In college, I learned Fortran (MS and Vax) and dabbled with Turbo Pascal. After college, C, shell scripting, perl, Lex, DOS Batch.
Most recently, Python. As a sysadmin/devops, it's all shell and python nowadays.
For a few years HyperTalk (the programming language of HyperCard) and a single reference book was my only contact with programming.
...an interpreted version of Fortran for the IBM 1620. The machine had 10K BCD digits plus the deluxe 10K add-on; the interpreter took up 15K of that, so you had 5K for your program. I/O was on cards or a console typewriter.
We also had a compiler for Fortran IV.
I started with BASIC on a Commodore Vic-20 and P.E.T. then moved on to assembly on a Commodore C-64 (thank you Jim Butterworth for your two books). After that, I programmed in Pascal, C and Visual Basic dependent on what I needed to get done and how much time I needed to dedicate to it.
I started learning BASIC in the summer time with a Timex 2048, in the autumn a TRS-80 at school, by november BASIC in XTs, and December went full head down on Z80 assembly.
PDP-8 asm hand assembled and entered on front panel. I had access to a PDP-8 but no tty. Painful, but a good way to learn the basics.
My first programming language was a version of basic (interpreter builtin ROM) on a 8 bit ZX Spectrum clone.
Or Turbo Pascal in CP/M as OS, on a 5" floppy disk. Actually was a nice programming environment for this days in 1991s, for educational/learning purpose and pretty flexible for a home computer.
Well, I must be REALLY old then. APL was the first language I learned, the most powerfull mathematical computer language in the 60's. It was decades ahead of its time. I remember, when I started getting familiar with other langauges like FORTRAN or BASIC, thinking how primitive those were compared to APL. Landed my first IT job in the 80's because of my APL skills which were very rare and in demand in the research job I was applying for.
My first programming language was Fortran IV, along with Control Data assembly and Algol 60 in a one semester course in 1964. I think the Fortran was covered first. I remember the punch cards well! But, hey, four years later they had terminals on campus--teletype terminals, and you could save your code on teletype tape. God I'm old!
PL/I as part of CS 1 & CS 2 as an undergrad in the late 1970's on Amdahl System 360 clone. Punched cards, green & white striped 132 column printouts. One-day turnaround to submit, compile, run, get output. Then on to PDP-11 Macro-11, MOS Technology 6502 assembler, COBOL, Pascal, Xerox Interlisp-D, C, C++, Python, Ruby, JavaScript, Objective-C, Swift, etc.
Retired software developer developing neural-net related software in Swift just for the hell of it.
yeah, I'm that old
Apple Basic.
Ahh, 'twere good times.
Even though I didn't actually take the course, my HS (in 1970-73) had a course called "Computer Math". The language was APL, we had a selectric typewriter and a 300 baud acoustic-coupled modem, and it connected to a System 360 at a university in the next town. I was obsessed with it .. along with a friend (who actually took the course and had credentials I could borrow) we used to sneak into the university computer lab so we could use the VDT instead ..
Weirdly enough, I currently program in a language derived from APL (k3 from kx systems)
1970, my high school had a Teletype model 33 connected to the timeshare mainframe at the local university. I was on my own with absolutely minimal documentation. Learned bad habits that took years to break.
FORTRAN, followed by Algol.
Yet Another Web Site
Intel 8088/8086 assembly
Starting with the Vic20 and BASIC, then on to my first C64 for more of the same,
. I also needed assembly for speed and low level drive routines for the first BBS. Next was the Amiga where I learned ARex because I didn't have money for a compiler and the magazines I had didn't have one I could readily type in.
In highschool they had two labs and one creepy guy with a Shemp haircut who taught in them, so I took Fortran in the Apple IIe lab because it wasn't typing on the PC Jr. I aced that class and skipped most of the sessions to chat up girls in other rooms, so 1st base was important here. After that I taught myself C while running Netware 2.1 which had to be run on top of OS2, because the cheapskate I worked for would not but a second workstation to run a client for Netware.
After that, I learned VB, C++ and ladder logic in my first real engineering job working for Siemens. So, it seems like a decade of firsts...
As 7th grader found Florida State University's PLATO system and learned TUTOR. First program was a frog icon (bitmap) that jumped to the location where you touched on the touch screen. Spent the next 6 years running to the university after school and staying until midnight when they shut it down.
Basic...in high school, circa 1973, on teletypes, with acoustic modems and paper tape.
FORTRAN... the first language I was taught in CS when I decided it was time to get out of working on hardware...around '84
Pascal... intermediate CS
C...one of my last CS classes
C++...at work in the late 90s
PHB...when I was pushed into management
Just another day in Paradise
I started my bachelors in Electrical Engineering having never programmed a line of code in my life.
One of our first classes was in VHDL and digital design, even before any other programming languages.
I have to say, I really can't recommend that as an introduction. My second language was Java, and needless to say I was not impressed with programming. To me at that point it seemed mostly like magic. It wasn't until I learned C for some embedded class that I began to actually understand programming (and Java). And although VHDL is a mess, I have to say that projects at work that involve hardware design in VHDL are some of my favorite. I never use Java anymore though. Only C and VHDL, and the occasional C++, mostly when doing code review.
At Griffith Uni (Australia) in the 70's: MIDITRAN, a cut down version of FORTRAN written on mark sensed cards with a B2 pencil.
It was run remotely at another University (Queensland Uni) that had the states only academic computer (a PDP 10).
When my University got its own computer (gasp!), elevated to the luxury of full FORTRAN on punched
cards, but could only get time on the Uni's only punch card machine at 2:00 am.
When PCs were invented, C and Assembler, both good for bit packing EVERYTHING, to fit in the available 640k of memory that shared the operating system and compiler.
In those days we knew how to CODE.
Now get off my lawn.
In 1966 my high school offered a computer programming class. Although we had a FORTRAN, compiler the class they offered was IBM 1401SPS. The instructor was one chapter ahead, at best, and his knowledge was so little he could not explain that when the Move data instruction was used the data was still in its original place also. The computer we used was an IBM 1620. Punch cards of course.
The class was enough to whet my appetite and I made my career working with computers. I first worked in H/W maintenance, then as a programmer (assembly and FORTRAN). My introduction to UNIX was in 1983. Then I spent 8 years in mini-computer sales as a pre-sales engineer and finally as a UNIX sysadmin. My first internet experience was in 1988. There certainly have been a lot of changes in the last 40+ years.
BASIC, then Pascal.
BASIC on a TRS-80 MC10. When teaching myself how to program using the "BASIC Games for All Computers" type of books, Radio Shack actually had knowledgable employees who taught me what a function is, and how to translate DEF FN to something useful in its version of BASIC. As an elementary school kid, I had no idea that functions were a "math thing" until probably high school.
Later, BASIC on my C=128, some 8502 assembly just to speed things up, then Turbo Pascal once I got into the PC world. Later, C/C++/Objective-C, dabble in Ruby when necessary, dabble in Javascript when forced to, and was never interested in Java. Oh, and AppleScript. God, I hate you AppleScript, but sometimes you're a necessary evil. Played with PHP for a while.
--Jim (me)
My high school got a Wang 360 programmable calculator. Programs were punched into IBM Port-a-punch (hanging chad fame) cards. My project was Barrowman's equations to compute the center of pressure of a model rocket. My first conventional language was FORTRAN on an IBM 1620, then machine language for that machine. 4900796 Then 1401 Autocoder, playtoy Lisp, 360 assembler, Pl
...and then BASIC.
Though I did dabble with a bit of BASIC to get the hang of things before that, but ditched it pretty quickly. I suppose my first real "language" was Turbo Pascal quite a bit later.
First computer without external storage. Had to make the balloon dance around the screen the hard way.
Then assembler and C
Kind of like Latin, except not as current.
BASIC, the some machine-level cose. First programming class was FORTRAN. Still program in C.
Lets see, first came Basic on an Apple ][, them 6502 Assembly followed by Fortran, Varian-620 Assembly. Then along the way I learned Pascal the hard way - I was given a task to write a process in Basic, but I felt that it would be better done in Pascal - and it succeeded. Ok, after that dBase3, C, then the interpreted languages (awk, php, perl,,,) and DEC Assembly. Now I mainly use C for serious stuff.
APL\360 (Fairfield University, 1969). This was after some 1620 assembly and WANG 300 calculator programming.
Earliest language (high school): BASIC, operating on a time-shared (Honeywell?) minicomputer using punch-tape program storage and a teletype for input / output.
Earliest college language: FORTRAN on a time-shared CDC Cyber. Initially wrote software using a teletype on IBM punchcards, then stood in line to pick up my output from a high-speed line printer. It was quite the thrill the first time I was able to sit down at a VDT and type / run / save my software using a video interface.
Earliest application programming as an engineer: REXX and APL. Three guesses who I was working for. I still look back fondly at APL; it put you in a very different mindset while programming, as opposed to standard structured languages.
Was ZX Spectrum Basic, followed by Z80 Assembly.
The rest is history...
It was BASIC, then Pascal, then C. Perl when I was older, nowadays it's Node.
Specifically, WATFIV and ALGOLW at CMU. I was exposed to Basic early on but never had any opportunity to write anything in it. A couple semesters before I got there, they were starting students out on PLAGO (a reduced PL/I for student use that attempted to do fancy error detection and correction), but they left PL/I behind for Fortran. Very shortly afterwards, I got into PDP-8 assembly.
I first learned to program on an Apple ][e at school; was ecstatic when we got one at home. Technically this was after being taught Apple Logo, but I don't consider that my first language.
In Middle school I still remember learning IF PEEK(-16384)>127 THEN a key was pressed; the most important statement in moving from prompt based games to action based games. (Another good one POKE(49200) for a "click" through the speaker).
In High school I learned about Beagle Bros. and their BASIC compiler; running some of my games 10 times after... really allowing me to make something fun.
http://beagle.applearchives.co...
Eventually that gave way to Turbo Pascal, which gave way to C++.
The fortran 77 compiler failed to compile your card deck for two reasons:
1) the instructions were not 7 spaces from the right margin
2) it's written in basic and this is a fortran compiler.
Some drink at the fountain of knowledge. Others just gargle.
Texas Instruments basic to be exact. First taught language was pascal.
Autocoder
Then Pascal -> Turbo Pascal, VB, C, etc, etc, etc.
I self-taught myself Basic, followed by RBase / DBase, if those can be considered proper languages. My first college level language course was COBOL, of which I remember the formatting, but no syntax. C is still my favorite, mainly because it's so simple and powerful, but sadly it's rarely practical anymore. Golang is my second favorite.
Good people do not need laws to tell them to act responsibly, while bad people will find a way around the laws-Plato
EDSAC 2 had vacuum tubes for logic and mercury delay lines for memory. The programming course was taught by Maurice Wilkes in an auditorium to several hundred undergraduates, using a very bad PA system. I persuaded my Physics practical supervisor to let me use EDSAC to perform simple calculations on my experiment results and I wrote my first program in 1963 or 1964. [I was studying Maths and Physics because there were no Computer Science degrees back then.]
After that, during my PhD, I learned machine code for the Digital PDP-8, a lovely little machine, and used it to drive my experiment hardware and collect results. I also learned PDP-8 Fortran, which was so stripped down it did not even have subroutines, and Algol 60 to use the Maths department's IBM 1620.
Over my career I have had to be promiscuous about programming languages: POP-2, LISP, PROLOG , POP-11, Pascal, Java, C, C++, Basic(!), Javascript...
C64, Merlin assembler and Jim Butterworth book.
Very similar to Vaporators, in most respects.
Atari BASIC and the book by Bob Albrecht, LeRoy Finkel, and Jerald R. Brown. Don't remember if I had
the cassette "mass storage" device right off the bat, but I eventually did get the tape drive. If you
had an error trying to read something, it just aborted the entire operation. After loosing several things
to the write-only device, I purchased an 810 floppy disk drive. Never looked back to the cassette drive,
although the 810 had a "habit" of mangling the spindle hole if you weren't careful about closing the door
after you inserted the floppy, somewhat slow transfer speed, and some of its own reliability issues as well.
Good times...
Because BASIC was so limited, I got interested in 6502 assembler soon after that. Mr Zaks was my inspiration.
Pointers (in zero-page) were difficult for me to wrap my head around, as well as the (adr),Y and (adr,X) differences.
But once I got 'em, there was little stopping me. I eventually wrote a macro assembler / editor and it was
sold through Bill Wilkinson's company, O.S.S (more great times as I went to work for them later).
I wrote the assembler because I wanted to write a game (my original purpose for buying a computer in the first place),
but to this day, have never written a game for publication (wrote bunch of other things through my career).
Eventually, learned C in an Unix environment: SQL; shell scripting; PHP; Python; etc.
CAP === 'expertly'
When I arrived at Stanford in 1963, three computer languages were being taught: IBM 7090 assembly language, FORTRAN for the IBM 7090, and Algol 60, as implemented on the Burroughs B-5000. I learned all three, and taught myself DEC PDP-1 assembly language.
FORTRAN as well, '66 for an IBM1401 (only arithmetic IF) at HighSchool. Later WATFIV (uWaterloo Fortran IV) on a '370.
I still miss the IMPLIED DOLOOPS for READ/WRITE() -- load or dump pages of an array with one statement&fmt. And FORTRAN is said to have poor I/O :)
ALGOL58 - Electrodata B204 Datatron (a base 10 machine!), machine language at the same time. The compiler was written by Don Knuth,
I can still remember spending many days reading and re-reading parts of "The Scelbi/Byte Primer", trying to understand the source listings. When I finally understood how a processor actually works, everything suddenly snapped into focus.
No, actually it was IBM 1410 Fortran I.
Like everybody else my age.
BASIC on a Sinclair ZX81, followed by Z80, 6502 on a Commodore 16 (they were cheap), then 68000 on an Amiga. From there it was C/C++, Perl, Java, Javascript, Python, C#, bunch-of-other-stuff. Best days? 68000 assembly on the Amiga - translating C into assembler as the C compiler was too darn expensive.
My first programming language was Atari BASIC. It was okay.
I then fiddles with Visual Basic on an XT. After that it was perl for a couple of years, and then PHP. For all its warts and shortcomings, PHP has made me a mountain of cash over the years. Sneer all you want, but PHP has made my house payment for 15+ years as well as paying for cars and food and toys and vacations abroad.
Please feel free to tell me how terrible PHP is, as I get a warm, satisfying feeling inside whenever I hear people bitterly criticizing PHP. It's like hearing people complain that the really cute girl I'm banging is wearing shoes they don't like. Guess what? I'm not dating her for the shoes, lol. :)
Just cruising through this digital world at 33 1/3 rpm...
A made-up teaching language (because it was 'pure and simple') in the late 60's at U of T (Toronto). Like many, my first real language was FORTRAN.
BASIC on a north star computer..then on an Apple 2. Then pascal on an apple. Then Fortran on DEC then forth on mac, and then C
Which was a JOSS-like interpreter for the PDP-8. The first thing I ever did non-trivial work in was probably Scheme. The first professional programming I did was in Ratfor -- a C-like language which transcompiled to Fortran IV.
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
I learned FORTRAN 66 (or FORTRAN 4 - can't quite remember) in 1975 when I was 36 years old. The class was offered by the School of Business and run on a CDC 6500 60 bit computer. Input was punch cards ander the cycle was: punch the cards for code being really careful to keep them in order; sandwich the cards between the CDC control language cards, wrap with rubber bands and drop in an input window; after 45 minutes to a couple of hours time later start checking for output consisting of the printer output wrapped around the cards; correct errors; and repeat the cycle.
I learned quite quickly that the lab was almost empty at 10 PM so I got in the habit of doing my homework at night. I made friends with the operator and learned how to operate the machine which had 5 MB disk drives that were larger than my washing machine. IIRC it had 64 MB of memory and that 32 MB were available to the user. The printers were really, really fast and someone had wired a speaker to some part of the CPU so one could differentiate sounds and sometimes discern what tasks it was doing.
Later that semester a time sharing system was set up and I switched to using a teletype for input and then used it for class but the FORTRAN was a little different, I taught myself BASIC at that time as well.
One other thing I remembered was that most of the students, I think they were actually in the School of Business, had a really hard time 'getting it'. I used to compose my homework while the instructor was answering their questions.
It was 'spaghetti' programming at its worst.
Nate
On the Commodore PET. On the BBC Micro not long after.
Max.
Atari BASIC, then QBasic, then Visual Basic. Then in college C++. Post-college, PHP and Javascript.
This space intentionally left blank
It was in 1984 using Commodore 64's fabulous BASIC. Then I got my hands on Simons' BASIC. The highlights of those days were:
1) I did a quiz program that drew a flag and asked what country it belonged to. I measured the dimensions of the flags from a 18-part encyclopedia with a ruler. I also created, with trial and error, subroutines to draw stars (eg. pentagon, 15-gon). The colours were approximations, of course.
2) I figured out how to create an equal temperament tuning, and created arrays of the relevant C=64 POKE addresses so I could enter notes like index,duration,index,duration in DATA and READ it in and so make three-voice tunes.
Afterwards I got acquainted with Amiga BASIC, AMOS, Pascal (only very little), Perl and Bash, and then VBA...
I'm not a professional programmer.
Wordbasic in MS Word 6.0. Created a slot machine type poker game in it with handdrawn cards in ms paint, when I was 14.
or Langage Symbolique d'Enseignement in French.
Borrowing elements from Basic (Goto) and Pascal (procedures, "répéter...jusqu'à" or do...while)
A very interesting language that definitely started my passion for programming.
The language was developed by the French school Supelec at the request of the French Ministry of Edutation [https://fr.wikipedia.org/wiki/LSE_(langage)].
Algol on the Atlas computer of London University, 1964.
Then Pascal and finally settled on Fortran II and then IV for several years on IBM machines.
Can't remember the first workstation or the version of Fortran, in 1982.
With all of these I was earning a living.
From about 1980 or so, Sinclair Basic, a spaghetti languange, no structure but a lot of fun.
Apple Basic for the IIIG or GII, nice and easy, earning a living again
By 1985 switched to Lotus 123 for work and then Excel. More efficient for work
Visual Basic for building a neural network, for fun
Foxpro database development, earning a living again, 1998
Back to Excel and no more programming because it's a hard way to make a living.
Was my first thought, but then I remembered that in order to do anything in BASIC, the machine actually has to be running.
Booting the PDP-11 involved learning a series of binary codes which had to be entered by way of a bank of large toggle switches.
The codes literally told the machine about itself - addresses of disks, etc., so it could find everything it needed.
Once the last switch was set to the proper state, only then would the machine boot and be usable.
So I guess my first programming language was some sort of DEC ML, entered in binary.
Ti-35 Calculator. I programmed it to calculate moles for HS Chemistry.
A semester later, I was in a computer science class there learning TRS-80 BASIC, then FORTRAN66 the following semester.
Then off to college as an engineering student, but we didn't use computers at the time. Still used my Ti-35 that first year. Transferred to a better, top 10 engineering school and got an HP-55 calculator and started learning WatFOR on the university's CDC mainframes.
in high school, then FORTRAN in college.
I am an engineer and used discrete components and latter RTL, TTL, and CMOS chips long before the 4004 was even thought of. Although these "computers" ran only one "program" which was hard wired into them they used the same laws of logic and Boolean algebra that latter software programmable computers used, I have always thought of solder as my first programming language.
However, I have also written code in the following languages in roughly chronological order. Algol 60, PDP 8 assembler, Fortran, CDP-1802 op codes (hand assembled to Hex), C, Perl and probably a few more I can't remember. I also had to become at least fairly competent in using IBM JCL in order to run some packages of various kinds on big iron back in the day. Having just passed 70 years on this planet my current favorite toys are Arduino's and Raspberry Pi's. either of which are orders of magnitude past that PDP 8 I worked with decades ago. However, they still work the same way and everything I learned has built on everything I had learned before.
System/360 Assembler back in 1969
No compiler, no editor, no tools.
Just hand written on paper and toggled in.
Happy not to be doing it now, glad I had the experience.
In 1972, I wrote a tiny program in machine language for an IBM 1620. It was a decimal machine (sort of: see below) with 12 digit instructions and 40000 digits of memory. I punched the program onto cards. The program read a punched card, added two numbers on the card, and punched a card with the result.
The machine had a disk operating system, a macro assembler, a Fortran II compiler, and a useful set of file manipulation programs. You could enter commands from a teletype machine. We had a washing machine sized disk drive and a line printer.
We were required to start at the bottom with machine language so we knew what was really happening. The instructor introduced addressing, conditional branches, loops, subroutines, etc before we were allowed to use Fortran. He then convinced us, not rigorously, that it was at least possible for a computer to parse, translate, and compile. Only then were we allowed to use Fortran.
I left home at 6AM to ride the New York City subways to school, arriving one hour before first class so I could learn assembly language from a manual I found in the closet. I struggled to write programs that were too advanced for me. When I eventually learned a technique, I had been primed with a problem that required it.
For every type of computer I have ever programmed, I programmed it first in assembly language. I retired when this stopped being practical,
http://tincansandstring.net/co...
(Footnote) The hardware actually used 8 bit bytes. Six bits represented the usual characters, and the remaining 2 bits per byte where used for special purposes.
--
Hi to all my friends at NSA.
Don't mess with The Phone Company. Piss them off and you'll be using two tin cans and a piece of string.
It ran on an RCA 301 computer.
I aim to misbehave.
Fortran and BASIC in high school, and the once vaunted 4G macro language in WordPerfect 4.1.
Basica was my first programming language
Short course on APL with Hap Peele, then formal logic and computational lingistics, LISP, C, and Fortran. I think there's an advantage to programmers learning logic and functional algorithms before diving into specific languages. It gives the student conceptual models, ways to think about parts of languages, that work in multiple languages and make learning much easier (and solving problems faster and more efficiently comes along for the ride).
Unfortunately, we don't seem to value logic much these days, as a preparation for programming or for real life.
French - The lingua franca of Europe!
FORTRAN in high school.
Followed by multiple assembly languages during college summer jobs.
Then COBOL.
Dave Barnes 9 breweries within walking distance of my house
The underlying question behind the question is really about what CS students should be exposed to...
When I was a beginning CS student I was exposed to a number of different languages, each being an example of a different mindset: machine language, object-oriented, functional, logical.
I think that's important to learn not just about a programming language but about concepts. Especially in object-oriented programming there are quite a few concepts that you should have a grasp of to be a good programmer in any object-oriented language. And there are times that you could use lessons learned from functional or logical programming that you could apply also in OO programming.
Once you are proficient enough in one language, and having seen a few different languages, picking up another language is easy enough. (the exception being C++) Then the challenge becomes getting acquainted with the standard library.
Myself, I was somewhat self-taught before college. Started with Basic on the Commodore 64 and then 6510 assembly. Some basic on the Atari ST. 68000 assembly on the Amiga. Then C and C++ on PCs.
I would otherwise recommend learning Ruby or Python. Ruby is underappreciated.
"We mustn't be caught by surprise by our own advancing technology" -- Aldous Huxley
It was really nice to have a programming language in ROM on 8-bit machines.
Then Atari BASIC XL, Action!, 6502 assembler, etc.
VBScript. Yeah, I know. Not the prettiest of languages, but you know, she was there and ready and willing. I really didn't know what I was doing, and I'm sure did quite a bit wrong, but I generally knew what to put where to get the job done.
assembly on the Odyssey 2 video-game console, then basic (and assembly for game cheats) on Apple ][... ...man it was ugly entering hex codes for everything, line-by-line...20=JSR, 4C=JMP, thanks to the Woz et al
My high school offered a fairly comprehensive Computer Science program with a focus on Java, with the 2nd year giving AP credit.
My college's first CSE course was focused on Python, which was many/most of my peers' first exposure to programming, but the breadth and depth of the material (excluding the language-specific stuff) was more or less equivalent to the HS material, so I breezed through it.
The red and white checkered one from 1962
WTF? Pascal is not clean? Pascal was DESIGNED to be clean. It is very clean. It has strict type checking and is extremely sensitive to syntax. It doesn't allow any hanky panky to take place with any of its variables. You can't modify any variable without its assignment operator. Variables have to be declared, or else you get a runtime error. How is that not clean? Tell me one thing Pascal (Not Turbo Pascal and other flavors, but the language as it was created) does that is not clean?
Now, don't get me wrong. Pascal was a great language to learn straight programming, but was very limiting for every-day programming. Come Turbo Pascal. I must have written dozens, if not hundreds, of TSR programs that created ISRs, from sitting in the background and capturing keyboard input to recognizing that you changed your password on a NetWare server and sync it up to other servers. I even wrote a visual Connect 4 game that you could play over the network with your buddies, when the only LAN game I was aware of was "ncsnipes". Now those are things Pascal wasn't meant for, but Turbo Pascal extended the language very successfully and created a world where there was no end to what you could develop.
Is that a roll of dimes in your pocket or are you happy to see me?
Our school got an of Videoton 1010B, a Hungarian copy of a French minicomputer.
The mini itself was made in 1973-1974.
We got it in 1985.
http://www.mmkm.hu/index.php/c...
It had a classroom of 16x40 teletype displays, 64 kB hard drives the size of a big fridge, etc.
I have the printouts of the programs.
It was pure hex, not even assembler or anything mnemonic.
and 512 bytes of ram, sufficient for a game of tic-tac-toe. :) Directly followed by Algol.
On my dad's Apple ][+ clone (upgraded to a ][e for LOGO and PASCAL). Then MS BASIC v2.0 on my very first own computer, a breadbox C64. Afterwards, 6809 assembler in CEGEP, some PERL couple years ago, I don't really code anymore, but I'd like as hell to be able to read those old 5.25 floppies. That I can do for the C64 (still have one, and x1541 can transfer to PC, but Without buying extra hardware I'm kinda fscked for Apple disks.)
I've got better things to do tonight than die.
Ahem, as I just get 'you cannot use this resource' whenever I post using my 'peetm' account, this will be slightly 'anon'!
My first 'language' was machine code - Zilog Z80. And I mean machine code as I didn't know about assembly language, assemblers (sadly). So, whenever I needed to change something - which was very often - you (well, some of you!) will appreciate the effort required. But, no regrets, it was such a useful experience.
After that it was BASIC on a self assembled ZX80, and then Pascal - which is still a rather beautiful language IMHO.
P.S. if anyone knows how I can get past the /. error I get when trying to post, please do tell!
Also an introductory programming course at Stanford; the course title was, "Introduction to Algorithmic Processes." Instructor: Niklaus Wirth, who later created Pascal, Modula, Euler, Oberon, etc.
Truman State taught Ada in their intro classes because it was an extremely strict language and taught you to be mindful of data types. My favorites are still C and Python though.
Logo was my first programming language. Indirectly through the Big Trak toy (the 1970's version, not the iPhone version). Directly on the Apple ][ in the seventh grade (1983).
Anyone else? ...anyone?
https://en.wikipedia.org/wiki/ZZT-oop
And not as clean as C? They’re smoking crack or what? Pascal is so clean you can’t shoot yourself in the foot like you can with C! Ever wondered why there were no exploits in MacOS like there are in Windows? Because MacOS is written in Pascal! Good luck doing a string buffer overrun in Pascal! Here is on what I wrote my first program ever: https://en.wikipedia.org/wiki/...
Fortran, then BASIC, then 8008 assembler, then C, COBOL, x86 assembler, SQL, Dibol, Snobol, Smalltalk, C++, ... Latest serious language is PHP.
Sometimes, real fast is almost as good as real-time.
TUTAC (TUTorial Automatic Computer, as I recall) was a pesuo-computer programmed in a made-up assembly language, this being a key part of a self-paced Introduction to Computing course. Purchased by and offered in the early 1960's at no cost at California Sate College, Hayward California (now the multi-campus East Bay University), the course material was displayed on a device consisting of a reel-to-reel film strip rear projected on a screen, with several several push buttons along one edge. The film consisted of multiple images organized into short segments of instruction followed by a brief multiple-choice test of the section. If you missed a question you would get an instruction to push a specific button a certain number of times. This would reverse the film through a series of "Push Again" screens until it returned to a previous section for review. This setup was quite clever as no actual computer was utilized by the device. The course was strictly voluntary and without course credit. I thought I would be good with computers and this confirmed it. My next step was a formal course in Fortran on an IBM 1620 operated as a batch machine. Having had the TUTAC course gave me the confidence to tackle 1620 Assembly language with "blinking lights" console debugging and also complex printer plugboard wiring. I found it to be lots of fun and I graduated with a B. S. in mathematics with a Computer Science option and have worked in the industry ever since, continuing with a long-term personal project in my so-called "retirement".
- Leonard
Just like others who started up in the 80s, my first language was BASIC. Specifically, AtariBasic. Later, when I had gotten a C128, it switched to Commodore BASIC 7.0
In both cases, I remember the hours I would spend typing in programs from magazines. Some of the games were fun. Unfortunately, I didn't have a disk (or tape) drive at the time, so after getting a program to work, the computer was kept on for days at a time until I tired of whatever I was playing with and moved on.
The Penguin Producer
Assembler. Shows my age. We still used keypunch.
C language
Batch files because they could be easily read and it was obvious what they did, and there were tons of examples in shipped software and shareware disks... They could have variables, logic, labels, etc.
Ruby, weirdly enough.
Prof specifically didn't want people to start with Java to prevent over-reliance, so we got this eight-week one-language-a-week introduction to programming.
Appropriate Captcha: 'Language'
BASIC programs were published in magazines and I taught myself from their example as a child. My first Computer Science class years later in High School was TurboPascal.
Java has a use as a strict typed, object oriented language with lots of libraries. It might be hard to program creatively, but strict language, and good compiler errors, are good at cutting down on bugs. Allows the use of mediocre programmers to write big stuff.
Applesoft Basic on the Apple IIe was my first, along with some of the older Integer Basic, which seemed to run faster. Back then, programming for me consisted of typing in programs from magazines and books. I even typed in Apple hexadecimal machine code from magazines.
Next was Basic programming on an IBM PCjr in high school, which was my first exposure to real, proper programming. Look back now, my high school was very forward thinking, and I was lucky to have attended that school.
Pascal was my favorite early language, starting with a Pascal compiler on the Z-80 Softcard, followed by a very good Pascal compiler that ran on the Macintosh. In the late 80's, colleges taught basic principles, such as data structures and algorithms, using Pascal.
My student days were with Fortran IV and then when those new-fangled microprocessors were almost affordable, moved on to 8008 coding in hex. Ah, then the heady days of Z80 hex... Even when I ran BASIC, I spent more time hacking new commands into it (starting with EPSon and EPSoff) than BASICing. No IDEs then, sigh.
BASIC had so poor internal form, Fortran had unnecessary console reduction for architecture-dependent hardware-precision, and Pascal looked like Fortran.
They all internally could address EGA, CGA, and VGA graphics modes, and play the 4-bit PC Speaker and ... all were stunted to late 70's I/O developments.
InfraRED was revolutionary.
It wasnt until 30 years later when simple concepts of wireless radio transception would render as modern WiFi yet should have been common place back in the 70's.
Was modern WiFi suppressed by tge Cellular network service companies? The only modern computer languages are they that have no access to hardware and memmory allocation routines.
I totally disagree.
If you were any good and had a "serious" program to build, you would realize the lack of
a) structured loops
b) structured if then else
c) conventional ways of passing arguments into subroutines
in early basic and learn by experience how to invent all of those out of re-usable patterns of gotos and assignments.
This was actually really good for you, kind of like Army bootcamp.
Where are we going and why are we in a handbasket?
The first time I saw a computer with a screensaver when I was 6, I understood it had to use math to represent logic and data. I spent the next few years thinking of how a computer could be programmed and made up my own programming language in my head. Mind you, I had never used a computer nor saw any programming language before. The programming language that I made up closely resembled ASM. It did one logical operation at a time, no syntactic sugar.
My first real-world language was Basic, but I hated it in less than a day and never touched it again. About the age of 10, I got a book on ASM programming. It very closely matched the language I made up in my head and I took to it naturally. After a few days of learning how ASM worked (stacks, registers, memory alignments, things my mental language did not need to worry about), I got annoyed by the repetition. I then found out about C. To this day, whenever I write code, I fist think about how I would code it in ASM, then translate that into whatever language I'm working in, typically C#.
My first language is nothing anyone has ever seen because it was never real, but I practiced it all the time.
Unreal Script, One of the only games we owned on PC at the time, Then I got into micros and learned basic, then PHP/HTML/Javascript.
Then quickly learnt z80 for that extra bit of speed.
Task Mangler
A fortunate move to upstate New York put me on a track to pick up some classes on BASIC and Pascal at the high school and Watfiv and assembly language at a local university that had a high school summer program. My senior project in high school was a graphing program that generated several kinds of graphs using Apple Pascal and the turtle graphics package that came with it. The system could barely handle it, but it was pretty spiffy. I wrote my own keyboard input routines that would allow me to set up fields of a specific size that would only allow certain characters to be typed into them.
College was more Basic, which I was entirely fucking sick of by then, and some scripting languages. I got my intro to REXX there, which was much nicer than Basic. I switched schools into a more CS-oriented program and picked up C, Ada and COBOL. By then I was starting to hear about this newfangled C++, which really sucked back in the early '90's, let me tell you. They didn't even have a STL yet. They started talking about adding templates to the language a few years later.
By then I knew my way around C pretty well, but mostly had to work on the shitty proprietary languages of the 90's. I got into some work that involved actual C programming in the mid 90's, and had a pretty solid decade of C programming. Since 2005 it's been a pretty steady mix of Java and C++, along with a bit of maintenance on some really badly-designed projects in Perl, Ruby and TCL. I'm currently doing a mix of C++ for hardware-level access to some specialty hardware I'm working on, and Java to provide some web services associated with that hardware. I might get into some Javascript to put it all together, but I'm going to try to leave that to the guys who are more comfortable with Javascript than I am.
I don't see much new coming along the road. .net, go and rust are all sufficiently close to Java or C++ that they really don't interest me. Maybe if someone offers some large briefcases full of cash to work with them. I'd be more interested in doing some hand-optimized assembly language and perhaps some GPU programming, but that would probably take another decade to get good at.
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
FORTRAN. On punched cards.
punched on paper tape, for a Royal Precision computer, in 1962.
In 1980, as there was only the course "Microprocessors" from A.J. Dirksen here available (Belgium/Holland). I was 14.
I was given a Programma 101 with all docs, fortunately, that just needed some repairs. It used an assembly-like language, and i managed to write a checkbook balancing routine on it. Then i gave it away.
I acquired an HP-41 soon after, that was much more fun. Balancing a checking account in RPN is simple.
deleting the extra space after periods so i can stay relevant, yeah.
Surely you want to hear my life story. What else on a drab Sunday like this. (The sun actually shines brightly.)
I Built an Elektor TV Games Computer. Programmed 2650 assembly but I was too young and actually sucked at it.
Then came Basic but I didn't see/have an actual purpose.
My first job I got for knowing Prolog and Pascal.
First significant projects were actually in C.
Then Java. Huge amounts!
C-like syntax rocks!
I hadn't the slightest objection to his spending his time planning massacres for the bourgeoisie... (P.G. Wodehouse)
STB Bus board, nailed onto a piece of wood, with a Hex keypad and a 4-character LED display.
English.
Then arithmetic. Then algebra. Then geometry. Then integral/differential calculus.
Then TRS-80 Basic. Then 6502 assembly language. Then Forth.
Then Scheme. Then dBase II. Then C on Unix w/ tcsh & bash. Then Java. Etc.
Note that the question was “programming language”, not computer “programming language”.
First order logic came into play fairly early on, too, but that's not a language per se so much as a technique/methodology.
Error: NSE - No Signature Error
Not much beat having a REPL loop be the OS boot prompt. But BASIC is a crappy language to learn programming in. Similarly, fuck JavaScript. A language you teach with should not be full of surprises and exceptions. It should be consistent and simple. How about LUA?
"I will trust Google to 'do no evil' until the founders no longer run it." Hello Alphabet.
I guess my very first programming experience would be Logo sometime in elementary school, but about the same time I was learning GWBasic. My dad got me a book from the library that had programs you could type in and run. I've never forgotten typing in 500 lines (supposed to be some kind of space shooter) and then program didn't work. I never figured it out!
Soon after I started using Qbasic (the version that could compile EXE files).
My next programming language was Pascal through Delphi and then C++ through Borland's C++ Builder. I picked up a copy,of the K&R C book around the same time that today is very well worn!
I was very interested in different languages around high school and so I picked up a smattering of Visual Basic, a senior high school independent study in Visual Studio C / windows API (why?!), x86 assembly, OS/2 REXX scripting, etc. I wrote an ecommerce site for a local business in 1999 using PHP and a perl cgi-bin cart system.
Picked up Java in college, one course with Prolog, etc.
Today I'm not a professional programmer, but I end up using PHP, Python and Perl for text processing, SQL, etc with some regularity.
The first I touched was APL. It helps to have a dad who taught math at the university. An APL program to land the lunar module simulation. Input the engine thrust for the next time interval. Watch distance, V and A change. As a kid the IBM selectric (2741 terminal) was more interesting ( https://www.youtube.com/watch?v=r67StSAmEjk ) than the cold room of blinking lights.
The first I programmed was PLI. Punched cards. About simultaneously I started on BASIC. Then within the year assembler. Then COMAL.
Hit Fortran and APL again when in university, followed by Pascal and C.
In 1977, at age ten, I started reading BASIC, from a paper book, before I ever saw a computer.
CGAT. Started at the age of -9 months.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
When I was an 11 year old in the mid 90s. It was an amazing discovery...
I soon had to learn some assembly to do graphics programming. int 13h, 0xA0000, good memories...
At some point I moved from Pascal to C, but I can't quite remember what led to that transition. It was a fairly trivial transition since the languages are very similar and Borland had similar compilers / IDEs for both languages.
Those were the days! The magic of learning to program at that age is something that I'll probably never experience again. Seriously, it was one of the highlights of my life. Massive doses of nostalgia.
BASIC was the first language I learned, FORTRAN was the first language I was taught. After BASIC, I learned PDP-8 and Nova assembler, and Logo. After FORTRAN I learned COMPASS for the CDC 6000 series and 7600, then SNOBOL, then I was taught PASCAL, PDP-11 assembler and C.
BASIC and Z80 Assembler on a Sinclair Spectrum clone, then Pascal with some x86 Assembler - routines to enable mouse pointer, get coordinates, init the video modes, fast memcopy for video buffering. C came a little bit later with C++ following closely :) Then a lot more x86 Assembler.
Afterwards, all went bad - JavaScript, Java, C#, Objective C and many more :)
I went from BASIC to Assembly to C to Java to C++, etc. I know there are at least half a dozen languages I used and forgot from disuse.
.. followed by Turbo Pascal 7.0
I went to a public university. They taught Java or C++ in the introductory class to weed out students that couldn't handle the major, which was about half. At top private colleges who are supportive and don't need to weed anyone out, the choice should make more sense pedagogically than at a ruthless public school.
MIT uses Scheme: http://web.mit.edu/alexmv/6.037/
Yale also uses a lisp variant: https://zoo.cs.yale.edu/classes/cs201/Spring_2017/Racket-style-guide.html
Swarthmore uses Python: https://www.cs.swarthmore.edu/~adanner/cs21/f13/
Middlebury uses Python: https://catalog.middlebury.edu/courses/view/catalog/catalog%2FMCUG/course/course%2FCSCI0101
Harvey Mudd has two intro classes.
first one is Python: https://www.cs.hmc.edu/csforall/
second one: "Students in CS 42 write programs in Scheme, Java, Prolog, Python, and special-purpose languages."
Stanford's choices are a bit uninspired here, IMVHO.
Fortran, but I learned later you can write Fortran in any language.
Old. My first programming (1967) was done on a programmable Wang calculator on hand-punched cards, followed closely by learning Fortran II on CDC Big Iron. However, I really didn't start learning the skills of programming a computer until I took a class in CDC assmbly language (SCOPE) programming a couple of years later. That down-to-the-metal level of programming taught me what was going on in the machine that the Fortran compliler had been hiding from me. Made me a much better programmer than I would have been otherwise.
The summary:
When Roberts came to Stanford in 1990, CS106A was still taught in Pascal, a programming language he described as not "clean."
Now he's thinking Javascript is a good first language to teach CS? Is he on meth?
While Pascal had its foibles, I always considered it to be a good strong language - comparable to C in that what you programmed went to the machine pretty much the same way C does.
FORTRAN II was my second language; first was FOCAL on a PDP 8. The bootstrap had to be keyed in to read and load the paper tape.
Great minds think alike; fools seldom differ.
I learned OCaml first in school, I do not use it anymore, but it's quite nice. It's a pretty good way to start learning programming if you have a maths background too.
Then C, and that's when you really start missing some nice functional things like pattern matching, first class functions or type inference.
When I was in grade school, my father used to work on a mainframe computer. I was curious and used to bug him with questions, and eventually he brought me a couple of manuals. My first computer program was written on an 80-column paper form and started with "IDENTIFICATION DIVISION."
Shortly later, I joined a "computer club" and got to play around with an 8080 board with a hex keypad for input and a line of LEDs for output. That was my first exposure to assembly language and machine code.
Later, in high-school (early '80s), I got exposed to personal computers and programmable calculators. So, roughly in chronological order: 8085, TI-59 (belonging to a fellow student), BASIC, 6502 (neighbour had a VIC-20), 6509 (got my first computer: a TRS-80 CoCo)
Apple's BASIC. Does Apple's LOGO count too? I loved them. And then, college for Pascal, C++, C, ASM, HTML, ASP, etc. I hated them since I prefer breaking stuff.
Ant(Dude) @ Quality Foraged Links (AQFL.net) & The Ant Farm (antfarm.ma.cx / antfarm.home.dhs.org).
On a Burroughs B6500 at UW-Madison in the mid 70's. Worked as a tape ape for my work study job.
I suppose you could argue that it was BASIC on the C64, but I never really *learned* any of it, just typed in stuff. I made a half-ass effort with Perl. I got taught C++ at Illinois Wesleyan (last class to take C++; the next year, they switched to Java).
-- "Broadly speaking, the short words are the best, and the old words best of all."
Jan, 1976 - UoGuelph
PL/C using mark-sense cards, lying in an infirmary with a collapsed lung and nothing to read but textbooks.
Read the whole PL/C textbook while waiting to heal - never had to go to class afterwards except for exams.
Then a parade of languages: COBOL, APL, PDP assembler, VAX assembler, IBM 360 assembler, C, Snobol, Lisp, Pascal, Fortran and a bunch I've forgtotten - all while getting a Zoology degree.
Ended up as a CS prof. That collapsed lung wasn't the catastrophe I thought it was at the time.
First and last. I started with COBOL in the beginning of my career and have not looked back. Today I'm a consultant working with various agencies and corporations on maintaining codebase. It's quite lucrative.
I had access to a Commodore 64 the Summer between 5th and 6th grade. I spent a lot of time playing games on it, but I also became interested in writing BASIC programs to do things like create AD&D character sheets, text adventure games, and things like that. In retrospect, going a bit further and learning "machine language" would have taken me a lot further.
I mean, polls can have comments on them, right?
Good old mainframe COBOL. Followed by System 360 assembler. Some years later the PC was invented.
Apple ][+, 6502 assembly language was my first real programming experience. I used it to write a few simple games, a very capable timing loop based disk copy program (capable of determining and replicating sync bytes with better than 95% accuracy), and a commercial teleprompter that I sold to a local production studio (when I was 16).
It was TI-BASIC on the TI-83 Plus graphing calculator. Taught myself from the calculator's book sized manual, mostly during study hall period in high school. I would print out my more complex programs (I had a serial to 3.5mm audio data cable), so I could trace the logic of my GOTO statements. I knew exactly what the professor was talking about the first time I heard the term "spaghetti code." My second language was assembly on the calculator's Z80 CPU, also self taught. And my first language taught in college was C++.
IBM 370 via punch cards. This was 1979. Luckily got a wilbur acct for the 370 assembly class or it too would have been punch cards. Imagine assembly on punch cards....
Before that if it counts, Ti 58C calc.
H.
Using toggle switches to load the resulting machine code into the system RAM.
I believe the university was teaching 4004 a couple of years before I started my course and they moved to 8080 the year after.
First contact with programming languages was APL at Orange Coast College in 1972. Next was PDP-8 Basic and paper tape on teletypes.
Comal, for the COMPIS.
Started with Fortran IV and migrated to APL. Then switched to Basic. Picked up PDP-8 Assembler along the way.
Now you kids get off my lawn.
I dabbled in PBASIC when I was like 6 when someone showed me how to get to the interpreter on an Apple ][. The first things I actually learned were HC11 ASM and C at a college program for electronics design.
Most of what I do is still in straight C.
Assembler on a PDP-4 loaded by paper tape
I played with Basic in high school but did my first undergrad stuff in ALGOL-W. As an undergrad I messed with Pascal, Fortran and PL/I. One of my profs at the time was an author of the ALGOL 68 report, thought BCPL was cool and that C (a relatively new language at the time) was a mental disorder. He gave us an assignment in APL once. I guess I'm showing my age.
Now I do 99% of my work in C. My boss and I agree to disagree on scripting languages. I like Python. He thinks Python is ridiculous and insists on Perl for production work.
...laura
Fortran/Watfor/Watfiv for doing actual math efficiently
Then COBOL because business contracting
Then PL/I because IBM wanted it to be (yet it never really was)
Then IBM assembly language, so that knowing LM 14,12,12(13) ; BR 14 would remain in my brain as long as it sits inside my head
Basic on the ZX Sinclair, Basic on apple II+ (I tried to learn 6502 assembler at the time but sadly it was over my head), Basic on C64. When I got an IBM-XT clone I decided that C was the way to go, but I also dabbled with pascal because Pyroto Mountain the online BBS game was in it. Later in my post-grade school they used Pascal for the early classes, and there was PL/I, APL, lisp, C. In the end I got a job as an assembler programmer (how ironic is that??) which I picked up easily by then, and then I learned bash/perl/python.
Laws are rules for the court, but merely a bottom bar to hit for life. Think beyond laws in your actions always.
APL on teletype in high school. PL/I on punch cards in college. Fortran on PDP-11 in grad school.
I'm surprised that no one has mentioned assembler language. My first programming language was IBM 360 assembler in 1967. The original 360's had a plethora of front panel lights and a fun projects was to get the lights to show amusing patterns. Advances programmers could also play tunes on nearby radios since the machine radiated tons of RF. The IBM 360 assembler even had a secret op-code - HCF Halt and Catch Fire. Nowadays I program C/C++ and C# with a little Python for small stuff.
I'm a grey-beard, so it's likely most of you never heard of a Motorola 6800. 8 bit "single" core. I doubt you could even find a fresh one nowadays!
I messed with logo first but Bourne shell is when I really got in to it. Suppose that makes me weird...
Learned BASIC on a high-school teletype connected to a nearby time share computer. Once we got enough proficiency we were allowed to move to the new TRS-80 Model I.
BASIC on a VZ200 with a Z80 processor and (according to the ad), a "whopping" 8kb of RAM. Ah, peek, poke, gosub and goto, sigh...
COBOL and RPG.... yes.. I'm old...
We did Basic in high school and then Pascal my first year of college. Then on to assembly (IBM 360 mainframe) and then C.
If school teach languages like Java script how are students suppose to understand anything about how modern computer works? How are suppose to learn stack, heaps, system call, OS architecture, compilers etc. If they don't have solid foundation in all these thing, how are they suppose to get decent engineering job without knowing iota of fundamentals. JavaScript or even Java doesn't teach you fundamentals of memory management etc which is crucial to know for any software engineering job. You don't need to go-to college to learn JavaScript.
... while still at school (i.e. aged ~15). Algol 60 was clearly elegant and 'well-designed'. We learned it in an after-school club run my one of the maths teachers (thanks "Jake"). It was followed by Fortran IV for the comparison with a language that while very useful was about as horrible to use as a language could be. We wrote on coding sheets which the teacher posted to a nearby university, and we received the corresponding punched card deck and lineprinter output showing our syntax errors "in as little as a week".
NB: I freely acknowledge that there are worse-looking languages than Fortran these days: Perl, APL, Mumps, IBM mainframe JCL for starters :)
Our first teaching language at university was BASIC, which I'm not ashamed about .... soooo easy to write in (at terminals which were teletypes with scrolling paper and paper-tape readers) ... it's kind of limiting, but we had a lot of fun that first year. Then came the second year, in which we were introduced to The One True Language - Algol68. If it were still commonly used I'd look for jobs requiring it even now.
To paraphrase a well-worn metaphor: C ... meh ... shoot yourself in the foot ......... C++ .. meh ... blow the whole of your damn leg off.
FWIW: comparison of Algol68 with C++
PS: non type-safe languages ..... what ????!??!
(Javascript ... ugh, puke) ..... what ?!???!!!!!? (I'm looking at *you*, Python)
Languages in which white-space is significant
If you don't pray in my school, I won't think in your church.
CBM BASIC (CBM VIC-20).
Later, 6502 Assembly Language (CBM VIC-20), and then all IBM PC compatible computers using MS BASIC, MS-DOS Batch Files, WATFOR, MS FORTRAN 77, Turbo PROLOG, Turbo Assembler, Turbo C, MS C, Turbo C++, MS C++, MS Assembler, Modula-2, Smalltalk, BASH, Perl, Python, R, and a variety of other programming languages over the years since 1982.
BASIC: My first computer language was BASIC, in various forms. It started with Commodore BASIC on a VIC-20, then later Commodore 64's in school. A few years later my VIC-20 was "upgraded" to an Apple IIc. So, I learned Apple BASIC. My senior year of high school the C64's at school were "upgraded" to IBM PS/2 computers. So I learned IBM (or GW) BASIC.
Pascal: The first language I learned in college was Pascal, in my CS101 class, my freshman year. Having BASIC so ingrained in my brain, I remember I initially panicked... How can you write a program without numbers on each line? lol. These fears quickly subsided, as I learned what I was doing.
Others: Second language in college was COBOL. Third was C and C++. I think I took a class in FORTRAN, as well. This was all before the WWW, the release of Java and other "advances". Now days, I'm a systems admin and mostly use bash and ksh scripting. As well as a little Python here and there.
Fortran, on punch cards, and I only dropped them once. Rubber bands quickly became my best friend.
My first programming language was unlike most posting here as either Fortran or Basic. I went straight to a box I found in my dads room, full of the Borland C++ compiler on about 30 floppy discs, and its technical manual explaining each function. I remember installing this on one of our 7 computers, a strange amount for a family to have back in 1998, and getting familiar with the Borland IDE.
For Christmas that year my parents got me more programming books, and I continued my self study for the last two decades and have held various jobs programming in anything from PHP and Python, to C++ with Qt, or most recently, C#.
"All tyranny needs to gain a foothold is for people of good conscience to remain silent." [Thomas Jefferson]
Specifically, FOCAL Amity 1969, on a DEC PDP-8/L with 4K core. Attached to an ASR33 with paper tape reader and punch. Good times.
Mission: To provide products that consume time and energy as entertainingly as permitted by the laws of thermodynamics.
6502 assembler.
Followed by Pascal, 6809 assembler, 68000 assembler, APL, Cobol, AN/UYK-502 assembler, Z8000 assembler, C, C++, Javascript, C#, F#, Haskell
Still want to do a deep dive into assembly for my i7.
In 1966 my first serious job was as a punch card operator at an insurance company that had an IBM 1401. There I learned to plug the control panels for the IBM 77 collator. I registered for a programming course at a community college where I learned to program in assembler on an IBM 1130. That was the best return on $20 that I ever had. That course led to a job programming business applications in assembler on an IBM 360/30. That led to programming CICS applications in the days when IBM licenced it free to any business that was interested and ultimately to systems programmer positions overseas. That initial $20 paid my mortgage, put my two sons through university, paid my way around the world twice.
For a DEC PDP 8. Paper tape-based, two pass. Followed quickly by FOCAL and BASIC.
"Eve of Destruction", it's not just for old hippies anymore...
Started out with Basic in 5th Grade(1990). Put one floppy in to load dos. Put the other floppy in to load Basica or GW-Basic and you are off to the races. Hard Disks? What Hard Disks? .net or Java (Though had to take the training on all of them). Yes it was one product with each module in a different language . Go figure .net. Mess around with all of them. Get interested in Python as a scripting language. Then get interested in Android. New job. PM for a group doing mobile development. Learn ObjC so that the developers cant bullshit me.
Then Grade 7 we start with this cool new Language Pascal. Structs Cool!!
Grade 9 We start C. Pointers. ugh!!!
Grade 11-12 C++. Well we pretty much kept writing C code just used objects.
Then this cool new hot Language comes around everyone is excited about Java!!
Get to college- Computer Sci 101- Fortran. WTF? Well our professor is smart. He says we will use Java even though the course is called Intro to programming using Fortran. (The college was a state college and it used to take 5 years to change the official course).
So we use Java and C++(MFC&ATL) in college.
First job - Training on Cobol!!! WTF squared. Anyway lucky enough to get assigned a group using C++ and not to a group using Cobol , VB ,
Then get on a project porting the old code base from C++/Tuxedo to Java/J2EE. Good times. Not much time to do laundry, sleep or take showers but good times.
Leave to go do a Masters and the first course is AI . Learn Lisp. Then ML, of course Java and C are around as is C++ templates and one wierd Machine learning class that uses Algol.
Leave college and go to a job. The company is doing Java, C++ and
Now Java 8 and scala are bringing functional programming and closures . For someone who did Lisp and Objective C thats old news.
What I am trying to say is the languages change and each one teaches you something. Each has its place. As long as you are willing to keep learning the particular language you are using today does not matter.
**Life is too short to be serious**
Technically, it was Fortran coded on mark-sense Hollerith cards and mailed off to Iowa State University's IBM 360. But that was my junior year of high school (1968) and the programs were very simple.
I went into the transportation industry and ended up working for a trucking company as a dispatcher. IBM worked their sales magic and sold the company an IBM 5100 desktop system running APL. The application was to print bills of lading from stored information. A job the machine was uniquely unsuited to perform, with it's two cassette tape drives. I took up the challenge, taught myself APL, and came up with a working piece of software. I think it was 20 lines long or so, which was a major fail for a language where the goal was programs that were 1 line long.
I ended up running the IT department for the trucking company as the first step in a career in IT.
Followed by TI Extended BASIC, then PowerBASIC, Visual BASIC, and finally got around to Pascal, C, and C++. First language doesn't matter. You're either born the kind of person who cares how many bits are in an int or you're not. You'll eventually find where you belong in the spectrum skills and applications and either learn until you die or be that asshole who repeats the same mistakes every day and leaves it to his coworkers to clean up.
Anything but what our uni hit us with in unit one, year one. I don't care how "pure" Miranda was/is: it was a asinine waste of 6 months of my and everybody else who did that course's life.
If you were willing to dig into the obscure commands, which I was, you'd have found it very powerful. When I say dig, I mean the specs of your hardware rig, too. My first was BASIC – 1st on an Apple IIe, and later on an IBM PCjr.
Using just BASIC, I was able to write polyphonic music, cartoons, games, multiple-screen programs, and even a Photoshop-like drawing program (in 1987) that let you save and re-open files later for more editing. Last, I almost constructed a robotic CD-player, with playlists being columns checked or not, but then along came college.
BASIC was powerful if you were willing to really dig deep into the manual. Of course, once things came to data structures, you were basically out-of-luck.
basic (I was a kid around 10, had an old computer that couldn't run most games so I somehow found DOS nibbles and gorilla .bas code and started there)
then some DOS scripting
visual basic a few years later, very limited but so easy to drag and drop components and build a gui.... even with those OCX winsockets to make stupid troyans for fun at school
then at about 14 yo I figured out a web server wasn't an expensive box in a remote-expensive datacenter but just software serving html and at that time I knew IIS
was crap so jumped into a linux box running mandrake, set up an apache and paper-printed the entire manual
figured out I that if your DNS TTL is short enough you don't need a static IP so started a free webhosting site
some stupid useless pascal at the university
one of the guys I hosted was a web designer, asked if I could write some php forms for him so learned php (php3 at that time), had to drop the webhosting site b/c my mom told me to... was too young to get paid properly for that and at the time my mother didn't even knew what internet was.
after a while had to drop the university and looked for a job, nailed my first full time PHP/css/javascript job at around 17
after 1 year got offered a bunch of money to learn Pro*c / oracle
after a year big reengineering project from Pro*c / oracle forms to java (java 5, struts/hibernate/spring/html/javascript/jsp) learned java, I was about 19 at that time
after picking up java bigger jobs started to show up, traveled to many countries, even opened my own company for a short period of time (argentina's retarded economic policies screwed up my company)
went back to work as an employee and since then I've been coding Java/html5/css/javascript and C++ (hadoop,mongodb, casandra, any buzzword you've probly heard in the past 17 years
I am 35 now, still working as a dev/team lead/software archict and make hobbie electronics and basic AI for fun
as many of you I figured out I should code something like fb, google linkedin, amazon's aws, ebay, arduino, 3d printers, drones and etc before they existed and there was always something else to do, my vision now is that the next thing is a global currency backed by price of kWh, probly using blockchain as support, probly there is something being developed right now or slowly comming out, need an exchange for that, I am trying to see if I can save for a solar panel / inverter and batteries to disconnect from the grid in the meanwhile
It came with ms-dos, so before i had met anyone who knew anything about programming, this is what a had to teach myself the ropes.
My first encounter with programming was on a Digi-Comp, a plastic three-bit mechanical computer sold by Edmund Scientific in the early 60's. But my first "real" programming language was HP time shared BASIC in the early 70's. Writing simple games such as a lunar landing simulator, craps, blackjack, etc. in high school is what initially got me interested in programming as a career.
CDC FORTRAN using decks of cards, almost simultaneously with poking around on a PDP-8 that we had to bootstrap with binary to read a paper tape to load BASIC.
IBM 1401 Autocoder followed by Cobol, Fortran, Fargo, BAL, PL/1, .....
My first programming language was original basic. Taught in high school. One letter, one character variable names. Gosubs.
Whatever it was that a Sinclair ZX81 used.
ZX Spectrum BASIC!
Followed a few years later by Turbo Pascal and C.
I also learned (at a more basic level), Java, Fortran 77.
I self-taught myself BASH scripting, Perl, Python and PHP.
I cut my programming teeth on a VIC-20 and BASIC. Peek and Poke, ftw!
Otherwise, Pascal, then Modula 2 in CS
Specifically, BBC Micro Basic.
"How much truth can advertising buy?" - iNsuRge - AK47
If this thread has shown anything, it has shown that the age of people on Slashdot is not below 35.
My first was BASIC on a GE MARK IV time-share system developing engineering support, data circuit analysis, and interactive data circuit design programs for what was then the Ohio Bell Telephone Company. Later I got to convert all the programs to FORTRAN.
In college, the first language I learned was Fortran, followed by Cobol and APL.
The first language that I got paid to write in wass assembly.
COMMODORE BASIC
?SYNTAX ERROR
Not assembler language -- machine language .
Punched cards and numbers.
There was a calculator before that, but I don't remember its name.
Official Pi Ambassador -- inquire for details!
1974: APL , University of Pennsylvania. Incredibly innovative. Half the students watched lectures through TV! Lecture room too small. There was a computer terminal in a dorm! Holy GD twenty-first century! Sat in front of an IBM Selectic typewriter with APL type-ball, you typed at it, it typed back at you, on PAPER! FORTRAN came later, punched cards....
My first language was BASIC, in various forms. My first computer was a Commodore VIC-20 and my school had Commodore 64's, so Commodore BASIC was my first language. My next computer was an Apple IIc, so then it was Applesoft BASIC. When I was a senior in High School, the Commodore 64's were replaced by IBM PS/2's, so I also learned some GW BASIC.
The first language I learned in college was Pascal. Followed by COBOL, FORTRAN, C, C++ and Assembly. Java, html, perl, and python did not exist yet.
As a UNIX/Linux administrator, I mostly "program" in bash/ksh shell script, with a little python sprinkled in. :-)
Basic followed by Turbo Pascal, Fortran & Cobol
I think we used a Harris H/500 minicomputer and connected via VT100's wired through a Gandalf box into a baseband network. Actually I'm not sure they even taught anything else back then, except maybe COBOL if you were a business major, LOL. I guess there must have been some sort of Assembler courses perhaps? FORTRAN was pretty much the language of choice in those days, but within 5 years (this was 1981) C was dominant. I think I took a Pascal class in about '83.
"Malo periculosam, libertatem quam quietam servitutem." -- Jefferson
Our school was given an old computer by a company upgrading to a Pdp8. We learned Eliot 803 autocode before many school kids saw a computer: http://www.sciencedirect.com/s...
Hyperscript back in the days of hypercard
IIRC
Computer kid of the 80ies here. ZX81, ZX Spectrum, C64, Sharp PC 1402 ... all had Basic. :-)
Later I even did some QBasic on DOS.
We suffer more in our imagination than in reality. - Seneca
Apple II DOS 3.3 BASIC. Taught myself initially from "The Beginner's Computer Handbook" (Tatchell, Bennett, Watts) - yes, I still have my very first programming book. At the back were short BASIC computer games - I took them and started modifying (in my school's computer lab - IIRC we had an Apple IIc, 2x IIe and I think there was an IBM clone of some type). I was 11 years old.
Later my Dad got a Mac 512K (or was it a Plus?) and was trying to teach himself Pascal to teach a computing class at high school (he was a physics/chemistry teacher). One day I took his MacPascal book, combined it with a 68K programming and ROM reference that I'd bought and read through and wrote a quick MacPaint-style program over the weekend (fake menus, I didn't understand XOR, etc but it basically worked).
I learned more in that weekend than Dad did in the whole time he was working on it - I recognise it now as my first larval stage experience. It was at that point that I started to realise what my career would be.
Technically I guess Apple II Logo was my first language, but I don't consider what I did with it to be "programming". My Year 6 class (last year of Primary education) we had some access to an Apple II and Logo, but I didn't exactly find directing the turtle to be fascinating and barely touched it (nor did anyone else IIRC). I never did anything that required any significant thought with it.
Mine was Pascal.
I was born in 1965 and was around 13 years old when I started poking around on a friend's TRS-80 using the original (simple) Level I BASIC before he upgraded to the Level II BASIC. A few years later I started learning Pascal in high school and even helped out my math teacher when the math department had to start teaching Pascal for "Advanced Placement" classes starting the year after I graduated. I even learned enough FORTRAN to translate a bunch of FORTRAN subroutines into Pascal. Since I had been working on an Apple 3 computer since 1980 I also learned 6502 Assembly language to speed up things in both BASIC and Pascal.
When "The Web" came along in the mid-1990s I picked up HTML, then a smattering of Perl and then some PHP although I'm certainly no expert in Perl or PHP. I'd like to learn Python and Ruby at this point.
Pascal has been my "go to" (pun intended!) language for a long time and I use "Free Pascal" (in either Windows or Linux) to quickly throw together a short program.
FORTRAN (the WATFOR variant) was used for Computer Mathematics 11 in my high school, and again in grade 12 but we also had a few weeks of access to a portable (transportable, IBM 2741 in a suitcase!) APL terminal to the local U's IBM system running York APL.
This.
I used BASIC as it was what was available on the machine I was paid to write.
My BASIC, though, looked more like good FORTRAN than most basic, with thought out calls, etc.
If the language you need to use doesn't have the control structure you need, just write it.
Although I don't miss worrying about what line number to put routines at for efficiency (MBASIC until 5 or so would search through memory on a GOTO or GOSUB, making low-numbered calls faster than high-numbered).
And it's amazing that noone has pointed out the adage that a sufficiently skilled programmer can write bad FORTRAN in any language . . .
hawk
on punched cards, put through a reader and then waiting for the operator to tear off your dot-matrix printed output to find out why it failed to compile (again). Within the hour, if they weren't too busy.
Later on a teletype connected via Gandalf modem to a Honeywell multics timesharing system.
Still later on a monochrome green CRT -- the first CRTs I'd ever seen. And the computer would respond in real time!
Finally from home on a Compaq luggable via 300 or 1200 baud modem over a telephone line. And then things really took off.
licet differant, aequabitur
which I did on punched cards submitted to my teacher for runs. Yes, I'm ancient. My foggy recollection is that I perpetrated some of the worst code ever seen for that class; real spaghetti code, because that's what we were taught. Structured code? What's that?
Javascript for me, then on to PHP. Tried a bit of C, C++, & ASM, but never really dove into it enough to be productive. Learned a lot from them though. Eventually I settled into Python, 'cause PHP had certain deficiencies that made it far less useful than Python to me. Now I'm exclusively a Python & Django guy.
Learned on an Apple] [ with their tutorial diskette. Some C64 basic. Moved on to QBasic then Visual Basic. Finally learned something else with x86 assembly then settled on C. Which I loosely group Javascript, Java, Php inio
from 09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0
to 45 2F 6E 40 3C DF 10 71 4E 41 DF AA 25 7D 31 3F
GW Basic
I did my own research on this, and went through the top 10 computer science universities and looked at what they taught in their introductory CS classes. Python and Java made up 100% of them, with only one (Stanford) having a C++ option.
Personally, I think C++ should be the introductory language for computer science majors. (Non-CS majors? Sure, teach them Python or Javascript.) Why? Because CS majors all have to learn computer architecture and usually assembly programming is part of learning architecture. It's way, way easier for people to go from C++ to ASM than it is to go Python to ASM or Java to ASM. So a lot of assembly classes I've gone through have backed away from teaching ASM and instead teach C with a touch of ASM in it, which means that their education gets compromised by an attempt to make the introductory class easier.
But research in computer science education shows that you can learn basic computer science principles pretty much equally well regardless of language taught, so we're sacrificing educational quality for no real benefit.
I think most opposition to C++ came from people that learned it back in the day with square bracket arrays and char* strings, none of which really should be used any more now that we have vectors and strings. (And have had for a very long time, really.) Modern C++ is a very enjoyable language to code in.
I taught myself BASIC at university from reading a printout of the entire STAR TREK game (interactive dot-matrix printer version). At the same time, I learnt FORTRAN formally for a maths or physics course (can't remember which). The first FORTRAN program I wrote was for a DIGITAL PDP/11 minicomputer (about the size of a small refrigerator). The code was written in pencil on marked-sense cards. Oh, the humanity. . . . . .
A year of so later, I learnt COBOL, then a bunch of garbage languages taught by self-indulgent lecturers who thought they were interesting and useful (they weren't).
During my career, I also learnt PL/1.
Then QMF DB2-SQL. In fact, I believe that most business batch applications could be written using a series of SQL queries. My managers disagreed.
My first programming language was a form of Basic (I forget which one) on Apple IIe computers. During middle school, we were instructed to program a slot machine program. Essentially, the assignment was to pull three random array entries and display those. Easy, right? I coded mine, looked up, and everyone was still working. So I decided to add more features. I added in betting with the game repeating until you lost all your money or decided to walk away with your winnings. I looked up and people were still coding. So I added in a loan shark who would lend you money which you had to pay back (with interest) or he'd end your game for you. (I actually had it display that he "took an arm and a leg.") I looked up and FINALLY people were finishing their assignments.
I blew the teacher and my classmates away with what I had made. That SHOULD have been my sign that I needed to go into programming, but it took me until college where I almost failed quantum mechanics as I aced my computer science classes to switch on that light bulb.
My sci-fi novel, Ghost Thief, is now available from Amazon.com.
I learned BASIC on an Orange Toaster
I wanted to play games so I had to type them in from Creative Computing magazine and various other magazines and books and of course they didn't always work because there were subtle differences in various versions of BASIC.
I eventually got my hands on an Apple ][ Plus on which I expanded my knowledge of BASIC and learned 6502 assembly language. The first programming class I ever had was in Fortran.
Like most of the good programming courses I've taken though it was not a class to teach a specific language, it was meant to be an introduction to programming and Fortran just happened to be the language we used. And that's the only time I've ever used Fortran.
BASIC on an HP-3000 mainframe in 1980. We had a DECWriter terminal (basically a dot-matrix printer with a keyboard attached) that connected from our junior high school to a local university's mainframe via modem. You took a regular phone, lifted the handset, dialed the number, the modem on the other end would pick up, and you'd put the handset into this cradle that was attached to the DECWriter. Then you'd get a login prompt. Awesome. }:-)
MASM and LINK came with MSDOS on the second hand 8088 I was given when a relative upgraded to a 286. So I taught myself assembly language from a book over the Summer holidays. When my birthday came around I asked for Turbo C and The C Programming Language. That was a good way to learn, starting with binary and working my way up.
At university they taught Pascal in 1st year (because it was supposedly easier for beginners) and then C in second year. I didn't see the point of learning Pascal and my tutor let my do everything in C. A few years later they replaced Pascal with Blue, a simple and strict object-oriented language that they created for teaching beginners the concepts properly, before moving on to C++.
BASIC, quickly followed by FORTRAN, Cyber assembly, and Pascal. The latter I loathed.
Using a SYM-1 single-board computer.
It was fun, and I learned a tremendous amount about programmming close to the hardware.
First language was FORTRAN IV on the CDC 6600 at UT Austin.
I learned BASIC a couple of years later, then various assembly languages (specifically including 6600 CP COMPASS), then PASCAL on the 6600. LISP on 6600 a little, more assembly languages (PDP-11 and DEC-10 in particular, Intel 8080, Motorola 6800 and 6809, and I don't know what all else).
Starting in about 1988, I was doing Ada and C. I started doing C++ while doing refresher work at UT Austin in 2003-2004, and still am.
As a kid in 10th grade in 1975, I had a friend who had a login to a large city's public school system's CDC 7600. We used an acoustical coupler, manually dialed, connected at 110 or 300 baud, played games, and wrote fun BASIC programs. The games were written in BASIC. I've loved it ever since. Don't use it a lot, but have over the years. Helps when a VB project comes up.
COBOL with punch cards, learned at a community college
On the TI-994A. Oh the fun.
Why is it so hard to only have politicians for a few years, then have them go away?
I first learnt to program APL on an IBM 360 running MVS.
That was in 1976 as a high school summer course. APL is a functional language, and as I went on to do computer science at university what it taught me was there were other language patterns out these beside procedural languages such as Fortran and C. I went on to learn Prolog and Smalltalk, as well as C++ and Java.
I no longer program professionally, but use Pharo Smalltalk for my hobbies, and looking to use Jason.
Forth, to victory! On a "smart terminal" that actually had a whole chip to do the "Backspace" function. I was 8 or 9 I think.
on a PET. I didn't actually do much with it.
North American Recomp III *MACHINE* language. Hand coded in octal.
General Relativity: Space-time tells matter where to go; Matter tells space-time what shape to be.
Taught myself various flavors of assembly in high school (8080, 6502, 6809) as well as Apple integer basic. In college (1979) CS100 was FORTRAN taught by a "visionary" that was convinced that learning how to punch cards was a useful job skill. Best language learned that year was Pascal in an elective class. No matter what the first language is, the second one should be assembler. Modern languages are great, but a lot of people have lost touch with how their fancy functional language actually executes on the hardware and what the memory consequences are of their code.
Fortran was my first language: taught to me because it was available.
What you teach depends on the goal: if you are teaching so that people may become software engineers, teach languages they will use and need. If you are teaching in order to teach principles of programming language design, then teach a variety of paradigmatic languages (for example: Pascal, Scheme, a string processing language, etc.)
But overall, if you think of software as like bricks and mortar -- small amounts of 'language programming' that glues together calls to libraries and uses of frameworks -- you want to teach the bricks (the frameworks and APIs) much more than the mortar (the snippets of C that make the calls).
I started properly programming with C in my Programming I class in university in the mid/late 1990's. Prior to that, I had done some simplistic programming on a TI calculator (I forget the model) and a minuscule amount of work with Perl for my high school's web server.
I have a preference for C as an introductory language, but I'm willing to admit that's completely formed from my own experiences without serious contemplation on the issue. I can see different languages providing better foundations for different industries.
I work on embedded, real time, safety critical systems, so Ada should be my natural goto for introductory language.
In H.S. in 1981 we were taught pseodocode using Pascal like structures, which we then translated to basic. The next we learned a new language (MacroL) but still did psuedocode first.
English, as well. Biggest problem was the divide by donut error.
Later on, I tought myself assembler on the same computer. Then I learnt assembler on the Commodore 64, followed by Pascal, Modula-2 and finally C on the Amiga. As life got on, I learned C++ and Java, and recently I've learnt Python. But I still use C and assembler in my daily work as embedded software designer on ARM Cortex-M and smaller MCU's.
Algol as part of Electronics Degree
Vivid 2.0 raytracer input files. I feel it greatly shaped my thinking for the better. I had to imagine the result in my head, then code it in and wait for the raytracing process to complete to see and confirm the result.
There were no programmey things like IFs or loops. But math alone can do plenty.
COBOL followed a couple of years later by BASIC and 6502 assembler (Apple ][)
Yup 512 bytes were used for screen memory, 128 for system memory and 384 for basic. I quickly learned to program in assembly, because you could actually do things in assembly, whereas the basic was filled up very quickly.
Optimization was all about code size.
It may seem like a joke, but I actually learned the basic logic from scripting in mIRC IRC client. I think it's python or TCL based scripting language.
I moved to C afterwards, then C++ and so on, staying in C syntax languages.
I use it as an example when people ask me how I learned to code. My answer is always to "find something you use a lot and learn to modify it or figure out an small application you could use and learn to make it"
- Don't do what I do, it's probably not healthy nor safe. -
I hate to admit it, but it was BASIC. First on a Schneider/Amstrat CPC 464, then with Quick Basic on MS-DOS 3.3.
But the first "real" programming language I used was C (K&R C, not this CPP fuzz).
I first started programming in Fortran, "taught" by the Mathematics Department. Was a year later that CS taught me Pascal. This was the 1970s, before things like Java or C++ had been thought of. Didn't learn C until 1985, by which stage I'd been exposed to assembly languages, Cobol, more Fortran, and a few others.
Basic? er, no.
And get off my lawn!
And yes, I still cut code ... though not, I admit , in Fortran. Thankfully. (Tried C, Basic, Pascal, Java, C#, COBOL, RPG, BCPL, Algol, Simula, PHP, Forth, assemblers, Javascript, and many, many others. They all look the same after a while - oh boy, the number of times I've used a + in PHP where it needs to be a dot).
Yup, Fortran on an IBM 11/30 - 1970 (think bell bottom jeans and possibly The Beatles). It had a multi pass compiler (said to be 14, but maybe someone was exaggerating) and 4096 words (not bytes) of memory - core memory. Actual core, with little rings and everything. And an IBM Selectric output printer. I made the sucker play chess really, really badly - hey, I was 16.
"Cats like plain crisps"
Oric-1 BASIC -> Spectrum BASIC -> AMOS -> C
I had a TRS80 Model I, too! My first program was written in BASIC on a TRS-80 Model I, but I ultimately learned to program in BASIC on the Tandy CoCo 2, using the Color BASIC and Extended Color BASIC books.
In retrospect, it was a somewhat harrowing way to write any kind of code. We didn't have IDEs. We typed our lines of code straight into the command line, and if we wanted to read the lines we had already written, we had to dump the range we wanted to see to the screen. There was nothing like code completion. We didn't have anywhere to look things up except for whatever books we had on hand. There wasn't any Google, or StackOverflow, or anything like that. Nobody else knew how to program, so there was nobody to ask for help. There weren't any standard libraries for anything... anything at all. My programs had to be saved on cassette tapes. You had to really want to program, but it was such a power trip!
In my teens, I learned my second language, Pascal.
(I went on to use 18 other languages, after that!)
My first programming language was FORTRAN on an IBM 360 clone. On punchcards (edit-compile-run cycle length: up to one day).
All this as a hobby ( I had just became a teenager).
In my second year (1977) at Queen Mary (University of London) they had the idea that it was better to start students with RATFOR (rationalized Fortran - https://en.wikipedia.org/wiki/Ratfor) because it would make them write better Fortran code in the future (1978). As I recall Jean Dollimore wrote the Sofor Q Mk6 front-end that converted Ratfor into Fortran since we were using an ICL mainframe at the time. Most Unix Fortran comilers of the time had a '-r' switch for Ratfor.
I think their idea worked - it certainly seemed to be a backwards step when I had to use Fortran the following year. Fortunately Fortran has moved with the times and is now a really nice modern language which I still use in my professional work today.
For sprites and speech synthesizer, Extended BASIC was mandatory! :)
Great fun and very satisfying.
In chronological order:
toying: basic, C
jobs: Turbo Pascal, Matlab, Java, perl, C#
CS Engineering studies: Scheme, Maple, Java, C++, Matlab
Today I mainly use Matlab for work.
My first language was BASIC. Initially on the Texas Instruments TI 99/4A, then on the Commodore 128D. I was 6-8 years old at the time :). Wrote loads of interesting stuff, worked with sprites and simple blocky graphics.
The first languages I was taught were Pascal and FORTRAN. My first real programming job was in Delphi, and from there (after a very short dip into SmallTalk) I moved onto C++ (with a small bit of Ada thrown in) where I stayed for many years before adding C# into the mix. Somewhere along the way I also learned Java, but never really got into it.
Since then I've written programs in most mainstream languages, everything from Perl and Python to Java, Javascript and F#.
The language I remember most fondly is Delphi. Easy and simple on the surface, especially the really easy way to build Windows apps, but with all the power of C++ if you dig deep enough, powerful enough that I got to know and more importantly understand, pointers in Delphi. It's no surprise to me that C# (having the same designer) borrowed so many excellent features from it. I've always considered myself really fortunate that it was Delphi and not Visual Basic that introduced me to Windows programming.
Basic on a Commodore Vic-20
Eagles may soar, but weasels don't get sucked into jet engines
Wonderful language for starting. At least at that time ;)
And on a ZX Spectrum-compatible, you could really learn to program hands-on, with immediate feedback and lots of fun.
I did not really program actively while in 2nd grade, so my dad's VIC20 does not count.
But I did program quite a lot on my own faithful Amstrad CPC 6128, which was light years beyond any C64 of my friends. Only, they did not realize that.
I did a little assembler Z80, but was too young to understand.
Later I started on my then 386-sx with Turbo Pascal 5.5. Got quite good eventually. That was years before any decent IDE with visual form designer and debugger.
A BASIC dialect on AtariST with auto indentation and enforced single command per line and without line numbers.
https://en.wikipedia.org/wiki/...
Atari rules... ermm... ruled.
As I'm writing this there are still two applications that I wrote 17 years ago that are still in production.
A kludgy interface between Mainframe, LDAP and an Oracle database. I've left that job 15 years ago.
Good luck replacing that.
It was on an expansion cartridge for our TI-99/4A. I wrote a game in it, nothing terribly complicated or good. Didn't help that the joystick port was broken and only allowed movement left, up, or diagonally left and up.
In 2014 Python and Java were the two most commonly-taught languages at America's top universities, according to an analysis published by the Communications of the ACM.
My first language was BASIC, because I learned it myself for an extra credit math problem using these things called 'computer manuals' every computer room had in the 70s. My second language was FORTRAN, because I learned it myself after I discovered that going to college was a complete waste of money when I could teach myself FORTRAN in a week for the cost of a book instead of paying someone else to do it.
37 years later, I'm still learning languages by myself from books and now the Internet because going to college to learn programming is a complete waste of money and time for smart people.
Mediocre people need it because they have to have that little piece of paper that says they know how to pass tests in order to get a job. And people that have been there lie about it to justify their waste of time and money.
I rarely read replies, it's my opinion and if you thought about your opinion a little more, I'm OK with that.
My first language, followed by Turbo Pascal, both still close to my heart even though after 25 years I've moved to Java/C++/C#/Python. Matter of fact, I did some part-time work developing VB and Turbo Pascal/Delphi applications while in college. That certainly helped me through college (another reason why I don't jump on the BASIC or Pascal hate bandwagons.)
FORTRAN IV. Yeah, I am that old.
--- Andy West http://andywest.org
For some reason (probably because it is handy for web programming and has powerful regexps), Perl was my first serious programming language.
== Jez ==
Do you miss Firefox? Try Pale Moon.
Here I learned the intricacies of a tape drive and programming with one (87-88). By the time I reached high school, I was BASIC'd out...I moved on to Objective-C on a NeXT Cube in the early 90s.
Unless you want to count various HP programmable calculator keystrokes as being a language. After Algol it was Fortran, some assemblers, snobol, lisp, bliss-10, and others.
Nice to see all the old /. greybeards posting!
Any way, for me it was just enough Basic to get to the C= monitor and have fun with 6502 assembly. Later it was 8086 assembly, then enough C on the old MSC compiler to get into a lot of trouble. The first language I sat down and really tried to learn was Modula-2, and later some Oberon.
-> I dislike sigs...
My dad brought home a KIM-1 from one of his engineering courses and let me play with it.
https://en.wikipedia.org/wiki/KIM-1
Tandy Color Computer, 6809 Assembly Language.
TRS-80 Model 3 with dual floppy drives, took 30-45 minutes to compile COBOL programs. So you had 1 maybe 2 shots to compile and run.
Interestingly enough, COBOL is not on my resume.
You can lose something that is loose, so tighten the loose item so you don't lose it.
The first attempt I made at learning programming was with C. Then I started playing around with ksh and perl, and that's how I first started to grok it. Then it was back to C and soon after C++.
My first 'formal' computer programming training was in High School, using a language developed at the University of Toronto called Turing.
https://en.wikipedia.org/wiki/...
It was a cute little language, and I remember doing some fun stuff in it, including some basic 3d wireframe engine work. Which was pretty exciting stuff in high school computer programming in the early 90s on a 386.
Vintage computer games and RPG books available. Email me if you're interested.
To paraphrase Steve Ciarcia: solder.
Sinclair BASIC, TRS-80 BASIC and GW-BASIC followed by QuickBASIC and then VisualBasic. I had some assembly, Pascal, FORTRAN and C along the way. But VisualBasic was always my favorite.
The first non web development class was C#. First language was Java (this includes web development languages). You might make a case for bash scripting, but That was barely more than stringing commands together.
lol BASIC
Yes, really. Machine language. Not even assembler. Punching numeric codes into cards. The 1620 was a decimal computer, so that wasn't quite as mind-bending as an octal or hexadecimal machine language would have been. That was in high school; computers in schools were still a rare thing in those days (1971). The 1620 was already an antique by then; in the fall the school replaced it with a less-antique 1130 because IBM was no longer willing to rent out the 1620. (IBM had run out of people who knew how to fix them and they were probably running low on spare parts as well; they hadn't made the system for years, so any spares they had were removed from decommissioned computers.)
Second language: Fortran. Also on the 1620.
First programming language I learned was Pascal. First on paper only, then on a DEC PDP-8, way back in '76. Then used 6502 assembly (by hand) on a KIM-1, my first own computer...
In 1968, my father brought home the user manual for TINT, the Timeshared INTerpreter for JTS, JOVIAL for Time Sharing. The rule of the house was that I could read anything except the books on abnormal psychology (and I didn't want to read those, they were yucky). I read the TINT manual, and said, "I can do that." A few months later, my father brought me in for a few hours to where he worked, System Development Corporation, Santa Monica, CA. I demonstrated sufficient proficiency on the AN-FSQ/32 timesharing system to have passed the programming class, had I taken it. In 1970, I spent some of the summer working at UCLA, translating statistical programs from JOVIAL to FORTRAN (F40 on the DEC PDP-10). In 1971, I was old enough to be paid as a programmer, working on statistics programs, novel user interfaces, and operating system modifications. I never did learn how to flip burgers or serve ice cream, like my high school friends did.
JOVIAL (Jules Own Version of the International Algorithmic Language) was an ALGOL-class language created to program US Air Force systems, such as SAGE (the Strategic Air Ground Environment), starting in 1958. System Development Corporation (SDC) was the world's first software company. DEC built the most fun computers in the 1960's and 1970's. UCLA is the home of the Bruins.
Craig Milo Rogers
Algol on a Univac 1108. Since that was 47 years ago, my recollection is a little rusty.
Bauermlb
My first program was the Sieve of Eratosthenes in Algol 68 in 1978. After handing in your punch cards you had to wait 3 hours before you got your results, of some syntax errors.
In 1981 with computer studies in high school we started with mainframe assembler and COBOL, I was on the verge of quitting when we started Fortran. I realized the power of computing and the rest is history.
He who experiments learns much but reboots/reinstalls often.
Started in 1972. RPG II on a 360-20 (RPG was with Tape only, do disk). Then Basic Assembly language on IBM 360-20 and Hitac 8000 (A Japanese IBM 360 blatant copy). Thereafter NCR 315-100, NEAT (NCR Effective Coding Technique) , NEAT III on B1, B2, and B3 O/S. Then over to teaching Cobol. Taught my son Basic when he was 6 years old. Then a slew of databases; from Pick, DBase, Foxpro Unidata to Informix. Last language I taught professionally was Delphi.
I wrote a music synth that used a Gravis Gamepad as input for my computer literacy class at the local JC when I was sixteen. I loved that it had a built in manual!
Bamabell (Univac SS-80) or GUNI (General Utility Numerical Interpreter for the Univac 1004); The University of Alabama Computer Center.
One of them was my first.
In 1985 I was using the DEBUG command to create .COM programs, Does this count as a programming language?
About the same time, I started creating games in BASIC, but this was for a hobby. My elementary school had a course teaching Turtle with simple instructions (pen up / down, turn left / right by certain degrees, change pen color, move forward / backward a certain distance, etc). Was this my first programming language?
My first ISCS class at university used Smalltalk. While I was on my 2-year mission, IS and CS separated and the first CS class used Java. Subsequent classes used C, C++. Eventually we could use any language we chose.
Previously known as MetaCard and now known as LiveCode. VisalBasic 6 shortly after that.
My first "language" were hardware opcodes on an IBM 1620. I was in high school in the early 70s and a local government lab gave school access to the system which was still maintained by IBM at that time. It had a typewriter and a card reader/punch. You could enter instructions through the typewriter or read them in through cards.
Each op-code had two decimal digits and up to two parameters. No registers as such operations were memory-to-memory. There were 20K words each 6 bits -- 4 for BCD and two flag bits. Core memory of course.
Always fun that in order to do arithmetic you had to pre-load the addition table. The architecture was decimal-based and did not include hardware addition logic. For that reason the system earned the name "CADET" (Can't Add Doesn't Even Try).
There was a FORTRAN II compiler for it that we didn't use much except to try it. It was a multi-pass compiler and it would punch out intermediate steps on cards that you had to feed back in to perform the next pass. Good times.
But I recovered.
Ironically I still get involved in BASIC being used in industrial applications - it's still a thing because the rigors of becoming and remaining a Subject Matter Expert precludes becoming an expert in even mundane languages like C. In addition, hiring an actual programmer generally is not economically viable.
Programmed IBM 1401 with 4K of RAM....1963
Yes, I'm really that old.
Learned BASIC at summer camp on a TRS-80 Model 1, then my father got a Model 3, then I eventually got a TI-99/4A.
In high school they had BASIC classes, but I learned C on the PDP-11/70 running Unix from friends at school. My first C program was very BASIC-like. Once I got a PC, I started dealing with 8086 Assembly (and totally doing frame setup wrong). Learned Pascal to take the Computer Science AP class.
In college, I ended up having to take the low-level intro to programming class, despite my AP scores, because they added "two weeks of FORTRAN" at the end of the class. I got to skip the Data Structures due to AP, but ended up taking classes in 8086 Assembly, Ada, 68K Assembly, SQL and Scheme. Started learning C++ on my own around this time, too.
On my first job, learned just enough AMD 29K assembly before they cancelled the project.
Learned Java while taking classes for my masters program.
After that, learned Perl for scripting a source control server.
I've picked up a little bit of python at my current job.
Before PL/I I used to key in octal commands to enable a Digital computer to bootstrap the OS, which was on punch tape. This was in the mid-1970s.
In publishing punch tape was a common data transmission source inside a shop, so using it for the OS and code was a no brainer. Plus 6 level and 8 level tape gave you two common byte sizes.
I enrolled in a BS/CS program in 1980 which used PL/I as the main instructional language. I never used it professionally, but it was common in Grad School too.
Think of the Irony!
8080 machine code and hand assembly programmed into EPROMs via a Prolog programmer. After that it was Z80 macro assembler on a CP/M system with floppy disk drives.
University, 2009.
Aside from BASIC and 8080/Z80, FORTRAN.
FORTRAN was -- for some still is-- the 'Perl' of scientific computing. Get it in and get it done... and it doesn't always compile down very tight, but always fast because for mainframe developers getting this language optimized for a new architecture was first priority.
At 15, the first real structured program I ever de-constructed completely while teaching myself the language, was the FORTRAN IV source for Crowther and Woods Colossal Cave Adventure, widely regarded as 'the' original interactive text adventure, a genre which would later go multi-user to become the MUD. Read about it here, or play it in Javascript.
FORTRAN IV and Dartmouth BASIC (I'll toss in RPG II also) were the 'flat' GOTO-based languages, an era of explicit rather than implicit nesting -- a time in which high level functions were available to use or define but humans needed to plan and implement the actual structure in programs mentally by using conditional statements and labels to JUMP over blocks of code. Sort of "assembly language with benefits".
Crowther's PDP-11 Adventure version was running on the 36-bit GE-600 mainframes of GEISCO (General Electric Information Services) Mark III Foreground timesharing system... this is in the golden age of timesharing and no one did it better than GE. It took HOURS at 300bps and two rolls of thermal paper to print out the source and data files, and I the Adventure code and data out on the floor and traced the program mentally, keeping a notebook of what was stored in what variable... I had far more fun doing this than playing the game itself.
Then the "real life" adventure began. I started poking around on the Mark III timesharing system, and found a way to jump out of my partitioned access and explore. What really helped was a collection of FORTRAN/77 system utilities written by an engineer working at GEISCO (this is General Electric, no relation to GEICO and the year is ~1980). Their development environment as well as the commercial systems were controlled by password protected accounts, each with file/user areas... BUT there was also this command line debugger that was able to write to memory regions beyond your own job, and if you were able to parse out memory structures (reading source for the utilities helped) you could "punch yourself in" to any user number (location), effectively changing identity to that of another user and seeing their files. Or examine the buffers containing character streams of other users' terminals in real time. It was fascinating and I soon had developed a suite of tools in F77 to assist in exploration of the system, leap-frogging onto the commercial file systems too. I kept the source encrypted by the F77 'SCRAM' function, decrypting it only to edit and compile. My cache of tools was stored "in" a user number that did not exist, you can think of it as a unpointed-to lost cluster of sorts. I was totally white hat about it, never prying into customer files (McDonald's etc.) and even wrote a summary of vulnerabilities and dropped it into one of their secure areas. I just wanted to be hired. Cat 'n mouse games ensued, even a trace and FBI phone tap. GEISCO originally thought I was a rogue employee but when they learned I was just a kid the heat was off, they were afraid of public embarrassment. They bought me a plane ticket to Rockville MD so they could pick my brain, and the matter was closed soon after. I was not hired.
Lots of people have played Colossal Cave Adventure over the years, but in my mind the game is synonymous with the Mark III timesharing system itself, that was the biggest cave of all.
I had write access to their entire network. What did I do with my "superpower"? Well for one thing, I scanned to find ALL copies of Colossal Cave Adventure on their system, there were about a dozen that had been
<blink>down the rabbit hole</blink>
Advanced math class summer of 1965 used a Monrobot XI computer, It had a drum memory and you loaded programs from paper tape. Picked up BASIC then PL/1 second year of college.
Or as I liked to call it. Random Problem Generator.
Worse than Cobol and Fortran combined.
The day Microsoft creates a product that doesn't suck, it will be known as the Microsoft Vaccuum Cleaner!
Don't know what version, but it was on a time-sharing (a sort of antediluvian version of "the cloud"), and at first, program storage was on paper tape.
There's no time like the present. Well, the past used to be.
There was no programming language for the NCR Elliott 405 that I first wrote programs for in the 1950's in Sydney, Australia. It was considered to be the first commercial computer in Australia. Everything had to be written in machine language because there was no compiler. The only software available on the machine were two programs named Roger and Albert both of which were on paper tape. Albert's only function was to set the computer up to read Roger which allowed one to create a program in assembler. The resulting program could the be punched out onto paper tape. I just wish that I could find the manual for it now but am unable to locate it anywhere.
circa 1996, started teaching myself Perl in order to write CGI scripts to hook up a data source to an HTML form.
Actually, the TI-58/TI-59 opcode set. I think earlier Texas Instruments TI calculators in the 5x series shared opcodes - but I'm not sure.
Think of it as an adjustable Harvard machine architecture. Programming in a language that was written like APL (special keyboard) and read like machine language.
Not knowing that BASIC was not necessarily BASIC, I used a programming manual for the TRS 80. That's how I learned to do work-arounds...
In their order of learning, the very first was Basic v2.0, used a good 4 to 5 years, then inside the same year I learned: Turbo Pascal, Fortran and Lisp. Then thankfully, I turned away from the dark side of the force and ditched programming all together to switch toward systems and networking ;-)
IBM 360 assembly language BALR (Branch and Link Register)
My first programming language was that of the HP-65 calculator.
As a child - long time ago - I met "basic" atari. Several programming languages along the way and ... nothing to do with this.
I do not even improve PHP anymore.
Now I only write blogs:
Social Media Marketing
and Very normal travel blog Ciekawe miejsca w Polsce What you can see interesting in Poland (castles, palaces, sacral objects, museums etc)
Sanyo BASIC.
10 symbol(100,100), "Some big coloured text",4,3
20 out (&h38,1)