call-with-current-continuation.org

I recently did this, as in about a month ago, I became interested in learning Lisp. I started with a bunch of things. First I tried to get various working environments going like:

Emacs + Slime + SBCL

Emacs + Quack + PLT Scheme

I also tried DrScheme (which is a great learning environment).

Not knowing what i'd really need I also did some searching and discovered a few books:

http://mitpress.mit.edu/sicp/

http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme.html

http://www.gigamonkeys.com/book/

i also purchased the little schemer. I learned various interesting things from these different sources.

1. practical common lisp was essentially useless to me since i'd already been kind of feeling sold on using scheme and had very little interest in common lisp. what it DID teach me was how datastructures in lisp are created under the hood (or how one might go about implementing them). from this perspective it was very nice and helpful when understading, car, cdr and mapcar. although i wish i'd had a nice example of implementing a scheme in C.

2. reading The Little Schemer, has been the single most satisfying read of my entire computing life. so much so
that i bought The Seasoned Schemer and The Reasoned Schemer
without hesitation at price. this book will teach you to "think lisp" if you can just make it through the first book you will honestly know everything you need to about the lisp mindset and be ready to actually write useful code and no be shocked or…

Here are some great resources on Forth:

http://www.call-with-current-continuation.org/articles/forth.txt

https://git.sr.ht/~vdupras/duskos/tree/master/fs/doc/design/simple.txt

https://www.youtube.com/watch?v=9TJuOwy4aGA

Let me quote the first essay at length:

> Writing "good" Forth code is very hard, or at least what I consider good
Forth code, which may be different from what others consider good. Forth
has been called a "write only language", but only because it requires
an additional effort to simplify your code to a point where everything
becomes obvious. This is an art, it is a moment of transcendence, which
I don't claim to have ever reached, but sometimes I get a glimpse of it,
an inkling of the fact that if I would work very hard on this, it will
become so simple, so heavily factored, using such obvious and clear names
that everything just falls into place. It is this moment that programmers
experience every once in a while, where a short, simple piece of code
just does what it is supposed to do, without any extra baggage, easily
understandable. To achieve it in Forth is much harder, it may require
more time, many rewrites, but the results are even more satisfying,
as the result is smaller, much simpler, fully self-contained and not
burdened by code that you can not trust. When you forget about that urge
of productivity, which has become the moloch we sacrifice our children to,
you may be able to achieve that particular thing that is called quality,
elegance,…

Since you explicitly mentioned C# and F#, I'd suggest OCaml. There's a free translation of a French O'Reilly book, _Developing applications with Objective Caml_, at http://caml.inria.fr/pub/docs/oreilly-book/ (the site seems to be down for me at the moment). The first few chapters focus on functional programming, then imperative programming, then compare their strengths, weaknesses, and when using each is most appropriate. (OOP and others are covered later in the book.) It's a pretty good intro to FP, imho.

Once you know FP techniques, you can apply them in many languages people don't tend to think of as functional (though tail-call optimization helps, and support for higher-order functions is all but necessary); I write strongly FP-influenced code in Lua, for example.

Scheme is also an utterly fantastic language, but I'm going to defer recommendations there to others. (Except: I really like Chicken - http://www.call-with-current-continuation.org/)

It sounds like you're asking these questions because you're stuck inside the scripting language box. There's a much greater range of choice open to you than Perl/Python/Ruby on the one hand, and C/C++/maybe-Java on the other.

For example, Common Lisp implementations often compile functions as they're entered at the interactive prompt. From your perspective, you see an "interpreter" that runs code on the order of 100 times faster than it should. I'm told popular OCaml and Haskell implementations work this way too.

If you're interested in portability, there are efficient Scheme compilers that target ANSI C, which gives you portability, good integration into just about any environment, and access to lots and lots of library code. My favorite of these is Chicken Scheme, which you can read about at http://www.call-with-current-continuation.org.

Strand is one of the languages that particularly blew my mind, I think it was Armstrong that said that Strand was "too parallel"

Strand is a logic programming language for parallel computing, derived from Parlog[2] which itself is a dialect of Prolog[3]. While the language superficially resembles Prolog, depth-first search and backtracking are not provided. Instead execution of a goal spawns a number of processes that execute concurrently.

http://www.call-with-current-continuation.org/strand/strand.html

> This implementation
additionally can distribute pools of parallel processes over native
OS level threads, thus taking advantage of multicore architectures.
Locking overhead should be small, as data is normally not shared
among processes executing on different threads.

From: http://www.call-with-current-continuation.org/fleng/fleng.html

It seems the author has taken this into account, it's not a 1:1 mapping of processes to OS threads.