15
\$\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

  • September: R

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

| |
\$\endgroup\$
  • \$\begingroup\$ Ah, good. 15 chars. \$\endgroup\$ – null Aug 30 at 6:22
  • 5
    \$\begingroup\$ @null Hey!!!!!! Why did you edit everything into /(null )+/!? \$\endgroup\$ – hi. Aug 30 at 14:12
  • 2
    \$\begingroup\$ @hi. Actually seems to be /((null ){3}null)+/ \$\endgroup\$ – Redwolf Programs Sep 6 at 15:18
12
\$\begingroup\$

Husk

Husk is a purely functional and lazy golfing language created by me and Leo. It's inspired by, implemented in, and transpiled to Haskell. It can perform rather well (comparably to Jelly and 05AB1E) in many challenges, especially ones involving list manipulation.

Husk has never had a large pool of users, and it's been stable for about two years now (largely because we don't have time or motivation to extend it).

What makes it special?

  • AFAIK, it's the only golfing language that wholly embraces the functional paradigm. Its syntax is (mostly) based on prefix notation, like Pyth, but many golfing tricks rely on things like passing partially applied functions to other functions.
  • It has a strict and static (but implicit) type system, which is also unique among golfing languages.
  • Like Haskell, it's lazy, meaning that some programs that would result in infinite loops in most other languages will happily compile and run. For example, you can first map a function over a list and then filter out those partially computed results for which the remaining computation would loop forever.

Resources

Caveats

Husk seems to be pretty hard to get into, not least because of the type system. AFAIK the only users that know it well are its creators (myself and Leo), and I won't have much time to participate in chatroom conversations in the foreseeable future.

Another minor caveat is that certain challenges can't be answered in Husk without considerable extra effort or rule-bending. This includes anything involving randomness (Husk is completely deterministic, so you'd have to roll your own PRNG and give a seed as input) or many forms of user interaction (Husk programs only take input from command line arguments).

| |
\$\endgroup\$
10
\$\begingroup\$

Forth

Forth is the first stack-based practical language.

Reasons

  • Forth has a compact and simple syntax, which makes the learning curve very low.
  • Thanks to Forth's compact syntax, it would be very easy to write very concise programs.
  • It allows users of traditional practical languages to think in a different way than the way they are used to.

Resources

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ Forth is interesting because due to the low-level-ish way it treats its stack contents, we can use various built-in words to achieve obscure things. E.g. s>d, whose original purpose is to extend a single-precision signed int to double-precision, can be used as a non-negativity test (as it essentially pushes 0 if non-negative and -1 otherwise). \$\endgroup\$ – Bubbler Aug 31 at 4:12
  • \$\begingroup\$ @Bubbler I checked Gforth's documentation of s>d, and apparently a double-precision number is just two single-precision numbers next to each other on the stack. What a crazy design decision. \$\endgroup\$ – Zgarb Aug 31 at 12:22
  • \$\begingroup\$ @Zgarb True, though I guess there's no choice since every stack element in Forth is a register-sized integer/pointer (apart from the FP stack). \$\endgroup\$ – Bubbler Sep 1 at 2:27
5
\$\begingroup\$

Rust

Verbatim from their homepage:

A language empowering everyone to build reliable and efficient software.

It may not be a language built for golfing, but it sure is a language built for writing robust applications!

Reasons

  • It's a language designed to prevent memory-unsafe operations at compile time, to the point where (using safe Rust), "If it compiles cleanly, it's memory-safe". It does so by employing move semantics and references tagged with lifetimes, which also leads to writing programs that don't require a garbage collector

  • As a welcome side effect from its memory safety, Rust programs can easily be parallelized due to data-races being eliminated

  • It has a robust type system (which is interestingly also Turing complete provided limits are removed, similar to Prolog) which handles null using an Option type and program exceptions with a Result type, forcing exceptions to be handled explicitly

  • It has a very consistent toolkit, with cargo managing dependencies and working as a build, test, benchmark and documentation system, clippy providing suggestions to help Rustaceans of any experience level write idiomatic Rust, and more

  • It has excellent documentation and ensures examples provided in docs are tested as part of the test suite

  • It can run on a variety of environments, all the way from bare metal to WebAssembly

  • It has zero-cost implementations of iterators and asynchronous programming

Caveats

Part of why Rust isn't suited for golfing is the verbosity needed to deal with errors (due to its type system)

Resources

| |
\$\endgroup\$
  • \$\begingroup\$ errors do not matter at all in golfing so long as the program does the thing. \$\endgroup\$ – Razetime Aug 30 at 13:24
  • 1
    \$\begingroup\$ @Razetime The problem is, Rust forces explicit error handling, the shortest way to say you don't care is by saying .unwrap() on the Option or Result xD \$\endgroup\$ – K3v1n Aug 30 at 13:41
5
\$\begingroup\$

Vim

Vim is a text editor that is meant to be an improvement over vi.

Reasons

  • It's very concise - usual operations only take one or two ASCII bytes.
  • It's really good for string manipulation challenges ( is our second most popular tags), so you are going to find chances to use it very often.

Resources

| |
\$\endgroup\$
  • \$\begingroup\$ I don't know if Vim all by itself can be considered. Is it possible to use it as a general purpose language? \$\endgroup\$ – Razetime Aug 30 at 9:39
  • 5
    \$\begingroup\$ @Razetime All Vim answers on this site. Vim supports VimScript, an easy to use language that's probably general purpose. \$\endgroup\$ – hi. Aug 30 at 10:38
  • 1
    \$\begingroup\$ Furthermore, TIO can be used as V is entirely backwards-compatible with Vim (any Vim program can be run in V): TryItOnline! \$\endgroup\$ – caird coinheringaahing Sep 4 at 12:44
