Hi Matthew! It's really inspiring to see how you're going about this. Initiative and passion are the key.

I'd like to give my take on explaining this line:

var rmDuplicate = notes.filter((note) => note.title !== title)

First of all, lets call the variable uniqueNotes to better describe what it is, as we're removing the duplicate notes so we can save only the unique ones:

const uniqueNotes = notes.filter((note) => note.title !== title)

To better understand what it does, let's forget about arrow functions for a moment, so we can write it as an ordinary function and work our way to the arrow function notation.

const uniqueNotes = notes.filter(function (note) {
    return note.title !== title
})

So far so good. As a note, the filter function can be called on any array in JavaScript. You pass it a function as an argument , which is invoked for every element. This predicate function returns true if the element should stay or false if we want to remove it. Then, the filter function returns a new array comprised of all the elements that we decided should stay.

Ok, now we can refactor our predicate function to be an arrow function:

const uniqueNotes = notes.filter((note) => {
    return note.title !== title
})

Pretty similar, right? But we can go further, and remove the parenthesis around the note argument (because there is only one argument, if there were multiple, we'd have to keep the parenthesis)

const uniqueNotes = notes.filter(note => {
    return note.title !== title
})

Okay! But we can make it even more compact by removing the curly braces that denote the function block (we can do this only if our arrow function has one line, and this one does)

const uniqueNotes = notes.filter(note => note.title !== title)

By removing the curly braces, we also need to remove the return keyword, as it is implied when using this shorthand arrow function notation.

So what's the difference between using an arrow function and a regular function?

Well, obviously it's more expressive, meaning that it tells you what it's doing using less characters like curly brackets and the return statement.

But there's another thing that makes the arrow functions different - their scope. Arrow functions don't have their own scope, but are bound to the scope of the function that they are defined in.

In practice, this means that this inside of the arrow function will be that of the function they are called inside of. You'll find this quite useful if you've ever had to use the old var that = this trick to access the context of the parent function. Now you can simply use arrow functions!