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.

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/)

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…

Classic rant about X's clipboard subsystem, ICCCM: http://www.call-with-current-continuation.org/rants/icccm.txt (original mailing list hosting is no longer available)

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,…

FLENG[1] - Wow, "low level concurrent logic programming language descended from Prolog" - sounds like an easy swap out for Erlang since they have the same heritage. ;) [1] http://www.call-with-current-continuation.org/fleng/fleng.html

The Strand programming book states that an early version of the Erlang runtime was implemented in Strand (see "13.1: History" http://www.call-with-current-continuation.org/files/strand-book.pdf#pa… which is an interesting tidbit that I haven't seen come up when the history of Erlang is discussed, like in the featured article.

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

See also here for an actively maintained and relatively portable implementation of Flat GHC, Strand and PCN for UNIX systems: http://www.call-with-current-continuation.org/fleng/fleng.html

This is a bit OT, but does anyone know free implementations of logic programming languages other than Prolog? Portability is a bonus. I already know: * Strand * http://www.call-with-current-continuation.org/fleng/fleng.html * Racket's implementation of datalog TIA.

Not sure if this is useful for hardware, but there's UF [0] for Uxn [1], a tiny VM that can you can get to run on lots and lots of (old and new) devices. [0]: http://www.call-with-current-continuation.org/uf/README (git repo link at the bottom of that page) [1]: https://100r.co/site/uxn.html

Sounds interesting. I think the web page would benefit from some examples of what code in this language looks like. From scanning the user manual[1] it looks a lot like Prolog, but I can't see any complete example programs. [1] http://www.call-with-current-continuation.org/microfleng/MANUAL

A recent submission seems related: The joy of concurrent logic programming https://news.ycombinator.com/item?id=29139437 http://www.call-with-current-continuation.org/articles/the-joy-of-conc…

> 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.

From the same author, and in the same family of languages, is FLENG: http://www.call-with-current-continuation.org/fleng/fleng.html It lacks Strand's distributed features but includes prolog's unification.

I think this is very indicative of Winkelmann's philosophies about software in general. On his site he writes a little bit about why he thinks Forth is so important, and I think it makes for a good explanation of why he probably implemented Strand like this: http://www.call-with-current-continuation.org/articles/forth.txt

A sample from their user manual[0]: % print even numbers between 1 and 10 main :- count(1). count(11). count(N) :- N =< 10 | even(N), N2 is N + 1, count(N2). even(N) :- M is N \\ 2, even(M, N). even(0, N) :- writeln(N). even(_, _) :- otherwise | true. [0] http://www.call-with-current-continuation.org/strand/MANUAL

There's also Bones, an R5RS Scheme that compiles to x86_64 assembly (from the Chicken Scheme creator). http://www.call-with-current-continuation.org/bones/ https://bitbucket.org/bunny351/bones

There is a nice Tcl/Tk port of Acme: http://www.call-with-current-continuation.org/ma/ma.html

Chicken's author also created Bones, a Scheme that outputs x86-64 assembly language. http://www.call-with-current-continuation.org/bones/ README: http://www.call-with-current-continuation.org/bones/bones.html

The age ol' "How Software Companies Die"[1] has much on this point. The environment that nurtures creative programmers kills management and marketing types - and vice versa.... [1] http://www.call-with-current-continuation.org/rants/how-companies-die.…

Furry Paws is an "optimizing whole-program compiler and runtime-system for a dialect of John Backus' FP language": http://www.call-with-current-continuation.org/fp/

As far as FL/FP/FPr go, http://www.call-with-current-continuation.org/fp/ is the most mature and complete implementation I'm aware of. There's #proglangdesign on freenode where a bunch of us have been on an array language/function-level streak lately. Some people there might be aware of more.