I’m really surprised to see Java ranked as less-verbose than OCaml.

Here’s an equivalent code sample in Java 17 vs OCaml:

Java:

abstract sealed class Expr permits Value, Add, Subtract, Multiply, Divide {
  abstract long eval();
}
record Value(long value) extends Expr {
  @Override
  long eval() { return value; }
}
record Add(Expr left, Expr right) {   
  @Override
  long eval() { return left.eval() + right.eval(); }
}
record Subtract(Expr left, Expr right) {
  @Override
  long eval() { return left.eval() - right.eval(); }
}
record Multiply(Expr left, Expr right) {
  @Override
  long eval() { return left.eval() * right.eval(); }
}
record Divide(Expr left, Expr right) {
  @Override
  long eval() { return left.eval() / right.eval(); }
}

OCaml:

type expr = 
  | Value of int
  | Add of expr * expr
  | Subtract of expr * expr
  | Multiply of expr * expr
  | Divide of expr * expr

let rec eval = function 
  | Value value -> value
  | Add (left, right) -> (eval left) + (eval right)
  | Subtract (left, right) -> (eval left) - (eval right)
  | Multiply (left, right) -> (eval left) * (eval right)
  | Divide (left, right) -> (eval left) / (eval right)

…Java has so much more syntactical overhead than OCaml, and that’s even with recent Java and being pretty aggressive about using boiler-plate reducing sugars like Records. And F# has even less, since it doesn’t require you to use different operators for numerics or do as much manual casting between strings/numerics

Everyone’s comparing the placements of their favorite language and I’m just left wondering how GolfScript gets beaten by seven other languages. I take it out was created specifically to do well on code golf? Mission failed, I guess.

I’d love to see the same comparison with more real-world use-cases.

Code golf, is mostly pretty simple use-cases, which have been optimized many times over.

When, you build out an application with a user-interface, proper event handling, etc… c++ is MUCH more verbose then c# for example, and they are ranked pretty close together.

It’s interesting, the results here are way different than the Code Golf & Coding Challenges Stack Exchange. I would never expect Haskell to be that low. But after looking at code.golf, I realize it’s because I/O on CG&CC is more relaxed. Most Haskell submissions are functions which return the solution.

Sidenote: I like the CG&CC method, it’s semi-competitive, semi-cooperative.

• all languages welcome
• almost all users post “Try it Online”/“Attempt This Online” links
• most users post explanations under their submissions
• often people will post solutions beginning with “port of user1234’s excellent Foolang answer” when there’s a clever shortcut someone finds
• or people will post their own solution with “here’s a solution which doesn’t use user1234’s algorithm”
• or people will add comments to answers with minor improvements

IMO It’s geared towards what is the best part about code golf: teaching people about algorithm design and language design.

Java placed way better than I expected

im confused, c and c have header files that are super verbose, not sure how its so high up that list

On another look, though, we have to keep in mind, though that this is code-golf, so in no way representative for actual code-bases.

Not expected C# to be this high. Also did not expected F# be so far away from C#.

Rust is so brief it’s not even listed I can’t read

This is why I only use machine code

This is why I love Ruby: Nearly as concise as Python but never complains about whitespace or indentation.

Haskell being so high really doesn’t make any sense. Experience level maybe?

It’s one of the tersest languages out there.

Who tf uses OCaml. It was created by my alma mater, we hated studying that shit, it was invented for crazy people.

I’m not familiar with code.golf but I wonder how whitespace is handled? I find python is very concise anyway, but I wonder how the white space is counted (single tab, four spaces for black, etc).

Surprised by C# and Java. People always moan that they have too much boilerplate code and something else about how OOP sucks and that makes these languages too verbose, yet they’re close to the top of the chart here for least characters used on average.