Nominations for Language of the Month [duplicate]

Question

We've decided that we like the idea of a "Language of the Month" event. The main idea is to get more exposure for less-frequently used languages, and to have fun learning and golfing them together. The next question is, what languages shall we choose? And that's where you come in.

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 is modeled after Lit.SE's reading challenges.)

The chosen language will have a chatroom created for it, if it doesn't already have one. We could have a community ad to promote it, changing the ad each month to reflect the new featured language. (Does someone want to volunteer to create an ad?) It can also be featured as a site-wide event in the Community Bulletin Board sidebar; a mod would need to create the event.

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 really 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 would also be cool to study some lesser-known "real" languages.

* Better rules of thumb are welcome. I made this one up after thinking about it for ten seconds.

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 tips question, if it has one.
• Ideas for one or more language-specific challenges that will provide an interesting experience beyond answering regular challenges in this language. These can be code-golf, fastest-code, king-of-the-hill, answer-chaining... 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.

---

List of past and current Languages of the Month

• March 2018: Brachylog
• April 2018: Brain-Flak
• May 2018: MATL
• June 2018: QBasic
• July 2018: Japt
• August 2018: Self-modifying Brainfuck

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

Answer 1

R

R is a free software environment for statistical computing and graphics. It compiles and runs on a wide variety of UNIX platforms, Windows and MacOS. It is available on Try it Online!

Why is it a good candidate?

• It has a small community of active golfers. There are no more than 6 or 7 members who regularly post answers in R. There ought to be more!

• It is a general-purpose language, meaning it can be used to answer all questions on this site. Though to be honest processing strings requires a bit of flexibility.

• Its vectorized syntax allows for concise answers in case for multiple input.

• R is a functional programming language - almost everything is a function - including things that you would think (thanks to the parser) are just operators. This can yield some very powerful golfs, as displayed here.

• Environments, combined with lexical scoping are a power feature of the language.

• It is really good at plotting stuff.

And most importantly: Golfing R is fun :)

Here is the R golfing tips post.

Resources to learn R:

• This Cross-Validated post

Online Interpreters

• Try It Online!
• RDRR (includes most of the packages available for R)

Answer 2

Cubically

Cubically is an esolang created by me, MD XF, designed to work with Rubik's Cubes.

Interpreter - Documentation - GitHub Organization - Chatroom - Try it Online!

Why?

• Cubically is very easy to use. No, it's not easy to perform simple tasks such as "Hello, World!" in, but it's really very easy to get started writing code. The syntax is simple for the most part, and the docs are fairly easy to understand.
• Cubically is powerful. Its 3-byte 3x3x3 solver finishes in under a second and in very few moves; it uses a nearly optimal algorithm.
• Cubically is fun. It forces its users to find algorithms and crazy code snippets to achieve simple tasks, like obtaining the integer 1.
• Most of all, Cubically does not get a lot of attention! It was created over six months ago and it gets more and more useful every commit, but as far as I know, only four people have ever used it in something that wasn't a polyglot.

Answer 3

Gaia

Interpreter | Documentation | Online Interpreter

---

Gaia is a stack-based golfing language created by PPCG user Business Cat about a year ago, in late May 2017.

There are a couple of things that make Gaia a very good competitor for the Language of the Month event:

• Terseness and Ease of Use – It is stack-based, so it is particularly easy to learn and understand. It has some powerful one-byte built-ins, which are pretty well chosen, and also some two-byte ones that perform more complicated tasks.

• Features and Forte Points of Gaia – This language excels at date-time manipulation, having over 30 operators dedicated to it. Other than that, the meta operators combined with the separate functions and blocks make solving non-trivial tasks, which require loops, sorting, filtering or something else very easy in Gaia. Moreover, the input is implicitly pushed to the stack, so you might not need @ explicitly in some situations.

• Turing Completeness – Gaia is undoubtedly TC, and it is not hard at all to prove it.

• The Gaia community is very small – Albeit being well-suited to code-golf, there are just a few answers in it and only two users have ever used it on a regular basis (one of which, its creator, is no longer active).

