The thought has just occurred to me that conducting a public survey on
evolution across, familiarity with, and exposure to various
programming paradigms in students and practitioners of functional
programming could be illuminating in revealing the correlation between
degree of familiarity with and experience in
procedural/object-oriented programming paradigms, and ease of learning
functional programming in a non-strict, purely functional programming
language, such as Haskell or Clean.

Could you please outline your evolution as a functional programmer in
the following manner (preferably in this thread):

A) Your chronological evolution in programming languages; e.g. (in my
case):

I am not a programmer. I learned about functional programming through
Mathematica (not really a general purpose language, but it is very
good at what it was designed for). Before that I only knew some
BASIC, Pascal and a little 8086 asm. I enjoyed working with
Mathematica a lot, and after I have used it for a few years, I tried
to find a similar language that could replace C++ for high performance
numerical computing tasks (in particular monte carlo simulation). I
played a little with different languages but couldn't find anything
that seemed suitable. Of course the language itself is not the only
factor, it is important that there already be a community using the
language for the same kinds of tasks. After all the most important
thing is getting one's work done (note that I'm not a programmer...

On Sep 19, 11:42 am, Benjamin L. Russell Yahoo.com>
wrote:

Benjamin L. Russell Yahoo.com> writes:

QBASIC (1999) -> Scheme

I learned other languages (C, Perl, PHP, JavaScript) when it benefited
me, but I wouldn't consider that an evolution.

I learned Scheme because QBASIC limited my ability to program with deep
recursion, and I wanted something interesting. It was recommended that I
try Lisp, so I found Scheme, and haven't looked back.

Aaron Hsu

On Sep 19, 6:42 am, Benjamin L. Russell Yahoo.com>
wrote:

1988 - first contact with programming with Basic at an MSX (damn! I
should be retarded by now)
1994 - Pascal in Turbo Pascal at University
1997 - C, all by myself with guidance from Thompson&Ritchie and some
free compiler for Windows (later learned it was GCC underneath)
2000 - learned some Java, hoping for some stupid job
2001 - first contact with Linux and the full stack of scripting:
perl, python, tcl, ruby. Found guile scheme.
2004 - C# for work. It was either this or old VB ASP code...
2005 - first geared my head towards functional programming. Learned
some Haskell, settled on Scheme (PLT).
2006-today - Delphi and SQL for work

At work, I don't discuss technology choices with the guy paying my
salary. Whenever I get my hands at any code, though, I immediatly
begin some cleaning up by removing it away from aggressively
imperative...

On Sep 19, 9:51 am, Slobodan Blazeski gmail.com>
wrote:

Any language can do that by either using just single assignment or
function evaluation.

Hmm, that's very true.

namekuseijin wrote:

Not without loss of expressiveness, IIRC.

Szabolcs wrote:

Benjamin L. Russell Yahoo.com> writes:

Some dates may be a bit off.

BASIC, in QBASIC with line numbers (1994-ish to later in the 90's)
-> Visual Basic 2.0-6.0 (mid-1990s)
-> C in C++ syntax (1997)
-> Python (1998/9-present)
-> Perl (2004-present)
-> Java (2005-present, sadly)
-> Real C++ (2005-)
-> Scheme (2005?)
-> Common Lisp (2006-present)
-> OCaml (2007-present)
-> Haskell (2007)
-> Standard ML (2008)

Benjamin L. Russell wrote:

Off the top of my head: