I'd like to throw in Pattern Matching from C# 8 and F# as one of the coolest language features.

// fsharp
let name = match person with
           | None -> ""
           | Some p when p.FirstName = "" -> sprintf "Mr/Ms %s" p.LastName
           | Some p -> sprintf "%s %s" p.FirstName p.LastName

// csharp
var name = person switch
           {
               null => ""
               { FirstName: "", LastName: var lastName } => $"Mr/Ms {lastName}"
               { FirstName: var firstName, LastName: var lastName } => $"{firstName} {lastName}"
           };

In both these examples we first check if there was a value (using an Option<T> in F# or a nullable type in C#), then checking if there was or wasn't a first name to determine the name of the person to print.

I totally ❤ using pattern matching in code over nested if blocks!

There is a feature in Kotlin that I haven't seen in any other programming language and I think is the coolest feature ever.

Extension lambdas: It's a lambda where you specify the value of 'this', where 'this' is the implicit object where to find functions or fields. For example, the function apply() has a lambda as argument where the value of 'this' is the object used to call apply() (Kotlin lambdas are delimited by {})

StringBuilder().apply {
  append("hello")
  append(" ")
  append("world")
  append("!")
}

It creates an instance of StringBuilder and calls the method append() without having to write this.append(). In java you have to write this instead:

StringBuilder s = new StringBuilder();
s.append("hello")
s.append(" ")
s.append("world")
s.append("!")
s

This also works with properties, so you can easily build SDLs:

message {
  author = "Cout970"
  subject = "Hello"
  content = "Hello world!"
  method = Method.POST
  send(to = "everybody")
}

Great article Jeremy! Thanks.

Funny because I didn't know what extension methods were and instead of some voodoo thing they are just what you can achieve in Ruby with open classes:

2.6.1 :001 > class String
2.6.1 :002?>   def mutate()
2.6.1 :003?>     return self + " mutation"
2.6.1 :004?>   end
2.6.1 :005?> end
 => :mutate
2.6.1 :006 > s = "Hello, world!"
 => "Hello, world!"
2.6.1 :007 > s.mutate
 => "Hello, world! mutation"

or JavaScript extensions using prototype inheritance:

> String.prototype.mutate = function() { return this + " mutation"; }
> a = "Hello, world!"
> a.mutate()
"Hello, world! mutation"

Optional chaining should be added to all languages with the concept of null 😭

You can do this weird BS in PHP. I liked it when I super junior and starting out but now it horrifies me as quite the bad idea.

class Foo {
    public function bar() { return 42; }
} 

$foo = new Foo();
$voodoo = 'bar';
echo $foo->bar(); //42
echo $foo->$voodoo(); //42

$anotherVoodoo = 'Foo';
$foo2 = new $anotherVoodoo();
echo $foo2->bar(); //42
echo $foo2->$voodoo(); //42

Disclaimer: I didn't atually test the above.

What a great post! It's really kicked off some good discussion.

Now... to business!

Macros

For those of you that don’t know, macros are actually a metaprogramming feature. More specifically, macros allow us to modify the language directly by adding rules to the abstract syntax tree. These rules are generated through pattern matching.

Alas! Alas, that you should have stumbled upon macros in Rust of all places! Macros in Rust are horrible - look at that syntax:

macro_rules! print {
    ($($arg:tt)*) => ($crate::io::_print(format_args!($($arg)*)));
}

A whole new and weird 'pattern matching' language to manipulate Rust's AST. No wonder we're not meant to use it - it's horrible! macro_rules!? More like macro_sucks!.

My friend, if you want to see and do macro programming right, you need to get yourself a Lisp. Preferably Common Lisp, but Racket, Scheme or Clojure will do in a pinch. Because these languages exhibit homoiconicity, which is to say that the representation of the language - the way you write it - is a data structure of the language. You write Lisp - as lists!

This means that, when it comes to changing the program with a macro, you're using the same language (Lisp) to manipulate the list structures that are the syntax of Lisp. No weird embedded pattern matching language - just the same stuff you've been writing all along (only occuring before evaluation which takes a bit of getting used to...). Code is data! Data is code!

Try them today - Lisp macros are fun and easy!

(Whether they're a good idea or not is more contentious...)

Pattern matching! I've only been familiar with variable unpacking from Python and then I learned some Erlang. Many people don't like Erlang's syntax but pattern matching is great! I understand that F# and OCaml also have that.

Haskell types. I've been toying with language construction lately and it's very nice.

data Exp  
      = Let String Exp Exp
      | Exp1 Exp1
      deriving Show

data Exp1 
      = Plus Exp1 Term 
      | Minus Exp1 Term 
      | Term Term
      deriving Show

data Term 
      = Times Term Factor 
      | Div Term Factor 
      | Factor Factor
      deriving Show

data Factor 
      = Int Int 
      | Var String 
      | Brack Exp
      deriving Show

This would take an entire class hierarchy in Java.

And third, string interpolation is very handy.

The C/C++ preprocessor is still a feature I miss in virtually every other language I ever touch. The ability to transmute the actual code before it is parsed is invaluable in those environments. It also ties in directly with the inline ASM on your list, where the preprocessor can be used to select the proper ASM architecture for the given platform.

A great example of this is used in crypto libraries. They generally have a basic C/C++ implementation, but also optimized versions of certain routines for x86, x86-64, AES-NI, ARM, ARM-NEON, and more.

It is also nice to have platform-specific or build-specific flags that can toggle various parts of code on/off, or change things up entirely. This helps when porting code for example, because the path to a particular file may not be the same between Linux, BSD, MacOS, and Windows.

One last trick to mention. The preprocessor can also modify the linker. In one of my projects, I have preprocessor directives to link in static libraries. These libraries are compiler specific, so instead of creating countless different build scripts, I have a single CPP file with them all listed with different #ifdef tags to target each compiler.

I'd say another great language feature is generics. I'm not sure if C# was the language that first created this feature, but it was my first exposure to it.

Some references for those interested:

• Generics in C#
• Generics in TypeScript
• Generics in Java

Top 10 Coolest Programming Language Features! You won't believe number 9!!!

Have you tried Groovy? It has most of what you list here, and for someone that's familiar with Java it doesn't take much getting used to.

Really great post Jeremy!

Piping and Pattern Matching are some of my favorite language features 🦄

Okay, your lamba example is the first time anyone has succinctly explained and demonstrated what lambdas are and why they are useful in a way that clicks for me.

• Immutability
• No NULLs