Learn the meaning of 7 fancy, yet important, programming terms before your next technical interview https://fireship.io 

00:00 Intro
00:58 Idempotent
02:08 Ephemeral
03:16 Anonymous
04:13 Predicate
05:10 Memoization
05:59 Abstraction
07:06 Serialization

Install the quiz app 🤓

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

My VS Code Theme

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T06:02:31.992Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
bc1d94fe-d17b-4872-99b9-7caab8e7c6f0
b38a6738bfe429e74234757043285048cde0eb024ae0553297da5feb0c0a4c63
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
In a recent technical interview, I was asked to debug the Redux effect for the lunar waneshaft on a turboencabulator, but I failed because my asynchronous anonymous function abstraction was not idempotent or ephemeral and failed to memoize the predicate and serialize the output.
It's one thing if your code doesn't work, but it's impossible to fix if you don't understand the words that describe the problem.
When you learn to code, you not only have to learn a programming language, saw also a bunch of fancy words that you would never use in a normal conversation.
In today's video, we'll unpack and define a variety of different technical words that you'll definitely need to know for interviews and your day to day work as a programmer.
But first, a quick word from our sponsor.
Work has been proceeding on the crudely app received the idea of an instrument that would not only provide inverse reactive current for use in unilateral phase detractors, app But would also be capable of automatically synchronizing cardinal grammeters, Rockwell Automation's retroencabulator.
It's available soon app.
Wherever Rockwell Automation products are sold.
Idempotent.
Idempotent.
The key part of this word is item, which is Latin for same.
The word was coined in the 1800 in the context of mathematics, and it means an operation that, when applied multiple times, will always produce the same result.
For example, multiplying by 1 multiple times always produces the same result.
That's an idempotent operation, unlike multiplying by 2, which always produces a different result.
Think of a crosswalk button.
If you push it multiple times, does it go any faster?
No.
That's because it's an idempotent system.
In programming, it means the same thing.
In operation or function that can be called multiple times creating the same output or side effect.
For example, if we have an array and we push a new element to that array, it's making the array longer even if it's the same element, so that is not idempotent.
If we use a set on the other hand, we can run the same operation multiple times and it only keeps the unique element, Therefore, adding an item to a set is idempotent.
This term comes to play most often in the context of APIs.
The HTTP verbs of get, put, and delete should always be implemented in an idempotent way.
In addition, if you have an ecommerce app where a user can submit a payment, you likely want that operation to be idempotent as well because posting the same form shouldn't result in multiple charges to that customer.
Ephemeral.
Ephemeral.
It comes from the Greek word ephemeros, which means lasting only a day.
Think of an ephemeral plant like a daylily whose flowers only last for a day.
In programming, it's an antonym for terms like persistent and immutable.
At the hardware level, your RAM is ephemeral while the hard disk is persistent.
When you shut down your computer, any memory in the RAM is lost while the data in the hard disk can be retrieved later.
The term is also used to define data structures within our code.
For example, a plain JavaScript object is considered ephemeral.
That's because we can mutate its properties and have no way to get back to the original object.
However, we can make it persistent or immutable, there's a bonus word for you, by calling object freeze, which will prevent any future modifications to the object.
But the place you might hear ephemeral used most often is within the context of cloud computing.
Many things in the cloud are becoming serverless.
Instead of a persistent server always running in the cloud, we can use ephemeral servers that only run when they're needed.
You probably know these as AWS Lambda or Google Cloud Functions.
Apps.
You might also see the term used with IP addresses.
An ephemeral IP is one that is reassigned after a server shuts down.
App anonymous.
Anonymous.
1st and foremost, the word is used to describe a global group of hacktivists that fight against things like censorship and big government.
I would highly recommend that you sign up and put that on your resume today.
But the word anonymous is also used in our code, primarily to define functions that don't have a name.
Take for example a JavaScript function or a Python function if you prefer, that takes an argument and multiplies it by 2.
What we have here is a named function, but it becomes cumbersome to pass named functions around everywhere, especially as your code grows in complexity.
And that's where anonymous functions come in.
They're just functions that don't have a name.
Instead, the function is defined as the argument.
Therefore, it doesn't need to be referenced by a name.
In JavaScript, we can use an anonymous function with the arrow syntax, but many other languages, like Python, use the Lambda keyword to define an anonymous function.
The syntax feels a little weird at first, but it's incredibly useful for small simple functions as arguments.
Now speaking of functions, that brings us to our next fancy word, predicate.
The word has its roots in Latin for something declared or proclaimed.
In programming, it most often means a function that returns a single boolean value.
True or false?
By convention, you'll often see these functions start with the word is.
Is the value a turkey?
It's a simple yes or no question, so we can return a boolean.
You might see the word predicate come up more often in strongly typed languages like TypeScript.
One cool thing we can do is set up type guards.
Take, for example, this code where we have an interface of a dog that can f barked and a cat that can meow.
Then we have a function called makeSound that can take either a cat or a dog, a union type, as its argument.
The problem with this code is that we don't know whether we have a cat or a dog in the function body.
However, we can overcome this limitation by setting up a predicate function that checks whether or not the animal is a cat.
If we then use the predicate or a type guard in our function body, TypeScript is smart enough to infer the types based on this condition.
If it's a cat, we meow.
Otherwise, it has to be a dog, in which case we bark.
Memoization.
Memoization.
I'm not sure if this word means memo, like a written message, or memo, like memory.
And although it sounds like a scary word, it just means to cache the return value of a function.
If you've ever used React, you might be familiar with the use memo hook.
It creates a memoized value by only rerunning the function when its dependencies change.
App.
The classic example is the Fibonacci sequence.
Here, we have a recursive function.
This function works, but it needs to recompute the same values over and over again.
We can optimize it by creating an empty object.
Then when our function runs a computation, it will save the value in this object.
That means when we encounter the same value again, we can use the value in memory instead of recomputing it multiple times.
When you hear the word memoization, just think memorization of a return value from a function.
Abstraction.
Abstraction.
This word is derived from the Latin abs, which means from, enter here, which means draw.
So it roughly translates to drawn from.
In the most general sense, it's the process of hiding implementation details from the end user.
Programming is like an onion.
It's layer upon layer of abstractions.
When you build an application, you're doing it on top of programming languages and APIs that sit on top of networks and hardware, that sit on top of transistors and electricity, and so on.
As a programmer, you've likely heard the phrase, do not repeat yourself or write dry code.
In this example, we have a shark and a tuna, and both classes have the same implementation details for their swim method.
App.
Rather than duplicate this code for each class definition, we can create an abstract class called fish.
The abstract keyword means this class will never be instantiated on its own because there is no such thing as a generic fish.
Instead, it's used to hide implementation details that can be inherited from other classes, which we can do by extending them with the abstract class.
And that's just one of many ways you can create an abstraction in your code.
The word itself really just means to app hide unnecessary implementation details.
Serialization.
Serialization.
This word comes from the English word series, which is just a collection of items in a fixed order.
In the programming world, there's all kinds of different languages and formats, and we often need to interop between these different tools.
App Java doesn't know how to understand PHP code.
But what we can do is take code from either language and serialize it into a format that they both understand, is like binary.
Then it can be deserialized back into code that can be used natively.
Take, for example, a JavaScript app and a Python app that communicate over an API.
We have a JavaScript object that we want to use in our Python app as a dictionary.
Before we send the object from JavaScript, we serialize it as a string.
App.
JSON is a standard format that can be understood by virtually all modern languages.
That's how we serialize a JavaScript object.
Then we can go back into our Python code and deserialize it by using JSON loads.
The bottom line here is that serialization is the process of taking data from one format and converting it to a more generic form that can be used by other programs.
I'm gonna go ahead and wrap things up there.
If this video helped you, please like and app scribe.
Thanks for watching, and I will see you in the next one.
The lineup consisted simply of 6 hydrocoptic marzlevanes app So fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented.

Speaker 0: In a recent technical interview, I was asked to debug the Redux effect for the lunar waneshaft on a turboencabulator, but I failed because my asynchronous anonymous function abstraction was not idempotent or ephemeral and failed to memoize the predicate and serialize the output. It's one thing if your code doesn't work, but it's impossible to fix if you don't understand the words that describe the problem. When you learn to code, you not only have to learn a programming language, saw also a bunch of fancy words that you would never use in a normal conversation. In today's video, we'll unpack and define a variety of different technical words that you'll definitely need to know for interviews and your day to day work as a programmer. But first, a quick word from our sponsor.