• Golfing in it is fun! – I can't demonstrate this unless you try it yourself, but (at least in my case) this entirely true. Go check it out!

Currently, Gaia does not have an SE chatroom, but one can be created in case others are interested too. Alternatively, Esoteric Programming Languages can be used instead, as I expect the traffic not to be too high. _{^{(While Business Cat is inactive, I'd be happy participating and maintaining it)}}

---

Pro tip: If you are trying to solve an array-manipulation challenge (taking arrays as input), you should note that the array syntax is [elem1 elem2 elem3 ... elemN], and that e↑ added to the footer makes it easier to parse input.

Answer 4

Attache

Try it online! ~ Documentation ~ In-progress tutorial ~ Chat room

---

Attache is a practical language most similar to Mathematica in terms of basic syntax, but features much terser syntactic elements and enables practical, easy, functional programming. (No, purists, it's not state free.)

Why would this be a good language of the month? If for no other reason than to give it exposure, Attache is a favorite tool of mine for completing high-level tasks within a reasonable time frame. It features a plethora of built-in functions (perhaps not rivaling Mathematica) which minimize boilerplates in programming. It is actively developed (yours truly), and I'm open to suggestions regarding the language and its functions.

Attache features many function-oriented operators and functions, which makes fixpoint programming realistic and fun to golf with. Some of the fun in golfing is figuring out whether tacit or fixpoint programs will be shorter.

While the language isn't entirely bug-free, it's at a point in development where such bugs are rarely encountered in conventional programming and golfing, and the language isn't liable to change drastically.

_{(also the language has like one consistent user and it's lonely)}

Answer 5

Z80Golf

Z80Golf Machine | Z80 Assembly Materials | Z80 Opcode Reference (.txt)

Esolangs | Assembler | Try it online! | Chatroom (N/A) | Tips (N/A)

---

Z80Golf is a machine code language for "Z80 Code Golf Machine" by mokehehe, originally designed for anarchy golf. While Z80Golf has been used for several years on anagol, it was only recently introduced to PPCG by Lynn this year.

The specification of the Z80Golf machine is as follows:

• Z80Golf programs are binary files (.z8b). On initialization, the binary is copied to the address $0000, and the rest of memory (up to $FFFF) is padded with zeroes. All the registers are zero as well: AF, BC, DE, HL, IX, IY, SP (stack pointer), and PC (programming counter).
• Whenever the PC reaches $8000, the value in the register A is written to standard output, and then a RET instruction is simulated. (In other words, call $8000 is like putchar A.)
• Whenever the PC reaches $8003, the machine tries to read a single byte from standard input. On EOF, the carry flag is set and A is left unchanged. Otherwise, the carry flag is cleared and A is set to the value read. Finally, a RET isntruction is simulated. (In other words, call $8003 is like getchar A.)
• The program keeps running until HALT is executed.

Since every submission is a binary, xxd output format is used in TIO.

Why Z80Golf?

• This is the first machine code nomination.
• Unlike x86 and other architectures used for machine code golfing on PPCG, Z80Golf machine has absolutely zero boilerplate for writing full programs.
• While its instruction set is identical to e.g. TI calculators, complete lack of peripherals gives greater room for creativity. For example...
  • You can underflow your own stack into code,
  • You can write $76 in the code region to halt your program like Befunge and ><>,
  • You can manipulate somewhere in memory to do something entirely different each iteration,
  • ...and so on!
• Unlike many other nominations, this language is quite old (several decades for Z80 itself, and at least 8 years for Z80Golf machine), yet it was introduced recently to PPCG. As a consequence, PPCG has only 21 Z80Golf answers by only 3 users so far as of writing (Aug 17, 2018). Since Z80Golf is capable of lots of convoluted things, we desperately need more intra-language competition.

Showcase

• Insanely clever "Hello, World!"
• Super short Output with the same length as the code
  • Uses all three creativity points shown above.
• You can fool others with the binary code being fully ASCII
• I double the source, You double the output!
  • Hide the HALT inside a multibyte instruction, and directly return to it.
• The first proper machine code quine ever.
• Zero-byte program is infinite output :)

Answer 6

Keg

Keg is a tiny language designed by Jono 2906 that is astonishingly very powerful for code golfing. Try it online!

Reasons

• It is very easy to learn, with well-thought of built-in utilities that are very powerful.
• It have unique golfing features that other languages have not implemented; e.g. the auto-pushing mechanism, that makes representing large numbers using a few bytes possible.
• It is fun. Golfing in it is very easy, as it provides a lot of ways to code-golfing programs. Also, if you golfed it hard enough, you will find that it can compete with other well-known golfing languages.
• And perhaps most importantly, only a few people are using it!

Answer 7

Sesos

Sesos is a language largely based upon brainfuck, but it has some extra features:

• Unbounded signed integers (can be disabled)
• I/O with numbers (input and output must be enabled separately)
• Conditional jump based on whether the input's EOF has been reached
• Conditional jump, with the code before it having been executed at least once.

Additionally, it has a difference from brainfuck: While brainfuck's + and - increment and decrement the current cell respectively, Sesos's add and sub take an argument determining how much to add or subtract respectively. The same difference also applies between brainfuck's > (go one cell right) and < (go one cell left) and Sesos's fwd and rwd.

Another important difference is that you can't put certain instructions next to each other, due to how the program is encoded into a binary file. More specifically, add/sub, fwd/rwd and jmp/jnz are pairs of instructions which can't be put one after the other. Also, get can't go after add or sub.

The final difference is that jmp and nop can't be the last instructions of a program.

---

Programs are written top-to-bottom, instead of left-to-right, before compilation. There are 10 instructions and 3 assembler directives.

The instructions are:

• add <n>: Adds <n> to the current cell.
• sub <n>: Subtracts <n> from the current cell.
• fwd <n>: Moves <n> cells forward.
• bwd <n>: Moves <n> cells backward.
• put: Prints the content of the current cell.
• get: Takes one input character (or integer) and replaces the current cell's content with it.
• jmp: Sets an entry point, and jumps to its corresponding exit point (i.e. the closest following exit point that doesn't belong to any following jmps).
• nop: Sets an entry point.
• jnz: Sets an exit point and, if the current cell is non-zero, jumps right below its corresponding entry point.
• jne: Sets an exit point and, if STDIN's EOF hasn't been reached, calls get and jumps right below its corresponding entry point.

Leading jmp instructions can be omitted, as long as their corresponding exit points are explicitly present in the code. The same is true for trailing jnz, where their corresponding entry points must be explicitly specified.

The assembler directives are:

• set numin: Take input as integers instead of characters.
• set numout: Print as numbers instead of characters.
• set mask: Use 8-bit unsigned integers instead of unbounded signed integers.

In the source code, those directives can be put anywhere, and the result will be the same.

Extra whitespace is ignored.

Details about the compilation process can be found over the GitHub repository.

---

I'm nominating this language because interest was always little and gradually faded away. I think it's a very interesting language, and it definitely has golfing potential.

---

Tips for golfing in Sesos

Answer 8

Bit

Bit is a stack-based language created by myself, it is similar to Cubically in that it forces users to think of intuitive ways to do simple things (see examples below), the specification, documentation and interpreter are available at the link above.

Examples

Adding to the examples in the GitHub link, heres a Truth-Machine program (If input is 0, print 0, if input is 1, print 1 infinitely)

main.bit:

BYTE var $$ creates a variable called 'var'
IN $$ Read input, stack = [[I, N, P, U, T, B, Y, T, E, S]]
INTO $$ turn [[something]] into [something]
PUSH var $$ Sets var to the user's input in bytes
IMPORT var $$ Reads the value of var, and searches for a file called 0 or 1 depending on user input, then executes it

0:

BYTE
PRINT
PRINTLN

1:

BIT 1
BYTE one $$ Variable called one with value 1
PRINT one
PRINTLN
IMPORT one $$ Recursion

Why?

I think bit is an interesting language because of the type of thinking you need to program in it.

Tips

Programming in Bit

Chat room:

(none yet)

Interesting questions

Some interesting questions to be asked about this language:

• A cat program (actually quite easy)
• Input adder (Possible but hard)
• Split input by commas and print each item
• Quine