This is a course about functional programming. It is intended to introduce people to the concepts of functional programming and functional reactive programming with examples in C#, F# and TypeScript.
I believe that learning new paradigms and new practices makes us better programmers. It helps us to understand the systems, frameworks and the world of programming.
If you know one language, then you can write code in that language. If you know two languages, then you can code in two languages and maybe use techniques from one language in the other language. But if you know a language, or two languages, or three and you know patterns, principles, then it's an easy task to estimate the complexity of the system that you are working with. You can quickly understand how to integrate with it, how to fix the issue, what are the resources needed to work on this system. It becomes easier to go from one language to another and the learning process gets quick, simple and pleasant.
Nowadays there are armies of developers who use OOP in everyday life. They fight the imperative dragon with factories and strategies, and strategy factories. They use shields of inheritance to protect themselves and versatility of polymorphism parry the attacks of ever-changing requirements, until they burn themselves with tight coupling and boilerplate code. Functional programming is here to help and change the perspective.
Each paradigm has its own principles - pillars on which it stands. This course is will introduce those principles with examples in C#, F# and TypeScript. Some of those languages are imperative-first (like C# and TypeScript), some are functional-first (like F#). This should be a great way to introduce functional concepts in a language that people have been working with for some time. Moreover, comparing the code side by side will help to understand the implementation in other languages.
- A complete project as a real-world example, and examples ONLY for additional concepts.
- A comparison of code in different languages, for people with different backgrounds to understand the concepts easier.
- Introduce the functional principles.
- Show functional principles applied in different languages.
- Compare functional paradigm to imperative, so that people know when it's better and when not.
- Explain some of the techniques/architecture built around functional programming and how to implement them.
- Introduce F# language and it's syntax.
- Watch some great videos from community experts, discuss, communicate and simply have fun in the process.
As the result of this course you should know and understand the common principles behind functional programming. You shall learn when to use it and how to be more productive at times. It's not only about productivity, but about correctness of the system. So, you'll have a better understanding on how to write more error prone code and benefit from features like type inference and functional data types.
- Topic 1: Functions as First-class Citizens
- Topic 2: Immutability
- Topic 3: Referential Transparency
- Topic 4: Recursion
- Meeting: Module Summary and Workshop
- Topic 1: Immutable Data Structures
- Topic 2: Monads, Functors
- Topic 3: Functional Domain Modeling
- Meeting: Module Summary and Workshop
- Topic 1: Pattern Matching
- Topic 2: Pipelining
- Topic 3: Closures
- Meeting: Module Summary and Workshop
- Topic 2: Type Providers
- Topic 1: Workflows
- Topic 3: Railway-Oriented Programming
- Topic 4: Functional Reactive
- Meeting: Module Summary and Workshop