Speaker 1: Work has been proceeding on the crudely app received the idea of an instrument that would not only provide inverse reactive current for use in unilateral phase detractors, app But would also be capable of automatically synchronizing cardinal grammeters, Rockwell Automation's retroencabulator. It's available soon app. Wherever Rockwell Automation products are sold.

Speaker 0: Idempotent. Idempotent. The key part of this word is item, which is Latin for same. The word was coined in the 1800 in the context of mathematics, and it means an operation that, when applied multiple times, will always produce the same result. For example, multiplying by 1 multiple times always produces the same result.

That's an idempotent operation, unlike multiplying by 2, which always produces a different result. Think of a crosswalk button. If you push it multiple times, does it go any faster? No. That's because it's an idempotent system.

In programming, it means the same thing. In operation or function that can be called multiple times creating the same output or side effect. For example, if we have an array and we push a new element to that array, it's making the array longer even if it's the same element, so that is not idempotent. If we use a set on the other hand, we can run the same operation multiple times and it only keeps the unique element, Therefore, adding an item to a set is idempotent. This term comes to play most often in the context of APIs.

The HTTP verbs of get, put, and delete should always be implemented in an idempotent way. In addition, if you have an ecommerce app where a user can submit a payment, you likely want that operation to be idempotent as well because posting the same form shouldn't result in multiple charges to that customer. Ephemeral. Ephemeral. It comes from the Greek word ephemeros, which means lasting only a day.

Think of an ephemeral plant like a daylily whose flowers only last for a day. In programming, it's an antonym for terms like persistent and immutable. At the hardware level, your RAM is ephemeral while the hard disk is persistent. When you shut down your computer, any memory in the RAM is lost while the data in the hard disk can be retrieved later. The term is also used to define data structures within our code.

For example, a plain JavaScript object is considered ephemeral. That's because we can mutate its properties and have no way to get back to the original object. However, we can make it persistent or immutable, there's a bonus word for you, by calling object freeze, which will prevent any future modifications to the object. But the place you might hear ephemeral used most often is within the context of cloud computing. Many things in the cloud are becoming serverless.

Instead of a persistent server always running in the cloud, we can use ephemeral servers that only run when they're needed. You probably know these as AWS Lambda or Google Cloud Functions. Apps. You might also see the term used with IP addresses. An ephemeral IP is one that is reassigned after a server shuts down.

App anonymous. Anonymous. 1st and foremost, the word is used to describe a global group of hacktivists that fight against things like censorship and big government. I would highly recommend that you sign up and put that on your resume today. But the word anonymous is also used in our code, primarily to define functions that don't have a name.

Take for example a JavaScript function or a Python function if you prefer, that takes an argument and multiplies it by 2. What we have here is a named function, but it becomes cumbersome to pass named functions around everywhere, especially as your code grows in complexity. And that's where anonymous functions come in. They're just functions that don't have a name. Instead, the function is defined as the argument.

Therefore, it doesn't need to be referenced by a name. In JavaScript, we can use an anonymous function with the arrow syntax, but many other languages, like Python, use the Lambda keyword to define an anonymous function. The syntax feels a little weird at first, but it's incredibly useful for small simple functions as arguments. Now speaking of functions, that brings us to our next fancy word, predicate. The word has its roots in Latin for something declared or proclaimed.

In programming, it most often means a function that returns a single boolean value. True or false? By convention, you'll often see these functions start with the word is. Is the value a turkey? It's a simple yes or no question, so we can return a boolean.

You might see the word predicate come up more often in strongly typed languages like TypeScript. One cool thing we can do is set up type guards. Take, for example, this code where we have an interface of a dog that can f barked and a cat that can meow. Then we have a function called makeSound that can take either a cat or a dog, a union type, as its argument. The problem with this code is that we don't know whether we have a cat or a dog in the function body.

However, we can overcome this limitation by setting up a predicate function that checks whether or not the animal is a cat. If we then use the predicate or a type guard in our function body, TypeScript is smart enough to infer the types based on this condition. If it's a cat, we meow. Otherwise, it has to be a dog, in which case we bark. Memoization.

Memoization. I'm not sure if this word means memo, like a written message, or memo, like memory. And although it sounds like a scary word, it just means to cache the return value of a function. If you've ever used React, you might be familiar with the use memo hook. It creates a memoized value by only rerunning the function when its dependencies change.

App. The classic example is the Fibonacci sequence. Here, we have a recursive function. This function works, but it needs to recompute the same values over and over again. We can optimize it by creating an empty object.

Then when our function runs a computation, it will save the value in this object. That means when we encounter the same value again, we can use the value in memory instead of recomputing it multiple times. When you hear the word memoization, just think memorization of a return value from a function. Abstraction. Abstraction.

This word is derived from the Latin abs, which means from, enter here, which means draw. So it roughly translates to drawn from. In the most general sense, it's the process of hiding implementation details from the end user. Programming is like an onion. It's layer upon layer of abstractions.

When you build an application, you're doing it on top of programming languages and APIs that sit on top of networks and hardware, that sit on top of transistors and electricity, and so on. As a programmer, you've likely heard the phrase, do not repeat yourself or write dry code. In this example, we have a shark and a tuna, and both classes have the same implementation details for their swim method. App. Rather than duplicate this code for each class definition, we can create an abstract class called fish.

The abstract keyword means this class will never be instantiated on its own because there is no such thing as a generic fish. Instead, it's used to hide implementation details that can be inherited from other classes, which we can do by extending them with the abstract class. And that's just one of many ways you can create an abstraction in your code. The word itself really just means to app hide unnecessary implementation details. Serialization.

Serialization. This word comes from the English word series, which is just a collection of items in a fixed order. In the programming world, there's all kinds of different languages and formats, and we often need to interop between these different tools. App Java doesn't know how to understand PHP code. But what we can do is take code from either language and serialize it into a format that they both understand, is like binary.

Then it can be deserialized back into code that can be used natively. Take, for example, a JavaScript app and a Python app that communicate over an API. We have a JavaScript object that we want to use in our Python app as a dictionary. Before we send the object from JavaScript, we serialize it as a string. App.

JSON is a standard format that can be understood by virtually all modern languages. That's how we serialize a JavaScript object. Then we can go back into our Python code and deserialize it by using JSON loads. The bottom line here is that serialization is the process of taking data from one format and converting it to a more generic form that can be used by other programs. I'm gonna go ahead and wrap things up there.

If this video helped you, please like and app scribe. Thanks for watching, and I will see you in the next one.

