I started in Basic

need speed

Then Assembly

need sanity

Then Pascal

need gui

Then Delphi

need work

Then Perl

need fun

Then ActionScript

need objects

Then C#

I skipped a few (php, COBOL, C, C++, Java) for clarity.

If you get the concepts right, learning a new language is hardly any trouble. The tough part is learning the platform and idioms. Those who say they know Perl and PHP, Java and C#, usually mean they know CPAN and PEAR, JDK and .NET.

Edit: All of the languages above are procedural, that's why the are so similar. A programmer should know two kinds of programming languages, functional (e.g. Haskell, Lisp) and procedural (e.g. everything else). And no, HTML is not a programming language.

This is an experience/age related question. As you gain more experience, languages come and go. Although there's certainly merit to being extremely experienced in one language, most likely for your career, you'll end up knowing 5 or 10 languages. I suggest that you seek out opportunities to learn different languages and it will give you different ways of looking at a problem.

They say that if all you have is a hammer then everything looks like a nail. Different languages have been designed to solve different problems. If you know several languages, then when a problem comes along you can look into your toolbag and pull out the right one to solve the problem at hand instead of using a hammer where a chisel would be better.

Did you ever switch from one programming language to another?

Why yes I did! How could you know?

If yes, why?

Because the world changes. Once upon a time every computer came with a BASIC interpreter (or two). These days I have no idea how to lay my hands on one. Instead, my computer contains least Python, perl, Ruby and the whole GCC.

I started with BASIC. Now it's mostly Java and Javascript at work, Python at home. Next target... perhaps Erlang. Or Arc.

Besides personal language overhaul, the industry has gone from C/C++ to Java/C#. The world turns and we'd better turn with it or risk becoming the next generation version of the suspender wearing COBOL-hackers, who lurk in the dark hallways of most large companies.

The stereotypical programmer is very keen on writing software in one particular programming language and is very fanatic about defending their programming language in any way they can, without being realistic about whether their programming language is the best tool for the job. (emphasis mine)

GET OUTTA HERE! In my world, the stereotypical Programmer uses the best tool for the job. Period. Punkt. Piste.

Even the most stubborn one-language guys eventually give in. I've seen this a lot lately when former C++ or Java programmers discover Python or Ruby. Their eyes used to burn with zealous fire when they were talking about their Serious Language For Serious Business (yes, a Cal Henderson -quote)... but these days you can see a sort of a enlightened glow in there. And it is good.

Most Computer Science grads I know switch quite often between languages, for alot of different reasons...for example:

• I know people who refuse to program in C# because .NET = Microsoft (excluding Mono I guess), but have had to use .NET for a particular contract (and eventually enjoyed using C#). These were the same people who coded in C/C++ but have since changed to Java now that its open sourced.

• Functionality - in the course of 3 years we switched from Scheme to Java with detours around C, Perl and Python and Smalltalk (egh). Scheme is a great functional language and its strong on lists and is great to teach the young ones about recursion.

• Your Employer requires it - I've had the (dis) pleasure of working in an environment that used the motto "As long as it's Microsoft" - all the code was in VB/ASP and that killed me. At home I play with PHP and I've now discovered the awesomeness of GWT which is based on Java. I suck at Java but can make my way around it...sort of....sometimes I wish I payed more attention in Varsity.

At the end of the day I guess, all's well if you understand the foundations of programming concepts. My main problem is that I am a very slow learner :)

• Started in Basic - Wanted to modify the 'Gorillas' game that came with MS-DOS.
• Went to VB - So I could make AOL Bots.
• Went to Java - Because it was the new buzzword and I wanted to make annoying applets.
• Went to C - Because it was taught in High School and college (and got sick of the slow JVM at the time).
• Went back to Java - For my first job and I wanted to eat some JavaBeans.
• Went to C# - For my second job.

I can't really post a timeline of languages I've switched through because I tend to use multiple languages at the same time. I think it's important to have more than one language in your toolset - this means you can choose the right tool for the job. I hate having to work with developers who've learned to use one language and apply it to every single job they undertake. It's like working with someone who in the murky past was taught to use a hammer, and now uses it for everything.

• Got a nail that needs bashing in? That'll need a hammering!
• Got a screw that needs screwing in? That'll need a hammering!
• Got a kitten that needs looking after while you're on holiday? That'll need a hammering!

One reason to stay with one language as much as possible is to avoid the situation in which every project in your company is implemented in a different programming language, which in turn comes with a different IDE, standard library, custom written libraries, library quirks, programming language idioms, quirks and limitations, profilers, etc...

I remember when C# first came out, I was very passionate about it. Then one of my friends showed me some cool functional techniques using Lisp and then I realized that no language is perfect. It will take a long time for a language to evolve. There is no use being fanatic about one particular language. By the time it reaches maturity, we will hear another new language coming out. :) Some languages are for addressing performance, some for productivity, some for scientific or academic fields etc. We should never ever be influenced by marketing.

One advantage doing consultancy is that you will be forced to learn so many languages. It has helped me in many ways like understanding the strengths of each language, what domain they are best suited for etc.

Having said that, you need to really specialize in at least one particular language without being fanatic about it. They key is in understanding the fundamentals and having an open mind to learn or adapt to other languages and environments.

Only an idiot programmer would say they use a single programming language all the time.

Any programmer worth anything will know at least a half-dozen languages. It's not like most of them are all that different, anyway.

Nowadays I primarily use REALbasic, but I've worked with more languages than I'm sure I'll recount here:

• C, C++
• Java, PowerBuilder, C#, VB.NET
• BASIC, Visual Basic, Pascal
• PHP, ASP
• Assembly (8086)

I'm really keen at taking a look at Ruby and/or Python but just haven't had the time.

Why do I switch? Sometimes it's what the company requires, sometimes it's what I think will work best, sometimes it's what I think is the most fun.

I've used C++ throughout most of my career, initially on Unix platforms (SunOS/Solaris, HP-UX), and now on Win32. That's more due to circumstances than an explicit choice, though. As the need arose for a lighter-weight language for building tools and simulated servers, I started regularly using Python. I also use Python for my home projects, because I like the language. I've also dabbled in C# as required, to fix bugs in other people's code on my current project.

Each language has its strengths and weaknesses, but just as important is the broader context in which it is used. This includes whether a company is comfortable with a language (my current employer perceived Java to be too immature for robust development, hence we used C++), and the skills and preferences of the programmers you can get.

While languages come and go, the fundamental principles remain pretty much the same. Even the switch between imperative and functional isn't that big a deal if a programmer has a solid foundation in compsci principles.

If it can't be done in LOGO, then it isn't worth doing!

If that makes me a

REPEAT 4 [FD 100 LEFT 90]

I don't care!

Turtle Power!

I learned languages in the order listed below. I am actively using Java, C#, VB .NET, PowerBasic, PowerShell, Python, PHP, and VB 6. My favorites at this time are PowerShell, PowerBasic, and C#.

I try to use the language that best fits my task. This is usually a combination of language features, performance, run time requirements, and my comfort level. This is a dynamic combination that changes over time. I also devote some time each year to learn different languages. My goal is always to be more efficient and to maximize what I can do in as few languages as possible.

 1. Fortran                    11. Forth              21. Python
 2. Honeywell Assembler        12. 8086 Assembler     22. PowerBasic
 3. Cobol                      13. C++                23. REALbasic
 4. PL/I                       14. VB 2.0             24. Ruby
 5. IBM 370 Assembler          15. Perl               25. PowerShell
 6. C                          16. Java
 7. Atari Basic                17. PHP
 8. 6502 Assembler             18. LotusScript
 9. Pascal                     19. C#
 10. Action                    20. VB .Net

Lots of good reasons above to change languages because languages are different. I'm going to mention times I changed from one language to a very similar language.

Started out writing shell scripts in sh with plenty of sed and awk. Switched to ksh88 when I worked for phone companies; not much change. Then, when ksh93 was available, switched in earnest. Reason: sh compatible still works for 90% of scripts, but when extra power is needed, ksh93 is there. I never need or use awk any more.

Second example: Learned Icon in school around 1990. Still think Icon has the best string-processing model ever invented. Very good data structures for sequences, sets, tables. But Icon has poor libraries, poor integration with OS, and can't be extended. Still worth it for string processing and powerful search capability. But by 2000, Lua is powerful enough to have first-class functions, good integration with OS, great extensibility, and very good string processing. Essentially the same data structures as Icon, but a simpler design. Not as good at strings as Icon, but way better than awk, perl, and the rest of the regexp crowd. By 2005 I discover I have not written a new Icon program in 6 years. Now in 2008 I am replacing legacy Icon code with new Lua code.

Third example: Modula-3. Used M3 for a major project around 1990-1992, shortly after it was invented. Still the best design I have ever seen for writing large systems programs. Superb ability to have both safe and unsafe code in the same program. But Digital has no idea how to promote a language, in 1995 Sun rolls out Java, by 2000 it is clear that Modula-3 is dead. At the same time, systems code has become a tiny fraction of what I do. So now when I have to do it, it is back to the C I learned in 1984.

[fanboy vs. language slut] Did you ever switch from one programming language to another? If yes, why?

I'm a language slut. I like learning new languages, and somewhat perverted I like (sometimes) deliberately using the wrong tool for the job, just to see how far any given language can stretch. Of course, only for my hobby projects :)

I often "switch" languages, in that I'll typically use the language I know that'll let me do what I need fastest. For some time, all I knew was C, so I wrote everything in C. Then python, and bash scripting. If portability is ever an issue, I'll probably rewrite my ~/bin in python, but for now /bin/sh is fine.

To answer your question succinctly: I've never switched per se, I've just added new tools to the toolbox and stuck to "the best one", which has tended to remain constant throughout some time, but with sudden shifts once I learn a new language.

And I advocate learning new languages for a broadened understanding of what programming is. If I could force any languages upon people, I think I'd pick the following:

• C: for the pointers, and the low-level understanding you get
• Haskell: for understanding (pure!) functional programming
• Lisp (or scheme): for understanding macros and (so I've heard) (mini-)language design.
• Smalltalk: I don't know it, but I think it might teach you a thing or two about what OO was really meant to be about.

And I don't recommend a "switch" to any of them (I only know C well enough to be able to recommend a switch to that, and I know there are many jobs that C aren't the ideal tool for). But learn them for the better understanding they'll give you.

I started, like many, writing webapps in PHP. As I learned more and more about programming, and realized what an unmaintainable mess PHP was (as well as how cluttered the language was itself), I tried python, and loved it. I've stuck mainly with it ever since.

C -> C++ -> Java -> C# I usually switched languages when switching between projects. Used to be a big C++ fan, now I'm just using whatever language is right for a specific project.

I have done professional development work in (rough chronological order):

1. SBASIC
2. FORTRAN IV
3. CORAL 66
4. x86 Assembler
5. Ada
6. 680x0 assembler
7. C
8. C++
9. Pascal
10. C#

and several scripting languages. You use the language that's either (a) mandated, or (b) the right language for the job. This may be governed by needing to use a particular library (I had to use FORTRAN for the GKS library, for instance). It's not always a matter of your own choice. Get used to swapping between languages if you expect your career to have any longevity. The principles of procedural languages don't change.

I've always switched languages for two main reasons:

• I need them for work
• I though they might be useful on my cv (that's the main reason I learned C#)

The important think to keep in mind is that I don't really think the language is important at all. You learn one to get experience with it so that if you need it at work you'll be able to learn it more quickly but languages are just tools, almost everything is done the same way in every language.

Nontheless I've look up some programming languages for fun like Spec# which I like A LOT but is still in CTP stage and thus won't be used for real things in a while.

If you really wanna learn a useful new language then go for a paradigm change more than a language change. Learn Lisp or F# or Haskell or whatever functional language you choose (erlang might be useful someday for example). Learn Prolog as well. That will give you a more general overview of programming techniques and you'll learn about new ways of thinking about problems.

For me, it was GWBASIC -> QBasic -> Visual Basic -> C#.

I didn't spend any time on VB.NET. I saw C# as my way out of the BASIC world.

I would like to learn Ruby and master JavaScript, but I never make the time.

"Did you ever switch from one programming language to another? If yes, why?"

Yes. To stay employed.

See Programming Languages I've Learned, Programming Languages I've Learned in Order ^[1], Programming Languages I've Learned (In Rough Order) Meme ^[2].

Used: CBasic -> FORTRAN -> Z80 Assembly -> Lotus 123 (see below if you don’t think spreadsheets are a programming language) -> C -> 8080 / 8086 / x86 / 68000 Assembly -> Hyperscript -> Eiffel -> Objective C -> C++ -> Java -> C#.

Tinkered With: TRS-80 Basic -> 6502 Assembly -> Lisp, PL/1, MBasic, Dbase, Postscript, Visual Basic, SQL, Delphi, JavaScript, F#.

Someday I’ll have a look at what all the fuss is with dynamic languages, but I am too busy lately. Will C# 4’s new dynamic features count?

If you have nothing better to do, below is a little insight into how / why I ended up using some of these and how / why I moved on to something else.

TRS-80 Basic – I was a young Honda motorcycle mechanic in 1978 when the owner of the motorcycle shop purchased a TRS-80 in an attempt to automate the parts department (all those parts and no computer – how did we do it?). I tinkered with it some, but the unreliable cassette tape storage was too frustrating and racing motocross was a lot more rewarding for a 19 year old with a competitive streak. Too bad for me.

6502 Assembly - I was a bored motorcycle service manager in the dead of winter in Lawrence, Kansas (Rock Chalk, Jayhawk!) in 1982 (too cold for motorcycles and not enough snow for snowmobiles). So I bought an Atari 800 to play video games and found that programming was more fun. My Atari 800 did not have enough RAM for Basic - sometimes it's better to be lucky than good (I’ve often thought that learning assembly before anything else taught me something useful). I actually got a Reversi game and disk copy program working and somehow convinced Byte magazine to publish a reference to them. I think I sold three copies…not very rewarding considering the fact that I was sure I had the fastest disk copy program ever created.

CBasic – I decided it might be nice to get paid more than 9 months out of the year (motorcycle service in Kansas does not pay too well in January) so I sold the Atari and bought a Xerox 820 CP/M computer which had a pair of huge 241K 8 inch floppy disk drives and an unbelievable 64K of RAM! It was the most expensive thing I had ever purchased at the time. I was fortunate to find consulting work for a local VAR customizing CBasic accounting software for local businesses. CBasic was far superior to MBasic (Microsoft Basic) for many reasons (did I mention it was much faster). Looking back, CBasic was the first language I used which was reasonably good for developing business software.

Z80 Assembly - the VAR got involved in marketing a portable computer called the Zorba (like the old Osborne portable). It had reliability issues and I got involved in fixing some of the issues which was a great learning experience. Wow, I could write some amazingly fast stuff in Z80 assembly. Did I mention that I used to race Motocross and I like “fast”?

Lotus 123 - I know, most programmers don't think of spreadsheets as a programming language, but you could make a case that "spreadsheets are the most popular functional programming languages in the world" (Google it and you'll see what I mean). Lotus 123 was the first really great piece of software I used. It was so much better than VisiCalc, SupreCalc and Microsoft's Multiplan which I had helped our customers with. Did I mention that Lotus 123 was faster - like night and day! I went to my boss and told him we should develop our own spreadsheet, because as good as 123 was, we could do it better (I think I probably meant “even faster”). He laughed and promptly dismissed the idea – but I never forgot it.

C – Through a series of fortunate events, two years later I was leading the development of the Smart Spreadsheet 2.0, and later SmartWare 3.0 (office productivity software for DOS / Unix which never made the transition to Windows). After going to COMDEX in 1986, I persuaded the powers that be to let me start building a new spreadsheet for Windows – which eventually became Wingz for Macintosh because Windows wasn’t quite ready for prime time. Wingz went from 0% to ~25% of the run rate for spreadsheets on the Mac in a short period of time thanks to the fact that it was years ahead of Excel in several areas (yes, it was faster, but it was a lot more than that). Unfortunately for me, Informix had purchased the company and decided to get out of productivity software when their core database business hit a rough patch, so all that hard work went down the tubes (biz lesson – own your own code if you possibly can).

Smart Project Processing and Hyperscript - SmartWare and Wingz actually had their own builtin languages - Smart Project Processing and Hyperscript. Both were English like (wordy). I had argued for making the language built into Wingz a derivitive of Pascal - but the powers that be were sure that nobody who used a spreadsheet would ever want a real programming language.

8080 / 8086 / x86 / 68000 Assembly – back in the day when it was the exception to have floating point hardware it was crucial to have your own floating point routines. Smart Software and Wingz also had a fair amount of assembly for frequently used string and memory routines. Sometimes I still wish I could implement a crucial C# method in assembly…but who wants .NET code that is unsafe these days?

Eiffel - I stumbled upon one of Bertrand Meyer’s early books on OO programming in Eiffel. I never did any real work in Eiffel but I believe reading this book taught me more about creating reliable and reusable software than anything else I’ve done in all my years of programming (that sounds like something an old person would say).

Objective C – I purchased a beautiful Next Cube for $15K of my own hard earned cash (my wonderful wife though I was nuts). I quit my job (guess what my wife thought about that?) and tinkered around for a while, did some performance work for a networking company and eventually started to write my own spreadsheet for NextStep in Objective C. The Next was built on the Mach kernel and was the first OS I used with real lightweight threads – the things I learned about multi-threading back then are definitely useful now! It had Display PostScript – which was actually the thing that first attracted me to it. The concept of the display and printer having the same graphics language seemed like a no brainer to me and I was sure Next was the next big thing. Most people know the descendant to NextStep as Macintosh OS X.

C++ - Unfortunately, Next didn’t make it and I needed to find a way to pay the bills, so I converted my Objective C / NextStep spreadsheet to C++ / Windows (via MPW Pascal but that’s another story) and teamed up with some guys who knew how to run a business and sell things. We released Formula One as a VBX (Visual Basic 4 Extension) and C library in 1993, followed by a C++ wrapper, an ActiveX (COM) version and even a Netscape Navigator plugin – which was the first internet spreadsheet AFAIK.

Java – Having led the development of commercial software which ran on multiple platforms, I completely bought into Java’s Write Once Run Anywhere mantra. I already thought the idea of a “real” spreadsheet running in the browser was a real solution to a real problem and Java Applets seemed to be the perfect way to implement this. Formula One for Java was the dominant spreadsheet component for Java for several years – basically until the pricing model was changed to “as much as we can get” which drastically reduced the ability to add customers. Formula One is now the engine behind Actuate’s e.Spreadsheet which is still a pretty good product as far as I can tell (albeit expensive).

C# - My official reason for leaving Actuate several months after they purchased Formula One was the fact that they would not let me build Formula One for .NET (biz lesson – don’t have business partners who will sell your code to someone else if you can possibly avoid it). They had and still have good reasons for this and I still like the people there – but I was tired of trying to build a real GUI application with Java / Swing. While Java was great at some things, it was definitely not so good for building GUI applications (remember, this was 2002, I don’t know how true that would be today). C# made some important improvements (Java still had no enumerated type after 7 years!). But the key was that, IMO, Java’s Write Once Run Everywhere mentality led to sub-standard Windows applications – and most business software developers who wanted a spreadsheet component wanted it to look and feel like proper Windows software.

Managed C++? – I sometimes think we might rewrite our core engine in Managed C++. Theoretically, we could then build safe .NET components as well as a native core engine from the same source code base. I have no doubt that a C++ core engine compiled to native code would be faster at any given point in time than the C# equivalent. But my concern is that adding features and improving algorithms would take much longer in C++ than in C#, and that eventually we would get to the point where we would have been better off sticking with C# for it’s increased programmer productivity.

F#? - As I consider the work we need to do to take better advantage of multi-core processors, it seems that it might make sense to convert portions of our code to F#. If we’re lucky, all of the features which make F# better for multi-threaded scalability will find their way into C#.

tripping blindly, thru forests of apis where my little adventure; will soon meet it's demise;

of dragon hunting and compiler wrestling; my work is hardly done; I find the first much easier; the second is hardly ever won;

