Cultivate advanced programming language utilization skills and software design and implementation skills combining functional, object-oriented, and LISP paradigms, necessary for growing into a mid-to-senior level developer.
359 learners
Level Intermediate
Course period Unlimited
Reviews from Early Learners
5.0
끼룩쌔룩이
This isn't a simple lecture that just explains the theory and examples of Object-Oriented, Imperative, Iterator, and Functional programming. It sets the stage so that viewers can easily understand and approach each paradigm, gradually merging them one by one, and ultimately shows "how to use it." It felt like watching a drama with a perfect plot progression. I believe people will be divided into those who have seen this lecture and those who haven't. If you're a developer, or aspire to be one, I'm confident you'll enjoy watching it. :)
5.0
지호손
It's been a long time since I've had an experience where I could grow as a software person who programs, rather than just learning simple skills. While learning, I was amazed by Indong's insights every moment, and I was able to confirm that there were many other options besides the programming-related decisions I had made myself. I was able to grasp the fundamental design intentions of the technologies I had taken for granted, and to have more options, I need to develop the ability to mix various paradigms well and utilize them appropriately. I think that growth is just beginning. This course seems like a good start to that. I hope that other fellow developers will also be able to fully sympathize with and enjoy multi-paradigm programming through this course.
5.0
devsn
A lecture where you can learn the 'multi' paradigm. I've worked with many languages and frameworks over the years, but it's been a long time since I've experienced programming that focuses on the paradigm itself as much as this lecture. It reminds me of when I was learning functional programming a few years ago. The way it explains object-oriented/functional/imperative programming was very impressive. I was able to think structurally about the iterator pattern, and it was a valuable time because I was able to learn practical ways to use it. I was able to experience how programming languages expand thinking, rather than just learning the language itself. I highly recommend this to anyone who wants to make a new turning point in their current coding style.
Advanced Programming Language Utilization
Type System
Functional Programming
Object-Oriented Programming
List Processing
Multi-paradigm Programming
Programming languages have been mainly divided into functional, object-oriented, and procedural languages in the past. However, this trend has changed today. Hybrid programming languages with both functional and object-oriented features have begun to appear, and now most major programming languages such as Java, C#, Scala, TypeScript , JavaScript, Kotlin , and Swift have become multi-paradigm languages. This change has become a common characteristic of languages widely used in the field.
These languages provide a wide range of functional programming features , including first-class functions, list processing, lazy evaluation, and asynchronous/concurrent processing, as well as object-oriented features such as classes, inheritance, and interfaces . They also provide robust yet flexible type systems, type inference, generics, utility types , and even allow mixing static and dynamic types .
Some problems are better solved with functional programming, while others are better solved with object-oriented programming. Programmers no longer need to debate whether functional programming is better or object-oriented programming is better or static typing is better or dynamic typing is better. The organizations and companies that create languages and define standards have evolved to support multiple paradigms in a single language, allowing us to program in a single project, or even within a single function, using a combination of different paradigms .
Now, we may be relying on specific libraries or frameworks and following limited paradigms that fit them, and thus not fully utilizing the various functions and paradigms at the language level. Many of the technologies applied to functional programming languages or object-oriented programming languages have a very deep history and legitimacy, and have already been verified by solving various problems. Programmers with various skills at the language level can solve more problems quickly, safely, and flexibly. It also allows you to write code in a more fundamental way, without being tied to a specific library.
This lecture series primarily uses TypeScript and Kotlin as its languages , but covers techniques and concepts that can be applied to other languages such as Java, C#, Scala, and Swift . It helps you apply functional programming to your work while maintaining your existing environment and language. It also helps you expand your problem-solving skills by increasing your skills and application skills to effectively handle multi-paradigm languages by presenting code that solves problems by mixing object-oriented programming and functional programming .
And this journey is really interesting and fun. Through this lecture, I hope that you will be able to experience the various possibilities of multi-paradigm languages , develop the ability to use high-level programming languages , and develop the ability to design and implement software that combines functional, object-oriented, and LISP paradigms , and above all, enjoy the joy of computer programming and software engineering more deeply.
We provide broad and in-depth lectures based on the multi-paradigm programming book.
“This course covers multi-paradigm iteration and list processing in general, focusing on iterators, which are the intersection of object-oriented and functional programming. The main language used is TypeScript, and Clojure and Kotlin are also briefly reviewed to deeply understand the concepts of list processing and multi-paradigm iteration.”
Iterators, generators, iteration protocols, list processing
Abstraction combining functional, type system, classes, and generic programming.
Code : Object : Function = Generator : Iterator : LISP = IP : OOP : FP
Try it with Kotlin
Deepening the concepts of function composition and lazy evaluation
Handling real-world data with list processing
Expand to more problems
“This lecture introduces the design and structure of the language for asynchronous programming, how to handle the results of asynchronous operations as values, how to write asynchronous/concurrent logic using lazy evaluation and list processing, and how to handle asynchronous programming as types.”
Asynchronous programming by value
Concurrent programming with delay
Type system and asynchrony, AsyncIteration protocol
Asynchronous error handling
“In this lecture, we will learn about Iterable, Iterator, and Sequence provided by Kotlin, and through these, we will look at the sophisticated composition and extensibility unique to Kotlin, and cover the entire list processing. Also, based on Iterator and Sequence, we will deeply understand Kotlin’s iteration design, which will help us accurately understand and apply coroutines later.”
Iterable and Iterator(
Iterator)
Kotlin's sophisticated composability and extensibility
Sequence
List processing and lazy evaluation
Kotlin extension functions
Handling real-world data with list processing
Expand to more problems
“Focusing on the code required for backend programming practices, we implement a scheduler based on list processing to synchronize data between separated services in an MSA environment, and also cover essential backend techniques such as parallelism and request size limits from the perspective of list processing. We also look at multi-paradigm design and implementation cases, and cover examples that can establish criteria for which problems to apply classes (object-oriented), which problems to introduce list processing (functional), and which problems to adopt the imperative method.”
Draw a calendar
List processing pattern
Backend Asynchronous Programming: List Processing Handling MSAs
Hash-based optimization, request size limits, and parallelism for efficiency
Multi-paradigm technique for solving nested data and recursive logic
Extended concurrency handling that combines object-oriented, imperative, and functional.
“Learn about various concurrency mechanisms such as Coroutine, Flow, Deferred, and Channel, and take an in-depth look at multi-paradigm concurrency handling techniques. We also present how to efficiently apply these functions through real-world backend asynchronous programming scenarios.”
Coroutine, Flow
Deferred, Channel
Multi-paradigm concurrency handling
Practical Backend Asynchronous Programming
“We cover front-end development based on Web API (vanilla), and we look at object-oriented component design and multi-paradigm implementation techniques. We learn a wide range of topics, from classes, interfaces, inheritance, abstraction, events, and state management to headless UI, generic classes, strategy patterns, state patterns, and decorators.”
Front-end development based on Web API (Vanilla)
Object-oriented component design and multi-paradigm implementation
Classes, interfaces, inheritance, abstraction, events, state management
Headless UI, generic classes, strategy pattern, state pattern, decorator
Heuristic Diff Algorithm and UI Rendering Optimization
Asynchronous UI handling, inter-component communication design
The instructor draws on his experience in a variety of languages and technologies, including TypeScript, Objective-C, iOS, Java, Android, Node.js, PostgreSQL, Clojure, Kotlin, Ruby on Rails, Web APIs, and Canvas, to present methods for effectively combining object-oriented, functional, and imperative paradigms.
It also covers in depth the foundations, design, and practical code implementation of a robust type system and generics, as well as classes, interfaces, and design patterns.
We have compiled all the contents of various technical trainings conducted for major IT companies such as Nexon, Naver, Kakao, LGU+, and SK Planet.
Example code and how to install the environment can be found on the official Multi-Paradigm Programming and TypeScript GitHub ( link ).
Join us in our online community MDU for additional discussion and learning about multi-paradigm programming. 📢
Subscribe to our YouTube channel and get the latest news. 📺
15% of the proceeds from this lecture and all of the author's proceeds from the book will be donated to Seoul Asan Medical Center Children's Hospital.
This book provides additional theoretical content and perspectives to further support the content of this lecture. Studying with this book will allow for deeper learning and exploration.
The book also provides instructional material for other languages, including Haskell and Clojure.
View recommended articles |
Preview Chapters 1-3
View books - Kyobo Bookstore , yes24 , Aladdin
Multiparadigm programming is a language-independent concept that is not limited to a specific language, and is a methodology and technique that can be applied to most modern programming languages.
"Kotlin Multi-Paradigm Iteration" is an appendix to "Multi-Paradigm Programming" and is a material that explains some of the contents of this book in a way that is specialized for the Kotlin language.
"This course will teach you how to handle asynchronous programming more simply and intuitively using modern techniques such as lazy evaluation, generators, and iterables. It will also help you realize that complex areas such as backend parallel processing and error handling can be elegantly addressed using list processing techniques."
"You will naturally learn the multi-paradigm fusion of object-oriented and functional programming, so you will gain insight into the nature and design of code beyond simply 'working' code, and be able to flexibly apply practical patterns."
"If you want to grow from an intermediate developer to an advanced developer, you will be able to actively respond to various projects with a broader perspective by making extensive use of functional purity and immutability, as well as object-oriented encapsulation and division of responsibility."
"As you follow the process of optimizing data flow with lazy evaluation and intuitively solving difficult problems like parallel processing and error handling using generators and iterables, you will find the answer to the ultimate question: 'How can I create more value with less code?'"
"This course will help you develop an eye for seeing into the 'essence of code', and will provide you with the opportunity to acquire practical multi-paradigm design and pattern application know-how that goes beyond simple grammar knowledge, and to become a programmer who can present optimal solutions in various situations."
Who is this course right for?
A developer who wants to build solid fundamentals
Intermediate Developer
Frontend Developer
Backend developer using TypeScript
Kotlin/Java/Swift developer who wants to learn the foundations and usage of multi-paradigm languages
Need to know before starting?
Basic Syntax of Modern Programming Languages
TypeScript basic syntax
22,802
Learners
808
Reviews
457
Answers
4.9
Rating
5
Courses
CTO of Marpple Corporation
Former Developer at Kakao and NCSoft Openmaru Studio
Marpple Dev College YouTube Channel, Online Community
Developed the Object-Oriented FE Library Rune
Participated in the design of the functional library FxTS
Developed the functional library FxJS
Developed the functional database query builder FxSQL
Developed the functional DOM manipulation library FxJS-DOM
Author of Functional JavaScript Programming
Administering the Functional JavaScript Facebook Group
Technical training and corporate lectures for developers at Naver, Nexon, and Kakao
Numerous online and offline lectures
All
48 lectures ∙ (5hr 15min)
All
31 reviews
5.0
31 reviews
Reviews 3
∙
Average Rating 4.3
5
A lecture where you can learn the 'multi' paradigm. I've worked with many languages and frameworks over the years, but it's been a long time since I've experienced programming that focuses on the paradigm itself as much as this lecture. It reminds me of when I was learning functional programming a few years ago. The way it explains object-oriented/functional/imperative programming was very impressive. I was able to think structurally about the iterator pattern, and it was a valuable time because I was able to learn practical ways to use it. I was able to experience how programming languages expand thinking, rather than just learning the language itself. I highly recommend this to anyone who wants to make a new turning point in their current coding style.
It's really admirable how modern languages have evolved to handle repetition and various traversal strategies by encapsulating them as values (objects) called iterators, allowing for a shift between different paradigms within a single loop. Thank you. :)
Reviews 16
∙
Average Rating 5.0
5
It's been a long time since I've had an experience where I could grow as a software person who programs, rather than just learning simple skills. While learning, I was amazed by Indong's insights every moment, and I was able to confirm that there were many other options besides the programming-related decisions I had made myself. I was able to grasp the fundamental design intentions of the technologies I had taken for granted, and to have more options, I need to develop the ability to mix various paradigms well and utilize them appropriately. I think that growth is just beginning. This course seems like a good start to that. I hope that other fellow developers will also be able to fully sympathize with and enjoy multi-paradigm programming through this course.
"Growth as a person who deals with software itself" is a really wonderful expression and perspective. I'm glad it seems like the message I wanted to convey through the lecture will be delivered. I hope Jiho will be filled with wonderful and enjoyable things in the field of software engineering in the future!
Reviews 5
∙
Average Rating 4.8
Edited
5
It was a master's lecture that combined various elements and melted them into their own unique language. I had understood this content in a more mathematical language, like Iterable Functor -> Fx Monad, but I appreciated it being explained in a more practical form. Furthermore, the author's explanation of list processing has a mathematical framework for understanding it using adjoint functors, and it was excellent that they emphasized the potential confusion between code (meaning) < - > data (no meaning). However, personally, I found it difficult to consider it multi-paradigm, as almost all explanations seemed to be based on the functional paradigm. I am challenged by the instructor's ability to skillfully combine practice and theory. Thank you. Completed the course! Liked it!
Thank you very much for taking the course and for the wonderful review. :) After covering iterators, one of multi-paradigm intersections, in Part 1, the multi-paradigm content advances in Chapters 4, 5, 6, and 7 of the book, which include new material absent from Part 1. We kindly ask for your continued interest :)
Reviews 1
∙
Average Rating 5.0
5
As a developer with 9 years of experience, I've used various programming paradigms such as object-oriented, functional, and procedural, but I felt like I wasn't fully utilizing the differences or applications of each paradigm. After being deeply impressed by Indong's presentation at a developer conference for the first time, I encountered more content through Inflearn's functional programming course and YouTube. The newly released multi-paradigm course wasn't just about a specific development style or method; it changed my perspective on paradigms themselves. In particular, I was able to understand concepts such as lazy evaluation, iterable, iterator, and generator more deeply, not just in theory but also from a practical application perspective. It became an opportunity to think concretely about how these concepts can be applied in practice. I was stuck in a familiar pattern of development every day, but this course made me think about looking at code from a new perspective. Now, I want to share multi-paradigm programming with my team members and discuss how we can apply and improve it in our actual work code. 🔥 Hearing the course is planned to continue from Part 1 to Part 7, I'm really looking forward to the advanced content and application examples that will come out in the future. 👍
Thank you for taking the course. It's wonderful that you're thinking about applying it with your team members. I'm sure it will be helpful :) I'll do my best to help with good content! Let's work together!
Reviews 1
∙
Average Rating 5.0
5
This lecture focuses on the Iteration Protocol. We will explore the principles of operation by implementing the protocol in various ways, moving between imperative, object-oriented, and functional paradigms. Additionally, we will explore how different languages define and utilize iteration in their own ways, providing diverse perspectives and insights. Through this learning, you will understand that the iteration protocol is a common convention, unconstrained by specific languages or paradigms. Thanks to this characteristic, multi-paradigm programming, which blends different paradigms harmoniously, becomes possible. In addition to its multi-paradigm nature, the iteration protocol offers functional advantages such as improved computational and memory efficiency, and convenient type inference through lambda expressions, making it an inherently attractive concept. If your primary language supports generics, you can apply it anywhere, making it highly versatile and worth learning. We believe that both those familiar with OOP and those who have worked with FP will undoubtedly gain a new perspective by exploring the characteristics of iteration as explained in this lecture.
Thank you for the detailed review! It seems you've studied the lecture very thoroughly. As you mentioned, it's a concept that can be applied to most modern languages! I hope you have a pleasant programming journey! Thank you :)
Check out other courses by the instructor!
Explore other courses in the same field!
25% off for new members
$32.90
25%
$42.90
![[1 Hour] JavaScript for Developers (of other languages)Course Thumbnail](https://cdn.inflearn.com/public/files/courses/337877/cover/01jyvwkxfmyxtq5ny0e5fmwmqp?w=420)
![iOS App Monetization Start, Swift Grammar Master [Beginner, Intermediate, Advanced]Course Thumbnail](https://cdn.inflearn.com/public/files/courses/338375/cover/01k4z0gcg20pmkbh40vz2xtv5c?w=420)
![From JavaScript to React [PART 1/4]: The Road to Unstoppable ReactCourse Thumbnail](https://cdn.inflearn.com/public/courses/335779/cover/f59dccd0-8525-4113-aeb6-2366a94570d9/335779.png?w=420)
![iOS App Monetization Start, Swift Grammar Master [Beginner]Course Thumbnail](https://cdn.inflearn.com/public/files/courses/338128/cover/01k6et8h5h41twq0b2q2y5ymcg?w=420)
