Paradigms And Patterns

Question 1

Liskov substitution principle

Answer 1

Base class and subclass should be interchangeable. For example Square shouldn’t be a sub class to Rectangle even if it is mathematically. They should both be sub classes to Shape.

Question 2

Use ___ and ___ variable names

Answer 2

Meaningful
Pronounceable

Question 3

Use the same ___ for the same type of ___

Answer 3

Vocabulary
Variable

Question 4

Instead of short circuiting and conditionals?

Answer 4

Use default parameters

Question 5

How many function parameters?

Answer 5

Ideally two or fewer

Question 6

Three benefits of making sure functions do one thing only?

Answer 6

Easier to
1. compose
2. test
3. reason about

Question 7

How to set default objects?

Answer 7

Use Object.assign:

const menuConfig = {
  title: "Order",
  // User did not include 'body' key
  buttonText: "Send",
  cancellable: true
};

function createMenu(config) {
  let finalConfig = Object.assign(
    {
      title: "Foo",
      body: "Bar",
      buttonText: "Baz",
      cancellable: true
    },
    config
  );
  return finalConfig
  // config now equals: {title: "Order", body: "Bar", buttonText: "Send", cancellable: true}
  // ...
}

createMenu(menuConfig);

Question 8

Instead of using flags as function parameters?

Answer 8

Split out your functions if they are following different code paths based on a boolean.

function createFile(name) {
  fs.create(name);
}

function createTempFile(name) {
  createFile(`./temp/${name}`);
}

Question 9

How to avoid pitfalls of side effects?

Answer 9

1. Use clear structure when sharing state between objects
2. Use immutable data structures
3. Centralize where side effects can occur

Question 10

Three reasons to use getters and setters

Answer 10

1. Easy to add validation to set
2. Easy to add logging and error handling
3. Encapsulates internal representation

Question 11

How to set up your objects for method chaining?

Answer 11

Make every method return this

Question 12

The 3 cases when to use inheritance over composition?

Answer 12

1. Relationship is ‘is-a’ (and not ‘has-a’)
2. You can reuse code from base class
3. You want to make global changes to derived classes

Question 13

Single responsibility principle

Answer 13

There should never be more than one reason for a class to change.

Question 14

Open/closed principle

Answer 14

Software entities should be open for extension but closed for modification.

Question 15

Interface segregation principle

Answer 15

Clients should not be forced to depend upon interfaces that they do not use.
Split functionality. Make things optional.

Question 16

Dependency inversion principle

Answer 16

1. High level modules should not depend on low level modules. Both should depend on abstractions
2. Abstractions should not depend on details. Details should depend on abstractions

Question 17

Three things to do with thrown errors?

Answer 17

try {
  functionThatMightThrow();
} catch (error) {
  // One option (more noisy than console.log):
  console.error(error);
  // Another option:
  notifyUserOfError(error);
  // Another option:
  reportErrorToService(error);
  // OR do all three!
}

Question 18

What’s a functor?

Answer 18

A data structure that implements map

Question 19

Common JS functors?

Answer 19

Array, stream, tree

Question 20

What’s a monad?

Answer 20

A functor that implements flatMap()

Question 21

What’s a stream?

Answer 21

A series of promises. A bunch of objects that will arrive at some point. Or not.

Question 22

4 main principles of OOP?

Answer 22

1. Encapsulation (of data and methods for working on that data)
2. Inheritance, classes inherit properties and methods from other classes
3. Polymorphism, a method on a super class can be implemented differently on a sub class
4. Abstraction, simplify. Model classes on core characteristics (properties and methods)

Question 23

De tre viktigaste principerna inom funktionell programmering

Answer 23

1. Immutability
2. Pure functions
3. Functions as first class citizens

Question 24

What’s a pure function?

Answer 24

A function without side effects. It always produces the same output given the same input.

Question 25

What does it mean that functions are first class citizens?

Answer 25

That they can be assigned to variables, passed as arguments to and be returned from other functions.

Question 26

What is recursion?

Answer 26

Defining a function in terms of itself. ``` recursiveFunction(n) { if ( n > 0 ) // do thing recursiveFunction(n-1) } ```

Question 27

What's a higher-order function?

Answer 27

A function that takes another function as input or produces a function as output. Or both...

Question 28

What is currying?

Answer 28

Applying a higher-order function to transform a function that takes multiple arguments into a sequence of functions, each taking a single argument.

Question 29

When to use recursion?

Answer 29

Iterative processing of data structures by breaking a problem down into smaller subproblems. This pattern is useful for solving problems that can be divided into smaller, similar subproblems.

Question 30

What’s a signal (in JS)?

Answer 30

Basically an observable. It is a wrapper around a value and returns a getter and a setter. It then keeps track of where the getter is invoked and treats that as a subscription and updates it anytime the setter is called.