for newbs like me I stumble; thru docs and syntax unknown; thumbing threw appendixes; whilst my hair has overgrown.

If you don't want to end up like me this is a cautionary tale; stick to one language for now; lest your learning efforts fail.

That little poem describes what the last five years of my life were like trying to learn to program. I'm good with math and once I spend a week or so with a language I can get the feel for it. The problem is every time I started learning a new language I always found something to complain about it, until I realized there is no silver bullet.

Roughly this is how my experience panned out:

• BASIC: Not enough low-level control, slow in most varieties
• Assembly: Fast but largely system dependent, prone to causing crashes if not used right, not a sane method of developing large application. Too low-level
• C: Messy libraries, no reasonable methods for maintaining code in old, large apps.
• Obj-C: Largely dependent on Apple, the evil step-child of Microsoft. Difficult to setup and use on Windows.
• C++: Monolithic libraries, horrible hacks atop hacks atop hacks, design patterns implemented in the most obtuse of fashions. Wrestling with the compiler. Obscure and difficult to solve bugs.
• Java: Slow unless you know exactly what your doing. Support for the language has sort of devolved into a mass of monolithic libraries, while the community moves onto other languages based on the jvm. Terribly verbose.
• Python: Slow, lack of multithreading or some other efficient concurrency mechanism, transitioning between versions 2.6 to 3.0 which will break compatibility with some libraries until fixed.
• Lua: Really loved this one for the concise syntax, uniform semantics, efficiency, and small size. It's C interface needs reworking and true concurrency is a no-go.
• Haskell: Strong typing is a lovely thing when your like me and are not that great at debugging in the first place.
• Javascript: It's ubiquity is both a flaw and a strength. Terribly slow, virtually no access to the client if running in a browser (could be another strength or weakness) and variable implementation in major browsers which forces workarounds for certain operations.
• Delphi: Expensive, not widely supported. Every time I look at it I get the gnawing feeling it won't be around for much longer. That and I haven't seen too many jobs available for it.
• Erlang: Excellent scalability, "concurrency for free", difficult to debug.
• C#: The doom of every application using it, be it Mono or otherwise. A poison pill. Other than that it's shaping up to what Java should have been.
• PHP: A scripting language attempting to be more, and failing hard.

Pardon the bit of plagiarism but I like the saying "Pick one, and done." Yeah it's great and all to know multiple languages (or more importantly like another poster said, the idioms and environment surrounding a particular language) but unless you want it to stick you have to invest a significant slice of time to commit it to memory.

Well, it is a matter of age and the conditions you have encountered.

I started with Basic because the IBM machine I used has a basic interpreter in its ROM (you could call it via INT 18).

I switched to Assembly because Basic wasn't enough to create a virus like Dark Avenger (yes, I got that virus with a pirated 5 1/4 diskette, trying to learn C++, I never touched to C++ for the next 2 decades) I learned Turbo Pascal because I needed some TSR (that is, terminate and stay resident) to write something like SideKick from Norton. I memorized machine codes to write programs in machine code onto paper in dorm (there was no computers in dorm at that times)

I HAD TO learn COBOL to get my graduate from university, I finished 5 different departments' work in order to get the result. (I successfully completed the projects, but left the university because I was helping the teachers in Pascal and C classes). I even wrote some commercial products with Cobol because it was supporting ISAM indexed files. I used RMCOBOL, without knowing that it has support for colored output, I wrote RMCOLOR, a TSR waiting for special codes to change default colors for the text output.

I saw Windows 3.1 at 1992, it was 7 seven diskettes. I thought it is not productive. One of my friends told me that there is a thing called mouse is used to move that arrow (we were using it with keyboard). I thought "so we will have to buy something to use it". I didn't use it for a while because I'm a little bit mean.

I switched to Borland Pascal Windows because of memory support. The time I used the compiler, I used MaxAvailable to know how much memory is usable, I just got shocked. It was more than 10 megabytes of RAM. I was used to have 640K and that was enough for much of the things I needed to do. Even Bill Gates himself said "640K ought to be enough for everybody"

The first time I saw Delphi, I didn't understand what Mr. Heilsberg intended to. I closed an idiotic window named Object Inspector, than closed another idiotic window called Form1. After that, I couldn't find where to write code and closed Delphi 1 for a few months.

Then we all switched to Windows 95. I used to program with Delphi 2. It was fast, easy, data aware. I bought a Java book because it was really popular. The book was a disaster, I had bad thoughts for Java for a decade. I never learned it.

After Delphi 2,3,4,5,6,7... (4 and 6 were the most problematic by the way) I used Delphi 7 for years. I tried to use MS Visual Studio. There were no sharp languages at those days and they never been as good as Delphi.

I needed to run some of our core algorithms on ARM and Free Pascal really helped me because we implemented all the code in Delphi.

Nowadays I've been working with C++. With QT in fact. QT is really nice and it is a good designed library. All the things I feared to use C++ has a cure with QT. More over, it is cross platform. Now we are programming under Linux to cut TCO. It helped much.

I evaluated C# after a friend of mine requested. Mr Heilsberg created another good language but in signal processing, it has no value. It is slow, it may be secure but it is not created for the job I am doing. It is secure enough to let a 12 years old can write web code.

By the way I still remember Netherlands vs Soviet Union football match, in case you wonder how old I am. I hope you enjoy reading this as I enjoyed writing.

I use predominantly C# in my day-to-day job, but even within that I've switched from C# 1.0 to 2.0, and 2.0 to 3.0, because new versions of the language offered more features (generics, iterators, linq) which means you can write code faster and more accurately. Admittedly the new versions are backwards-compatible with the old versions (except in some edge cases) but it's still a switch as it requires learning new ways of doing things.

Outside that, I think there's great merit in learning other languages, even if it isn't to the same level as your day-to-day ones, because it helps to avoid the Blub paradox ^[1]. It also means you know the capabilities of other languages which can help you decide whether you should switch, and under what circumstances (for example F# is much better than C# for self-contained scientific/engineering applications due to things like units and infix function declaration, but is less good for writing libraries that seamlessly interoperate with other .NET languages).

BASIC

E

Pascal / Delphi (school)

Haskell (university, yikes)

C

C++

Java

bash scripting

SQL

Forgot about all the religious wars of my teenage years. These days it's all about comfort a language offers... I've become spoilt ;)

At work I program in the language I have to program in at work. :-) But for my own projects I started using Ruby in 2000. Fun language.

But last year I switched to Erlang. Why?

• I find that functional programming maps on to my mind much better than OOP.
• Concurrent programming is powerful, fun, and the only sane path forward in a multi-core world.
• Erlang is much faster than Ruby (and sometimes that really does matter).
• I like compiling. :-) Call me a dork, but I like having a sanity check. I like warnings. I like to know when there's dead code. I like it when the computer catches my stupid typos.
• Pattern-matching is the funnest ever.

It hasn't all been rosey and smooth, though. Erlang has it's warts. And I still turn to Ruby for the super-low-overhead. (Any program of 20 lines or less, I'll bust out the Ruby. $ ruby -e "[your one-liner here]" FTW.)

But for larger programs, Erlang's concurrent functional programming is for me: solid, performant, and fun enough to make me giggle on occasion.

if you are a skilled programmer never even give importance to one language and don't stick within the language barriers. Software is in its baby steps now, so adaptability is the best skill for a programmer in these days,

Personally I came from Pascal - C - C++ - Java - C# and VB.NET And now I am a Language agnostic

20+ years....

Fortran 77 Algol Cobol x86 Assembler Natural Basic Pascal Prolog C Delphi Java SQL C++ Javascript VB/VBA VB.Net Perl Cold Fusion PHP Python

And that's committing all sorts of stuff like Awk, Easytrieve, Snobol, Smalltalk etc etc which I've dabbled in or have used for small tasks and I'm sure to have forgotten a few too. I'm probably somewhat more 'new language' curious than many but I don't think I'm especially untypical.

Often, the development platform can make the decisions for you. i.e. I had to learn and program in lua ^[1] to make a World of Warcraft add-in. Early in my career, AutoLisp was the only option for AutoCAD programming, before they opened it up to C and latter C++ (and now .net).

Sometimes you have a choice in language, sometimes the platform narrows down that choice.

I'm a junky. I use and know all kinds of programming languages. This is not an exhaustive list, nor is it in any particular order. I've only listed languages in which I feel reasonably competent.

• Dylan
• Ruby
• Python
• Erlang
• Haskell
• REBOL
• C#
• VB.NET
• VB (trying to forget)
• F#
• Objective C
• F-Script
• Nu
• AppleScript
• XQuery
• XSLT

And several others I'm probably forgetting.

It can sound funny, but I started as C# developer, and then had to switch "temporary" to Java because of project which I was assigned to, but then I started using IntelliJ IDEA and switched to Java permanently because of it. I still think C# is better language and still prefer it for GUI desktop applications.

BASIC

Assembly

Pascal

C

Shell scripts

Python

Scheme (I gave this one up pretty quickly...)

Java

Then I realized that it might be best to learn more languages and use the right one for the job.

Now I use Objective-C, Java, PHP, Python, C, C++ and C#. From this list I can always find one that suits a certain problem/platform best.

I stayed away from perl because it makes my head hurt.

I've never used Ruby, but if a project will require it, I will add taht to the list, too.

Basic -> C -> C++ -> Visual C++ -> Java -> ARM C++ -> C# -> PHP (as a cronjob) -> Python -> Perl

as work requires it.

IBM/MS Basic -> Pascal and Assembly -> Java, C/C++ -> Java, C/C++, smattering of Lisp, Prolog, shell scripting -> Perl, VBScript -> PHP, Javascript, a bit of Python -> Ruby.

In language learning, I just kept looking for and finding increasing contentment, satisfaction and even joy. IMO, the "many tools in the toolkit" analogy only goes so far. Today's modern languages are extremely powerful and flexible, and most popular languages have the wherewithall to let you do 99% of the applications you want to, and do it reasonably well. That's the reason why you often hear "I would try Language Y, but I can already do it in Language X".

I think, in choosing a language for a task (or for "all" your tasks), you should aim to minimize frustration and annoyance. You want a language that gives you the shortest path from idea to working implementation. Since different people can have different mindsets and preferred approaches to problem solving, and languages (or rather, their authors) have different philosophies on how programming should be done, what fits you most comfortably will be different from what fits others. But I think everyone should strive to reach the goal of minimum effort for maximum results.

Excessively verbose syntax; syntax that "needs" an IDE to write; standard libraries and APIs that are difficult to remember; immature standard libraries; compiler quirks; exposure of underlying hardware or low-level architecture (and the need to work with or around them) -- we should seek to remove all these things. Ultimately, the only thing a programmer needs to do is specify things that a computer should not decide. Everything else is an obstacle to the utopian programming experience. If a language empowers us this way, then, in my opinion, we can begin to talk of that language as "the best language".

For me, Ruby comes closest to being this language.

I came from programming VB6 to VB.Net but now I'm in C#, I switched to this language cause at the beginning of this year (2008) i had to make a very simple application in a mobile device and i had to write the code in VC++, I never programmed in VC and was difficult but also was magical, the experience was awesome. I had to study very much and I really fell in love of the C language.

That hooked me to C# although is the same framework of VB.Net but you also find more resources in the web and another reason I switched (C, C++, C#) is that (IMHO) I feel that you become a better programmer, personally I found myself with an enlightment feeling about this language, the last time I felt that way was when I started to study Scheme.

I tend to dabble in every language I can get my hands on, but if I count just the languages with which I've actually produced something useful (in no particular order):

• 8080/Z80 assembly language
• MBASIC
• C
• Pascal
• FORTRAN
• C++
• C#
• Python
• Perl
• Visual Basic
• JavaScript
• PHP
• x86 assembly language
• dBASE
• SQL
• Informix-4GL

and a few DSLs I've built, some which were pretty useful and others I'd really like to forget :-)

Started in Quantel Business Basic

SAS on S/370 - changed employer

SAS & C on OS/2 - changed employer

SAS on Mac - changed employer (dual boot? don't remember...)

PowerBuilder - internal transfer to app dev group

PowerBuilder @ new employer

Java - client choice

Java/PowerBuilder/Javascript combined

Powerbuilder - changed employer

C# - new development @current employer

Yes, many times I have switched and probably will do so in the future. A few examples:

1) Basic -> Pascal. In high school, there was a shift to a language that allowed more types as Basic seemed rather limited to int, string, and arrays, at least the Watcom and Commodore 64 Basic I used.

2) Pascal -> Modula-3. Going from first to second year at university, from Macs to Unix systems this was the change in programming languages.

3) Modula-3 -> C/C++. 2nd to 3rd year university, the latter was used for both a Concurrency and a Data Structures course.

4) C/C++ -> VBScript. ASP replacing ISAPI Extension functionality in my world. It was kind of nice to get into HTML and add scripting tags to make the functionality rather than work in C/C++ Macros and a propietary mark-up language.

5) VBScript -> C#. Going to ASP.Net from ASP. This was useful in getting rid of the on-the-fly variable naming issues I had seen in ASP repeatedly as most variables are global by default.

Of course this omits reversions as legacy applications may have used older stuff as well as 3rd party code that may have been in something I didn't have a lot of control over. I also am skipping dialectal changes like going from Commodore 64 Basic to Watcom Basic.

As a hobbyist, BASICA to GWBASIC to QUICKBASIC, because that is what came with the computers. Those were the logical progressions.

Through high school, I picked up, in no particular order Borland C++, Visual Basic 3, a bit of Perl, and a little COBOL. I did odd contracts in each, none of which were probably particularly good.

Through college, I switched largely to Visual Basic 4/5 and Visual C++, with courses that covered Perl, C++, and COBOL.

My first job in development was Visual Basic 5 and moved to a shop that was using Visual Basic 6. That shop subcontracted me to a couple of vendors where I revisited Perl and COBOL again (the client was Honeywell, who I am sure is still using both languages, based on their rate of adoption).

Moving to another job, it was still mostly Visual Basic 6 with a side trip through PHP and Classic ASP. Finally, I was able to get my foot in the door with a little VB.NET very close to the time of initial release.

We packed up our bags and moved east for better job opportunities where I hit the ground running with C#. It has been mostly C# since then, with the occasional "legacy" application in VB.NET.

I went Basic, Pascal, Visual Basic, C#

with a little bit of C++ and Java at uni

Sure did

Fortran IV to Fortran 77 in the mid-eighties

Fortran 77 to Fortran 90 in the late nineties

Fortran 90 to Fortran 95 in the very late nineties

and Fortran 95 to Fortran 2003 about 15 minutes ago

Oh, and in case anyone reading this thinks I'm being frivolous, I've also programmed in Pascal, APL, C and C++, Haskell, Python, Mathematica, Matlab and probably other stuff I've blotted from my memory.

Heh...this is beginning to look like a programmer resume site.

List<ProgLang> relevantLangs = myMemory.RetrieveLanguages(
    ProgLang.InteractionFlag.OnceTypedSome |
    ProgLang.InteractionFlag.ForcedToUseInSchool |
    ProgLang.InteractionFlag.UseDailyAtWork |
    ProgLang.InteractionFlag.PlayWithForFun);

foreach (ProgLang lang in relevantLangs)
    lang.DumpToPost();

Did you ever switch from one programming language to another?

Absolutely. Do so daily.

If yes, why?

Many reasons (With higher likelihood first):

• Client N's code is in language X[N], and:
  • a rewrite is impossible/improbable
  • the language is suitable for the task
• I control a project's code but I must use language X1 because
  • Platform compatibility
  • Existing API interaction
• I control a project's code and I want to program in language X2 because:
  • Its strengths fit the problem
  • I want to learn the quirks of this new (to me) language
  • I want to keep up on new language features
  • I want to use its strong library support for task T

In summary, as a consultant, I language switch mostly based on external, hard requirements. That said, however, I often switch to try new things, continue learning, and stave off monotonous, required language inundation.

• c64 basic
• c64 asm
• Atari asm
• Atari C
• PC Pacal
• ML
• Modula-3
• Bash
• Ruby (2001) Unstable, need something with maturity
• Python - This I can rely on.
• Emacs - Wow,power, what have I missed?
• Common Lisp - Insane. This is crack.
• Prolog (ok,I did not write a whole program in prolog.)
• Erlang - Nice it scales
• LFE - Wow. Power of lisp and scales.
• Forth - Beautiful. This is art.
• Factor - Beautiful and useful.
• C++ (hehe) - I need a job. Do what ever it takes.

(I have coded a lot of MS stuff, but that is depressing.)

Yes, mostly due to business reasons. I used Java heavily in college days, but my final project was in PHP.

My first job required ASP classic and Visual C++.

My second job brought me back to Java. Then I switched to a C# winforms application team.

I occasionally do PHP on the side for fun.

In general I would say the big drivers are market demand and simplicity. Yeah you can be a LISP guru, but who would pay you for working with it?

Im young and can already notice, most of us dont switch by choice, but my job requirements. When a new job req. comes up requesting a specific language, you take on the challenge and the fun to learn or get better in that lanaguage.

You asked why.

why not

Started with Z80 machine code on my ZX Spectrum (yes, actually typing in opcodes). Learned a little Basic, used Pascal and Fortran for some jobs when I was in college, had to learn some APL for my job at the Central Bank of Turkey, learned C after my introduction to the internet (hat tip DJGPP ^[1]), learned Java when I started programming experiments and finally switched to Perl for most of my needs (although I try to stay familiar with other languages).

Along the way, I have had to use other languages as the situation called for it.

I switched from php to ruby to php because I tried ruby, but I knew php so well that I just couldn't make the switch :D

The Evolution of a Programmer ^[1]

For 25 years I programmed in IBM mainframe assembler. I recently got a new job, and now I program in Java. It's, ah, different.

All that your picture of the stereotypical programmer tells me is that you have a very limited social sphere of programmers.

Most programmers I know work with whatever tool does the job they want best (that their managers let them use). Some programmers--like me--are so language-agnostic they change their languages approximately as often as they change their underwear. (Daily, for the record.;)

This will probably get buried on page 7, but here's my progression. This is just the gigs that paid, not everything:

Basic

then, once I knew better

C

A quick regression into

Clipper

First full time job was

lisp

and we needed a bunch of utilites, so that lead to

perl

Then along came the web, so I needed

java

Clients started asking about the MS stack, so it was time to learn

VB.NET and C#

and because I quickly got sick of the webforms/viewstate mess, I looked into

Ruby (on Rails)

So now I'm one of those people who know a little about a lot, and a lot about nothing :)

You're seriously limiting yourself by only sticking to one language. I've been around for a little while, but am by no means ready for retirement and I've programmed in more languages than I can list. Back in my early days I was active in several varied languages because the demands of the project would dictate which language was best (some were not even reasonable for some tasks due to library limitations). Nowadays it's easier, with most languages able to handle most tasks quite well. However, exploring new languages is quite fun!

A couple downsides to using many different languages are:

• You never get to be an expert in any one. It's real hard to know every last detail about a language unless you only do that one language for a VERY long time.

• It frequently leads to arguments with ignorant fanbois. You have to learn to just walk away, realizing that they just don't have the experience to appreciate what you're saying about the problems with their chosen language.

I decided that there was a point in my career where I wanted to be verse and have professional experience in more than one language.

I went from C# to Ruby and use both in my daily development life.

It's very pragmatic to at least have a few languages under your belt for the reasons you mention... but I also felt that I would be more marketable having two popular languages on two sides of the spectrum.

Adding a third one currently, Objective-C... so I should be able to take on any platform: web, desktop, or mobile.

Use them all I say. If I were to summarise the languages I use on a daily basis

• Regexp ( Sed / Grep / Perl / Php / Ruby / Javascript )
• Php
• SQL ( Mysql and Postgres flavours, depending only on what I have been given to use )
• Javascript
• Ruby
• Perl ( still new here )
• Python ( Only did a little )
• Occasionally write C/C++ stuff ( hardly ever )

Some people will say the above and mean over a long course of time. I just jump from one to the other as demands require. Saying otherwise is like saying "yeah, i switched from screwdrivers to spanners, spanners are much better". Keep your toolbox handy and don't forget how to use them. :)

However, that Java thing and that C# thing i just stay away from.

I switch languages on a daily basis. I'm constantly swapping between bash and my active project. My current hobby project uses D, Objective-C and PHP so I'm often switching between them. At work I use C#, VB6 and SQL.

My progression was:

• Basic
• Borland Pascal
• Visual Basic
• PHP
• Java
• C#

I do maintenance on an enterprise PHP app, but all new development is C#.

I have switched almost every time I have changed jobs. The one that was under my control was early in my career, switching from C to C++. Since C++ was a superset of C, it was an easier transition -- the team wanted to use some of the features and we carefully transitioned as we got comfortable using the parts of C++ that were useful to us.

I have recently switched from Java to C# (2+ years ago) -- but that was because of a job change. Now that I have done it, I would say that each have their place -- for making Windows GUI's I would definitely stick with .NET languages.

On my own, I use Python for web site writing, but that's because I like Django for making web sites.

What the end product's runtime is, is a big factor in what language I choose to use. For example, if I was making an iPhone app, I'd have to learn Objective-C.

BASIC -> Perl -> PHP -> C++ -> C -> x86 ASM -> Python -> ARM ASM -> C# -> Nemerle -> Boo

These days I primarily write x86 ASM, Python, and Nemerle+C#. Best toolchain for compiler and emulation dev I've found.

It is always depends on the task at hand. I have worked many on different languages. The ones that I seem to work with the most (because of demand) are PHP and C#. If a project had more integration in a *NIX platform or needed to use MySQL or message between other *NIX applications then I choose PHP. PHP has great integration for the *NIX platforms, it is easy to get up and running (LAMP) and it feels more like it is "meant to be."

I have experimented with forcing a language to work, for instance C#/Mono on the Linux platform. This ends up being more hassle than necessary. I love C#, but that belongs in Windows :) I recently tried to use Mono with TeamCity, MySQL, NHibernate and Linq on Linux. I found that this got more and more painful as I integrated more and more. I ended up running the entire solution in Windows, scratched NHibernate and started using the Linq to Entities framework. I also scratched MySQL and started using SQL Express. Finally, I decided to use WCF since I was going all Windows and needed to use interfaces and generics over the wire.

Again, if you choose a platform than it is less painful to switch to something that is designed to natively work with that platform and/or anything you may be integrating with. It makes upgrading , maintainability and integration easier.

For the Most part, I think a lot of this is driven by the requirements of the project, If it is a startup, with no other dependencies, then choose what you are most comfortable with. For web projects, there is always cloud hosting, if you want everything :)

Turbo Pascal

PHP

ASP (VB Script)

ASP.NET (C#)

Visual C#

Java

I'm currently switching between PHP and ASP.NET for work reasons, and am studying Java to get some experience with Open Source Software Development.

Generic progression:

Perl -> SQL -> PHP -> Javascript -> CFML -> Ruby

Details:

Perl/cgi : began web programming in the later 90s

SQL : needed relational databases ...for some reason flat text files just were not cutting it any more ...mhmm

PHP : moved, and couldn't find work in perl so i picked up php.

Javascript : i need to add interactivity, beyond the the standard rollovers, and believe it or not javascript turned out to be a robust mature language.

CFML (coldfusion) : my first exposure to cfml was when i was stil writing perl, but didn't give it much thought. then once it was dubbed "a dead language" i had a mutual friend ask me about it.. i was between jobs so i picked it up and started playing around. Now i love it! everything compiles down to java on the fly, i can use java libraries. Quite the powerful language/framework for web applications.

Ruby (not just rails) : after seeing this might not be another "flash in the pan" buzz word language, i decided to check it. Really fun. All my previous languages i picked up for gainful employment of some sort. This one was pure fun, though i am still learning it, it it proving most enjoyable to write in (when i make the time ..:/).

Java [Coming soon].

Basic (self taught) -> Pascal (in high school) -> Visual Basic (for work) -> Delphi (Visual Basic done well) -> C# (for ASP.NET) -> Ruby (on Rails, because it's faster to develop in) -> Objective C (for iPad development)

In the middle there was COBOL, FORTRAN, x86 Assembler, OPS5 (ugh), Prolog and Perl, but those were the major ones.

BASIC -> C -> C++ -> Python

Now using C, C++, and Python

I learned during college several languages, including: Scheme, Pascal, LaTeX :), C, Fortran 95, Prolog, x86 Assembly, Java (JML, JavaCC, ...), PLSQL, C++, Yacc/Bison, Matlab, R, ML, PHP, ... (Of course, we have also studied several modeling stuff like UML, Petri Nets, COOPN & co, ...).

Finally, I work with C, C# & PLSQL.

The most important point is that when you know the programming paradigms, then you can easily switch between languages (and it's never a problem to discover a new one).

During my free time, I work with PHP (my own website, ...), Java and Prolog (just for fun).

I started in Basic

need speed

Then Assembly

need sanity

Then C

need GUI

Then Visual Basic

need GUI and speed

Then C++

need web applications

Then Perl

need more web apps in less time

Then PHP and JavaScript

Stuck with PHP (for web) and C++ (for desktop) currently. Did try Java a little bit, but found it too bloated for my hardware .

Lingo - verbose, but a nice easy intro to programming. Sprites!

Visual Basic - verbose, boring grey boxes

ActionScript1 - tellTarget? No thanks.

Java - way too hard for me at the time.

PHP + SQL + JavaScript + HTML = boring

ActionScript2 - good!

ActionScript3 - better!

C# - Best!

My progression: *BASIC *LOGO *TI-BASIC *Javascript *Java *C *Java

My parents bought me my first machine when I was 6, and I keyed programs in from ATARI Computer Monthly. I did some more BASIC in elementary and junior high on Apple II's. Then I did math programming in LOGO at a summer camp. Next, I got a TI-83 for high school chemistry and ended up building a math suite that lasted over 7 years in my high school, just getting passed around by different students. I started actually studying programming with Javascript tutorials online, and then I bought myself a Java book because I wanted to do graphics programming with Applets. In college, we were required to study C, and then later I took optional Java courses. My first employer gave me the option to implement his system in any language I wanted, and I chose Java. Since then, all my professional development has been in Java, but its ranged all over: *high-performance HTTP client *data-input web clients *data-input wizard rich clients *high-performance messaging servers

Yes, I've switched between languages many times.

The reason is, you should use whatever language makes sense to solve a given problem. That is why you should be able to dive into almost any programming language you see. For starters, it just helps to know your way around and to know where the documentation is.

E.g., assume you come and work for a company which is ASP.NET all the way. Why would you want them to switch to Python? Because you are more familiar with it - that's not in the best interest of your client. Of course you would program/build whatever they want in ASP.NET.

Over the years I've done Perl, PHP, Basic, Java, ASP, Python and even some Ruby (not on Rails). It just made sense in that situation to use another one.

Sometimes when I start from scratch and people come to me, I will recommend what I think is in there best interest and gets the job done. If that involves recommending someone else for a job, I'll do it.

Programming languages are tools, and you should use the best tool for each task. Sometimes this means you're using C++, other times Java, or Ruby, Perl, PHP, Erlang, etc.

At my current job we have apps in C++, Java, Ruby, and Perl. We (developers) definitely have a comfort zone and preference for programming languages, but that is secondary to the requirements.

When we hire people, we only require that they know one major language, with the assumption that a good developer can pick up a new language fairly easily. If someone is fanatic about a single language and isn't flexible enough to adapt then we don't want them.

That's a long way of saying "Yes, we switch from one language to another all the time."

In the world of development it's evolve or die.. ;)

FWIW: VB COM -> Delphi -> Java -> C# -> Objective C

I think I've used something on the order of two dozen languages over the course of my career. (FORTRAN, several proprietary implementations of BASIC, assembly, Pascal, INFO, R/BASIC, C, C++, Visual Basic, VBA, Perl, PHP, Python, C#, SQL, XSLT, Javascript, a couple of DSLs including one I wrote myself, man, it's endless.) I've gotten fanatical about a couple, at various points (AREV in 1989, XSLT in 2001, Python today).

Many times I've had the language chosen for me by circumstance, either because I'm working on an existing codebase or the hardware only supports one useful language. It was only fairly late in my career that I got to the point where I started making those decisions myself. I like that position better.

I constantly switch around depending on what I am trying to accomplish.

java - first language, but never use it anymore PHP - anything web related Perl - anything parsing related Python - usually use this if i need to make some kind of command line app really quickly C/C++ - anything speed related C# - anything windows gui related

Yay, story time...I was writing in assembler, and I took a class in FORTH. I saw how FORTH collected and organized the very habits we ASM coders had developed over time. Plus some more good ideas. I knew I couldn't switch over in the middle of a project, but vowed to use it for the next one. Meanwhile, the code in my current project started to rearrange itself to look more like FORTH. After the switch, I used FORTH for about 16 years.

More recently, I was constructing an embedded web server and writing the glue code in C. But I found I was having to generate html pages on the fly. Now, Rasmus Lerdorf had come to town and explained how PHP grew out of the same repetitious code writing. I knew the right thing to do was to find a way to embed PHP in this server. And once I did, boy was I glad! PHP let me do so much more.

Moral of the stories: Sometimes, the language calls out to you.

P.S. I see William Keller's comment about PHP becoming "an unmaintainable mess". I tend to agree. So I've made a mental note to pay more attention to Python.

I used to be a C++ programmer who frowned upon anything that was Java-related. Then in 2003, towards the end of my time at The University of California, Santa Cruz ^[1] I got involved with the SCATE Project ^[2], which involved pure Java development. After making a number of semantic and philosophical shifts in my thinking, I can to appreciate Java's understated elegance. And while, to this day, I continue to encounter my fair share of memory management issues, garbage collection has made this significantly less painful.

Basic -> Turbo Pascal -> Turbo C - > Turbo C++ -> dBase III -> Clipper -> Visual FoxPro -> Visual Basic 6 -> Visual Basic.NET -> C#

And throw in some more along the way like Perl, Python, Prolog, Fortran I learned but didn't really use :-)

Started in 8086 assembler and Pascal in college, moved to c++(DEC VMS), then my life got interesting using DEC MUMPS (PDP11/44), Visual Basic progressed to InterSystems MUMPS(later renamed 'M' or InterSystems Cache), then once .NET hit the market started using VB.NET and C#

I don't know about the "stereotypical programmer" but I've used dozens of languages in my career. Let's see if I can still list them....

I've used assemblers, machine code (not the same thing...), FORTH, APL, Pascal, assorted BASICs, Modula-2, COBOL, FORTRANs IV, 66, 77, 90 and 95, C, C++, Objective-C, Lisp, Prolog, sh, bash, csh, zsh, rexx, Perl, PHP, Java, Javascript, C#, SAS, SQL and assorted "4GL" database access languages.

And I'm sure I've forgotten some.

But of all those languages, I firmly believe that the best language of all time is what ever language is best for the job at hand. You don't write websites in APL and you don't write operating systems in Javascript - anymore than you'd use a band saw to build a car.

I started on old-school MUDs in c and then c++. Professionally I used Perl for quite a while then found a position that was mostly c++ with bits of Perl. My first book used PHP/SQL as a proof of concept language, however I've used PHP as a tinkering language more than a production language. Recently I was introduced to Erlang which has been the subject of my second book as well as several conferences and presentations. Professionally I do native iPhone development now.

C ~> C++ ~> Perl ~> C++ ~> PHP (first book) ~> Objective-C ~> Erlang (second book)

Pascal->C->Java->C#->Java->Python->C and so on... First for education, now because I use whatever is fit to get the job done.

I was a hardcore vb programmer, promoted to vb.net. In a program requiring lot of type casting, my vb code got too ugly even in the first class I wrote. Then i switched to c# for some cleaner type casts

4 years out of school now, and I switch all the time.

In school it was mainly java, c++, and 68K assembly, switching back and forth all the time.

Then my first project at work was in C++. I completed a hobby project in PHP during this time. When my first work project shipped, our second project had a C# GUI talking to a C++ back-end. Third project I was in C (the GUI library GTK is in C) and C++. Fourth project I jumped in and helped out doing perl that drove a web page admin portal. During that time I also did other components in C and C++.

I had the option to do a project in 8560 assembly, but I passed on it since it's just supporting a legacy product about 10 years old. New development for me only, please.

Anyway, who are these developers that just use one language?

Childhood through college:
Basic (c64) -> 6502 Assembly (c64) -> Basic (IBM/PC) -> Visual Basic -> x86 Assembly -> RPG -> Cobol -> C -> C++

Professional life: I started out with Java doing JSP. I then moved to ASP/VB Script which was an extremely painful move for me at the time. Then I moved to C# which I enjoy just as much, if not more, than Java development.

On the professional side, language switches tend to happen with job switches since many companies don't want development happening with more than a couple/few languages and tools at a time. I can't just go ahead and implement something in C because it would be the best tool for the job because it is not an approved language at my place of employment. In my current position, I switch between C#, batch script, Sql/DTS depending on the task at hand.

Assembly. I'm always writing in assembly. I just use my compilers as macros, and interpreters for scripting. :)

Seriously, I have progressed from Apple BASIC (Applesoft and Integer) to Apple 6502 assembly, to GW/MS-BASIC to C and 8086 assembly. A little further down the road, I picked up Unix and DOS shell scripting, and more assembly for various MCU's. C++ then became popular. I then had some VB, Java (mostly with .JSP) and Perl come my way, and I'm just now starting to touch the fringes of C#. Oh yeah, throw in some SQL, sed, TFLanguage (a proprietary language), some report generators that I don't care to remember anymore, and of course, the obligatory school classes on Pascal (high school) and Lisp (college).

Almost all of the language choices were dictated by market forces -- either the market of books available at the time, or the market of the guy cutting me the paycheck.

To me, the first class of the "stereotypical programmer" -- who sticks to his one-true-platform -- is a guy who then goes home after work and always eats the same steak and potatoes, and drinks his Pabst Blue Ribbon. Indian food? Isn't that grilled buffaloes or somethin'? If he's happy where he is, great for him. (Side note - he's probably also proud of always filing his TPS Reports...)

But I like a bit more variety in my programming diet, thank you. But I'm still main stream. I don't think I have the stomach to more than nibble on a little bit of Lisp. And the other exotic stuff? Not now, thank you.

Today: C#, VB6, VB.net. Why all three? Legacy code is in VB6. All new code is in C#. Interop user controls must be in VB.net. I have written for at least an hour in each one of these languages today.

While all this is going on, I am using ruby for hobby programming because I like rails.

I think a programmer should be able to switch from language to language without much difficulty; although, I am aware that to use a language well it takes a lot of experience with that language.

Started off with Basic as a kid, stayed there for a few years (didn't know any better).

Got to college and ended up in Pascal.

Then C on Unix.

First job was doing C on Unix. Ended up doing that long time about eight years.

Then the big boss at the company I was working at wanted an new application with a Windows GUI. He wanted to do PowerBuilder, looked at it, didn't like it, convinced him to go with C#.Net.

I wish I could say I had some brillant motivation for each switch but it was really just based on the job.

I started teaching myself C in high school. (Never learned much do to other activities and lack of motivation.)

Went to college and was doing C++ until I changed my major and quit programming. (Bad choice, I don't even like political science... kind of graduated on accident.)

Went BACK to college after getting a Political Science degree to go ahead and get my CS degree. All C++ and Java. (Not a fan of Java by the way.)

Decided to do some web development stuff on the side while working and going to school and got pretty comfortable with and somewhat addicted to PHP.

Eventually I got sick of trying to run my own business, though I still help with it some and still do some PHP, but I'm also working at a small shop doing C# and VB.NET now.

After being forced to use VB at work, I realized how much I hated it, and decided to try to get into graphics/game programming in my spare time.

So now, I'm getting familiar with C++ again, but I'm probably most comfortable with C# or PHP.

started on BASIC

did/doing c/java at school

learned php for doing web development

realized php sucks

ruby

I have switched multiple times and for a few different reasons:

1) Commodore 64 Basic to Watcom Basic -> This was going from grade school where we had Commodore 64s and I had one at home that I programmed a few things on and enjoyed, but the high school computing environment didn't use Commodore 64s so I had to switch dialects if not something more in going from a 64K very specific machine to an environment where we had a file server and people could switch machines and still use their code.

2) Watcom Basic to Pascal -> This was going from High School to first-year university. In Basic you have numbers and strings usually and the $ at the end distinguishes them while in Pascal you can now specify types which gives one some serious power, IMO.

3) Pascal to Modula-3 -> Going from first year Computer Science of Pascal on Macs to Modula-3 on UNIX machines. Big shift in going from single button mouse to 3 button mouse, to having a shell that can be customized and monitors that are shaped very differently for the most part as aside from a room of IBM AIX the others were simple terminals with only a couple of rooms with colour monitors and the rest are black and white.

4) Modula-3 to C++ -> Concurrent programming using a micro-C++ add-on to introduce flow control functions and allow us to learn these things.

5) Visual C++ to VBScript -> Going from ISAPI extensions and a proprietary markup language to VBScript and HTML was quite the shift but I did get though it. This was also my introduction to ASP.

6) VBScript to C#.Net -> Going from ASP to ASP.Net had a few interesting moments at timse as where in one you didn't have to define things, in C# you have to and this along with a few other differences were some of the big things I noticed.

7) Adding Javascript -> Client side validation was something of an add-on from my view and not really a change.

8) VB.Net, VB6, and JScript -> These are all add-ons when dealing with legacy systems built in something that I don't have control over.

I left out learning SQL, XML and a few other classes of languages. Generally I find aside from a few syntax changes most programming that I've done boils down to just a few things: Conditionals, repeating, and then the whole pile of things called variables.

I switch between languages daily if not hourly.

I guess in the programming world you're always working with several different languages at the same time (SQL, C#, JavaScript, HTML, XML, CSS, etc.), but I'm guessing that you're asking something more like switching from VB.NET to C# - which I do often, or .NET to PHP which I also have to do on a daily basis to handle all the different projects that I deal with.

So I guess basically being a programmer means knowing and using many different languages.

BASIC C x86 Assembler C++ VB (6 and earlier) PHP RDML/RDMLX C# VB.Net

Oh, and I read RPG (don't know the finer points of writing it, but I can figure out what it does).

C++ to C# Unfortunately I am back on C++ now

Anyone who has been in this industry for more than a few years has switched languages. In 30+ years of professional programming, I have used:

Fortran Pascal C Algol APL PDP-11 Assembler Cobol OS-360 Assembler Perl Javascript VB / VB.Net

There are various dialects of those languages - such as Cobol on Univac 1100, IBM MVS, IBM System/38.

A good programmer can pick up just about any language.

A Fortran programmer can write Fortran programs in any language.

More-or-less linear:

• 8-bit Durango BASIC because that was my first job
• Nixdorf BASIC - hired to maintain accounting software
• VAX Fortran - because I became a VMS sysadmin
• Modula-2 - because it was a nice compiler for my Fat Mac 512K
• Think Pascal - because it had a better debugger and let me build real Mac programs
• Think C - cut-down C++ because 3rd party libraries were increasingly using C apis
• C++ - to use Metrowerks PowerPlant framework, and MFC and others
• Objective-C because I had to leave PowerPlant behind and move to Cocoa for OS/X GUI

Pretty much in parallel over the last few years:

• REALbasic - to get some simple GUIs written, stayed because I found it productive for cross-platform GUI programming and they had implemented enough of my favourite OO features to make it a neat language
• Python because I heard people rave about it, tried it and felt comfortable, great for prototyping
• Ruby because Andy Hunt's praise intrigued me and I'm an OO guy to the heart who dabbled in Smalltalk and Python white-space sensitivity was in my way writing code generators
• C# because I wanted to program better GUIs than MFC and I like the new features in the language
• Forth to play with programming on my Palm on a tropical holiday
• Lisp (Scheme) because of Paul Graham
• ActionScript/JavaScript because I needed to receive brainwaves in Flash
• XSLT because I'm a masochist (and I've had to deploy some serious local XML transformations)

