location_city Bengaluru schedule Nov 19th 10:00 AM - 06:00 PM place Studio 5 people 4 Interested add_circle_outline Notify

Become the master of the multicore domain. Learn how to harness the powers of parallel computation and multicore computation to dominate peer applications in finance software, video games, web applications and market analysis. To yield the most performance, computer programmers have to partition and divide computations to maximize the performance while taking full advantage of multicore processors. Start your path from Padawan to Jedi, after this workshop you will be ready to return to work and have code bend to your will. This course will introduce you to technologies and tools available to developers at every level who are interested in achieving exceptional performance in applications.

You will gain an insight into the best practices necessary to build concurrent and scalable programs in .NET using the functional paradigm, which covers OnPrem and Cloud based applications.


Outline/Structure of the Workshop

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.

Learning Outcome

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:

  1. Functional Programming Techniques for Concurrency
  2. Building high-performance concurrent systems
  3. Implementing high-volume real-time event stream processing
  4. Implementing concurrent patterns such as divide-and-conquer, fork/join, producer-consumer, Map-Reduce, pipeline and more
  5. Asynchronous Functional Combinators
  6. Applying Reactive Programming Everywhere with Agents and Actors
  7. How to develop applications that scale up & out using the same programming model (Agents and/or Actors)

Target Audience

Any developer who want to improve their skills and employ polyglot techniques to solve concurrent problems

Prerequisites for Attendees

The preferred audience for this course is as follows:

  • Developer with 2-3 years’ experience and/or architect.
  • Basic knowledge a programming language, recommended either C# or F#
  • No experience in functional programming is necessary
  • Developers who want to improve their skills and employ polyglot techniques to solve problems.
schedule Submitted 3 years ago

  • Riccardo Terrell

    Riccardo Terrell - Taming and Composing high performance Stream-Oriented Processing Systems for Big Data

    Riccardo Terrell
    Riccardo Terrell
    Software Architect
    schedule 4 years ago
    Sold Out!
    45 Mins
    Experience Report

    Real time applications are dominating the industry! Data is the main ingredient in Internet-based, social media and Internet of things (IoT) systems, which generate continuous streams of events used for real time analytics. This poses a tremendous challenge due to the massive volume of data collected and processed. These event-based Real-time analysis systems can easily process millions of messages per second through new generation solutions by simply defining small flows and then combining them together to create processing graphs. In this talk, will cover the concepts behind high-performance streamed-oriented big data processing systems. We will explore messaging queue systems like Kafka and Akka Streams which let developers define their process workflows at a higher level to define a graph system enabling a high throughput. You will learn how to integrate high performance stream message queues and how to define process workflows in C# and F#.