2
\$\begingroup\$

MUMPS (Aka M)

MUMPS is a general purpose imperative language with a built-in database.

Reasons

  • Although MUMPS allows programmers to program in a verbose version, every keyword in MUMPS has a one-byte alternative.
  • Its imperative nature allows programs to be extremely easy to write.
  • As of now, we only have 65 MUMPS answers on this site, we need more!
| |
\$\endgroup\$
2
\$\begingroup\$

Vyxal

Vyxal is what one might term the "new kid on the block" when it comes to golfing languages. It's made by me, Lyxal, and tries to make golfing a pleasant experience.

Reasons

  • It's got potential to actively win against languages like 05ab1e, Jelly and Pyth... it managed to beat Dennis in fizzbuzz

  • It has features designed to make it feel analogous to practical languages while remaining concise

  • It has potential to adapt with the addition of new built ins over time

  • It's newly introduced, so it barely has any users

  • Although it's still got a bit to go, most of the key features are implemented and the essence of the unimplemented features has been determined. It's just a matter of adding built ins

Resources

| |
\$\endgroup\$
  • 5
    \$\begingroup\$ This language seems to be under heavy development (several major features were added this month). \$\endgroup\$ – Zgarb Aug 30 at 12:51
  • 1
    \$\begingroup\$ @Zgarb the heaviest of development has been completed... that's the heaviest it will be for a long time now. \$\endgroup\$ – Lyxal Aug 30 at 22:37
2
\$\begingroup\$

Whispers

Whispers is a rather unique programming language in how it executes a program. Rather than running line-by-line or command-by-command, Whispers only executes the last line in the program by default. All other lines are only run when referenced by either the last line, or by a line referenced by the last line (and so on).

Reasons

  • It is, to my knowledge, completely unique. I'm unaware of any programming languages like it. Additionally, I'm the only consistent user of the language.
  • It's heavily optimised towards math-based challenges, but is fairly easy to use across all types of challenge, once you know how it works
  • It's strict-yet-lenient syntax rules make it super easy to use in polyglots
  • Especially with the latest version, Whispers is very powerful, including a built in calculus engine, along with the ability to run and evaluate arbitrary mathematical expressions. Furthermore, it now has support for common sequences, a massive builtin library of functions and a large collection of builtin operators and constants
  • Versions 1 and 2 are available on TIO, with all 3 versions able to be downloaded from the Github repo, and are all written in Python, a widely available programming language.

Caveats

It does not currently have a chatroom (easily created), and I'm currently working on documentation, so that's missing, as of time of writing.

Resources

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ I think Jelly works like that, according to your description. \$\endgroup\$ – hi. Aug 31 at 1:14
  • 1
    \$\begingroup\$ @hi. One crucial difference between Jelly and Whispers is that Jelly can have arbitrary code on each line, where as Whispers can only run one command per line \$\endgroup\$ – caird coinheringaahing Aug 31 at 1:15
2
\$\begingroup\$

Plumber

Plumber is an esolang I made, based upon packets moving around in a 2d space. This space consists of a grid of 2-character wide units, of which there are 16.

It has no stack, queue, or tape. Information is only stored and moved by pushing, pulling, and dropping these packets between parts of the program.

Reasons

  • There are only four answers in it
  • People I talked about it with in TNB seemed to like it
  • It's very different to use compared to most other 2d languages:
    • There is no instruction pointer or stack
    • Rather than a linear order of operations, you can have multiple parts of an operation running next to each other to save time or space
  • It can be really fun to get a Plumber program working
  • The many ways to use each unit makes interesting golfing much more possible than in some of the more straightforward languages

Resources

| |
\$\endgroup\$
2
\$\begingroup\$

Scala

Scala is a general-purpose programming language that combines OOP and FP and improves a lot on Java. It mainly runs on the JVM, but there's also Scala Native and ScalaJS.

Reasons

  • Concise (and pleasing) syntax that sometimes makes it feel like a scripting language (here is a comparison between ScalaJS and ES6 and TypeScript.
  • The standard library is amazing. Not only does it have useful methods such as combinations, collect and builtin tuple and function types, the collections hierarchy makes it super easy to do all sorts of operations without explicitly declaring types or converting them like you would in Java. This, I think, is one of the best ways Scala helps with code golf.
  • Implicits are super powerful and can be used for everything from simply reusing values to doing logic programming at compile time.
  • Type inference means you don't need to declare types explicitly, except for method parameters (and sometimes for return types in recursive methods).
  • For comprehensions are a lot shorter than using multiple flatMaps and filters, and you can even create variables without using the val keyword inside them.
  • Pattern matching is convenient, and helps in destructuring declarations.
  • User-defined operators save bytes. list1.concat(list2) can be replaced with list1 ++ list2. Infix and postfix (the latter is deprecated) also save bytes.
  • Its type system is Turing complete, and using literal types and a couple dependencies, you can even do compile time operations on primitives and such.
  • It runs on the JVM, so you also have access to Java's standard library (java.lang._ is imported by default).
  • There's a research compiler called Dotty that adds a ton of features to Scala and is slated to be released as Scala 3.
  • This doesn't help a ton with code golf, but Scala makes immutability really easy - all you have to do is use val instead of using final SomeType, like in Java.

Despite being an amazing language that's been around for a while and has a big user base, I almost never see Scala used here, and I think more people should try it.

Here is a list of users using Scala. You'll notice that most of them have used it for less than 5 posts, and only 3 have used it for more than 15.

Resources

| |
\$\endgroup\$

You must log in to answer this question.

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