Javascript is my favorite language

…well, one of!

Javascript has a bad wat reputation. Despite the difficult history and being an ugly-duck of programming languages there are some ideas that Javascript today does better than other languages in my opinion.

Brendan Eich wrote javascript in 10 days, in May 1995 https://en.wikipedia.org/wiki/JavaScript

Personal context

In past I’ve never fully commited to writing Javascript. jQuery was my goto to enhance Rails apps for a long time but I never really invested into learning the language.

It was like Bash scripting: most people know how to use it but never really learn how to program with it beyond simple helper scripts.

With NodeJS things did change and I worked on projects where I started noticing features other languages don’t have.

I like learning languages that teach me something new, with Javascript one can say it’s prototype based programming. But that’s not what I like the most.

Javascript, the rebel

What I appreciate about Javascript is that it provides its own perspective.

Ie, Javascript had own solutions to problems most OOP languages solve with classes:

If you have state – use classes

OOP model familiar to everyone and easy to use

Unfortunately, the peer pressure was so strong that Javascript got class in 2015

JavaScript classes, introduced in ECMAScript 2015, are primarily syntactical sugar over JavaScript’s existing prototype-based inheritance. The class syntax does not introduce a new object-oriented inheritance model to JavaScript.

I’m convinced there’s no need for class in Javascript. Strong argument against classes is React’s transition to functional Hooks

For a while, the canonical answer has been that classes provide access to more features (like state). With Hooks, that’s not true anymore. How Are Function Components Different from Classes?

Now why is it all important?

Well, what if there are better ways to program and not use any classes?

Javascript, my favorite parts

State with functions
Named arguments, named returns
Decomposition: Destructuring and Spreads

1. State with functions

Returning a closure from a function enables “having state”:

// https://codepen.io/gmarik/pen/pXPxMR
const Count01 = (start) => {
  let count = start
  return () => {
    count += 1
    return count
  }
}
const inc = Count01(4)
console.log(inc())
// => 5

2. Named arguments, named returns

This approach is beautifully explicit: behavior is defined exactly by what’s returned by the function(aka constructor, compared to OOP’s opaque constructor)

// https://codepen.io/gmarik/pen/Prmxqw
const Count02 = ({start = 1}) => {
  let count = start
  const get = () => count
  const inc = () => count += 1 
  return {get, inc}
}

const counter = Count02({start: 3})
counter.inc()
counter.inc()
console.log(counter.get())
// => 5

3. Decomposition: Destructuring and Spreads

Destructuring is a duck typing in a way: it lets client request specific functionality. Thus focus shifts from types to behavior:

// https://codepen.io/gmarik/pen/OejgqM
const {log, table, ...rest} = console
log("hello world")
table(rest)

Conclusion

function is a building block for higher-level concepts.
state management is not just for classes
composition and decomposiiton are the foundation for modular software.

Thank you!

for reading this far.