Friday, September 3, 2010

Advanced Functional Programming Tutorials

Advanced Functional Programming Tutorials | 3.7GB
1. The Expression Problem
“The Expression Problem is a new name for an old problem. The goal is to define a datatype by cases, where one can add new cases to the datatype and new functions over the datatype, without recompiling existing code, and while retaining static type safety (e.g., no casts).” – Philip Wadler

2. Type Classes
In this second lecture in the series, Ralf digs into Type Classes, which are type system constructs that were originally introduced to provide a form of ad hoc polymorphism (i.e., an advanced form of overloading). Type classes amount to an intriguing element of the Haskell language, which is, for example, evident in their ability to solve the Expression Problem (make sure you watch Ralf’s first lecture on this subject). Furthermore, type classes directly relate to the interface notion of mainstream OO programming, adding important expressiveness to C#/Java-like interfaces.

3. Evolution of an Interpreter
In part 3 of the Advanced Functional Programming lecture series, Dr. Lämmel focuses on the domain of language interpretation as a method of understanding some important functional programming techniques. As a side effect, some basics of programming language theory are also informally presented.

More specifically, this lecture develops an interpreter for a simple functional programming language that contains Booleans, natural numbers, lambdas, and recursive lets. The interpreter is actually developed in a stepwise manner, which is why the lecture is called “Evolution of an Interpreter.”
In each step, another construct is added and the impact of the extension onto the interpreter is analyzed. In this manner, several interesting programming techniques are exercised. For instance, the Maybe type constructor is pervasively used for dealing with partiality, and Haskell’s fixed point combinator is used to model the semantics (i.e., interpretation) of recursive bindings.
This lecture also prepares us for some more advanced subjects. For instance, the next lecture in this series will cover the intriguing subject of monads while using interpretation as the application scenario. Soon, generalized folds (or bananas, according to Erik Meijer) will also be discussed (the folds will traverse abstract syntax trees as opposed to lists).
4. Introducing functional concepts
Visual Studio 2010 is going to be released soon, so it may be a good time finally try the new F# language. In this Webcast series, I’ll demonstrate interesting aspects of F#. In this part, we’ll look at basic functional concepts and working with data. Many of the functional techniques can be demonstrated in C#, so we’ll start by wrting functional C# code. Next, we’ll look how to write the same thing in F# and we’ll also look at working with collections in F#.

5. Using Asynchronous Workflows
In the previous webcast you’ve seen how to write a simple function for downloading RSS feeds and processing them. In this part, we look how to improve the function to download data asynchronously and process them potentially in parallel. Once we have the first version of the code, we can start refactoring it. We’ll wrap it into F# asynchronous workflow to run without blocking threads and we’ll also run multiple downloads in parallel. As you can see from the webcast, these kinds of refactorings are also very nicely supported by F# syntax…

6. Using .NET libraries
In this Webcast, we’ll write a demo application that grabs data from RSS feeds and processes them. You’ll learn how to access .NET libraries from F#. We’ll develop the code iteratively, which means that we’ll start by simply enumerating the RSS elements using for loop and printing the results and then we’ll refactor the code to use tuples and sequence expressions to turn it into processing code that generates a sequence of feed items. Finally we’ll also demonstrate how to use some of the functions from the previous part such as List.filter in practice.

7. Rebel with a Cause
Over thousands of years, language has evolved in order to provide mankind a mechanism for making it easier to communicate with one another. Today, the world is filled with a wide variety of languages, some of which are radically different from one another, while others bear striking similarities. In addition to improving interpersonal communications, however, languages have evolved to facilitate the transfer of information, instructions, and intent between people and machines.

Understanding, designing, and evangelizing many of these languages, and democratizing the programming methodologies within them, is Erik Meijer. Erik is a legendary figure in the programming language design community and one of Niner Nation’s favorite personalities. Today, tune in and meet the man behind the code; some of Erik’s fascinating personal and professional histories may well surprise you. The great Robert Hess moderates this latest edition of Behind the Code.
Download Link:
Password: cieb

No comments: