Java placed way better than I expected

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.

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

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.

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

It's one of the tersest languages out there.

Just gonna drop by to say that I love Crystal

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

I'm surprised C is so low. I feel like I need to write 5x more code (compared to C++/Rust) to do the exact same thing.

Hmm interesting, I would've thought that Haskell would rank much higher

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

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.

What the heck is brainfuck?? Maybe a hot take but I wouldn't wanna program in that /s

Would assembly be higher or lower than brainfuck?

Why would golfscript be more verbose than some others? Isn't it made for golfing?

I'm suprised by F# position

Is Dart inherently verbose, or does it just seem that way because people are using it to make Flutter widgets and they're verbose? When you look at the Dart syntax it doesn't seem like it needs to be verbose, but Flutter code certainly can be.

Interesting that zig is so much lower than c in expressiveness. Isn't that a bit weird?

With my professional experience in COBOL, I can honestly say I'm not surprised at all!

How come kotlin isn't there

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.