Language Exploration

Specifically, I am interested in its generic system.

Interested to look at this family because of:

• Dedicated array manipulation functionality
• Non ASCII characters

I recently tried to actually use C while doing some Advent of Code problems and working with Emacs Lisp dynamic modules. Its actually much nicer than I expected. Although there is no modern-ish package management, the type of packages I have been needing at this level are easy to get.

A few resources that I am finding helpful based on whatever background I have:

• How to C and the Modern C book.
• A few useful nuggets from comp.lang.c Frequently Asked Questions.

I have had some experience with C++ and know the general basics. As of now, I don't have anything specific to try learning its more advanced features. I might try it to learn some design patterns.

Creating a new section since I somehow have ended up using this more than others from the Lisp family. Coming from Emacs Lisp and Common Lisp, Clojure Cookbook was much better resource than the more famous ones like Brave Clojure. YMMW.

Want to see how English like it really is.

I have been using Common Lisp occasionally and strongly recommend trying. Things that I am missing are probably from the popular books that I will try to cover soon. Specially Let Over Lambda and The Art of Metaobject Protocol.

Lack of community hurts though.

General resources:

• Use roswell for building command line tools.
• lake is a neat make alternative.
• I keep a list of utility packages that I :use in repl (and shell-ish scripts) here. Probably you could use something like cl21 but then you would want to write packages in cl21 too.
• CL is also great for scripting if you live in the repl. I wrote my workflow here.

Have heard a lot about dylan macros. Considering that its syntax is pretty non Lispy, its really interesting to know how macros feel in here. This might probably be similar to how they feel in R or Julia, or maybe not.

Contracts are the basic motivation here.

One of those language that tell you how pleasant programming can be even in a badly designed system if the language is well integrated in the environment and community is alive.

General resources:

• Use s, dash, f and ht while programming in elisp for maximum pleasure.
• Here is a great documentation for creating and working with dynamic modules.

I have been playing with Erlang a little bit recently. The syntax at first looks weird but makes much more sense after you try Prolog first. The killer feature, actor based concurrency, is something I haven't really tried yet.

Looking for a nice problem to proceed here.

As far as other BEAM languages are concerned, Elixir looks neat but probably won't have much to throw at me if I look into the ML family first.

I used factor once very long ago and didn't appreciate it then. Recently used some of its features and am impressed. The special point to mention is how clearly the code is data idea translates here. Other than trying out its extensive set of libraries, I am interested in learning more about quotations and trying to implement the language itself.

Not sure if I will be using this IRL, but is a nice language to learn a lot of ideas from. A few resources that I have touched:

1. Obviously Learn You a Haskell for Great Good! Not sure if this really helped though. Too much of someone else controlling the speed made me stop somewhere midway.
2. Haskell Study Plan. This one is much more self paced, flexible and practical.

Touched Io in 'Seven Languages in Seven weeks'. It is a good case study for learning about

• Message passing system
• Prototype based objects

There are other interesting features like the actor based concurrency model but I am more inclined to try that in Erlang, so nothing much to do here.

I get to use it at a few places occasionally. Java has evolved but there are so much better languages right now on JVM that I probably will never touch it again.

Modern JS has come a long way and has some seriously powerful features. I have been using it along with TypeScript and like both a lot. As of now, there is no specific language feature on my list. Probably after digging deeper into the runtime there will be some.

Have used it as a Python user would. Like R, the interesting things here are in the language core and how the AST manipulation works. Will be looking into those soon.

Lua probably is pretty well used in the game community and has some really nice engines. Will be trying it while working on a game.

I have tried it in pieces here and there. Looks like follows the following relation crystal:ruby::nim:python. I don't have any specific use case for it though so probably won't be jumping deeper here.

OCaml got me into pattern matching and algebraic data types. That's probably enough of this since I find Haskell more interesting now.

I have an okayish understanding of Prolog now but sometimes the programs get stuck pretty deep while backtracking. Will need to dig into the language and implementation to see what's missing.

Probably my main language as of now. Is pretty practical so has some annoying warts. Not much to dig here.

General resources:

• The Definitive Guide to Python import Statements is a neat guide explaining the import mess in Python.
• Want more structure in python programs? Use dataclasses/attrs and mypy.
• pydash has nice set of high level functions.
• glom helps in working with nested data.
• For workflow management, I find snakemake really useful. Combining it with conda gives nice pavement for exploratory projects. For scripts, pipenv is probably the cleanest solution.
• Use poetry for developing python libraries and/or scripts. It avoids setup.py and its brothers altogether.
• For managing python versions, I have found pyenv to be very clean. Along with poetry for managing virtualenvs, this helps in closing the loop.
• I like docopt for command line parsing. Even though there are probably valid arguments against it, since it's not very popular, I haven't really felt any problem with it til now.

R's problem domain already has mirrors in Python so its not worth that much. The more interesting part however comes in the language itself. A lot of nice package APIs in R are result of the meta programming support in R.

Advanced R has a section on metaprogramming which should be a good place to begin.

Separating this from the Lisp family because its not a Lisp in the strict sense. Few reasons for learning this specifically:

• ☐ Hygienic macros
• ☐ First class continuations
• ☐ Typed racket

Although I have used it occasionally, I haven't really committed to it. A piece that keeps tempting me here are the carefully crafted documentations and proses surrounding this.

Last I used, it felt like a better Python. Better lambdas, better shell integration and better class system. Though Python's package ecosystem is too expansive and complete that I mostly won't be doing anything here.

A bit of fad at the moment, but has modern features for everything possible with something like C++. Not sure if I will be able to start properly without pushing this somehow in workplace.

Tried this while going through the book 'Seven Languages in Seven Weeks'. Its focused a lot on practicalities and so is more of a mixture of tricks rather than having a definite ideological inclination. You can't love more than a couple practical languages. I am already full.

Don't remember where I got the reference from for this. A cursory glance tells probably there are a few novel features rather than a compendium.

The key experience here might not be Object Oriented Programming but the immersive, live IDE(s).

Not a language to learn as such, but am wanting to get in the compiler side using this pathway.