Speaker 1: The lineup consisted simply of 6 hydrocoptic marzlevanes app So fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented.
In a recent technical interview, I was asked to debug the Redux effect for the lunar waneshaft on a turboencabulator, but I failed because my asynchronous anonymous function abstraction was not idempotent or ephemeral and failed to memoize the predicate and serialize the output.
It's one thing if your code doesn't work, but it's impossible to fix if you don't understand the words that describe the problem. When you learn to code, you not only have to learn a programming language, saw also a bunch of fancy words that you would never use in a normal conversation. In today's video, we'll unpack and define a variety of different technical words that you'll definitely need to know for interviews and your day to day work as a programmer. But first, a quick word from our sponsor. Work has been proceeding on the crudely app received the idea of an instrument that would not only provide inverse reactive current for use in unilateral phase detractors, app But would also be capable of automatically synchronizing cardinal grammeters, Rockwell Automation's retroencabulator. It's available soon app. Wherever Rockwell Automation products are sold. Idempotent. Idempotent. The key part of this word is item, which is Latin for same. The word was coined in the 1800 in the context of mathematics, and it means an operation that, when applied multiple times, will always produce the same result. For example, multiplying by 1 multiple times always produces the same result. That's an idempotent operation, unlike multiplying by 2, which always produces a different result.
mathematics
software
engineering
ibm
technology
computer science
systems
operations
programming
aerospace
Think of a crosswalk button. If you push it multiple times, does it go any faster? No. That's because it's an idempotent system. In programming, it means the same thing.
In operation or function that can be called multiple times creating the same output or side effect. For example, if we have an array and we push a new element to that array, it's making the array longer even if it's the same element, so that is not idempotent. If we use a set on the other hand, we can run the same operation multiple times and it only keeps the unique element, Therefore, adding an item to a set is idempotent.
operations
This term comes to play most often in the context of APIs. The HTTP verbs of get, put, and delete should always be implemented in an idempotent way. In addition, if you have an ecommerce app where a user can submit a payment, you likely want that operation to be idempotent as well because posting the same form shouldn't result in multiple charges to that customer. Ephemeral. Ephemeral. It comes from the Greek word ephemeros, which means lasting only a day. Think of an ephemeral plant like a daylily whose flowers only last for a day.
In programming, it's an antonym for terms like persistent and immutable. At the hardware level, your RAM is ephemeral while the hard disk is persistent. When you shut down your computer, any memory in the RAM is lost while the data in the hard disk can be retrieved later. The term is also used to define data structures within our code.
computer science
For example, a plain JavaScript object is considered ephemeral. That's because we can mutate its properties and have no way to get back to the original object. However, we can make it persistent or immutable, there's a bonus word for you, by calling object freeze, which will prevent any future modifications to the object. But the place you might hear ephemeral used most often is within the context of cloud computing. Many things in the cloud are becoming serverless. Instead of a persistent server always running in the cloud, we can use ephemeral servers that only run when they're needed. You probably know these as AWS Lambda or Google Cloud Functions. Apps. You might also see the term used with IP addresses. An ephemeral IP is one that is reassigned after a server shuts down. App anonymous. Anonymous. 1st and foremost, the word is used to describe a global group of hacktivists that fight against things like censorship and big government. I would highly recommend that you sign up and put that on your resume today. But the word anonymous is also used in our code, primarily to define functions that don't have a name. Take for example a JavaScript function or a Python function if you prefer, that takes an argument and multiplies it by 2. What we have here is a named function, but it becomes cumbersome to pass named functions around everywhere, especially as your code grows in complexity. And that's where anonymous functions come in. They're just functions that don't have a name. Instead, the function is defined as the argument. Therefore, it doesn't need to be referenced by a name. In JavaScript, we can use an anonymous function with the arrow syntax, but many other languages, like Python, use the Lambda keyword to define an anonymous function.
The syntax feels a little weird at first, but it's incredibly useful for small simple functions as arguments. Now speaking of functions, that brings us to our next fancy word, predicate. The word has its roots in Latin for something declared or proclaimed. In programming, it most often means a function that returns a single boolean value.
linguistics
True or false? By convention, you'll often see these functions start with the word is. Is the value a turkey? It's a simple yes or no question, so we can return a boolean.
You might see the word predicate come up more often in strongly typed languages like TypeScript. One cool thing we can do is set up type guards. Take, for example, this code where we have an interface of a dog that can f barked and a cat that can meow. Then we have a function called makeSound that can take either a cat or a dog, a union type, as its argument. The problem with this code is that we don't know whether we have a cat or a dog in the function body.
languages
programming
ideologies
However, we can overcome this limitation by setting up a predicate function that checks whether or not the animal is a cat.
If we then use the predicate or a type guard in our function body, TypeScript is smart enough to infer the types based on this condition. If it's a cat, we meow. Otherwise, it has to be a dog, in which case we bark. Memoization. Memoization. I'm not sure if this word means memo, like a written message, or memo, like memory.
programming
ideologies
And although it sounds like a scary word, it just means to cache the return value of a function. If you've ever used React, you might be familiar with the use memo hook. It creates a memoized value by only rerunning the function when its dependencies change. App. The classic example is the Fibonacci sequence. Here, we have a recursive function. This function works, but it needs to recompute the same values over and over again. We can optimize it by creating an empty object. Then when our function runs a computation, it will save the value in this object. That means when we encounter the same value again, we can use the value in memory instead of recomputing it multiple times. When you hear the word memoization, just think memorization of a return value from a function. Abstraction. Abstraction. This word is derived from the Latin abs, which means from, enter here, which means draw. So it roughly translates to drawn from. In the most general sense, it's the process of hiding implementation details from the end user. Programming is like an onion. It's layer upon layer of abstractions. When you build an application, you're doing it on top of programming languages and APIs that sit on top of networks and hardware, that sit on top of transistors and electricity, and so on. As a programmer, you've likely heard the phrase, do not repeat yourself or write dry code. In this example, we have a shark and a tuna, and both classes have the same implementation details for their swim method. App. Rather than duplicate this code for each class definition, we can create an abstract class called fish.
logic
ideologies
programming
computer science
software
languages
water
The abstract keyword means this class will never be instantiated on its own because there is no such thing as a generic fish. Instead, it's used to hide implementation details that can be inherited from other classes, which we can do by extending them with the abstract class.
And that's just one of many ways you can create an abstraction in your code. The word itself really just means to app hide unnecessary implementation details. Serialization. Serialization. This word comes from the English word series, which is just a collection of items in a fixed order. In the programming world, there's all kinds of different languages and formats, and we often need to interop between these different tools.
languages
App Java doesn't know how to understand PHP code. But what we can do is take code from either language and serialize it into a format that they both understand, is like binary. Then it can be deserialized back into code that can be used natively. Take, for example, a JavaScript app and a Python app that communicate over an API.
programming
We have a JavaScript object that we want to use in our Python app as a dictionary. Before we send the object from JavaScript, we serialize it as a string. App. JSON is a standard format that can be understood by virtually all modern languages. That's how we serialize a JavaScript object. Then we can go back into our Python code and deserialize it by using JSON loads. The bottom line here is that serialization is the process of taking data from one format and converting it to a more generic form that can be used by other programs. I'm gonna go ahead and wrap things up there. If this video helped you, please like and app scribe. Thanks for watching, and I will see you in the next one. The lineup consisted simply of 6 hydrocoptic marzlevanes app So fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented.
In a recent technical interview, I was asked to debug the Redux effect for the lunar waneshaft on a turboencabulator, but I failed because my asynchronous anonymous function abstraction was not idempotent or ephemeral and failed to memoize the predicate and serialize the output. It's one thing if your code doesn't work, but it's impossible to fix if you don't understand the words that describe the problem. When you learn to code, you not only have to learn a programming language, saw also a bunch of fancy words that you would never use in a normal conversation. In today's video, we'll unpack and define a variety of different technical words that you'll definitely need to know for interviews and your day to day work as a programmer. But first, a quick word from our sponsor. Work has been proceeding on the crudely app received the idea of an instrument that would not only provide inverse reactive current for use in unilateral phase detractors, app But would also be capable of automatically synchronizing cardinal grammeters, Rockwell Automation's retroencabulator. It's available soon app. Wherever Rockwell Automation products are sold. Idempotent. Idempotent. The key part of this word is item, which is Latin for same. The word was coined in the 1800 in the context of mathematics, and it means an operation that, when applied multiple times, will always produce the same result. For example, multiplying by 1 multiple times always produces the same result. That's an idempotent operation, unlike multiplying by 2, which always produces a different result. Think of a crosswalk button. If you push it multiple times, does it go any faster? No. That's because it's an idempotent system. In programming, it means the same thing. In operation or function that can be called multiple times creating the same output or side effect. For example, if we have an array and we push a new element to that array, it's making the array longer even if it's the same element, so that is not idempotent. If we use a set on the other hand, we can run the same operation multiple times and it only keeps the unique element, Therefore, adding an item to a set is idempotent. This term comes to play most often in the context of APIs. The HTTP verbs of get, put, and delete should always be implemented in an idempotent way. In addition, if you have an ecommerce app where a user can submit a payment, you likely want that operation to be idempotent as well because posting the same form shouldn't result in multiple charges to that customer. Ephemeral. Ephemeral. It comes from the Greek word ephemeros, which means lasting only a day. Think of an ephemeral plant like a daylily whose flowers only last for a day. In programming, it's an antonym for terms like persistent and immutable. At the hardware level, your RAM is ephemeral while the hard disk is persistent. When you shut down your computer, any memory in the RAM is lost while the data in the hard disk can be retrieved later. The term is also used to define data structures within our code. For example, a plain JavaScript object is considered ephemeral. That's because we can mutate its properties and have no way to get back to the original object. However, we can make it persistent or immutable, there's a bonus word for you, by calling object freeze, which will prevent any future modifications to the object. But the place you might hear ephemeral used most often is within the context of cloud computing. Many things in the cloud are becoming serverless. Instead of a persistent server always running in the cloud, we can use ephemeral servers that only run when they're needed. You probably know these as AWS Lambda or Google Cloud Functions. Apps. You might also see the term used with IP addresses. An ephemeral IP is one that is reassigned after a server shuts down. App anonymous. Anonymous. 1st and foremost, the word is used to describe a global group of hacktivists that fight against things like censorship and big government. I would highly recommend that you sign up and put that on your resume today. But the word anonymous is also used in our code, primarily to define functions that don't have a name. Take for example a JavaScript function or a Python function if you prefer, that takes an argument and multiplies it by 2. What we have here is a named function, but it becomes cumbersome to pass named functions around everywhere, especially as your code grows in complexity. And that's where anonymous functions come in. They're just functions that don't have a name. Instead, the function is defined as the argument. Therefore, it doesn't need to be referenced by a name. In JavaScript, we can use an anonymous function with the arrow syntax, but many other languages, like Python, use the Lambda keyword to define an anonymous function. The syntax feels a little weird at first, but it's incredibly useful for small simple functions as arguments. Now speaking of functions, that brings us to our next fancy word, predicate. The word has its roots in Latin for something declared or proclaimed. In programming, it most often means a function that returns a single boolean value. True or false? By convention, you'll often see these functions start with the word is. Is the value a turkey? It's a simple yes or no question, so we can return a boolean. You might see the word predicate come up more often in strongly typed languages like TypeScript. One cool thing we can do is set up type guards. Take, for example, this code where we have an interface of a dog that can f barked and a cat that can meow. Then we have a function called makeSound that can take either a cat or a dog, a union type, as its argument. The problem with this code is that we don't know whether we have a cat or a dog in the function body. However, we can overcome this limitation by setting up a predicate function that checks whether or not the animal is a cat. If we then use the predicate or a type guard in our function body, TypeScript is smart enough to infer the types based on this condition. If it's a cat, we meow. Otherwise, it has to be a dog, in which case we bark. Memoization. Memoization. I'm not sure if this word means memo, like a written message, or memo, like memory. And although it sounds like a scary word, it just means to cache the return value of a function. If you've ever used React, you might be familiar with the use memo hook. It creates a memoized value by only rerunning the function when its dependencies change. App. The classic example is the Fibonacci sequence. Here, we have a recursive function. This function works, but it needs to recompute the same values over and over again. We can optimize it by creating an empty object. Then when our function runs a computation, it will save the value in this object. That means when we encounter the same value again, we can use the value in memory instead of recomputing it multiple times. When you hear the word memoization, just think memorization of a return value from a function. Abstraction. Abstraction. This word is derived from the Latin abs, which means from, enter here, which means draw. So it roughly translates to drawn from. In the most general sense, it's the process of hiding implementation details from the end user. Programming is like an onion. It's layer upon layer of abstractions. When you build an application, you're doing it on top of programming languages and APIs that sit on top of networks and hardware, that sit on top of transistors and electricity, and so on. As a programmer, you've likely heard the phrase, do not repeat yourself or write dry code. In this example, we have a shark and a tuna, and both classes have the same implementation details for their swim method. App. Rather than duplicate this code for each class definition, we can create an abstract class called fish. The abstract keyword means this class will never be instantiated on its own because there is no such thing as a generic fish. Instead, it's used to hide implementation details that can be inherited from other classes, which we can do by extending them with the abstract class. And that's just one of many ways you can create an abstraction in your code. The word itself really just means to app hide unnecessary implementation details. Serialization. Serialization. This word comes from the English word series, which is just a collection of items in a fixed order. In the programming world, there's all kinds of different languages and formats, and we often need to interop between these different tools. App Java doesn't know how to understand PHP code. But what we can do is take code from either language and serialize it into a format that they both understand, is like binary. Then it can be deserialized back into code that can be used natively. Take, for example, a JavaScript app and a Python app that communicate over an API. We have a JavaScript object that we want to use in our Python app as a dictionary. Before we send the object from JavaScript, we serialize it as a string. App. JSON is a standard format that can be understood by virtually all modern languages. That's how we serialize a JavaScript object. Then we can go back into our Python code and deserialize it by using JSON loads. The bottom line here is that serialization is the process of taking data from one format and converting it to a more generic form that can be used by other programs. I'm gonna go ahead and wrap things up there. If this video helped you, please like and app scribe. Thanks for watching, and I will see you in the next one. The lineup consisted simply of 6 hydrocoptic marzlevanes app So fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented.
In
in
a
a
recent
recent
technical
technical
interview,
interview
I
i
was
was
asked
asked
to
to
debug
debug
the
the
Redux
redux
effect
effect
for
for
the
the
lunar
lunar
waneshaft
waneshaft
on
on
a
a
turboencabulator,
turboencabulator
but
but
I
i
failed
failed
because
because
my
my
asynchronous
asynchronous
anonymous
anonymous
function
function
abstraction
abstraction
was
was
not
not
idempotent
idempotent
or
or
ephemeral
ephemeral
and
and
failed
failed
to
to
memoize
memoize
the
the
predicate
predicate
and
and
serialize
serialize
the
the
output.
output
It's
it's
one
one
thing
thing
if
if
your
your
code
code
doesn't
doesn't
work,
work
but
but
it's
it's
impossible
impossible
to
to
fix
fix
if
if
you
you
don't
don't
understand
understand
the
the
words
words
that
that
describe
describe
the
the
problem.
problem
When
when
you
you
learn
learn
to
to
code,
code
you
you
not
not
only
only
have
have
to
to
learn
learn
a
a
programming
programming
language,
language
saw
saw
also
also
a
a
bunch
bunch
of
of
fancy
fancy
words
words
that
that
you
you
would
would
never
never
use
use
in
in
a
a
normal
normal
conversation.
conversation
In
in
today's
today's
video,
video
we'll
we'll
unpack
unpack
and
and
define
define
a
a
variety
variety
of
of
different
different
technical
technical
words
words
that
that
you'll
you'll
definitely
definitely
need
need
to
to
know
know
for
for
interviews
interviews
and
and
your
your
day
day
to
to
day
day
work
work
as
as
a
a
programmer.
programmer
But
but
first,
first
a
a
quick
quick
word
word
from
from
our
our
sponsor.
sponsor
Work
work
has
has
been
been
proceeding
proceeding
on
on
the
the
crudely
crudely
app
app
received
received
the
the
idea
idea
of
of
an
an
instrument
instrument
that
that
would
would
not
not
only
only
provide
provide
inverse
inverse
reactive
reactive
current
current
for
for
use
use
in
in
unilateral
unilateral
phase
phase
detractors,
detractors
app
app
But
but
would
would
also
also
be
be
capable
capable
of
of
automatically
automatically
synchronizing
synchronizing
cardinal
cardinal
grammeters,
grammeters
Rockwell
rockwell
Automation's
automation's
retroencabulator.
retroencabulator
It's
it's
available
available
soon
soon
app.
app
Wherever
wherever
Rockwell
rockwell
Automation
automation
products
products
are
are
sold.
sold
Idempotent.
idempotent
Idempotent.
idempotent
The
the
key
key
part
part
of
of
this
this
word
word
is
is
item,
item
which
which
is
is
Latin
latin
for
for
same.
same
The
the
word
word
was
was
coined
coined
in
in
the
the
1800
1800
in
in
the
the
context
context
of
of
mathematics,
mathematics
and
and
it
it
means
means
an
an
operation
operation
that,
that
when
when
applied
applied
multiple
multiple
times,
times
will
will
always
always
produce
produce
the
the
same
same
result.
result
For
for
example,
example
multiplying
multiplying
by
by
1
1
multiple
multiple
times
times
always
always
produces
produces
the
the
same
same
result.
result
That's
that's
an
an
idempotent
idempotent
operation,
operation
unlike
unlike
multiplying
multiplying
by
by
2,
2
which
which
always
always
produces
produces
a
a
different
different
result.
result
Think
think
of
of
a
a
crosswalk
crosswalk
button.
button
If
if
you
you
push
push
it
it
multiple
multiple
times,
times
does
does
it
it
go
go
any
any
faster?
faster
No.
no
That's
that's
because
because
it's
it's
an
an
idempotent
idempotent
system.
system
In
in
programming,
programming
it
it
means
means
the
the
same
same
thing.
thing
In
in
operation
operation
or
or
function
function
that
that
can
can
be
be
called
called
multiple
multiple
times
times
creating
creating
the
the
same
same
output
output
or
or
side
side
effect.
effect
For
for
example,
example
if
if
we
we
have
have
an
an
array
array
and
and
we
we
push
push
a
a
new
new
element
element
to
to
that
that
array,
array
it's
it's
making
making
the
the
array
array
longer
longer
even
even
if
if
it's
it's
the
the
same
same
element,
element
so
so
that
that
is
is
not
not
idempotent.
idempotent
If
if
we
we
use
use
a
a
set
set
on
on
the
the
other
other
hand,
hand
we
we
can
can
run
run
the
the
same
same
operation
operation
multiple
multiple
times
times
and
and
it
it
only
only
keeps
keeps
the
the
unique
unique
element,
element
Therefore,
therefore
adding
adding
an
an
item
item
to
to
a
a
set
set
is
is
idempotent.
idempotent
This
this
term
term
comes
comes
to
to
play
play
most
most
often
often
in
in
the
the
context
context
of
of
APIs.
apis
The
the
HTTP
http
verbs
verbs
of
of
get,
get
put,
put
and
and
delete
delete
should
should
always
always
be
be
implemented
implemented
in
in
an
an
idempotent
idempotent
way.
way
In
in
addition,
addition
if
if
you
you
have
have
an
an
ecommerce
ecommerce
app
app
where
where
a
a
user
user
can
can
submit
submit
a
a
payment,
payment
you
you
likely
likely
want
want
that
that
operation
operation
to
to
be
be
idempotent
idempotent
as
as
well
well
because
because
posting
posting
the
the
same
same
form
form
shouldn't
shouldn't
result
result
in
in
multiple
multiple
charges
charges
to
to
that
that
customer.
customer
Ephemeral.
ephemeral
Ephemeral.
ephemeral
It
it
comes
comes
from
from
the
the
Greek
greek
word
word
ephemeros,
ephemeros
which
which
means
means
lasting
lasting
only
only
a
a
day.
day
Think
think
of
of
an
an
ephemeral
ephemeral
plant
plant
like
like
a
a
daylily
daylily
whose
whose
flowers
flowers
only
only
last
last
for
for
a
a
day.
day
In
in
programming,
programming
it's
it's
an
an
antonym
antonym
for
for
terms
terms
like
like
persistent
persistent
and
and
immutable.
immutable
At
at
the
the
hardware
hardware
level,
level
your
your
RAM
ram
is
is
ephemeral
ephemeral
while
while
the
the
hard
hard
disk
disk
is
is
persistent.
persistent
When
when
you
you
shut
shut
down
down
your
your
computer,
computer
any
any
memory
memory
in
in
the
the
RAM
ram
is
is
lost
lost
while
while
the
the
data
data
in
in
the
the
hard
hard
disk
disk
can
can
be
be
retrieved
retrieved
later.
later
The
the
term
term
is
is
also
also
used
used
to
to
define
define
data
data
structures
structures
within
within
our
our
code.
code
For
for
example,
example
a
a
plain
plain
JavaScript
javascript
object
object
is
is
considered
considered
ephemeral.
ephemeral
That's
that's
because
because
we
we
can
can
mutate
mutate
its
its
properties
properties
and
and
have
have
no
no
way
way
to
to
get
get
back
back
to
to
the
the
original
original
object.
object
However,
however
we
we
can
can
make
make
it
it
persistent
persistent
or
or
immutable,
immutable
there's
there's
a
a
bonus
bonus
word
word
for
for
you,
you
by
by
calling
calling
object
object
freeze,
freeze
which
which
will
will
prevent
prevent
any
any
future
future
modifications
modifications
to
to
the
the
object.
object
But
but
the
the
place
place
you
you
might
might
hear
hear
ephemeral
ephemeral
used
used
most
most
often
often
is
is
within
within
the
the
context
context
of
of
cloud
cloud
computing.
computing
Many
many
things
things
in
in
the
the
cloud
cloud
are
are
becoming
becoming
serverless.
serverless
Instead
instead
of
of
a
a
persistent
persistent
server
server
always
always
running
running
in
in
the
the
cloud,
cloud
we
we
can
can
use
use
ephemeral
ephemeral
servers
servers
that
that
only
only
run
run
when
when
they're
they're
needed.
needed
You
you
probably
probably
know
know
these
these
as
as
AWS
aws
Lambda
lambda
or
or
Google
google
Cloud
cloud
Functions.
functions
Apps.
apps
You
you
might
might
also
also
see
see
the
the
term
term
used
used
with
with
IP
ip
addresses.
addresses
An
an
ephemeral
ephemeral
IP
ip
is
is
one
one
that
that
is
is
reassigned
reassigned
after
after
a
a
server
server
shuts
shuts
down.
down
App
app
anonymous.
anonymous
Anonymous.
anonymous
1st
1st
and
and
foremost,
foremost
the
the
word
word
is
is
used
used
to
to
describe
describe
a
a
global
global
group
group
of
of
hacktivists
hacktivists
that
that
fight
fight
against
against
things
things
like
like
censorship
censorship
and
and
big
big
government.
government
I
i
would
would
highly
highly
recommend
recommend
that
that
you
you
sign
sign
up
up
and
and
put
put
that
that
on
on
your
your
resume
resume
today.
today
But
but
the
the
word
word
anonymous
anonymous
is
is
also
also
used
used
in
in
our
our
code,
code
primarily
primarily
to
to
define
define
functions
functions
that
that
don't
don't
have
have
a
a
name.
name
Take
take
for
for
example
example
a
a
JavaScript
javascript
function
function
or
or
a
a
Python
python
function
function
if
if
you
you
prefer,
prefer
that
that
takes
takes
an
an
argument
argument
and
and
multiplies
multiplies
it
it
by
by
2.
2
What
what
we
we
have
have
here
here
is
is
a
a
named
named
function,
function
but
but
it
it
becomes
becomes
cumbersome
cumbersome
to
to
pass
pass
named
named
functions
functions
around
around
everywhere,
everywhere
especially
especially
as
as
your
your
code
code
grows
grows
in
in
complexity.
complexity
And
and
that's
that's
where
where
anonymous
anonymous
functions
functions
come
come
in.
in
They're
they're
just
just
functions
functions
that
that
don't
don't
have
have
a
a
name.
name
Instead,
instead
the
the
function
function
is
is
defined
defined
as
as
the
the
argument.
argument
Therefore,
therefore
it
it
doesn't
doesn't
need
need
to
to
be
be
referenced
referenced
by
by
a
a
name.
name
In
in
JavaScript,
javascript
we
we
can
can
use
use
an
an
anonymous
anonymous
function
function
with
with
the
the
arrow
arrow
syntax,
syntax
but
but
many
many
other
other
languages,
languages
like
like
Python,
python
use
use
the
the
Lambda
lambda
keyword
keyword
to
to
define
define
an
an
anonymous
anonymous
function.
function
The
the
syntax
syntax
feels
feels
a
a
little
little
weird
weird
at
at
first,
first
but
but
it's
it's
incredibly
incredibly
useful
useful
for
for
small
small
simple
simple
functions
functions
as
as
arguments.
arguments
Now
now
speaking
speaking
of
of
functions,
functions
that
that
brings
brings
us
us
to
to
our
our
next
next
fancy
fancy
word,
word
predicate.
predicate
The
the
word
word
has
has
its
its
roots
roots
in
in
Latin
latin
for
for
something
something
declared
declared
or
or
proclaimed.
proclaimed
In
in
programming,
programming
it
it
most
most
often
often
means
means
a
a
function
function
that
that
returns
returns
a
a
single
single
boolean
boolean
value.
value
True
true
or
or
false?
false
By
by
convention,
convention
you'll
you'll
often
often
see
see
these
these
functions
functions
start
start
with
with
the
the
word
word
is.
is
Is
is
the
the
value
value
a
a
turkey?
turkey
It's
it's
a
a
simple
simple
yes
yes
or
or
no
no
question,
question
so
so
we
we
can
can
return
return
a
a
boolean.
boolean
You
you
might
might
see
see
the
the
word
word
predicate
predicate
come
come
up
up
more
more
often
often
in
in
strongly
strongly
typed
typed
languages
languages
like
like
TypeScript.
typescript
One
one
cool
cool
thing
thing
we
we
can
can
do
do
is
is
set
set
up
up
type
type
guards.
guards
Take,
take
for
for
example,
example
this
this
code
code
where
where
we
we
have
have
an
an
interface
interface
of
of
a
a
dog
dog
that
that
can
can
f
f
barked
barked
and
and
a
a
cat
cat
that
that
can
can
meow.
meow
Then
then
we
we
have
have
a
a
function
function
called
called
makeSound
makesound
that
that
can
can
take
take
either
either
a
a
cat
cat
or
or
a
a
dog,
dog
a
a
union
union
type,
type
as
as
its
its
argument.
argument
The
the
problem
problem
with
with
this
this
code
code
is
is
that
that
we
we
don't
don't
know
know
whether
whether
we
we
have
have
a
a
cat
cat
or
or
a
a
dog
dog
in
in
the
the
function
function
body.
body
However,
however
we
we
can
can
overcome
overcome
this
this
limitation
limitation
by
by
setting
setting
up
up
a
a
predicate
predicate
function
function
that
that
checks
checks
whether
whether
or
or
not
not
the
the
animal
animal
is
is
a
a
cat.
cat
If
if
we
we
then
then
use
use
the
the
predicate
predicate
or
or
a
a
type
type
guard
guard
in
in
our
our
function
function
body,
body
TypeScript
typescript
is
is
smart
smart
enough
enough
to
to
infer
infer
the
the
types
types
based
based
on
on
this
this
condition.
condition
If
if
it's
it's
a
a
cat,
cat
we
we
meow.
meow
Otherwise,
otherwise
it
it
has
has
to
to
be
be
a
a
dog,
dog
in
in
which
which
case
case
we
we
bark.
bark
Memoization.
memoization
Memoization.
memoization
I'm
i'm
not
not
sure
sure
if
if
this
this
word
word
means
means
memo,
memo
like
like
a
a
written
written
message,
message
or
or
memo,
memo
like
like
memory.
memory
And
and
although
although
it
it
sounds
sounds
like
like
a
a
scary
scary
word,
word
it
it
just
just
means
means
to
to
cache
cache
the
the
return
return
value
value
of
of
a
a
function.
function
If
if
you've
you've
ever
ever
used
used
React,
react
you
you
might
might
be
be
familiar
familiar
with
with
the
the
use
use
memo
memo
hook.
hook
It
it
creates
creates
a
a
memoized
memoized
value
value
by
by
only
only
rerunning
rerunning
the
the
function
function
when
when
its
its
dependencies
dependencies
change.
change
App.
app
The
the
classic
classic
example
example
is
is
the
the
Fibonacci
fibonacci
sequence.
sequence
Here,
here
we
we
have
have
a
a
recursive
recursive
function.
function
This
this
function
function
works,
works
but
but
it
it
needs
needs
to
to
recompute
recompute
the
the
same
same
values
values
over
over
and
and
over
over
again.
again
We
we
can
can
optimize
optimize
it
it
by
by
creating
creating
an
an
empty
empty
object.
object
Then
then
when
when
our
our
function
function
runs
runs
a
a
computation,
computation
it
it
will
will
save
save
the
the
value
value
in
in
this
this
object.
object
That
that
means
means
when
when
we
we
encounter
encounter
the
the
same
same
value
value
again,
again
we
we
can
can
use
use
the
the
value
value
in
in
memory
memory
instead
instead
of
of
recomputing
recomputing
it
it
multiple
multiple
times.
times
When
when
you
you
hear
hear
the
the
word
word
memoization,
memoization
just
just
think
think
memorization
memorization
of
of
a
a
return
return
value
value
from
from
a
a
function.
function
Abstraction.
abstraction
Abstraction.
abstraction
This
this
word
word
is
is
derived
derived
from
from
the
the
Latin
latin
abs,
abs
which
which
means
means
from,
from
enter
enter
here,
here
which
which
means
means
draw.
draw
So
so
it
it
roughly
roughly
translates
translates
to
to
drawn
drawn
from.
from
In
in
the
the
most
most
general
general
sense,
sense
it's
it's
the
the
process
process
of
of
hiding
hiding
implementation
implementation
details
details
from
from
the
the
end
end
user.
user
Programming
programming
is
is
like
like
an
an
onion.
onion
It's
it's
layer
layer
upon
upon
layer
layer
of
of
abstractions.
abstractions
When
when
you
you
build
build
an
an
application,
application
you're
you're
doing
doing
it
it
on
on
top
top
of
of
programming
programming
languages
languages
and
and
APIs
apis
that
that
sit
sit
on
on
top
top
of
of
networks
networks
and
and
hardware,
hardware
that
that
sit
sit
on
on
top
top
of
of
transistors
transistors
and
and
electricity,
electricity
and
and
so
so
on.
on
As
as
a
a
programmer,
programmer
you've
you've
likely
likely
heard
heard
the
the
phrase,
phrase
do
do
not
not
repeat
repeat
yourself
yourself
or
or
write
write
dry
dry
code.
code
In
in
this
this
example,
example
we
we
have
have
a
a
shark
shark
and
and
a
a
tuna,
tuna
and
and
both
both
classes
classes
have
have
the
the
same
same
implementation
implementation
details
details
for
for
their
their
swim
swim
method.
method
App.
app
Rather
rather
than
than
duplicate
duplicate
this
this
code
code
for
for
each
each
class
class
definition,
definition
we
we
can
can
create
create
an
an
abstract
abstract
class
class
called
called
fish.
fish
The
the
abstract
abstract
keyword
keyword
means
means
this
this
class
class
will
will
never
never
be
be
instantiated
instantiated
on
on
its
its
own
own
because
because
there
there
is
is
no
no
such
such
thing
thing
as
as
a
a
generic
generic
fish.
fish
Instead,
instead
it's
it's
used
used
to
to
hide
hide
implementation
implementation
details
details
that
that
can
can
be
be
inherited
inherited
from
from
other
other
classes,
classes
which
which
we
we
can
can
do
do
by
by
extending
extending
them
them
with
with
the
the
abstract
abstract
class.
class
And
and
that's
that's
just
just
one
one
of
of
many
many
ways
ways
you
you
can
can
create
create
an
an
abstraction
abstraction
in
in
your
your
code.
code
The
the
word
word
itself
itself
really
really
just
just
means
means
to
to
app
app
hide
hide
unnecessary
unnecessary
implementation
implementation
details.
details
Serialization.
serialization
Serialization.
serialization
This
this
word
word
comes
comes
from
from
the
the
English
english
word
word
series,
series
which
which
is
is
just
just
a
a
collection
collection
of
of
items
items
in
in
a
a
fixed
fixed
order.
order
In
in
the
the
programming
programming
world,
world
there's
there's
all
all
kinds
kinds
of
of
different
different
languages
languages
and
and
formats,
formats
and
and
we
we
often
often
need
need
to
to
interop
interop
between
between
these
these
different
different
tools.
tools
App
app
Java
java
doesn't
doesn't
know
know
how
how
to
to
understand
understand
PHP
php
code.
code
But
but
what
what
we
we
can
can
do
do
is
is
take
take
code
code
from
from
either
either
language
language
and
and
serialize
serialize
it
it
into
into
a
a
format
format
that
that
they
they
both
both
understand,
understand
is
is
like
like
binary.
binary
Then
then
it
it
can
can
be
be
deserialized
deserialized
back
back
into
into
code
code
that
that
can
can
be
be
used
used
natively.
natively
Take,
take
for
for
example,
example
a
a
JavaScript
javascript
app
app
and
and
a
a
Python
python
app
app
that
that
communicate
communicate
over
over
an
an
API.
api
We
we
have
have
a
a
JavaScript
javascript
object
object
that
that
we
we
want
want
to
to
use
use
in
in
our
our
Python
python
app
app
as
as
a
a
dictionary.
dictionary
Before
before
we
we
send
send
the
the
object
object
from
from
JavaScript,
javascript
we
we
serialize
serialize
it
it
as
as
a
a
string.
string
App.
app
JSON
json
is
is
a
a
standard
standard
format
format
that
that
can
can
be
be
understood
understood
by
by
virtually
virtually
all
all
modern
modern
languages.
languages
That's
that's
how
how
we
we
serialize
serialize
a
a
JavaScript
javascript
object.
object
Then
then
we
we
can
can
go
go
back
back
into
into
our
our
Python
python
code
code
and
and
deserialize
deserialize
it
it
by
by
using
using
JSON
json
loads.
loads
The
the
bottom
bottom
line
line
here
here
is
is
that
that
serialization
serialization
is
is
the
the
process
process
of
of
taking
taking
data
data
from
from
one
one
format
format
and
and
converting
converting
it
it
to
to
a
a
more
more
generic
generic
form
form
that
that
can
can
be
be
used
used
by
by
other
other
programs.
programs
I'm
i'm
gonna
gonna
go
go
ahead
ahead
and
and
wrap
wrap
things
things
up
up
there.
there
If
if
this
this
video
video
helped
helped
you,
you
please
please
like
like
and
and
app
app
scribe.
scribe
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
The
the
lineup
lineup
consisted
consisted
simply
simply
of
of
6
6
hydrocoptic
hydrocoptic
marzlevanes
marzlevanes
app
app
So
so
fitted
fitted
to
to
the
the
ambifacient
ambifacient
lunar
lunar
waneshaft
waneshaft
that
that
side
side
fumbling
fumbling
was
was
effectively
effectively
prevented.
prevented
success
The use of " IdempotENT" in programming language is discussed, as it refers to an operation that is not idempotent or neither on the other side. Different terms used in cloud computing, including idempotent, persistent, and definition of anonymous functions, are also discussed. Multiple words and terms used in programming are also discussed, including memoization and the use of factory work. programming language privacy is addressed, along with a recap of the current state of programming language privacy.
7 Fancy Programming Words
In a recent technical interview, I was asked to debug the Redux effect for the lunar waneshaft on a turboencabulator, but I failed because my asynchronous anonymous function abstraction was not idempotent or ephemeral and failed to memoize the predicate and serialize the output. It's one thing if your code doesn't work, but it's impossible to fix if you don't understand the words that describe the problem. When you learn to code, you not only have to learn a programming language, saw also a bunch of fancy words that you would never use in a normal conversation. In today's video, we'll unpack and define a variety of different technical words that you'll definitely need to know for interviews and your day to day work as a programmer. But first, a quick word from our sponsor. Work has been proceeding on the crudely app received the idea of an instrument that would not only provide inverse reactive current for use in unilateral phase detractors, app But would also be capable of automatically synchronizing cardinal grammeters, Rockwell Automation's retroencabulator. It's available soon app. Wherever Rockwell Automation products are sold. Idempotent. Idempotent. The key part of this word is item, which is Latin for same. The word was coined in the 1800 in the context of mathematics, and it means an operation that, when applied multiple times, will always produce the same result. For example, multiplying by 1 multiple times always produces the same result. That's an idempotent operation, unlike multiplying by 2, which always produces a different result. Think of a crosswalk button. If you push it multiple times, does it go any faster? No. That's because it's an idempotent system. In programming, it means the same thing. In operation or function that can be called multiple times creating the same output or side effect. For example, if we have an array and we push a new element to that array, it's making the array longer even if it's the same element, so that is not idempotent. If we use a set on the other hand, we can run the same operation multiple times and it only keeps the unique element, Therefore, adding an item to a set is idempotent. This term comes to play most often in the context of APIs. The HTTP verbs of get, put, and delete should always be implemented in an idempotent way. In addition, if you have an ecommerce app where a user can submit a payment, you likely want that operation to be idempotent as well because posting the same form shouldn't result in multiple charges to that customer. Ephemeral. Ephemeral. It comes from the Greek word ephemeros, which means lasting only a day. Think of an ephemeral plant like a daylily whose flowers only last for a day. In programming, it's an antonym for terms like persistent and immutable. At the hardware level, your RAM is ephemeral while the hard disk is persistent. When you shut down your computer, any memory in the RAM is lost while the data in the hard disk can be retrieved later. The term is also used to define data structures within our code. For example, a plain JavaScript object is considered ephemeral. That's because we can mutate its properties and have no way to get back to the original object. However, we can make it persistent or immutable, there's a bonus word for you, by calling object freeze, which will prevent any future modifications to the object. But the place you might hear ephemeral used most often is within the context of cloud computing. Many things in the cloud are becoming serverless. Instead of a persistent server always running in the cloud, we can use ephemeral servers that only run when they're needed. You probably know these as AWS Lambda or Google Cloud Functions. Apps. You might also see the term used with IP addresses. An ephemeral IP is one that is reassigned after a server shuts down. App anonymous. Anonymous. 1st and foremost, the word is used to describe a global group of hacktivists that fight against things like censorship and big government. I would highly recommend that you sign up and put that on your resume today. But the word anonymous is also used in our code, primarily to define functions that don't have a name. Take for example a JavaScript function or a Python function if you prefer, that takes an argument and multiplies it by 2. What we have here is a named function, but it becomes cumbersome to pass named functions around everywhere, especially as your code grows in complexity. And that's where anonymous functions come in. They're just functions that don't have a name. Instead, the function is defined as the argument. Therefore, it doesn't need to be referenced by a name. In JavaScript, we can use an anonymous function with the arrow syntax, but many other languages, like Python, use the Lambda keyword to define an anonymous function. The syntax feels a little weird at first, but it's incredibly useful for small simple functions as arguments. Now speaking of functions, that brings us to our next fancy word, predicate. The word has its roots in Latin for something declared or proclaimed. In programming, it most often means a function that returns a single boolean value. True or false? By convention, you'll often see these functions start with the word is. Is the value a turkey? It's a simple yes or no question, so we can return a boolean. You might see the word predicate come up more often in strongly typed languages like TypeScript. One cool thing we can do is set up type guards. Take, for example, this code where we have an interface of a dog that can f barked and a cat that can meow. Then we have a function called makeSound that can take either a cat or a dog, a union type, as its argument. The problem with this code is that we don't know whether we have a cat or a dog in the function body. However, we can overcome this limitation by setting up a predicate function that checks whether or not the animal is a cat. If we then use the predicate or a type guard in our function body, TypeScript is smart enough to infer the types based on this condition. If it's a cat, we meow. Otherwise, it has to be a dog, in which case we bark. Memoization. Memoization. I'm not sure if this word means memo, like a written message, or memo, like memory. And although it sounds like a scary word, it just means to cache the return value of a function. If you've ever used React, you might be familiar with the use memo hook. It creates a memoized value by only rerunning the function when its dependencies change. App. The classic example is the Fibonacci sequence. Here, we have a recursive function. This function works, but it needs to recompute the same values over and over again. We can optimize it by creating an empty object. Then when our function runs a computation, it will save the value in this object. That means when we encounter the same value again, we can use the value in memory instead of recomputing it multiple times. When you hear the word memoization, just think memorization of a return value from a function. Abstraction. Abstraction. This word is derived from the Latin abs, which means from, enter here, which means draw. So it roughly translates to drawn from. In the most general sense, it's the process of hiding implementation details from the end user. Programming is like an onion. It's layer upon layer of abstractions. When you build an application, you're doing it on top of programming languages and APIs that sit on top of networks and hardware, that sit on top of transistors and electricity, and so on. As a programmer, you've likely heard the phrase, do not repeat yourself or write dry code. In this example, we have a shark and a tuna, and both classes have the same implementation details for their swim method. App. Rather than duplicate this code for each class definition, we can create an abstract class called fish. The abstract keyword means this class will never be instantiated on its own because there is no such thing as a generic fish. Instead, it's used to hide implementation details that can be inherited from other classes, which we can do by extending them with the abstract class. And that's just one of many ways you can create an abstraction in your code. The word itself really just means to app hide unnecessary implementation details. Serialization. Serialization. This word comes from the English word series, which is just a collection of items in a fixed order. In the programming world, there's all kinds of different languages and formats, and we often need to interop between these different tools. App Java doesn't know how to understand PHP code. But what we can do is take code from either language and serialize it into a format that they both understand, is like binary. Then it can be deserialized back into code that can be used natively. Take, for example, a JavaScript app and a Python app that communicate over an API. We have a JavaScript object that we want to use in our Python app as a dictionary. Before we send the object from JavaScript, we serialize it as a string. App. JSON is a standard format that can be understood by virtually all modern languages. That's how we serialize a JavaScript object. Then we can go back into our Python code and deserialize it by using JSON loads. The bottom line here is that serialization is the process of taking data from one format and converting it to a more generic form that can be used by other programs. I'm gonna go ahead and wrap things up there. If this video helped you, please like and app scribe. Thanks for watching, and I will see you in the next one. The lineup consisted simply of 6 hydrocoptic marzlevanes app So fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented.
The use of " IdempotENT" in programming language is discussed, as it refers to an operation that is not idempotent or neither on the other side. Different terms used in cloud computing, including idempotent, persistent, and definition of anonymous functions, are also discussed. Multiple words and terms used in programming are also discussed, including memoization and the use of factory work. programming language privacy is addressed, along with a recap of the current state of programming language privacy.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : 7 Fancy Programming Words 
        and a small summary : The use of " IdempotENT" in programming language is discussed, as it refers to an operation that is not idempotent or neither on the other side. Different terms used in cloud computing, including idempotent, persistent, and definition of anonymous functions, are also discussed. Multiple words and terms used in programming are also discussed, including memoization and the use of factory work. programming language privacy is addressed, along with a recap of the current state of programming language privacy.
        [/INST]
        
        Generate the video : In a recent technical interview, I was asked to debug the Redux effect for the lunar waneshaft on a turboencabulator, but I failed because my asynchronous anonymous function abstraction was not idempotent or ephemeral and failed to memoize the predicate and serialize the output. It's one thing if your code doesn't work, but it's impossible to fix if you don't understand the words that describe the problem. When you learn to code, you not only have to learn a programming language, saw also a bunch of fancy words that you would never use in a normal conversation. In today's video, we'll unpack and define a variety of different technical words that you'll definitely need to know for interviews and your day to day work as a programmer. But first, a quick word from our sponsor. Work has been proceeding on the crudely app received the idea of an instrument that would not only provide inverse reactive current for use in unilateral phase detractors, app But would also be capable of automatically synchronizing cardinal grammeters, Rockwell Automation's retroencabulator. It's available soon app. Wherever Rockwell Automation products are sold. Idempotent. Idempotent. The key part of this word is item, which is Latin for same. The word was coined in the 1800 in the context of mathematics, and it means an operation that, when applied multiple times, will always produce the same result. For example, multiplying by 1 multiple times always produces the same result. That's an idempotent operation, unlike multiplying by 2, which always produces a different result. Think of a crosswalk button. If you push it multiple times, does it go any faster? No. That's because it's an idempotent system. In programming, it means the same thing. In operation or function that can be called multiple times creating the same output or side effect. For example, if we have an array and we push a new element to that array, it's making the array longer even if it's the same element, so that is not idempotent. If we use a set on the other hand, we can run the same operation multiple times and it only keeps the unique element, Therefore, adding an item to a set is idempotent. This term comes to play most often in the context of APIs. The HTTP verbs of get, put, and delete should always be implemented in an idempotent way. In addition, if you have an ecommerce app where a user can submit a payment, you likely want that operation to be idempotent as well because posting the same form shouldn't result in multiple charges to that customer. Ephemeral. Ephemeral. It comes from the Greek word ephemeros, which means lasting only a day. Think of an ephemeral plant like a daylily whose flowers only last for a day. In programming, it's an antonym for terms like persistent and immutable. At the hardware level, your RAM is ephemeral while the hard disk is persistent. When you shut down your computer, any memory in the RAM is lost while the data in the hard disk can be retrieved later. The term is also used to define data structures within our code. For example, a plain JavaScript object is considered ephemeral. That's because we can mutate its properties and have no way to get back to the original object. However, we can make it persistent or immutable, there's a bonus word for you, by calling object freeze, which will prevent any future modifications to the object. But the place you might hear ephemeral used most often is within the context of cloud computing. Many things in the cloud are becoming serverless. Instead of a persistent server always running in the cloud, we can use ephemeral servers that only run when they're needed. You probably know these as AWS Lambda or Google Cloud Functions. Apps. You might also see the term used with IP addresses. An ephemeral IP is one that is reassigned after a server shuts down. App anonymous. Anonymous. 1st and foremost, the word is used to describe a global group of hacktivists that fight against things like censorship and big government. I would highly recommend that you sign up and put that on your resume today. But the word anonymous is also used in our code, primarily to define functions that don't have a name. Take for example a JavaScript function or a Python function if you prefer, that takes an argument and multiplies it by 2. What we have here is a named function, but it becomes cumbersome to pass named functions around everywhere, especially as your code grows in complexity. And that's where anonymous functions come in. They're just functions that don't have a name. Instead, the function is defined as the argument. Therefore, it doesn't need to be referenced by a name. In JavaScript, we can use an anonymous function with the arrow syntax, but many other languages, like Python, use the Lambda keyword to define an anonymous function. The syntax feels a little weird at first, but it's incredibly useful for small simple functions as arguments. Now speaking of functions, that brings us to our next fancy word, predicate. The word has its roots in Latin for something declared or proclaimed. In programming, it most often means a function that returns a single boolean value. True or false? By convention, you'll often see these functions start with the word is. Is the value a turkey? It's a simple yes or no question, so we can return a boolean. You might see the word predicate come up more often in strongly typed languages like TypeScript. One cool thing we can do is set up type guards. Take, for example, this code where we have an interface of a dog that can f barked and a cat that can meow. Then we have a function called makeSound that can take either a cat or a dog, a union type, as its argument. The problem with this code is that we don't know whether we have a cat or a dog in the function body. However, we can overcome this limitation by setting up a predicate function that checks whether or not the animal is a cat. If we then use the predicate or a type guard in our function body, TypeScript is smart enough to infer the types based on this condition. If it's a cat, we meow. Otherwise, it has to be a dog, in which case we bark. Memoization. Memoization. I'm not sure if this word means memo, like a written message, or memo, like memory. And although it sounds like a scary word, it just means to cache the return value of a function. If you've ever used React, you might be familiar with the use memo hook. It creates a memoized value by only rerunning the function when its dependencies change. App. The classic example is the Fibonacci sequence. Here, we have a recursive function. This function works, but it needs to recompute the same values over and over again. We can optimize it by creating an empty object. Then when our function runs a computation, it will save the value in this object. That means when we encounter the same value again, we can use the value in memory instead of recomputing it multiple times. When you hear the word memoization, just think memorization of a return value from a function. Abstraction. Abstraction. This word is derived from the Latin abs, which means from, enter here, which means draw. So it roughly translates to drawn from. In the most general sense, it's the process of hiding implementation details from the end user. Programming is like an onion. It's layer upon layer of abstractions. When you build an application, you're doing it on top of programming languages and APIs that sit on top of networks and hardware, that sit on top of transistors and electricity, and so on. As a programmer, you've likely heard the phrase, do not repeat yourself or write dry code. In this example, we have a shark and a tuna, and both classes have the same implementation details for their swim method. App. Rather than duplicate this code for each class definition, we can create an abstract class called fish. The abstract keyword means this class will never be instantiated on its own because there is no such thing as a generic fish. Instead, it's used to hide implementation details that can be inherited from other classes, which we can do by extending them with the abstract class. And that's just one of many ways you can create an abstraction in your code. The word itself really just means to app hide unnecessary implementation details. Serialization. Serialization. This word comes from the English word series, which is just a collection of items in a fixed order. In the programming world, there's all kinds of different languages and formats, and we often need to interop between these different tools. App Java doesn't know how to understand PHP code. But what we can do is take code from either language and serialize it into a format that they both understand, is like binary. Then it can be deserialized back into code that can be used natively. Take, for example, a JavaScript app and a Python app that communicate over an API. We have a JavaScript object that we want to use in our Python app as a dictionary. Before we send the object from JavaScript, we serialize it as a string. App. JSON is a standard format that can be understood by virtually all modern languages. That's how we serialize a JavaScript object. Then we can go back into our Python code and deserialize it by using JSON loads. The bottom line here is that serialization is the process of taking data from one format and converting it to a more generic form that can be used by other programs. I'm gonna go ahead and wrap things up there. If this video helped you, please like and app scribe. Thanks for watching, and I will see you in the next one. The lineup consisted simply of 6 hydrocoptic marzlevanes app So fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented.
        