• 1989: Started with Pascal (Turbo, CPM)
• Moved to Pascal (Turbo, MSDOS) - when I bought a PC!
• Integrated 8086 assember (inside Turbo Pascal) - because I could. Fancy graphic demo scene FTW!
• Moved to Delphi - needed to get PAID for the work.
• 2000 Moved to Java - because it was the cool thing, and delphi didn't do web.
• Moved back to Delphi a bit - money, again.
• Moved to C#, because I wanted to do .NET.
• Learned Ruby, because rails looked cool. Never used it.
• 2008 Learned Python because google app engine looked cool. Using it a little.
• 2009 Learning Objective-C again - because I have an iphone :) Not using it much.
• Still using C#. Pays the bills. Wish I could use it on the iphone and GAE....

Learning new stuff keeps me interested, and also frustrates me no end. Go figure.

• Started in Basic - cause it shipped with DOS (I didn't have money for anything else)
• Moved to Pascal - cause my friend used it (he used it because in high school thats what they used, and I had yet to get to high school)
• Moved to Delphi - cause turbo vision was a ball ache and making windows apps seemed cool.
• Moved to ASP, PHP and Perl - cause my job required me to do it
• Moved to Kylix - cause i didn't realise Borland would shoot themselves in the foot so bad and cause making Linux apps seemed cool (pheh I'm better than those Windows developers now)
• Moved to C# - cause I needed a job and that's where the jobs were.

So to summerise: No budget -> peer-pressure -> wow factor -> finally to get the job done (i.e. basically the same process corporates go through when picking anything)

I switch from language to language on daily basis, at work i use C#, for personal projects PHP for Web and Delphi for windows applications.

For me:

• Pascal
• Lisp
• C
• Objective-C
• Java

A lot actually.

C/C++ -> Java -> PHP -> Perl -> Objective-C -> Applescript -> Python -> Ruby

Basically, right tool for the right job, and some languages are fairly mature enough for specific jobs (C/C++ for speedy apps, Java for Mobile Dev, PHP for Web Dev, Perl for Web Services and Text Manipulation, Objective-C for Mac Dev, Applescript because you have no choice [some say Carbon... but come on], Python for Math and Netwwork Server Stuff, Ruby for RAD Web Development).

Besides, all of the new languages are based on C constructs so I think there won't be too much issues moving in between languages.

• I switched Perl for web development.
• I switched to Python for large number calculations.
• I switched back to C++ for certain fast applications.

Sinclair BASIC -> Pascal -> C -> Java

Has some fun with Fortran and C++ on the side.

Several times for several reasons: I do believe there is no perfect language for every application and want to use something appropriate for the job. Addtionally, I am one of those people who just likes to learn new languages

Anyway, the reasons (briefly):

BASIC to Pascal (then VAX Assembler then switching around between those three + FORTRAN and COBOL, depending on the class) when I went from a programming class in high school to majoring in CS in college.

From BASIC to FORTRAN to C to Perl for various jobs. Throw in some DCL and Bourne/BASH scripting along the way. Also, Pick Access/English (anyone else on SO done that?).

Perl to Python when I could choose my language on the job and found it too difficult to use Perl for what I was trying to accomplish at the time.

Most recently, Python to Java, PHP, and IDL (Interactive Data Language) for a new job.

C++ -> Java. Why? Android.

Of course: (alphabetical order)

Assemblers – 315, Neat/3 (Levels 1-2), Z80, Cadol 3, DG MV and 68000 (Motorola) (6 Implementations).

Access

BASIC - GW, TIB, QBASIC, DEC BASIC (4 Implementations).

C – Megamax and Borland (2 Implementations).

COBOL – VS2, Fujitsu, AS/400, Wang, NCR (Century, IMOS and Criterion), RM, TI, Realia, BOS, VAX, Alpha, PRU-COBOL, IBM System 36, Microfocus and Data General AOS/VS COBOL (16 implementations).

Clarion 4 for Windows

dBASE Plus 2.6 (2009 version by DataIntelligence Inc.)

Forth – Texas Instruments (1 Implementation).

FoxPro (2.0)

HTML

Javascript

Logo – Texas Instruments (1 Implementation).

Modula-2 – TDI (1 Implementation).

Mouse – IMS, Z80, Macro Assembler (1 Implementation).

MUMPS – MGlobal, MSM and InterSystems Cache' (3 Implementations).

Oracle PL/SQL – Versions 6-8.

Pascal – JRT, DR-MT, OSS, USCD, Borland Turbo and Delphi (6 Implementations).

PL/I (IBM 3090)

PowerBuilder

Progress 4GL RDBMS (aka OpenEdge ABL) w/WebSpeed – Versions 5-10.1b

RPG II (IBM System 34)

The two best language/database development environments are (IMHO)

Progress and ISC Cache'.

Albeit, for UI work I prefer Borland Delphi (Pascal).

1. Basic
2. Pascal
3. PL/360
4. PDP-11 Assembler
5. Back to Basic!
6. Z80 Assembler
7. 8086 Assembler
8. Pascal - Again
9. Back to Basic and Assembler
10. C
11. Clipper
12. C++
13. Delphi
14. Java
15. Perl
16. Python
17. C#
18. Scala

So yes!

Pistos talks the most sense.

Any decent programmer can quickly learn any language, and anyone that has been in the industry for more than a hadful of years will have had to learn several during their career. It is possible to produce useful programs in a nerw language with as littel as a few hours experience but it takes much longer, possibly years, to learn to use a language really well.

Most of the responses above talk about switching from one language to another. Pistos innparticular displays good sense. But no-one has mentioned the plight of the support programmer that might have to switch beteween half a dozen languages on the same day. This is not easy, and if the languages are similar it can lead to many mistakes.

Conceptually - for understanding programming, you only need to know half a dozen languages, each embodying a different philosophy or covering a different problem domain. For example a low level 3GL (C), a modern OO language (Java), a declarative language (SQL), a logic language (Prolog), a functional language (Lisp), and a general purpose scripting language (Perl), etc.

Personally I think C++ is an awful language - it just ruined C - a beautiful and elegant language. For object orientation I don't understand why Java was invented - much less C++. We already had Smalltalk - and that could have been built on.

Well that is hard to answer. When I was in college I attempted to learn as many languages as I possibly could in order to cover all bases. But as time goes by languages change and new languages come out. For example I got jobs writing Visual BASIC programs and it was not my choice but a choice that employers made. Some jobs I did ANSI C programming, FORTRAN, COBOL, Oracle, Linux, DBase, Clipper, etc but the main language was Visual BASIC.

Visual BASIC for example has evolved since version 6.0 and Microsoft added in the Dotnet Framework and made Visual BASIC a bit like C++ in some ways. In which case my C/C++ experience helped me to learn Visual BASIC.Net. I really cannot say which is the best language because it depends on what OS platform you run it on, how fast the machine is, what it is being used for, etc. Python or Java might be a good choice for cross platform programming when you don't need to recompile code, and C++, FreePascal, FreeBASIC for when you do want to recompile code. Also Novell has made the Mono language for Visual BASIC.Net and C# for Windows developers using Visual Studio.Net to port code to other platforms but the Windows forms may have to be rewritten.

It also depends on what libraries you are using and which languages they support. Either you develop your own code to do something and that may mean developing your own libraries, or you use someone else's libraries to do something you are not able to or can't or don't have the time to write. Some libraries are open source and some are commercial so you have to pay attention to the license for each library. For example if you want to write a commercial program and use an open source library, make sure that the license does not restrict you from using it to write commercial programs or if it requires a fee to be used for commercial programs you'd better license it and pay the fee.

I tend to be programming language agnostic and I like to write a program in different languages to see which one runs best. But that is on my own time. I feel that writing the same program in different languages will help to sell the program because sometimes people who buy the program want it to be supported in a certain language. For example if I write in Visual BASIC 6.0 someone might want it in Visual BASIC 2008 , or C#, or Python 2.6, or ANSI C/C++, etc. So I feel I should write it in a few languages and see which one works better and is used better.

I prefer C++. It's quite possibly the hardest language on the market to master.

I use C# and Perl at my current job.

I use C & C++ for my graduate work.

I've also used... Lisp, Delphi, Prolog, Java, x86 assembler, QBASIC, VHDL, MIPS assembler, lex, yacc, PHP and others I've forgotten about.

I switch because I have different situations that require different languages.

To be honest, I've been switching programming languages to learn something new. In the process I've learnt that all languages are very similar to each other. Imperative languages all have the same control flow mechanisms, i.e. the three primitives: sequence, conditional (choice), and iteration (loop). The only differences between all the languages are the feature set and syntax.

If I want to learn a new language it is often because there are some features which helps developers accomplish stuff with less code. Those features are interesting to try out but don't necessarily replace one with another.

Started with:

1. MSX Basic, on my first computer
2. Z80 assembly, because I needed speed
3. Pascal, on school
4. Turbo Pascal, because school changed
5. x86 assembly, needed speed
6. C++, also on school
7. Clarion, needed to write a administrative tool for my club
8. Progress 4GL, started working
9. Visual Basic, because I liked it. Pushed company in that direction
10. C#, because I liked it more

And a bunch of other "tool" languages, that are not the core of you app, but support it.

I wasn't able to get through an associate's degree at a junior college without taking at least two different languages, and I wound up taking classes covering 5 languages... two in one class.

You'll benefit greatly by knowing multiple languages. Be an expert in at least one though.

Well,

ZX81 Basic, BBC Basic, Modula-2, Visual Basic (old), PHP, Javascript, C#.

Along the way I've dabbled in 6502 assembler, C, C++, XSLT and some bizarre OO language at university called Enact. My favourite? Visual Basic 6, it rocks.

I am going to go out my way and say I only program in C# yet I switch languages all the time (and please read on prior to giving me negative points and/or throwing flames :) )

All mature .NET languaes are polyglot-languages- if you are great at one, in a way you know many languages. You have declarative programming in it since .NET 1.0 (like JAVA). You have functional language capacities with LINQ (like Haskell). You have dynamic language capacities via .NET 4 (like Ruby). So are using C# to a high degree, you are in a way switching languages all the time.

