Channel 9 - Entries tagged with Haskell

Alexandrescu, Bright, Meijer, Moran: Pure versus Native (and much more)

Charles — Thu, 12 Apr 2012 13:00:00 GMT

Continuing with the series of conversations filmed in the "social room" at Lang.NEXT 2012, we present Andrei Alexandrescu, Walter Bright, Erik Meijer, and Andrew Adams-Moran discussing/debating various programming topics including pure versus native languages, Haskell, D, and more. Thanks Andrei, Andrew, Erik, and Walter for an excellent conversation! As always, this is presented to you exactly as it happened.

Tune in. Enjoy.

Simon Peyton-Jones and John Hughes - It's Raining Haskell

Charles — Sun, 25 Dec 2011 16:00:00 GMT

Ever wonder what would happen if you happened upon Simon Peyton-Jones, author of the Glasgow Haskell Compiler (GHC) and a key contributor to the Haskell functional programming language, and John Hughes, fellow Haskellite, computer scientist, creator of QuickCheck, and author of the landmark paper, "Why Functional Programming Matters," sitting on a park bench, in the rain, right next to Sydney's iconic opera house? Well, let's find out, shall we?

Simon and John have been friends for many years and studied mathematics together at Trinity College Cambridge. What were they like as young men? As students? What was Simon's issue with wearing shoes, anyway? It's always wonderful to learn about the humans behind the software, the science. This is classic C9. Yes, it's raining on us as we converse, but the view is spectacular with Sydney's Opera House behind us. It's funny how wet we were by the end of this interview, but the rain was refreshing—just like the conversation.

Thank you, Simon and John, for the great conversation, for being so comfortable in the rain, and for taking the random questions in stride. You're true gentlemen. Keep pushing the envelope!

Happy holidays from Channel 9 wherever you are and whatever, if anything, you're celebrating!

The YOW! Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies, and methodologies for building innovative software solutions as well as the chance to meet and network with international software experts and other talented developers in Australia. Thanks to Dave Thomas and the event's excellent staff—Mary Catherine (MC), Lisa, Aino, Melissa, and others—for inviting me to this excellent pure developer event and thanks to all of the speakers for letting me take some of their time to record conversations for Channel 9. If you live in Australia, or aren't too far away, or just like to travel (who doesn't?), then you need to go to this yearly event. It's outstanding. There are many great developers down under. That's for sure. The speakers are exceptional—Dave and team set a high bar!

YOW! 2011: Simon Peyton-Jones - Closer to Nirvana

Charles — Thu, 15 Dec 2011 19:52:04 GMT

I caught up with Simon Peyton-Jones, author of the Glasgow Haskell Compiler (GHC) and a key contributor to the Haskell functional programming language, at YOW! 2011. Simon is a pure functional guy. That said, he's OK with side effects as long as you can control them (so, monads are great!).

Simon works at Microsoft as a research scientist in MSR. Simon's work on Haskell is legendary and the language has seen an increase in usage over the years and a steady evolution toward being not only a general purpose, strongly-typed functional programming language, but also a practical one. No longer is Haskell suited only for academic experimentation (though this continues to be an important aspect of the language—in fact, it's one of the very effective ways the language is pushed forward). As Simon says, Haskell is like a laboratory in which to test new functional ideas and novel language constructs.

One of the very interesting aspects of Haskell is how the surface language (so, the syntax you write) is boiled down to a very small intermediate language, System F. Simon spends a nice chunk of time in this conversation explaining this. It's a rather excellent approach. We only touch on C--, but I have a feeling I'll be interviewing Simon again in the future.

How has the language evolved over the years? What's Simon working on these days (besides evolving Haskell, he's helping to make general purpose computing education for the masses much better!)? What's next? What are the big problems he and others are tackling with respect to moving Haskell forward? As always, it's a real pleasure to converse with and learn from Simon. His passion, enthusiasm, and intelligence are infectious (well, maybe not the intelligence part—you're born with the smarts you have. So, I didn't get smarter by talking with Simon, but I sure learned a lot!). Very few people are able to explain complex concepts in ways mere mortals can understand and assimilate. Simon is one of these people.

