In order to start our journey on thinking functionally, one really important concept

to dial in on is the difference between imperative and declarative coding styles.

The imperative style focuses specifically on how to perform the operations.

Typically at a low level, taking the system it is running on into account.

Declarative style focuses more on

what specifically you are attempting to accomplish.

The imperative style is definitely more difficult to read as there are more lines

of code and declarative is usually very clear as to what is happening.

Let's walk through an example one that you've probably already seen and

it will help demonstrate the differences.

For those of you with people in your lives that have food allergies,

you know how difficult it is to find something that they can eat.

My daughter has an egg allergy.

It's a bummer.

It's pretty horrible.

It seems like everything has eggs in it.

Cupcakes, taffy, ice cream.

You know, everything a kid likes to eat.

Now as a parent, I am constantly needing to check

a list of ingredients to see if it indeed contains eggs.

Let's write a quick simulation of this in code, in both styles.

So here I have the current version of IntelliJ IDEA open and

I'm just going to make a new project.

I'm gonna click create new project.

Cool. And I'm gonna just leave

the defaults here.

I'm gonna click next and I do want to just make a quick command line.

Let's go ahead and call this exploration.

Okay so that's set everything up for us.

Let's go ahead and let's start write our code here and suggest it.

Oops I indent with two space I'm using the Google style.

So we'll say list the string and those are ingredients, right?

And we'll make a new Arrays.asList.

And we'll just go ahead and we'll enter those guys, that's what we want.

So let's see, we have flour, what else do we have?

We've got some salt.

Delicious cupcakes here, some baking powder, butter,

I don't know how to cook really, eggs and here comes the milk.

All right, and we will close off with a semicolon here.

Okay, so let's solve our issue of checking whether or

not our ingredients has eggs, okay.

I'm gonna go ahead and give us more space.

Get rid of all the windows that are open, Here we go.

Okay, so first thing's first.

We'll need a variable to store our state, right?

So we'll wanna say boolean hasEggs, and we'll just go ahead, and

we don't know yet.

We don't know if it has, and so we said false.

And now, what we wanna do is we wanna loop through each of those ingredients.

So we can do that by starting to define a for loop, right?

So we'll say for and now we need another one of those temporary

variables to store in the loop where we're gonna currently process.

So we'll say int i for index, kind of standard thing there, right?

And we'll make another temporary variable, right?

So now we've got 2, we've got hasEggs and i, two temporary variables.

And now we wanna make sure that we go through all of the ingredients.

So we wanna see if i is less than the ingredients.

And we wanna see if it's as long as it is which was size.

And we've gotta remember that it's zero-based, right?

It starts at zero, so it's gotta be less,

not less than or equal to, always have to think about that there.

And then we're gonna go ahead and we're gonna increment.

Then we need to check if that specific ingredient, so

what we need to do is we need to pull it out, right?

We need to pull that one out.

So we'll say String.ingredient equals ingredients.get, and

we're gonna pass in that index that we've been running through the loop with, right?

Okay so then we wanna see does this ingredient that we pulled out,

does that equal eggs, right?

Okay, and if it does we will for sure.

We'll say hasEggs, we're gonna set that to true.

You know what since we did know it hasEggs,

we don't need to look at the other stuff right?

We can finish here, so we can just go ahead and say break.

Let's look at this code here for a second.

That's a lot of code and brainpower needed just to understand what's happening.

Now we've done this a lot and probably see code like this quite a bit.

So it's probably feeling kind of familiar.

But just imagine for a second if you hadn't.

There's a whole lot of what is this doing going on, right.

So now that we have our variable, we can go ahead and see if it has eggs.

Gotta break the news to my daughter and say, sorry sweetheart.

It has eggs.

Sad face emoji.

Now of course there's been some evolution in looping.

So we can of course clean up this cognitive overload a little bit of all

these things, right?

So we can, we can just go ahead we can say for

the ingredients in ingredients, right?

This enhanced four loop.

So we can lose this index cause each one is gonna have a specific time, right?

We don't need to know how long the list is anymore.

This reads nicer, but it's still an awful lot

when all we really want to know is, does ingredients contain eggs.

We're still saying give me each of the ingredients and

I'll tell you when to stop.

So the more declarative way to ask this question,

is just to ask the question, right?

So, let's do this.

If ingredients.contains,

Eggs, Right?

We don't need this.

And there's nothing new here.

Contains has been around since the collections framework was introduced.

But it's declarative.

Look at how it explains what it is that we're trying to do.

It's not specifying how.

Now this can be optimized efficiently behind the scenes.

And this is how it works in the real world, right.

If I'm at a restaurant, and I wanna know about a possible cupcake for

my daughter, I don't go, can you please tell me every ingredient in this cupcake.

Now don't worry I tell you when to stop listing them and

the case that I happen to hear what I'm concerned about, right.

I simply say, does this contain eggs?

And the waiter or waitress has their own method of knowing.

How they get the answer isn't really something I need to concern myself with.

I'm really just concerned with the answer to my question.

So ready for it?

This is the start of the shift of your thinking.

Functional programming is declarative.

It'll take a little bit of shifting in you programming mind, but

we do it in real life.

So it should feel more normal than how we already force our imperative mind to work.

One more example of how this looks in something you've probably seen.

Is SQL or Structured Query Language.

It's all declarative.

Even if you haven't seen SQL before, this is how you write the statements.

The language allows you to declare

very specifically what you would like to get back.

In this case, it's some specific fields like first name, last name, and email.

For a student with the id of 123.

Notice how it doesn't specify how.

This allows the database to do whatever indexing or

caching it needs on whatever platform that implements the language specification.

Let's stay in the declarative mindset and introduce our first function.