To paraphrase the winning post in "up's" so far.

Did Coldfusion

needed work

Did ASP

needed sanity

Did PHP

needed more money

And now working on Java to resolve that.

I tend to use multiple languages, but I did make a big change in platform.

I started out my career working mainly with MS languages, servers, tool-stacks, because they were easy and kind of the default.

At one point though, it became necessary for me to do a bit of work with various langs/tools on *nix servers for several months.

Much of it was difficult because I wasn't familiar with it, but I did get used to it.

Then, when I went back to working mainly with MS, I found that I didn't like it anymore. I just liked open source better, I liked linux better, I liked the various languages better, and the support community, and the fact that you could take ownership of a project to whatever depth you needed to, even though you don't need to most of the time, without hitting a proprietary black box, beyond which only employees of a particular company can go.

I was a contractor, so it was pretty easy for me to make the switch by making recommendations and looking for different types of projects. At this point, I only really use MS for my workstation, which is one thing I think it really does excel at.

Why yes of course!

BASIC

Awesome, I can really make useful stuff myself, like this awesome crossword puzzle generator.

Turbo Pascal

Cool, it makes real EXE files! No interpreter required! Bit slow for pixel-by-pixel graphics stuff though...

C++

Now this is awesome. Check out this awesome Star Wars game I made (I was a kid, who cared about copyright back then) - oh and this thing that zooms in on a Mandlebrot image in real time, oh and this thing that is an audio codec/speech recognition thingy but that never really got finished...

Dabbled in Java, C, even Haskell for university

It's amazing how little free time you have when you finish high school. If I'd have kept programming at the rate I'd been going back when I was doing Pascal and C++ stuff I'd probably have created the equivalent of a few operating systems or office suites by now.

PHP

Now I'm coding PHP professionally and I think I'm expert at it.

Javascript

Now here is something I am definitely not expert in yet, but I intend to master.

Edit: revisiting this question 8 months later: I believe I've now mastered Javascript.

But then I'm also thinking of going back to C++.

Or learning Python.

Edit: 8 months later: haven't got around to learning Python yet.

...

I went from one language to another in a quite strange order

• vb6 : read about it in a magazine and stuck with it for 3 years
• Basic : took it in the first year at college (foundation year)
• vb.net :imagine cup france .. (for a small time)
• java : first year at computer science dept.
• c/c++ : first year summer
• objective-c : i was an intern at a company developing iphone applications
• python : at my free time .. really a great language

dont know what is next ... but may me more python , ruby and/or c#

In school I worked with QBasic, C/C++ (started platform neutral, but then worked with Win32 and DirectX), COBOL, VB6, Java/JSP, x86 Assembler, and various flavors of SQL.

Since school I've learned enough PHP to get by, a bit of OPL, VB.NET, a bit of C#, and InstallShield scripting. I've really been enjoying learning .NET, right now my preference has been with VB.NET because that is what our current big project is written in, but I'm comfortable with C# and have gotten to where I can understand it just as easily.

Pascal - Delphi (OOP, DB) - Java (Servlets, Desktop Software) - C (system programming) - Ruby (Rails) / Javascript (Qooxdoo)

And that is not including the ones that I spent less than a year working with...

I started programming professionally with FORTRAN66. After a few years we moved to FORTRAN77 and c. This was for a program that could run on virtually any hardware.

We then switched to Ada for a while before switching to C++ (MS Visual Studio 1.52) as the company migrated it's products to PCs.

I then changed jobs and stuck with C/C++ for a while, but with some VBScript and even VB on the side.

Technology moved on and we switched to C#. I've been doing that with ASP.NET and SQL on the side for the last few years.

I've also dabbled in Lisp, Pascal and Java.

Think about it, a programming language is just another tool you have in your repertoire, it is thankfully no Ideology that you (should) build your world upon.

You always chose the one tool that fits best: It does the work for the least amount of money, work, the most fun or whatever else requirement you might have.

For example PHP: It is not the most practical nor the most beautiful neither the fastest hammer in your tool chain, but hosting PHP applications is incredibly cheap and there is also an incredible community support. Another example is C#, which does have an efficient and free IDE and a solid framework with a good documentation. Python also comes with batteries included.

Or I want to work on an embedded project, I can't use my usual tools if all I have available is 2kB ram and an 16 Mhz 8bit CPU.

You would not make a sculpture with a sledgehammer or tear down a building with chisel.

I was a die hard C Fan.

Needed OOPs understanding

So Learnt C++

Needed some fun

Learnt AutoIt

Needed fun with ease

Learnt AutoHotkey

Needed Database query handling with ease

Learnt R

Thought of doing web development

Learnt HTML, PHP, Javascript and Ajax

Again needed ease of doing web developing

Learnt Codeigniter framework and Jquery

One of my friend was doig silly and funny things with VB So currently learning VB

Figure I might be the only person to include Huron.

BASIC (though didn't write any actual software, or even master the language)

to Pascal because I learned it at school and liked it

to COBOL because of my first job

to VB also because of my first job

to Huron/ObjectStar also because of my first job

to Delphi/Object Pascal because of my second job, then third & fourth

to C# because of my fourth job, then fifth & sixth

With a few minor adventures with other languages scattered throughout.

Started my first real applications in DarkBasic Pro.

wanted speed/library independence switched to C

Wanted objects and exceptions switched to C++

Disliked overly/complex syntax switched back to C

Needed a scripting language switched to Ruby

Needed for my job switched to C#

So now, I program mostly in C, C#, and Ruby. I also use PHP quite a bit but it's such a side language of mine that I wouldn't necessarily include it(for instance my website is currently PHP, but I really don't work very often with PHP)

I started off learning Javascript and HTML way back in the day. Dabbled in Java when it first came out but didn't feel like I could get my head around it. Learned some VBScript when ASP became an option in the MS server hosting side of things. It was a natural progression into ASP.NET which lead me into C# and VB.NET for desktop applications as well. It was right about then that decided I was really going to figure this stuff out and become a developer (8 years later!), so I learned c, c++, java, python, ruby and enough perl and bash to work my way through linux administration/development. PHP got picked up somewhere along the way as well, but actually most of the actual code I do, right now, is HTML and JavaScript still. I write Python to manipulate data pretty often as well. Most of the more recent language decisions were driven more by curiosity and a sense of adventure then by any actual need.

I switched from Fortran to C/C++ and then to Java.

It is not important for what language you are using. And I think most programmer can code with any programming languages. For me, I switch language if the language is suitable for the project. For example, if You going to develop a simple website for your company,You can use Python or some languages that can reduce the development time. But if you are building a public website, You should use PHP. Because You can find a PHP Hosting Server easily.

1. ASP
2. VB
3. PHP
4. C/C++
5. Basic
6. JAVA
7. Assembly
8. Python
9. SQL
10. BASH

I started out on Python, just to get a good understanding of computer programming in general, as it's incredibly easy to use.

I wanted to do some real-time graphics manipulation. So I learned Javascript and HTML and made some small demos like fireworks using colored text.

Then I heard about a free trial for Flash. I downloaded it (And later got the full version) and of course began exploring ActionScript (2.0) (and then AS 3.0 later on). This pretty much replaced Javascript for graphics.

But for complex animations (eg nice explosions), I couldn't squeeze enough speed out of ActionScript. So I tied Python's great text/file manipulation with ActionScript/Flash's image manipulation to create static animations and imported those into Flash.

Then I got into programming for my GameBoy. I learned C because nothing much else was available for that platform at the time, and I needed speed + direct access to specific registers/areas of memory.

And later, I learned assembly for the GameBoy Advance's primary processor (ARM7TDMI) to better understand such a complex system. I learned a few other assembly languages to allow me to program other micro-controllers and use them in projects.

Along the way, I also learned PHP and Basic, and probably a few others that I just can't remember right now. But I feel that I learned those because of my ignorance (of alternatives), and that they led nowhere.

But I do consider myself a Python fanatic. Python just flows so well, feels so natural. I'd choose it over any other interpreted languages I know of whenever it can get the job done, assuming it's available.

I don't normally "switch" between languages - I learn new ones and add them to my repertoire.

BASIC (learned in a bookstore) > Assembly (reverse-engineering of Apple ][ game binaries, any body remember CALL-151?) > Pascal (Turbo Pascal is the good enough reason) > C (for a DOS TSR project) > dBASEIII+ (summer job, an office application) > Visual Basic (event-driven programming, and Windows apps) > C++ (Windows system level programming) > Perl (text/html processing) > Ruby (web applications, Rails) > Objective C (iPhone! ;-)

• ActionScript 2 to Actionscript 3
• ActionScript to JavaScript, and back, and then back again
• still cheaply bought for either :P

Don't laugh because my list is short! I'm short too, so I'm used to it.

I'm really posting because Peter Norvig wrote this interesting piece " Teach Yourself Programming in Ten Years ^[1]", which comments on the amount of time it might take to "master" an art, like programming, and he suggests a "language set" which he thinks would stand you in good stead.

I switch regularly. As long as you know the fundamentals of programming it is easy. For me learning C was the language that made it easy to switch between languages.

Mostly I program in whatever the boss wants, unless given a choice. Then I attempt to pick the best tool for the job (considering things like maintenance [is the code easy to understand, can someone else check out the code and fix it], cost to business [licensing, retraining, etc], and is it a quick and dirty job [if so I will script it]).

The short answer, yes many times, because I like to be efficient and productive.

For me it is far easier in an academic setting to gracefully switch between langauges. There is a language for a task and as tasks vary so do languages. Ever hear of the R statistical package? It works both ways, you would work yourself to death without it when doing forecasting and related statisical work, but trying writing a killer game with it. In the business world I am a Java developer. Not that I would use Java for everything, but I like to put food on the table each night. I am discouraged from changing languages as they want experience, experience and more experience. Heck, I even floated an Actionscript solution to a problem we were having recently and it was laughed at.

My advice, even if you have to slip down to your basement on a night with a new moon so that no one can see you, crack open a book/ebook, open your computer, and learn a new language. You will be a programmer for it even if you do not have occasion to use it. Likely it will give you a better perspective of your current language.