31
\$\begingroup\$

We've decided to revive the Language of the Month event. We've also decided to start a new post for nominations. (You can see the old nominations post here.) So let's get to nominating!

Procedure

A language can be nominated for Language of the Month by posting an answer to this thread. We all vote on the languages we'd like to see featured. At the beginning of each month, the nomination with the highest net vote total is chosen as the Language of the Month. (This nomination process was modeled after Lit.SE's reading challenges.)

The person who nominated the language will post a new question on meta, declaring that language to be Language of the Month, with an answer to collect all related golf submissions, tips, and challenges during the month. (See the previous posts, linked below, for a good format to follow.)

  • If the person who nominated the language is not able to make the post by the 3rd of the month, anyone else can make the post.
  • If there is a tie in the voting, the tied language that was nominated earlier will be Language of the Month.

The chosen language will have a chatroom created for it, if it doesn't already have one. During the month, everyone who wants to participate will:

  • Learn the basics of the language (if they don't know it already)
  • Answer challenges in it (new ones or old ones, doesn't matter)
  • Try to outgolf each other's answers
  • Discuss all of the above in the language's chatroom

Past Languages of the Month will be added to a list at the bottom of this post. Their nomination posts should be deleted (preferably by the person who made the post) to reduce clutter.

What sort of languages should I nominate?

We hope to see a wide variety! But not every language is a good choice for Language of the Month. Some things to consider before nominating, and when voting on nominations:

  • It should be somewhat general-purpose and possible to program in. Bubblegum isn't a good choice, because it's only capable of solving a small subset of challenges. Neither is Malbolge a good choice, because it's prohibitively hard to create a working program in it at all.
  • It should not be one of our most commonly used languages on PPCG. The point of this event is to bring attention to lesser-known languages. We don't need to bring more attention to Python or JavaScript. Suggested rule of thumb: if there are fewer than 10 PPCG users who regularly golf in this language, it's a good nomination.*
  • It should have a freely available implementation. This can be TIO, some other online source, or a downloadable interpreter/compiler.
  • It should be fairly stable. Most languages change over time, even well-established ones, so this is a subjective criterion. But if a language is likely to experience significant modifications in the next month, don't nominate it yet.
  • It can be either esoteric or practical. Of course we like our esolangs around here, but it's also cool to study lesser-known "real" languages.

* Better rules of thumb are welcome. Here are a couple SEDE queries for estimating how commonly a language is used: a strict version (useful for languages with short names that could show up as false positives within other languages' names or URLs) and and a loose version (useful for languages whose headers frequently mention a flavor or version number with the name).

What should I include in a nomination post?

At a minimum, your nomination must include:

  • The language's name.
  • A link to a free implementation (or more than one, if available).
  • A short description of the language, for those unfamiliar with it.
  • Why you think this would make a good Language of the Month.

Ideally, your nomination should also include:

  • Some links to documentation and other good resources for learning the language.
  • A link to the language's question, if it has one.

You can also include ideas for one or more language-specific challenges that will provide an interesting experience beyond answering regular challenges in this language. These can be , , , ... you name it. Good language-specific challenges will focus on some aspect of the language that makes it unique, such as an ability or a weakness that most other languages don't have.

Feel free to re-nominate a language that was nominated last time but never won. You can copy over the old nomination post if you like. Languages that have previously been Language of the Month are not eligible.


List of past and current Languages of the Month

2018

2020

2021

Don't forget to keep nominating and voting on languages for next month!

\$\endgroup\$
2
  • 1
    \$\begingroup\$ By the way, the top few languages have been downvoted, so make sure you look at the upvotes. \$\endgroup\$
    – user
    Dec 1 '20 at 17:41
  • 3
    \$\begingroup\$ @user the language is chosen by net vote score, not by number of upvotes. \$\endgroup\$
    – pxeger
    Sep 1 at 12:58
13
\$\begingroup\$

BQN

BQN is a powerful modern language based on the ideas of Ken Iverson's APL, which is already quite popular on CGCC.

The main aim of BQN is to remove irregular and burdensome aspects of the APL tradition while adding newer modern concepts to the mix. This makes BQN oftentimes more practical than APL, and gives it a much more consistent, streamlined design refined from many years of array programming experience.

Why BQN?

  • BQN uses cool looking(important), carefully chosen symbols. This makes it readable and practical, yet very golfy.
  • BQN provides strong fundamentals for array programming which you can use for algorithmic coding in any language.
  • Lisp style functional programming support which is outlined here.
  • BQN has the most powerful tacit system available in an APL family language.
  • Why BQN? is a more comprehensive document on what BQN is currently and what it aims to be.

Resources

BQN has already been featured in Learn you a lang for great good, and I've made this submission as a result from the response to that event. I hope you enjoy learning BQN as much as I did.

\$\endgroup\$
1
11
\$\begingroup\$

Add++

Add++ is a language that combines both short commands and other golfing features with general usability and practical language features. For example, I've written a programming language in Add++, and most solutions in Add++ are easy to understand for users of both practical and golfing languages.

Reasons

  • There aren't many languages like it. In my experience on the site, I don't recall seeing any languages with a similar model to Add++
  • It is widely usable. I would describe Add++ as a practical language with one- or two-byte commands, so it's easily accessible to all golfers
  • It's somewhat used across the site. Primarily by me, but there are multiple answers by other users, and we already have a chatroom
  • Due to its wide range of builtins, it is very powerful, and so can complete most challenges competitively with other golfing languages.
    • Closer to Pyth and CJam rather than Jelly and 05AB1E however
  • It has version tracking, and each version can be run via command-line flags
  • Its docs are fairly comprehensive, thanks to Razetime

Caveats

The docs do not contain a comprehensive list of commands, and it is somewhat strict in its syntax, which can lead to a lot of errors. Furthermore, Add++ still has some bugs in the code, along with some confusing behaviours.

I'm currently writing the latest version (v6) in order to someone mitigate the biggest problems I have with Add++

Resources

\$\endgroup\$
1
  • \$\begingroup\$ I think MUMPS is a much better candidate than this - syntax shorthands, competitive, comprehensive docs. I haven't used MUMPS yet though, not sure about other potential reasons. \$\endgroup\$
    – user99151
    Jan 19 at 7:23
9
\$\begingroup\$

Knight

Knight is a new programming language created back in April by sampersand.

Interpreters

There is a list of interpreters on the official GitHub page. It has been ported to many languages, even itself.

Here is an interpreter on TIO, a patch to a previous commit to c/golf which updates and fixes some conformance issues. (Note that it memory leaks like crazy and segfaults on malformed inputs).

However, the "preferred" interpreter is c/ast, which is the fastest, most up-to-date interpreter and has actual error checking.

Description

Knight is a Polish notation language (meaning x + y is + x y, and everything has fixed arity) which is relatively simple. It has some useful string manipulation tools, eval, shell commands, and type coercion.

Reasoning

  • It is a new language which deserves some attention.
  • It is simple and very easy to pick up.
  • It is surprisingly golfable despite not being a dedicated golfing language.
  • Knight has some qualities/quirks that make it very unique to golf.
    • Polish notation
    • Tokens are separated by their character class. So, for example, WX is WX, while Wx is W x. This makes ordering very important.
    • Only the first statement is executed, everything must be chained (typically using ;).

I have posted some solutions here already.

Resources:

\$\endgroup\$
2
  • \$\begingroup\$ Food for thought: maybe we have a golfing challenge where people golf knight? \$\endgroup\$
    – Sampersand
    Jun 9 at 20:09
  • \$\begingroup\$ Usually they don't do that here, what some people like to do is create a bounty for the first programs in that language \$\endgroup\$
    – EasyasPi
    Jun 9 at 22:59
9
\$\begingroup\$

Desmos

Desmos is an online graphing calculator with strong mathematical functionalities. It's not designed to be a programming language, but it can certainly be used as one.

Reasons

  • Even though it is a graphing calculator, it can be used as a programming language, albeit a limited one.
  • Following the previous point, Desmos has certain limitations that make it fun/challenging to golf with.
    • For example, lists/list manipulation are quite limited; for one, lists can only be 1d, so finding clever ways around that limitation can be interesting.
  • Desmos differs from many of the more popular languages in that the code is based on mathematical(\$\LaTeX\$) formulae instead of purely on executing code instructions.
  • There is an abundance of builtin functions and functionalities(see Resources below) that you can use in your Desmos code.
  • There are active communities on Reddit, Twitter, and even Discord. People there can probably help you with any questions you may have.

Caveats

  • Strings are not supported whatsoever, meaning any challenges requiring string I/O cannot be done with Desmos.
  • Sometimes tedious to do the simple, but necessary, golfs every time an expression is copied out from Desmos. (c.f. this)
    • e.g.: \operatorname{min}\left(a,b\right) --> min(a,b)
  • Usually very hard to search on the Internet for any questions you may have; you'll most likely have to join one of the communities listed in Resources and ask the question there.

Resources

\$\endgroup\$
8
\$\begingroup\$

Arn

Arn is a rather new J-like language I designed back in mid-August (2020). It's designed to beat out its inspiration and also be competitive against other, older golfing languages.

Reasons

  • it does well at what’s it meant to, consistently beating J and APL. I’ve also seen it do better than languages such as Vyxal.
  • The tutorial has been finished, making it easy to start.
  • Done with a major rewrite. TLDR new features, adding new ones easier
  • Has entered a semi stable state. I have a feeling a few larger changes are due in the future, but for now I’ll probably just be adding a few new symbols every once in a while.
  • There are very few (if any, other than me) people who use this language (as far as I'm aware) so this will help spread the language around.

Caveats

  • Does not currently have a chatroom, as I don't believe there are enough people to warrant one.
  • The online version is out of date and has some bugs.
  • I believe there’s a bug in the lexer that shows when using symbols that take multiple expressions on the same side, which I’m looking into.

Resources

\$\endgroup\$
8
\$\begingroup\$

Nim

The Nim programming language is a ergonomic general purpose programming language.

A quick list of features:

  • Whitespace-oriented syntax, much like Python
  • Static typing,
  • Transpilation to C/C++/ObjC/JS
  • Multi-paradigm memory management (several GCs, no GC, and others)
  • Dynamic & static seqs/arrays
  • First class functions, called "procedural types"
  • User-defined iterators
  • Metaprogramming of all sorts, with everything from text-substitution, to macros that operate on it's AST (Introduction to metaprogramming in Nim)
  • Great C/C++/JS interop

It has a very active community. (Forum, subreddit).

A quick intro, covering only the most basic constructs: Nim basics

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Nim looks like a really neat language. afaik there's multiple GC's to fit your purposes, right? \$\endgroup\$
    – user
    Sep 12 at 18:34
  • \$\begingroup\$ Yes, that is true. See nim-lang.github.io/Nim/gc. \$\endgroup\$
    – Pyautogui
    Sep 12 at 23:39
8
\$\begingroup\$

tinylisp

A minimalist Lisp dialect that I (DLosc) invented for an interpreter golf challenge. Because Lisp is powerful, tinylisp's small set of builtins can be combined to solve a wide variety of tasks.

Reasons

  • The core builtins are one character each, contributing to golfiness.
  • There is a standard library that implements a bunch of more-complex functions.
  • Being a Lisp dialect, tinylisp is pretty good at functional programming and list manipulation.
  • I'm basically the only one who uses it.

Caveats

  • The only documentation is the GitHub readme, which gives a decent introduction to the syntax and builtins but doesn't cover the library at all.
  • String operations are supported, but not very thoroughly. All numbers are integers--no rationals or floating point.
  • If you don't already speak Lisp, tinylisp might be hard to understand.

Resources

\$\endgroup\$
7
\$\begingroup\$

Curry

At first brush Curry just looks like a dialect of site darling Haskell. It has a slightly different basic library, and slightly more powerful pattern matching. If this were all there was to Curry I wouldn't be recomending it here.

But Curry has something that makes it really interesting. Curry can also do logical programming. Meaning that while Haskell always takes the first available path, Curry will take all paths looking for correct result. You can get the compiler to do the search for you. This is the power behind Prolog combined with the clean expressive functional nature of Haskell.

Not only does this make Curry really unique and interesting as a language, this opens up all sorts of opportunities for golfing. Curry can be logical when it's the best and functional when it's not.

If you're into Haskell or Prolog golf I cannot recommend Curry enough. If you're not so into those but you are interested I think Curry is an excellent way to sample both techniques.

Curry has 2 implementations on TIO PAKCS and Sloth, as well as MCC and KiCS2. Each implementation has it's own quirks.

\$\endgroup\$
2
  • \$\begingroup\$ Is this the official Curry website? \$\endgroup\$
    – user
    Sep 10 at 23:13
  • 1
    \$\begingroup\$ @user It's hard to tell who runs that site exactly. I think it's the people who make KiCS2. It is a useful link though. \$\endgroup\$
    – Grain Ghost Mod
    Sep 10 at 23:14
2
\$\begingroup\$

Groovy

Groovy is a static/dynamic language that runs on the Java Virtual Machine. It supports a large subset of Java, but features such as dynamic typing, optional semicolons, and implicit returns allow writing of code that is much shorter than Java (here is a nice demonstration of how short it can be compared to Java). Groovy is also widely used in DSLs, with Gradle being the most notable example.

Why am I nominating it? It is a practical, widely used language in which you can make a program as long as Java, but you are not forced to. This language allows you to remove all the forced stuff (unlike the good ol' public static void main(String[]a) and simply let your juices flowing. It'd be nice to start and end the year with JVM languages ;)

Features

  • Optional static typing; you may declare the type of a variable, but you don't have to
  • Closures; anonymous functions
  • Implicit it parameter in closures
  • Implicit returns
  • Boolean evaluation
  • Optional semicolons and parentheses
  • Command chains: i came i saw i conquered equates to i(came).i(saw).i(conqered)

Resources

\$\endgroup\$
1
  • \$\begingroup\$ In addition to code golf, Groovy is amazing for DSLs! I'm looking forward to this one becoming LotM \$\endgroup\$
    – user
    Nov 15 at 21:55

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .