Concurrent Functional Programming in .NET
Concurrency, multi-core parallelism, and distributed parallelism are powerful and accessible. These computing concepts promise big impacts on the full spectrum of software applications, including video games, web applications and market analytics suites. Programmers of these products know how to partition computations over large distributed datasets in order to take full advantage of modern hardware and computing environments. These programming skills are not easy to master. This course will introduce technologies and tools available to developers at every level who are interested in achieving high-performance, reliable and maintainable code through functional-style parallelism and concurrency.
We are facing a new era of geographically-distributed, highly-available systems with processor designs that are scaling out in core counts quicker than they are scaling up in core speeds. In keeping up with performance expectations as complexities and dataset grow, scaling out software architectures over these modern computing resources is one of the biggest challenges facing developers today. This course will provide insight into the best practices necessary to build concurrent and scalable programs in .NET with functional style, applicable to both On-Premises and Cloud based applications.
Computer languages generally favor one of two major programming styles: Imperative or Functional. The majority of developers use Imperative language, but many believe that these languages have given all they have to give. The functional alternatives, however, provide some novel solutions and are often the more expressive programming model for writing clean, concise, bug free code.
Because it is a style, Functional techniques can be applied in any language, even primarily Imperative (and Object-Oriented) languages. This course provides information about how to write more readable, modular, maintainable and concise code in both C# and F#. Adoption of these techniques make for more capable and more productive developers. Ultimately, armed with new found skills, the attendees will have the knowledge necessary to deliver high-performance solutions appropriate for both On-Premises and Cloud-based infrastructures.
What the attendee will learn
In this course, participants will learn powerful techniques in C# and F# for parallel programming to leverage multi-core computation, increasing the capacity and speed of their programs. Major theories and practices will be covered and participants will have the opportunity to design projects learning the key principles and techniques. Participants will be introduced to concurrent and parallel programming designs, emphasizing functional style with theory, practice and lots of code samples.
By the end of the course, participants will know how to build concurrent and scalable programs in .NET in functional style. This intermediate-level course is aimed at developers, architects, and passionate computer programmers who are interested in writing code with improved speed and effectiveness by adopting declarative and pain-free programming techniques.
The following objectives will be satisfied during the duration of the course:
- Why Choose Functional Programming for Concurrency
- Functional Programming Techniques for Concurrency
- Building high-performance concurrent systems
- Implementing high-volume real-time event stream processing
- Implementing concurrent patterns such as divide-and-conquer, fork/join, producer-consumer, Map-Reduce, pipeline and more
- Asynchronous Functional Combinators
- Applying Reactive Programming Everywhere with Agents and Actors
- How to develop applications that scale up & out using the same programming model (Agents and/or Actors)
- How to write scalable and robust server-side asynchronous code, that can be deployed and executed on the Cloud
- Any developer who want to improve their skills and employ polyglot techniques to solve concurrent problems
- Developers who want to design high performance and scalable applications
- Anyone who wants to break the bonds of imperative programming and leverage the power of multi-core computers
- Developers who know object-oriented technologies work and are interested in learning about “Functional Programming” and the benefits of writing concurrent programs
- Software Engineers and Developers who needs to increase the performance of programs by leveraging and maximizing the hardware resources available (Both Server and Client side)
- Software Engineers , Developers and Solution Architects who needs to develop Reactive Systems that satisfy the Reactive-Manifesto principles: Responsive, Resilient, Elastic, Message Driven
- Software Engineers and Developers who wants to combine different program paradigms and concurrent libraries to write maintainable, concise and concurrent code dramatically reducing the introduction of bugs.
The preferred audience for this course is as follows:
- Developer with 2-3 years’ experience and/or architect.
- Basic knowledge a programming language, especially C#.
- No experience in functional programming is necessary
- Developers who want to improve their skills and employ polyglot techniques to solve problems.
About Riccardo Terrell
Riccardo Terrell is a .NET seasoned software engineer, senior software architect and Microsoft MVP who is passionate about functional programming. He is well known and actively involved in the .NET community and the author of "Functional Concurrency in .NET", which features how to develop highly-scalable systems in F# & C#. Riccardo believes in polyglot programming as a mechanism for finding the right tool for the job.
Registration is not currently available.