(Here's the video referenced at the beginning of this conversation.)

Simon's YOW! speaker page

Tune in. Enjoy. Learn.

The YOW! Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies, and methodologies for building innovative software solutions as well as the chance to meet and network with international software experts and other talented developers in Australia. Thanks to Dave Thomas and the event's excellent staff - Mary Catherine (MC), Lisa, Aino, Melissa, and others - for inviting me to this excellent pure developer event and thanks to all of the speakers for letting me take some of their time to record conversations for Channel 9. If you live in Australia, or aren't too far away, or just like to travel (who doesn't?), then you need to go to this yearly event. It's outstanding. There are many great developers down under. That's for sure. The speakers are exceptional—Dave and team set a high bar!

C9 Lectures: Graham Hutton - How To Be More Productive

Charles — Wed, 30 Nov 2011 11:18:09 GMT

It's been far too long since we've had some meaty functional programming content on C9. Luckily, none other than Graham Hutton dropped off a present on our doorstep! Dr. Hutton graciously provided Channel 9 with his latest self-filmed lecture—thank you, Graham! We're honored. This is certainly a treat and we appreciate it. For all of you out there interested in FP, this one's for you, and it's from one of the functional domain's titans.

Graham's goal here is to share technical knowledge and insights that span programming domains and skill sets—an excellent goal and one that we at Channel 9 fully support!

Enjoy. Learn!

From Dr. Hutton:

Streams, or infinite sequences, have many applications in programming, and can naturally be defined using recursive equations. But how do we ensure that such equations make sense, i.e. that they actually produce well-defined streams? In this talk, Graham Hutton presents a new approach to this problem, based upon the topological notion of contractive functions on streams. This talk is aimed at a general audience, and doesn't require special knowledge of topology or functional programming.

Lecture Materials:

Slides: http://www.cs.nott.ac.uk/~gmh/contractive.ppt

Paper: http://www.cs.nott.ac.uk/~gmh/contractive.pdf

Speaker Bio:

Graham Hutton is Professor of Computer Science at the University of Nottingham, where he co-leads the Functional Programming Lab. His research interests are in formal reasoning about program correctness and efficiency, with an emphasis on functional languages such as Haskell. He is also the author of a best-selling Haskell textbook, for which he's recorded associated Channel 9 lectures that have received more than 600,000 downloads.

MDCC TechTalk - Fun with type functions

martinesmann — Tue, 22 Nov 2011 21:40:51 GMT

by Simon Peyton Jones, Principal Researcher, Microsoft Research

Today's most widely used technology, by far, for static program verification is the ubiquitous type checker. Alas, static type systems inevitably exclude some good programs; and allow some bad ones. Thus motivated, Simon describes some fun he has been having with Haskell, by making the type system more expressive without losing the benefits of automatic proof and compact expression.

About Simon Peyton Jones

Simon Peyton Jones, MA, MBCS, CEng, graduated from Trinity College Cambridge in 1980. After two years in industry, he spent seven years as a lecturer at University College London, and nine years as a professor at Glasgow University, before moving to Microsoft Research (Cambridge) in 1998.

His main research interest is in functional programming languages, their implementation, and their application. He has led a succession of research projects focused around the design and implementation of production-quality functional-language systems for both uniprocessors and parallel machines. He was a key contributor to the design of the now-standard functional language Haskell, and is the lead designer of the widely-used Glasgow Haskell Compiler (GHC). He has written two textbooks about the implementation of functional languages.

More generally, he is interested in language design, rich type systems, software component architectures, compiler technology, code generation, runtime systems, virtual machines, and garbage collection. He is particularly motivated by direct use of principled theory to practical language design and implementation -- that's one reason he loves functional programming so much. His home page is at

http://research.microsoft.com/en-us/people/simonpj

MDCC TechTalk - Classes, Jim, but not as we know them

martinesmann — Tue, 22 Nov 2011 21:40:02 GMT

by Simon Peyton Jones, Principal Researcher, Microsoft Research

Haskell is now quite widely used, but its most important contributions are the ideas that it embodies. In this talk Simon focuses on one of these ideas, namely type classes, with a few anecdotes and reflections along the way about the process of developing the language.

Type classes are probably Haskell's most distinctive feature. The original idea is very neat and, better still, it led to a long series of subsequent generalizations and innovations. Indeed, although the language is now nineteen years old, Haskell's type system is still in a state of furious development. For example, Simon is involved in adding type-level functions to Haskell, as he briefly describes.

Simon explains what type classes are, how they differ from the classes of mainstream object oriented languages, why he thinks they are so cool, and what the hot topics are.

About Simon Peyton Jones

http://research.microsoft.com/en-us/people/simonpj

C9 Lectures: Dr. Ralf Lämmel - Going Bananas

Charles — Thu, 20 Jan 2011 19:53:14 GMT

Dr. Ralf Lämmel returns for an exploration of folds, aka bananas. This is lecture 5 in his C9 Lecture series covering advanced functional programming topics. Welcome back, Ralf! We're so happy to have you here!

Why bananas, Ralf?

Banana is functional programming slang for "fold"—an application of the catamorphic recursion scheme most widely known in the higher-order list processing tradition of Bird-Meertens Formalism and the Squiggol community. Erik Meijer used to be known as the "banana man" because of his early research on the subject; he also co-authored the seminal paper with theoretical (categorical) foundations on the subject. Incidentally, the paper used the notation of so-called "banana brackets" (instead of using the plain string "foldr"), which sort of explains why we sometimes say bananas. There is no shortage of crazy paper titles on the subject, by the way: "Functional Programming with Bananas, Lenses, Envelopes, and Barbed Wire," "Bananas in Space: ...," "Dealing with large bananas," "Boxes go bananas: ...," "See more through lenses than bananas," etc.

More to the point, foldr is the Swiss Army Knife in functional programming. Monoidal reductions of lists or mapping over lists and many other list-processing idioms can be modeled with the regular recursion operator foldr. Even a beginning lecture on functional programming would have to discuss foldr. Not discussing foldr in a Haskell course, however, is like not discussing for loops in a C# course. Indeed, the lectures on Graham Hutton's introductory Haskell course covered the basics of foldr very well. However, a lot more interesting stuff concerning folds or, say, bananas becomes apparent when one becomes fluent in functional programming. For instance, foldr and friends suddenly make sense for container types other than the concrete list type. Foldr and friends even generalize to arbitrary algebraic datatypes in different ways. The combination of folds and monoids also helps us understand key aspects of parallel data processing. These are the more advanced banana subjects that are covered by Ralf Lämmel's lecture this time. He has also contributed a stack of bananas papers over the years, and he draws from that interest.

Learn more:

Going Bananas lecture slide deck
Download source code for this lecture
Ralf's blog

For the exercises/riddles in the slide deck:

Slide number (complexity):

12 (medium)
18 (medium)
21 (medium)
23 (easy)
24 (hard)
31 (hard)
34 (easy)

C9 Lectures: Dr. Ralf Lämmel - The Quick Essence of Functional Programming

Charles — Wed, 22 Sep 2010 15:58:37 GMT

We had to cover monads eventually, and there are many great monad tutorials out there (see, for example, here: http://www.haskell.org/haskellwiki/Tutorials#Using_monads). In fact, there are web resources concerned solely with organizing the many monad tutorials available in the wild, and developing new monad tutorials seems to be a popular sport in the Haskell community.

Today, Ralf Lämmel's lecture goes back to the roots, essentially revisiting Wadler's "The essence of functional programming"—the 1992 paper that discovered monads and popularized their use in functional programming. Ralf Lämmel's lecture and accompanying code distribution show Wadler's seminal insight: those original scenarios and observations still make sense today. Indeed, Simon Marlow (a Haskell/GHC high priest @ MSR Cambridge) recently noted: "it's still the best monad tutorial" (see http://twitter.com/simonmar/status/21397398061).

Focusing on a few generically useful monads, Dr. Lämmel explains how the work within the interpretation domain. While the lecture also takes a look at the contemporary Haskell library for monads and monad transformers, there are obviously many monads and associated domains that cannot be covered this time. If you want to learn more about monads, then continue with state threads, IO, parsing, and concurrency (STM).

Slide deck:

http://developers.svn.sourceforge.net/viewvc/developers/repository/ralfs-channel9-lectures/decks/monads.pdf

Exercises/riddles:

Slide #4 (easy), #6 (modest), #13 (modest), #40 (hard)

Code distribution:

http://developers.svn.sourceforge.net/viewvc/developers/repository/ralfs-channel9-lectures/code/monads/

Blog post:

http://professor-fish.blogspot.com/2010/09/essence-of-essence-of-functional.html

C9 Lectures: Dr. Ralf Lämmel - Advanced Functional Programming - Evolution of an Interpreter

Charles — Tue, 31 Aug 2010 20:01:00 GMT

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).

Enjoy. Learn.

Thanks to Ralf for providing another excellent lecture!

Earlier lectures here.

Slides: https://developers.svn.sourceforge.net/svnroot/developers/repository/ralfs-channel9-lectures/decks/interpretation.pdf

C9 Lectures: Dr. Ralf Lämmel - Advanced Functional Programming - The Expression Problem

Charles — Tue, 10 Aug 2010 18:22:00 GMT

"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

Welcome to another series of C9 Lectures covering functional programming. For this series, Dr. Ralf Lämmel has generously taken the time to produce videos for Channel 9 from his office at the University of Koblenz-Landau (Germany), where he is a professor of computer science. The idea here is to take the next step from Erik Meijer's fantastic introductory series on functional programming. Accordingly, Ralf's series will dive into more advanced areas of functional programming, again focusing on the Haskell language (the functional concepts here span beyond any one functional language, however).

To begin, Dr. Lämmel teaches us about the Expression Problem. Now put on your thinking caps, make yourself comfortable, and enjoy this installment of functional programming lectures on Channel 9. Huge thanks to Dr. Lämmel, both for doing this series for Channel 9 and for filming and producing it all by himself! Finally, thanks to Erik Meijer for suggesting this series and putting me in touch with Ralf.

See Dr. Lämmel's blog post about the new lecture series here: http://professor-fish.blogspot.com/2010/08/lecture-series-on-advanced-functional.html

[Homework assignment is on slide 26 - Get the slides]

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 13 of 13

Charles — Thu, 24 Dec 2009 23:07:00 GMT

Well, my friends, the day has arrived. For thirteen weeks, you have been provided all the conceptual tools to take the leap into the deep end of the functional programming pool and float safely. The great Dr. Erik Meijer has generously given his value time to teach us the fundamentals as delivered by Graham Hutton in his book
Programming in Haskell. Of course, Erik merged his own extensive knowledge, unique perspective and experience into the educational weave: so, you got the best of two worlds. We hope you enjoyed this series, the first in a new a format of Channel 9 content (lectures).

The Channel 9 team and Niner nation thank our dear friend Erik for this stellar contribution to Channel 9 and programming education, generally. Of course, we also thank Graham Hutton for writing the book (and for guest lecturing Chapter 11) that Erik is both so fond of and which provided a basis for these lectures, which, by the way, were all done in true Channel 9 fashion: They were recorded in single takes with Erik doing a brilliant job articulating, contextualizing, expanding on the fundamentals and being, well, Erik, one of our favorite geniuses, all in real time.

In Chapter 13, Equational Reasoning (and also revealing why Erik says 'uhm' and 'you know' so often), the grand finale, Dr. Meijer digs into referential transparency and being able to replace equals by equals in all contexts.
In some sense, the purity inherent in functional languages like Haskell makes it easy to express and implement equational reasoning. In Haskell, our old friend "=" means "is equal to by definition". But what does equational reasoning
mean? It is clear that propositional logic is too weak for many applications and that equational logic is a first step towards a more powerful system*. Is it? Dr. Meijer, please do explain.

Tune in. Enjoy.

* source: http://www.cs.cmu.edu/~cdm/pdf/EquLogic.pdf

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 12 of 13

Charles — Fri, 18 Dec 2009 01:00:00 GMT

In Chapter 12, Lazy Evaluation, Dr. Meijer takes us on a journey into the world of order of evaluation (when expressions are evaluated). In the case of lazy evaluation, computation is delayed until the result of the computation is known to be required.

Most programming languages that most of you use day to day use eager or strict evaluation, which is the
opposite of lazy evaluation. In the strict evaluation world, expressions are evaluated as soon as they are bound to a variable (this is also known as greedy evaluation). In Haskell, laziness is first class!

Tune in. Learn and enjoy!

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Graham Hutton - Functional Programming Fundamentals Chapter 11 of 13

Charles — Thu, 10 Dec 2009 19:15:00 GMT

Yes. You read the title correctly! For today's lecture in the Functional Programming Fundamentals series of lectures the great Dr. Graham Hutton, author of the Programming in Haskell book that Dr. Erik Meijer has based this lecture series on, is guest lecturing Chapter 11 - The Countdown Problem! Thank you, Graham! What an honor and a treat to have you on Channel 9, especially in this context.

This lecture was filmed in Dr. Hutton's office at the University of Nottingham. What is the Countdown Problem, exactly? It's a numbers game, based loosely on a very popular television series. The point is that you will need to use, well, functions to solve the Countdown Problem. Of course, it goes without saying that Haskell is very well suited to solve these kinds of problems.

Tune in and learn from a Haskell master. It should be clear that you will want to have had gone through the earlier episodes (if you are beginning with functional programming and Haskell, specifically) to get the most out of this lecture. That said, it's quite amazing to learn directly from the author himself. What a nice surprise!

Enjoy!

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 10 of 13

Charles — Tue, 08 Dec 2009 00:38:00 GMT

In Chapter 10, Declaring Types and Classes, Dr. Meijer teaches us about type declarations, data declarations, arithmetic expressions, etc. In Haskell, a new name for an existing type can be defined using a
type declaration:

type String = [Char]

String is a synonym for the type [Char].

Like function definitions, type declarations can also have parameters. Type declarations can be nested, but
not recursive.

Nested:

type Pos = (Int,Int)

type Trans = Pos -> Pos

Illegal recursion:

type Tree = (Int,[Tree])

A completely new type can be defined by specifying its values using a data declaration:

data Bool = False | True

Bool is a new type, with two new values False and True.

Get the presentation slides here

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 9 of 13

Charles — Thu, 26 Nov 2009 18:48:00 GMT

In Chapter 9, Interactive Programs, Dr. Meijer will teach us how to make programs in Haskell that are side-effecting:
interactive. Haskell programs are pure mathematical functions with no side effects. That said, you want to be able to write Haskell programs that can read input from the keyboard and write output to the screen which are in fact side effects. So, interactive programs have side effects... Interactive programs can be written in Haskell by using types to distinguish pure expressions from impure actions that may involve side effects.

Consider the following:

IO a
The type of actions that return values of type a

IO Char
The type of actions that return a character

IO()
The type of purely side effecting actions that return no result value|

Warning: This lecture may contain the use of the term Monad. Do not fear. Everything will be OK.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Get the presentation slides here

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 8 of 13

Charles — Thu, 19 Nov 2009 18:55:00 GMT

In Chapter 8, Functional Parsers, it's all about parsing and parsers. A parser is a program that analyses a piece of text to determine its syntactic structure. In a functional language such as Haskell, parsers can naturally
be viewed as functions.

type Parser = String -> Tree

A parser is a function that takes a string and returns some form of tree.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Get the presentation slides here

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 7 of 13

Charles — Thu, 12 Nov 2009 16:42:00 GMT

In Chapter 7, Dr. Meijer teaches us about Higher-Order Functions. A function is called higher-order if it takes a function as an argument and returns a function as a result:

twice :: (a -> a) -> a -> a
twice f x = f (f x)

The function twice above is higher order because it takes a function (f x) as it first argument and returns a function (f(fx))

Dr. Meijer will elaborate on why higher-order functions are important and there are some really interesting side-effects of higher-order functions such as defining DSLs as collections of higher-order functions and using algebraic properties of higher-order functions to reason about programs.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 6 of 13

Charles — Thu, 05 Nov 2009 15:53:00 GMT

In Chapter 6, Dr. Meijer guides us through the world of recursive functions. In Haskell, functions can be defined in terms of themselves. Such functions are called recursive.

For example:

factorial 0 = 1
factorial (n+1) = (n+1) * factorial n

factorial maps 0 to 1, and any other positive integer to the product of itself and the factorial of its predecessor.

Some functions, such as factorial, are simpler to define in terms of other functions. As we shall see, however, many functions can naturally be defined in terms of themselves.

Properties of functions defined using recursion can be proved using the simple but powerful mathematical technique of induction.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 5 of 13

Charles — Thu, 29 Oct 2009 17:31:00 GMT

In Chapter 5, Dr. Meijer introduces and digs into List Comprehensions. In mathematics, comprehension notation is used to construct new sets from old sets. In Haskell, you can create new lists from old lists using a similar
comprehension syntax:

[x^2 | x <- [1..5]]

The above notation represents the list [1,4,9,16,25] of all numbers x^2 such that x is an element of the list [1..5]. The <- [1..5] syntax is known as a
generator and list comprehensions can have mulitple generators that can have explicit dependencies on other generators. You will also learn about
guards, which restrict values created by earlier generators.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 3 of 13

Charles — Thu, 15 Oct 2009 15:46:00 GMT

In Chapter 3, Dr. Meijer explores types and classes in Haskell. A type is a collection of related values and in Haskell every well-formed expression has a type. Using type inference, these types are automatically calculated at run time. If
expression e returns a type t, then e is of type t, e :: t. A function is a mapping of one type to another type and you will learn about new types of functions in this lecture, specifically curried functions: functions that return functions as a result (and
functions are values, remember) and polymorphic functions (function with a type that contains one or more type variables).

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 2 of 13

Charles — Thu, 08 Oct 2009 15:33:00 GMT

In Chapter 2, Dr. Meijer introduces Haskell syntax and notation (via a Haskell implementation called Hugs, to be precise, which is based on Haskell 98) and we learn about the Haskell syntax that represents the fundamental construct of functional programming:
functions. It's not like you're used to in mathematics like f(x). Instead, in Haskell, a function is denoted without parentheses:
f x. So, given the almost OCD requirement by Haskell language designers to eliminate
any unnecessary clutter in the language, parentheses are replaced by space. Also, in mathematics, you're accustomed to multiplication expressed either as xy or x y. In Haskell, since space denotes a function, multiplication is denoted with a *, like
x*y...

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 1 of 13

Charles — Thu, 01 Oct 2009 15:50:00 GMT

Welcome to a new technical series on Channel 9 folded into a different kind of 9 format: C9 Lectures. These are what you think they are, lectures. They are not conversational in nature (like most of what you're used to on 9), but rather these pieces are entirely focused on education, coming to you in the form of a series of high quality technical lectures (1 or more per topic) on a single topic.

We kick off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

Lecture Context:

Over the past two years, you've learned a fair amount about the functional programming paradigm's foray into general purpose imperative progamming languages (LINQ, Lambda's, etc in C# and VB.NET). And, of course, the newest language to join the Visual Studio family of languages, F#, is a functional language. You've heard us say how important functional language constructs are to the our current languages' capabilities to evolve in the right direction to meet the needs of the many-core future (the need for reliable and comprehensible concurrency, parallelism, etc) and, most importantly, to help vault computer programming into an age of compositionality (remember our talks on 9 regarding composability and evolution of software engineering as an engineering discipline?). Well, we decided to take a step back and teach you the fundamentals of functional programming at a level equivalent to any university. We even have a text book and professor who will expand our minds.

Dr. Erik Meijer will teach us Functional Programming Fundamentals using Haskell as the language for understanding the basic functional principles (in fact, the specific language isn't all that important, but Haskell is a pure functional language so it is entirely appropriate for learning the essential ingredients of functional programming. It is also a relatively small language and should be easy for you to get up to speed with Haskell once you understand the Why, What and How that underlies all functional languages...).

In Chapter 1, Dr. Meijer takes us through the fundamental fundamentals of functional programming: The philosophy and history of functional programming. As you can imagine, these lectures will go deeper and deeper as the chapters progress, but you need to understand the philosophical and historical contexts. This will provide a nice layer of fresh conceptual soil in which to plant the seeds of understanding the technical details of functional programming, of functional reasoning.

Welcome to C9 Lectures. Enjoy and learn, learn, learn.

ALWAYS ask questions right here. Erik will answer them. Remember, he is professor Erik Meijer in this context and professors answer the questions of their students. Thank you, Erik, for doing this!

Welcome to C9 Lectures!

See the rest of this great series:

Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13

Parallel Performance Tuning for Haskell

Charles — Sat, 12 Sep 2009 19:30:00 GMT

Very interesting work with implications for integration into more mainstream runtimes... In general, runtime support for parallel tuning is necessary going forward. The Many Core age has only just begun... This paper is a great read.

Parallel Haskell programming has entered the mainstream with support now included in GHC for multiple parallel programming models, along with multicore execution support in the runtime. However, tuning programs for parallelism is still something of a black art. Without much in the way of feedback provided by the runtime system, it is a matter of trial and error combined with experience to achieve good parallel speedups.

This paper describes an early prototype of a parallel profiling system for multicore programming with GHC. The system comprises three parts: fast event tracing in the runtime, a Haskell library for reading the resulting trace files, and a number of tools built on this library for presenting the information to the programmer. We focus on one tool in particular, a graphical timeline browser called ThreadScope.

Erik Meijer and Matthew Podwysocki - Perspectives on Functional Programming

Charles — Tue, 24 Mar 2009 15:50:00 GMT

Matthew Podwysocki is a senior consultant for Microsoft platform technologies in the D.C. area. He's been programming since he was a child and has a particular interest and passion for functional programming. Functional programming is all the rage these days. General purpose imperative languages (like C# and C++) are adding functional constructs to help improve software developer prodcutivity in an increasingly concurrent general purpose computing environment as notebooks and PCs with multiple processors are now the norm.

Matthew was in Redmond a few weeks ago, so we thought it would be awesome to invite Matthew into the the lair of our resident functional programming extremist (though I must say that Erik is mellowing out with age), high priest of the lamda calculus, category theorist and Expert to Expert host, Erik Meijer. Now, it's a little scary to be asked into Erik's den of functional orthodoxy (aka Erik's office) and be put to the task of explaining functional principals in a way that is widely accessible to developers who have little or no experience with thinking functional, but Matthew was up for the task and spends most of the time at Erik's whiteboard explaining important functional programming concepts (Haskell and F# are the languages used in the examples, but the language isn't that important - the concepts are), sharing some his very interesting history with us, waxing on future directions in programming, engaging us in a really interesting conversation. Great job, Matthew!

Enjoy!

Duration: 1:07:41