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!

<div class="pull-right">

<center>https://media.giphy.com/media/rH50laWEAC25O/giphy.gif [Source Credit:  giphy](https://giphy.com/gifs/rH50laWEAC25O/)</center>
</div>

I have been interested and involved with computers and code since the 1970s as a hobby. I remember the time before hard drives and the <em>A:</em> and <em>B:</em> drives. The <em>Microsoft Disk Operating System (MSDOS)</em> was my first operating system.

I use the  <em>Fedora</em> operating system exclusively now. Much more secure than the Windows and Mac systems.

I wish you great fortune with your learning coding. I also wanted to thank you for upvoting my comment on <em><strong>[Can I Reconcile Anarchism/Voluntaryism with My Faith? Wrestling with Romans 13](https://steemit.com/anarchy/@sargento/re-ch4nel-can-i-reconcile-anarchism-voluntaryism-with-my-faith-wrestling-with-romans-13-20170913t181908898z)</strong></em>. 

Have a wonderful and safe week!
___
<center>![BOTTOMBANNERSTEEM.png](https://steemitimages.com/DQmdHz71u9WJSxvGnNEyTp6RoNz4Gtt32YSq54Xpp7GpgU1/BOTTOMBANNERSTEEM.png)</center>

Do you need this part?

var note = {title} ?

JS is dynamic so not sure you need the definition. If not you could reduce to this :)

```
var removeNote = (title) => {
    saveNotes(fetchNotes().filter((note) => note.title !== title)
}
```

The bit you are fighting with should click in a minute...

```
var wantNote = (note) => note.title !== title;
```

Notice how similar the definition of removeNote is when written this way. That is because wantNote is just another function but in this case you have not assigned it to a variable, just passed it direct to filter.

Filter is known as a high order function, in that it takes a function as an argument. You can pass functions around as you would say a string. They are just another bit of data.

This is very common in JS and also many current languages. 

How filter works is this, it gets the list of notes and your tester function. It then walks through all the notes and tests if you want to keep it, if so it adds it to the results and if not it discards it. The results are all the notes that passed the test function you supplied.

Done in C# as know the syntax better but similar enough you should understand :)

There is a cleaner way but this should make it easy to see what is going on

```
public static IEnumerable<Note> Filter(
    this IEnumerable<Note> toFilter, Func<Note, bool> predicate)
{
    var result = new List<Note>();
    foreach (var note in toFilter)
    {
        if (predicate(note))
        {
            result.Add(note);
        }
    }
    return result;
}
```

So this gets an IEnumerable (list) of notes and a function from note to bool. Called predicate as that is the common term for something that takes a value and returns true/false because maths :)

HTH

Woz

btw, these are all the same. note is just what you have called the argument and note is a good name as makes it clear what is going on

```
(note) => note.title !== title
(x) => x.title !== title
(burger)  => burger.title !== title
```