mytechne : User bittercoder

1985–

My first experiences with Basic where learning the language (without even having a computer) from listings in "learn to the program" books aimed at children in the early 80's - I moved on from there to APPLESOFT BASIC, then COMMODORE BASIC, GWBASIC, QBASIC and then Visual Basic.

AppleSoft BASIC

1985–1987

While at primary school in Warkworth, got my first introduction to writing simple programs in AppleSoft BASIC. More just wrote input of programs / tinkering - then understanding all the concepts like variable assignment etc. (I was only 5 at the time)

Commodore BASIC

1986–

My cousin had a VIC-20 when I was a kid, used to borrow it in the holidays and write basic programs.

C

1991–2003

I learnt C and C++ at the same time. Did briefly work on an a DOS accounting product written in C while I was at school, it was my first experience of header file hell :) Still read C/C++ code, but don't write any these days (useful skill to have to understand algorithm examples).

C++

1991–2003

Started teaching myself C++ when I was 11, mostly from the Turbo C++ manual (which was actually quite a good introduction in OOP). Continuted to use it until around 2003, where I finally shifted across to writing only managed code (or working with dynamic languages etc.)

x86 Assembly

1991–2000

I mostly did "inline assembler" within C++ dialects. But also did a little MASM while studying. My love affair with assembler began after getting into the demo scene in the early 90's, where squeezing every last bit of performance out of line and texture blitting operations was important :)

VisualBasic

1992–2002

My first experience with Visual Basic was at high school, where it was being used to teach basic programming classes. Took to it quickly, and developed a number of programs with it - though still favoured c++ programming for games etc. development at the time. Started using the language again (VB5/6) to develop COM objects for use from within ASP classic applications just prior to adopting ASP.Net.

Bourne Shell

1997–

Still use this shell on a few devices every month or so, though only rarely write shell scripts these days (mostly batch files, powershell scripts instead for windows-based machines).

VBScript

1997–

Started learning VBScript/VBA while studying. Then moved onto commercial ASP classic development (mostly building content management sites) - can't say I enjoyed the technology. Still on the odd occasion have to support ASP classic code (unfortunately) - would be nice to put and end year on this language!

Pascal

1997–1999

Learnt turbo pascal while Studying. Actually went on to use those Pascal skills when learning Delphi and building a few applications using Delphi.

Delphi

1997–2001

I learnt delphi while studying - for GUI programming courses (along with Jade). Though I didn't really use the language for commercial purposes, I did write a number of reasonably complex applications in it. At the time it had one of the best debugging experiences I had encountered in an IDE, and quite a cool component model compared.

Javascript

1998–

I started with very basic javascript (form validation anyone) during my time studying. Javascript skillls have grown slowly by surely every year since.

QBasic

1998–2000

QBasic I adopted immediately after GWBasic - I wrote a number of different games and programs in this language before moving on to Turbo C++.

Perl

2000–2001

Taught myself Perl while studying - worked on a project to provide a Perl based platform for converting ASP based "commerce server" applications across to Perl (replicated the whole commerce server pipeline etc.)

XSLT

2000–

Don't use it often - but do tend to use XSLT at least once per year for something. First learnt it while working with an XSLT based CMS system when working at Terabyte Interactive. Hate the signal to noise ration of XSLT compared to other templating/transformation languages.

Tcl

2001–2003

I became a big TCL fan while writing ASP code in early 2000's. Mostly because at the time it looked far superior to the ASP classic's VBScript. Later on I embedded it in a few hobby projects as a scripting engine etc. before my interest started to die off, in favour of the Python language instead (which was the new hotness at the time).

Python

2001–

I had a love affair with Python while being an ASP classic developer (because ASP classic was terrible!). But after the release of .Net I really neglected the language. After the releae of IronPython 1.0 I started learning/adopting python again, as it was a script language we embedded into a number of products. Since then I have sporadically used it, I still think python code is some of the most pleasant to read (significant whitespace, list comprehensions etc.).

C#

2002–

Started off with the first Beta of C# and took to it, glad to leave both VB6 and C++ behind for business development.

ColdFusion

2003

Worked briefly on some Cold fusion projects - OH GOD - it was just simply awful.

PHP

2004–

Still maintain some PHP Code. write a little commercially, mostly to support PHP based CMS's (i.e. CMS modules). Really don't like the language all that much, though there are some pretty slick libraries out for it these days (the developers must be very patient ;o)

Eiffel

2004

I learnt Eiffel in 2004, while reading the "Object Oriented Software Construction" book... mostly to understand the code examples. I still find some of the features of the language innovative today.

Ruby

2005–

Got into this language via Rails. Mostly via a few books: The Programming Ruby pickaxe book. Why's poignant guide to Ruby. A few ROR books/cookbooks. Have also used IronRuby on a few occasions, mostly a hosted script language in .Net applications (though I still prefer IronPython because it's a little more mature).

Factor

2008–2009

Started learning Factor in 2008, found it totally mind bending. Also learnt Forth around the same time (using GnuForth mostly). Never used it to write any commercial code... I suspect people having to maintain that code in the future might curse my name :)

F#

2008–

Love the language, though I think it's adoption has definitely been hampered because of a lack of good IDE experience (looking forward to using it for a few projects in VS2010 once we make the shift).

Forth

2008–2009

Started teaching myself Forth, mostly after learning about Factor (which I learnt at the same time). Definitely mind bending, though I can't say I ever felt particulary profficient in the language. Have not returned to it for a good year or so.

Scala

2009–

I learnt Scala from the "Programming Scala" book in mid 2009. I really like the way the language hangs together - but haven't had much of a chance to use it for any commercial development so far (predominantly being a .Net / CLR based developer).

Clojure

2009–

Have been learning Clojure since late 2009. Mostly by reading the "Programming Clojure" book by Halloway.

Haskell

2009–

I've been learning Haskel since mid 2009. Keep picking it up / putting it down, but like it's terseness.

Programming Languages