Functional Programming and JavaScript ES6+

"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 specialized way for the Kotlin language. Multi-Paradigm Programming is a language-independent concept that is not limited to a specific language, and is a methodology and technology that can be applied to most modern programming languages.

See: https://github.com/marpple/kotlin-multi-paradigm-iteration

Modern programming languages integrate object-oriented, functional, and imperative concepts for iteration, and provide conventions that make them work organically. In 『Multi-paradigm Programming』, we looked at cases where functional, imperative, list processing, and object-oriented programming are combined and utilized, focusing on TypeScript. This time, we will focus on multi-paradigm iteration in Kotlin, a multi-paradigm language, and expand the application capabilities of multi-paradigm programming languages.

Kotlin is a multi-paradigm programming language. Mike Ruckides, VP of O'Reilly Media and author of several technical books, recently wrote, "We need to learn how to use a multi-paradigm language effectively, providing functional, object-oriented, and imperative paradigms. Many of the tools have improved, and now it's time to learn how to use them well. And now it's time to mix paradigms that have long been unique and even conflicting."

Now that this environment is here, using only one paradigm may be a big missed opportunity. Some problems we have to solve are better solved with functional programming, while others are better solved with object-oriented programming. Programmers no longer need to debate whether functional or object-oriented is better, or whether static or dynamic typing is better. The organizations and companies that create languages and define standards have already made it possible for a single language and platform to support multiple paradigms, and we can program by combining multiple paradigms in a single project, or even in a single function.

Kotlin is characterized by its ability to handle lazy evaluation and asynchronous code in a sophisticated and flexible manner through structures such as Iterable, Iterator, Sequence, Flow, and Channel. This is combined with extension functions and a rich set of standard library helper functions to more concisely express various patterns beyond simple list iteration. This allows high-level list processing to be realized without a separate library. Kotlin's unique sophisticated interlocking structures, flexible extensibility, and rich convenience features provide much inspiration and enjoyment to developers who use the language. However, if you are not fully utilizing these features, you may not be able to fully enjoy the pleasure of Kotlin programming.

In the appendix content of 『Multi-paradigm Programming』, 『Kotlin Multi-paradigm Iteration』, some of the contents of 『Multi-paradigm Programming』 are explained from the perspective of connecting Kotlin iterables, iterators, and sequences to object-oriented, functional, and imperative paradigms. We will examine the relationship between iterators designed in an object-oriented manner and sequences written in an imperative style, and examine code that handles objects that are both sequences and iterators using functional extension functions. We will also examine the paradigm-shifting ability of Kotlin iteration by handling a sequence that has operations stacked using functional extension functions in an imperative manner and then converting it back to a functional manner.

In addition, we will deeply understand the lazy evaluation of sequences and iterators, explore the perspective of combining code and data by borrowing the philosophy of LISP, and cover the practical application of these techniques. In addition, we will explore how to design flexible and robust code structures and create code that operates efficiently, accurately, and safely. Through this, we hope to realize the various possibilities of the multi-paradigm language Kotlin and enjoy the joy of software engineering and programming more deeply.

This time, our company's developers, Lee Do-hyung and Jo Hyeon-woo, created and released fxts, a TypeScript-based functional library.

It has better type inference than other libraries, is easy to use for concurrent programming, conforms perfectly to standard ECMAScript, and is good at error handling!

Please visit the fxts site below to see what kind of concepts and functions it has, visit GitHub to check out Do-hyung and Hyun-woo's code know-how, and come to Slack to share a lot of technical know-how!!

Github: https://github.com/marpple/fxts

Site: https://fxts.dev

Slack: https://join.slack.com/t/fx-ts/shared_invite/zt-yw1x81zq-pNa8nM40X6mQAsu2L4m1Fw

hello.

We have opened an application course, the sequel to Functional ES6+. It is on sale until June 18th.

https://www.inflearn.com/course/Functional_ES6_Application

Part 3 of Functional ES6+ will cover databases.

thank you

Hello. This is Yoo In-dong.

Thank you so much to everyone who attended my lecture.

I've created two lectures so far.

1. Functional Programming with JavaScript (Free)

- https://www.inflearn.com/course/functional-programming

2. Functional Programming and JavaScript ES6+

- https://www.inflearn.com/course/functional-es6

This time, we have created a follow-up article, 'Functional Programming and JavaScript ES6+ Applications'.

We have prepared a variety of ways to apply functional programming and how far it can be used with iterable programming, so please show a lot of interest.

Currently, six sections have been completed.

If you would like to see it in advance, you can see the code.

https://github.com/indongyoo/functional-javascript-02

We'll notify you again as soon as production is complete.

thank you