
Ask HN: What are some interesting languages you use or have used? - vram22
I mean programming languages. Also, the qualifier is: you should have been able to use it for practical non-trivial programs: a small utility, a simple game, a data processing task, etc. Not just for computing Fibonacci or factorial number sequences
======
stray
Interesting is in the eye of the beholder.

SQL is interesting because it forces you to think in terms of sets. And
because it wants you to tell it what to do but not how to do it.

Lisp is interesting because:

It is expressed in one of its own primary data types: the list.

But the thing that reads Lisp -- the Lisp reader, is itself programmable. So
if you want it to understand JSON syntax for example, or maybe Python
dictionary literals -- you can write reader macros to add the new syntax.

And of course because it can manipulate data stored in lists, that means it
can manipulate source code. Code in Lisp, is data. And data can be code if you
need it to. That's essentially what Lisp macros are: code that writes code on
the fly.

The backquote facility. This is basically a little template language for
rewriting data structures on the fly. It is the killer feature that, along
with the reader, enables the killer feature lispers won't shut up about.

The condition system. It separates signaling of conditions (including errors)
from the decision about how to deal with them. One implication of this is that
when an error is reached, you need not unwind the stack to handle it.

And because it is pretty.

~~~
vram22
That's some good points about Lisp.

I did know about the fact that code is data (everything is a list) and so Lisp
programs can write programs, parse their own code more easily than other
languages can, etc.

Didn't know the reader was programmable. Do remember reading a PG article,
where I think he said in Lisp, reading can be done compile or run time,
compiling at read or run time, and so on - all 3 possibilities. Not sure what
the uses of those are though, since I don't know Lisp much. Find it
interesting, though, for sure. I've read some of Practical Common Lisp by
Peter Seibel, and parts of a few other small tutorials. Do you have any other
recommendations? Also, what Lisp would you recommend for someone learning it,
in the early stages?

Didn't know about the backquote facility or that point about the Lisp
condition system. Will check it them.

Thanks for all the info.

~~~
stray
> Also, what Lisp would you recommend for someone learning it, in the early
> stages?

I'm partial to Common Lisp and I think it fits the brain pretty easily.

But Racket is a good choice too. There is a nice, friendly development
environment and plenty of libraries and learning materials.

> Do you have any other recommendations?

Sure. Check out SNOBOL: [http://www.snobol4.org](http://www.snobol4.org)

Oh, and Pharo Smaltalk is definitely worth looking at, imo.

~~~
vram22
Just remembered, I had tried out the Icon language some years ago, for a
while. Interesting, and had some unusual features. Just saw in the SNOBOL
Wikipedia article that it influenced Icon (and also Lua). And Ralph Griswold
was involved in both languages, SNOBOL and Icon.

[https://en.wikipedia.org/wiki/SNOBOL](https://en.wikipedia.org/wiki/SNOBOL)

[https://en.wikipedia.org/wiki/Ralph_E._Griswold](https://en.wikipedia.org/wiki/Ralph_E._Griswold)

------
noufalibrahim
I recently used Inform 7 for a workshop and have a half cooked game done using
it. It's interesting and the whole culture around the genre even more so. I
wrote about the workshop and posted the sample game here
[http://thelycaeum.in/blog/2016/02/24/inform_7_talk_at_fossme...](http://thelycaeum.in/blog/2016/02/24/inform_7_talk_at_fossmeet_2016/)

~~~
vram22
Cool. Will check it out, thanks.

~~~
vram22
The semi-natural language thing does seem good.

------
groovy2shoes
Off the top of my head: Scheme, Tcl, Prolog, ML, Kernel, Rust, and Kitten.
Each one blew my mind in one way or another when I first encountered it.

On a related note, Go is the most utterly _un_ interesting language I've
encountered in recent memory. Depending on where you're standing, that can be
an argument in its favor.

~~~
vram22
Thanks. Of the ones you mention, in the past, I've explored Scheme, very
little, Tcl a little, and Prolog a little. Did not know about Kernel and
Kitten. Kernel looks very advanced. Will check out Kitten. I thought you were
kitten me at at first - about the name :)

~~~
vram22
> Tcl a little

Actually Tcl more than a little, in the context of Expect, and also some with
Tk (and Tkinter in Python, though that is about the toolkit, not the Tcl
language). Tcl definitely is mind-blowing in its dynamic nature. So are the
capabilities of Expect, actually. I read most of the Expect book by its
author, Don Libes. He goes very deep into it. Fascinating. Even his writing
style is unique.

~~~
groovy2shoes
What I found most interesting about Tcl was its capacity for metaprogramming,
due in large part to its quoting mechanism. Due to this, procedures in Tcl
wind up somewhat akin to the fexpr construct found in some ancient Lisp
dialects -- a construct which forms the theoretical basis for Kernel, albeit
in a rigorous, formal manner called "vau calculus".

~~~
vram22
>What I found most interesting about Tcl was its capacity for metaprogramming,
due in large part to its quoting mechanism.

Cool.

Ah yes, memories coming back a bit now. (Had read both the Ousterhout (Tcl and
Tk) and Libes (Expect) books years ago.) I remember that though the Libes book
is about Expect, he does go into talking about Tcl a lot, including some of
the advanced features you mention (though always or a lot, in the context of
how they are used in Expect).

I guess part of its (Tcl's) dynamic nature comes from the fact that everything
in Tcl is a string (and the quoting and the ability to evaluate expressions),
like everything in Lisp is a list (or an atom).

------
vram22
Thanks to all who replied or will, BTW.

