Martial arts of the orthodox sect (Jeongpa) uphold tradition, principles, and discipline. Likewise, functional programming, rooted in mathematical principles, adheres strictly to purity and immutability, aiming for clean code. Just as orthodox martial arts build up each move step by step, functional programming constructs efficient and solid code through pure functions and function composition. However, just as learning only moves (i.e., pure functions without side effects) may not be enough to win in actual combat, pure functions alone can be insufficient to address the complex realities of the world.
Martial arts of the unorthodox sect (Sapa) value practicality and flexibility, taking a more liberal approach to achieve goals. Object-oriented programming models the real world by encapsulating state and behavior into objects. As unorthodox martial arts sometimes break rules or display flamboyant moves for efficiency, object-oriented programming underscores flexibility and extensibility. In particular, object-oriented programming handles real-world complexities by considering relationships and interactions among objects. However, if you add too much mutable state and create unnecessary dependencies, you can fall into “internal injury” or “madness” (Juhwaipma), making code maintenance difficult.
A master who has studied the martial arts of both the orthodox and unorthodox sects skillfully applies the style best suited to the situation. They handle data predictably and without side effects using pure functions, yet secure flexible structure and extensibility via object-oriented methods. A multi-paradigm developer is akin to the ultimate grandmaster who selects the best martial art based on the essence of the problem.
Reading this new book by CTO In-dong Yoo, I felt the excitement of discovering a secret martial arts manuscript left by a master who has mastered both orthodox and unorthodox techniques. Developers familiar with object-oriented programming will be captivated by the simplicity, predictability, and efficiency in parallel processing provided by functional programming, while those experienced in functional programming will marvel at object orientation’s unique flexibility and extensibility that elegantly models the real world. I believe this book will serve as a turning point for your development skills, delivering a rare opportunity.
– Seokwang-Yeol (CEO of Codebox, Former Ecma TC39 Committee Member, and Administrator of Haskell School)
This book is not just another technical reference. The author, Indong Yoo, is a seasoned professional who provides practical approaches for applying the complex concepts of multi-paradigm programming in real-world projects.
Focusing on list processing, it explains the essence and practicality of functional programming in TypeScript. By filtering and transforming data to solve problems clearly and concisely, the book shows that functional programming is not just theoretical but a practical tool. In particular, it demonstrates how to address real-world issues in back-end development—such as asynchronous tasks, parallel processing, and data handling—using list processing, achieving both reliability and scalability.
The book reaffirms the importance of “basic principles” in programming. It reminds us that no matter how advanced the features and techniques become, they truly shine only when built upon a solid foundation, and it guides you in methodically and incrementally developing your skills. It goes beyond simply making code “work” by teaching you to write “good code” that remains faithful to fundamental principles and structure.
Beyond multi-paradigm concepts, it offers concrete guidance on how to extend language features using the iterable protocol and decorators. Such techniques provide insights into building an efficient environment for problem-solving and help you gain the ability to create tools you can apply directly in real projects.
The content is based on the author’s extensive experience in the industry, devoted to solving various problems. Readers can learn from his firsthand experience—how he overcame complex challenges and how those experiences have added depth to his programming. This book goes beyond theory, providing real insights into how to apply multi-paradigm programming in practice.
I am delighted to recommend this book, and I believe it will be a wonderful gift for developers seeking to deepen their programming expertise.
– Hyunwoo Cho (Main Maintainer of FxTS, Tech Lead at Mapple Corporation, Former Naver Developer)
Software development progresses every day, continually introducing new tools and methodologies. Yet we often overlook the value of what we already have when chasing innovation. In-dong Yoo’s book re-examines the powerful features already present in modern programming languages and demonstrates how to fully utilize their potential. With major languages like Java, C#, TypeScript, and Kotlin all supporting multi-paradigm approaches, we can now flexibly harness multiple programming paradigms in a single language. This book accurately captures this trend and explains in detail how to use it effectively in real projects.
What impressed me most was Indong Yoo’s penetrating insight into “the essence of code.” He handles even complicated business logic gracefully using the iterable protocol and list processing, and he deals with tricky asynchronous operations cleanly via lazy evaluation and generators. Working with him, I’ve continually heard him emphasize the elegance of code and the value of writing less, more concise code—every bit of that philosophy is encapsulated in this book.
Notably, the book strikes a superb balance between theory and practice. While explaining advanced theories from the functional programming tradition—such as LISP’s metaprogramming concepts or Haskell’s type system—it also provides TypeScript-based examples so you can apply these methods right away in real projects. Its examples aren’t just trivial demos but realistic code for challenges encountered in actual services.
I consider multi-paradigm programming a necessity rather than an option. Still, it does not mean mixing all paradigms indiscriminately. Instead, this book teaches you to accurately understand the strengths of each paradigm and choose the best tool for each situation. Yoo’s statement, “Use object orientation for structural problems and functional programming for logic,” is the wisdom gained from repeated trial and error.
I’m convinced this book will become more than just a technical guide; it will be a compass for developers. While writing code is something anyone can do, writing “good code” is akin to an art form. This book moves you one step closer to that art.
– Jaemin Kim (Tech Lead at Mapple Corporation, Former Senior Researcher at OCI)
Object-oriented programming (OOP) and functional programming (FP) are often portrayed as polar opposites in some texts. Some even introduce FP as a cure for OOP’s problems, limiting developers’ thinking by implying one must choose which is “better.”
However, unlike in the past, modern programming languages can handle both OOP and FP. Solving a problem using OOP does not exclude functional techniques, and favoring FP does not forbid using classes.
While OOP and FP may appear to stand at odds, combining the two often yields the best outcome. OOP shines in encapsulating the “what” and distributing the “how” among responsible entities, while FP excels at combining and testing the “how” behind logical operations.
Until recently, there weren’t many books on how to effectively use OOP and FP together, or ones addressing real-world cases, such as teaching OOP-based back-end developers FP or teaching FP-minded front-end developers OOP. Now we have a book that demonstrates harmonious OOP-FP usage.
For those who have heavily focused on one paradigm, whether modeling complex domains through objects or using purely functional style to minimize side effects and maintain immutability, this book showcases multi-paradigm programming—expanding your perspective by combining the best of OOP with FP.
– Dong-wook Lee (CTO at Inflearn, Former Back-End Lead at Woowa Brothers)
I first met Indong Yoo when inviting him as a corporate instructor to teach developers at our company several years ago. I’ve encountered countless instructors, yet Indong’s lectures remain among the most engaging. In particular, the unique style of “live coding” was impressive. By building up concepts step by step in a live environment where unexpected variables arise, he guided the audience to an “aha!” moment, accompanied by cheers and nods of agreement. The feedback was so positive that it was the only session we’ve ever asked to repeat—an indication of its uniqueness.
This book encapsulates everything from those lectures, covering a wide array of techniques for practically applying the strengths of both object-oriented and functional programming in real projects. Centered on TypeScript, it features a wealth of examples and ideas relevant to modern languages, giving readers a solid insight into understanding and utilizing various programming paradigms. From novices to seasoned professionals, anyone seeking to transcend the boundaries of a single programming paradigm to write better code will find immense value here.
– Jaeseung Lee (React Contributor, Author of Practical React Programming)
I was thrilled to hear about Indong Yoo’s new book. Already well-known in the domestic front-end community for establishing and promoting the functional paradigm, I wondered what new content he’d introduce this time.
From my perspective—someone who constantly ponders “good code, good software” with coworkers, and someone who has taught front-end courses from junior to senior levels for a long time—this practical front-end development book is a welcome addition. It will enrich front-end developers at all experience levels with insights into the language and front-end development. Here are a few features that impressed me:
- The core message, “There are many ways to solve a problem,” will resonate with many developers. When developing a service, it’s often better to adapt the solution to the context rather than forcing a single pattern. This book highlights a balanced mix of object-oriented and functional approaches, offering crucial realizations to many readers.
- Readers can delve deeper into TypeScript (JavaScript) from multiple angles. Beyond the basics like standard APIs or type systems, it covers real use cases involving asynchronous programming and high-level error handling. Throughout the book, real-world experience and coding philosophy—gleaned from the author’s longtime career—are tangibly present. It offers a glimpse into long-standing concerns about good code and design patterns.
- It examines the philosophy and syntax of various programming languages like LISP or Haskell and explores how to replicate them in TypeScript. Along the way, you’ll get a sense of modern programming language trends, and you might even sharpen your general programming skills by exploring new languages. You’ll also get a taste of the author’s knowledge and insights, forged by extensive experience in multiple languages over many years.
The book features near real-world examples, final project code, and many other points of interest—though I’ll leave readers to discover them on their own.
– Gihyo Jang (“Captain Pangyo,” Front-End Developer at Naver)
This is not just a book for learning programming techniques. Here, author Indong Yoo delves into how to practically and in depth combine object-oriented and functional programming in a multi-paradigm style. The content is packed with examples that can be readily applied in real situations, allowing readers to grasp both the theoretical and practical sides. In particular, it’s fascinating to see how the book handles functional programming in TypeScript—demonstrating how complex business logic can be tackled in a safe and elegant manner.
Also noteworthy is how the book weaves together technologies developed from past to present, almost like tracing a historical progression. It illustrates not merely the evolution of technology, but how various paradigms have been utilized and evolved. Following the author’s journey, readers will gain the skills to harness both OOP and FP. Moreover, by blending object orientation and functional programming, they’ll be equipped with better design and maintainability for their code.
Anyone aiming to deepen their understanding of programming paradigms—and acquire practical, immediately applicable tools—should read this book without fail. The rich experiences and know-how the author has poured into these pages will help developers take one step closer to writing great code.
– Haegeol Pyun (Flex Front Product Engineer, Former Developer at LINE Plus)
I’m thrilled to write a recommendation for this book. Several years ago, I attended an offline functional programming seminar at Naver, discussing various dilemmas with Indong Yoo—someone who had faced many of these issues earlier. I asked him questions, got deeply insightful answers, and learned a lot. While his lectures were outstanding, this new book not only encapsulates everything from those sessions but goes beyond, offering even deeper insights and points to ponder.
Rather than just explaining theory or introducing techniques, the book takes a multi-paradigm perspective on how to approach problems, handle data, and ultimately solve them. In the process, it naturally addresses code maintainability, guiding readers toward better design and implementation.
Reading it, I felt that my own questions and reflections integrated seamlessly with the problem-solving process, as if conversing with the author. From Chapters 1 to 4, I discovered the joy of tackling problems with multi-paradigm thinking. Then, in Chapters 5 to 7, I found concrete ideas on how to apply these approaches practically, getting excited about using them in real projects.
I’m honored to recommend this book once more and hope readers enjoy the same sense of learning and excitement I did.
– Youngjun Kim (Back-End Product Engineer at flex, Former Naver Pay Developer)
I’m a developer who has been observing Indong Yoo since a functional programming seminar last winter. Thinking about what defines a skilled developer—algorithms, familiarity with libraries or frameworks, architecture skills, and last but not least, the ability to produce beautiful code—this book addresses that final aspect: writing elegant code. From thoroughly explaining the theories behind functional programming to showcasing how to write asynchronous processes in a more graceful way (like parallel execution), it exemplifies what “beautiful code” really is.
Additionally, this book shares insights from a “nationally influential developer.” In my view, a developer of this caliber is someone who maintains or creates widely used, highly advanced open-source projects. The author, Indong Yoo, developed Fx.js, an even more powerful library than Lodash or Ramda. He has put substantial effort into writing this book, so I can confidently call it a masterpiece worth reading multiple times.
– Hongcheol Joo (Mocha.js contributor, Author of Interview Preparation for CS Knowledge)
JavaScript and TypeScript may seem easy to pick up, but mastering all their language features is challenging. If you want to become a more proficient developer, I recommend referencing this book.
Rather than simply using the language, you’ll explore its underlying structure. Everything from the
for ... ofsyntax andPromiseobjects to everyday tools likemap,flatMap, and array methods will be examined at their roots, illustrating how they originated. Along the way, comparing them with Java or C# can be quite enjoyable.Beyond theoretical discussions, the author provides actionable strategies for front-end developers to handle complex data and asynchronous scenarios. If you follow the exercises in this book, you’ll experience the beauty of functional programming, breaking down complicated array operations into small, composable functions. You’ll also practice concurrency, error handling, and more in a safe and modular way.
I applaud Indong Yoo for consolidating so many difficult topics into one volume.
– Seojin Park (Head of Frontend Engineering at Toss)
I previously reviewed Indong Yoo’s earlier book, Functional JavaScript Programming, which introduced me to the concept of functional programming. Eight years later, I’m thrilled to have the opportunity to review this new release. Every time I read one of Indong’s books, I learn so much.
This one starts by leveraging iterators and generators to build your own functional programming methods. With JavaScript’s evolution, such functionality is now simpler to implement than before. I used to rely on RxJS or Lodash and seldom questioned the internals, presuming the implementations would be messy and complicated—this book breaks that preconceived notion. It made me realize I could implement it myself.
Initially, I wasn’t sure where functional programming would be most useful. However, by gradually incorporating functional methods into complex logic, I found the resulting code more readable and robust. Still, I felt uneasy mixing functional code with object-oriented code in the same object-oriented project—shouldn’t I stick entirely to OOP or FP? Reading this book dispelled that worry, showing me that we don’t have to pick just one. Each paradigm has strengths, and we can adopt whichever suits the situation. Through logical argumentation, this book reassured me of the benefits of multi-paradigm approaches. Now I know where to go from here, and I hope you’ll share a similar epiphany.
– Hyeonyoung Jo (a.k.a. ZeroCho, CTO of S’moreTalk)
While developing the Danggeun Alba (당근알바) server, our team actively introduced FP (functional programming) ideas alongside OOP, using iterators, generators, higher-order functions, and currying in our business logic. Doing so yielded many advantages. Because FP minimizes side effects, it was easy to see how the code behaves just by reading it, making it well-suited for rapid decision-making in fast-moving new business environments.
As modern languages increasingly support multiple paradigms, more code in real projects naturally blends OOP for some issues and FP for others—and sometimes different paradigms are mixed even in a single solution. After searching for a more harmonious use of various paradigms, I was delighted to hear of Indong Yoo’s new book.
Following his trademark style, you’ll find not just conceptual explanations but also how to tackle real problems on the job. By weaving typical real-world pain points into a multi-paradigm approach, the book gives an abundance of ideas you can implement straight away. Backed by the author’s experience in addressing various production-level challenges, it’s full of practical tips.
For anyone who wants to simplify patterns, combine code elegantly, and reduce errors by adopting the “list processing” approach described in this book, I highly recommend it.
– Byeonghan Baek (KARROT Tech Committee, Former New Business Engineer Lead)
Programming languages have evolved steadily over a long time. Developers today realize there’s no single “ultimate truth” that solves all software problems, yet we keep striving toward it. Along the way, diverse paradigms have emerged—object-oriented, aiming at abstraction and encapsulation with collaborative communication between objects; functional, emphasizing immutability and pure functions for predictability; or data-oriented, focusing on simplicity and transformations.
These paradigms can progress on their own paths but also influence each other. Object-oriented programming, once reliant on mutability, has embraced immutable objects for stability, while functional programming has recognized the value of objects for architecture. This melding birthed multi-paradigm languages like TypeScript, Kotlin, Swift, and Scala.
Developers craft software using the tool of programming languages. As you wouldn’t rely on just a hammer to build a house, you need multiple tools to build robust software. Consequently, multi-paradigm programming becomes a realistic choice. This book reaffirms that notion, and I’ve learned a great deal while reading it. It isn’t just about theory; it’s packed with real-world examples and philosophy. If you want to become a better software developer, I highly recommend it.
– Sunhyup Lee (CTO at Cobalt, Author of Passing Coding Tests with JavaScript)
While generative AI can assist with coding, it’s still up to developers to write intuitive code that remains understandable even one week or one month later. This book, through a multi-paradigm approach, helps readers develop the skill to select the most appropriate technique for the problem at hand.
The early chapters focus on building Iterable Helpers that unite the object-oriented “iterator pattern,” the imperative “generator,” functional “higher-order functions,” and type systems. Building on that foundation, the latter chapters show you how to apply these concepts in both back-end and front-end real-world cases, honing your ability to move seamlessly between paradigms.
This multi-paradigm approach gives junior developers—who might otherwise rely heavily on libraries—a sturdy practical foundation, and gives senior developers a fresh lens on existing knowledge, providing an opportunity for renewed growth. Finally, we, the subscribers of the “Mapple Developer College,” thank Indong Yoo for offering us the chance to preview this remarkable book.
– Reviewers from the Mapple Developer College subscriber community
We also extend our deep gratitude to those who contributed to reviewing and testing this book: the Mapple Developer College subscriber reviewers Park Jaeyoung (SaeWooKKang on GitHub), Ryu Hangyeong (ryuhangyeong), Kim Sangmin (Sang-minKIM), Kim Mogeon (redcontroller), Na Hojun (Rojojun), and Lee Seongpil (goohooh); plus Mapple Developer College staff Jeong Jae-hun (Jeong-Jae-Hun), Park Byeonghun (parkbyeonghoon222), Shin Seongwoo (sungwoo-shin), Jeong Gyeongjin (okyungjin), Choi Yeonjeong (padosum), Choi Seungjune (seungjune-choi), Nam Boram (Boramnam), Choi Junman (JunmanChoi), Ji Yeongjun (jiyeongjun), and Park Piljeong (piljung89). Thank you for your invaluable support.