Previously you learned how to declare an object, and assign a value to it. The value assigned was typically a number or text. In Kotlin, you can also create objects that can have a function assigned as their value. In this video, you will explore the idea, that functions can be used as objects, how this can be useful, and how its implementation corresponds with a core principle of functional programming. There are several criteria that determine what good code is, and these include how concise, and efficient the code is, how well it uses resources such as memory, and device abilities, and it takes into account the code readability and maintainability. Consider the code you've written so far, and you'll find that there are different ways of organizing classes, and the relationships between classes in a project. For instance, you may inherit one class from another or use them as compositions. Ultimately, a single class will not function properly until all its dependency classes are provided. Therefore, any change to any item in a class can require a significant amount of work, refactoring the code. Treating functions as objects, takes a different approach. A function as an object, is one of the core principles of functional programming. Functional programming is a programming paradigm that utilizes creating functions for clean, consistent, and maintainable code. While Kotlin is an object oriented programming language, it does provide tools to support a functional programming paradigm as well. These tools, such as working with functions as objects, allow you to effectively combine the best of these two paradigms, to create the most efficient code. Let's imagine you're building the menu functionality of the Little Lemon food ordering app. You need to get the list of menu items and display the received menu items on a screen. ClassA will be responsible for getting the list of the menu items in its loadMenuItems function. After receiving the result, it executes that displayMenuItems function from ClassB and passes the items to it. With this code, you need to have an instance of ClassB to call the displayMenuItems function after loading the list. This approach creates a tight coupling as ClassA holds a reference to ClassB. It is aware of the whole class, and all of its aspects such as its variables and other functions. In resource terms, this is known as overhead, since only the displayMenuItems function is needed for correct behavior. Such overhead can be avoided by passing only the displayMenuItems function itself as an object. Storing a function as an object is useful when it needs to be executed from a different class. This lets you replace the dependency on a whole class with a dependency on just a single function that you need. The code is not bound directly to classes, and this lets you effectively refactor, replace, or mock the implementation. Using a function, as an object, is a powerful tool that lets you separate the code blocks and execute a function, from different parts of the code, without tight coupling. It is an effective approach when you need a function to be executed from a different class. This is one of the fundamentals of functional programming. Try using it in your code and judge for yourself how it can improve the performance, readability, and maintainability of the code you write.