⏮ Recap: What is Software Engineering?

Software Engineering is where we focus on building the right software for the right people, and making sure it's maintainable over time as it grows and as the people who work on it change.

🤔 Maintainability: Why care?

Why does it change over time?

• Different people working on it.
• Requirements changing over time (e.g. new features).
• Needing to increase performance.
• Fixing bugs.

Code always grows, and never shrinks. You will never get on top of it.

You just need to be ready to adapt.

🤔 Maintainability: Why care?

Maintainability is also more important than performance.

If code isn't maintainable, performance issues will appear through growth or through patching issues.

If code is easy to maintain, it will be easy to speed up because things tend to be modular.

🧼 Maintainability: But how?

Generally there are a few key ways that improve software maintainability, including:

• Testing: By verifying the correctness of your code, it becomes easier to make changes to it without worrying about regressions in correctness. We've covered this.
• System design: Planning systems to make sense at a very high level / conceptual level (we cover this later).
• Code design: Thinking about code at a high level and low level of detail in terms of what makes things resilient to adapt to inevitable changes in the future.

🧼 Maintainability: But how?

Generally there are a few key ways that improve software maintainability, including:

• Testing: By verifying the correctness of your code, it becomes easier to make changes to it without worrying about regressions in correctness. We've covered this.
• System design: Planning systems to make sense at a very high level / conceptual level (we cover this later).
• Code design: Thinking about code at a high level and low level of detail in terms of what makes things resilient to adapt to inevitable changes in the future.

We'll be talking today about the last one.

1️⃣ Is there one source of truth for this?

How can we clean this up?

import { argv } from 'process';
 
if (argv.length !== 3) {
  process.exit(1);
}
 
const num = parseInt(argv[2], 10);
 
if (num === 2) {
  for (let i = 10; i < 20; i++) {
    const result = Math.pow(i, 2);
    console.log(`${i} ** 2 = ${result}`);
  }
} else if (num === 3) {
  for (let i = 10; i < 20; i++) {
    const result = i ** 3;
    console.log(`${i} ** 3 = ${result}`);
  }
} else {
  process.exit(1);
}

2️⃣ Is this as simple as possible?

Sometimes we refer to this approach as the "Keep it Simple, Stupid" (KISS) principle: the idea that a software system works best when things are kept simple. It is the belief that complexity and errors are correlated.

Clear code > Clever code.

No sane person likes clever code if it could be simpler.

2️⃣ Is this as simple as possible?

Example 1: Write a function to generate a random string with up to 50 characters that consist of lowercase and uppercase characters

2️⃣ Is this as simple as possible?

Example 2: Write a function that prints what day of the week it is today

2️⃣ Is this as simple as possible?

Example 3: Write a program that takes in command line arguments!

(Hint: Look at Commander.js)

3️⃣ Is this over-designed or under-designed?

For example, sometimes repeating yourself twice (but only twice) is OK! Unconditional conforming to a principle is a bad idea, and can sometimes add complexity back in.

3️⃣ Is this over-designed or under-designed?

(In my opinion) most programmers go through three stages of growth:

• (Early) Under-design
• (Amateur) Over-design
• (Matured) Good design

6️⃣ Am I speuclating about how necessary this is?

Question 1: Given two Latitude/Longitude coordinates, find out what time I would arrive at my destination if I left now. Assume I travel at the local country's highway speed

7️⃣ Does this follow standard conventions?

function dateNow() {
  return new Date().toISOString();
}
 
console.log(dateNow());

7️⃣ Does this follow standard conventions?

This is arguably a good reusable abstraction - but is it really easier to maintain? Why would you take away clarity for this?

function loop(count: number, callback: (num: number) => void) {
  for (let i = 0; i < count; i++) {
    callback(i);
  }
}
 
loop(5, console.log);
loop(7, console.log);