Here, we talk about functional programming—when to go functional and why—and Tony addresses some of the problems that face developers who want or need to go functional but possess only an imperative way of thinking when it comes to designing and writing software. It's the functional way of thinking that most newcomers to functional programming find most difficult. Of course, there's no conversation about functional programming without talking about monads, so we talk about monadic design (and definition).

Thanks for joining us on C9 Tony!

Tony's YOW! speaker page

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!

The fundamental concept here is the monad, and Greg has a novel and conceptually simplified explanation of what a monad is and why it matters. This is a very important and required first step in the series since the whole of it is about the application of monadic composition to real world web development.

In part 4, Greg primarily focuses on the idea that a monad is really an API—a view into the organization of data and control structures, not those structures themselves. In OO terms, it's an interface. To make this point concrete, Greg explores one of the simplest possible data structures supporting at least two different, though consistent, interpretations of the same API. The structure used, Conway's partisan games, turns out to be tailor-made for this investigation. Not only does this data structure have the requisite container-like shape, it provides opportunities to see just what's necessary in a container to implement the monadic interface. 

Running throughout the presentation is a more general comparison of reuse between an OO approach and a more functional one. When the monadic API is "mixed into" the implementing structure, we get less reuse than when the implementing structure is passed as a type parameter. Finally, doing the work puts us in a unique position to see not just how to generalize Conway's construction monadically, but also the underlying pattern that allows the generalization to suggest itself.

Source code for the Conway game
Slides for this presenation

See part 1
See part 2
See part 3

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)

The fundamental concept here is the monad, and Greg has a novel and conceptually simplified explanation of what a monad is and why it matters. This is a very important and required first step in the series since the whole of it is about the application of monadic composition to real world web development. 

In part 3, Greg continues to take us on a monadic journey, en route to the design of a composable web stack from client to database. This series is specifically about monadic design patterns and not implementation details using Scala and asscoiated dev tools. Open your minds and let the design pattern knowledge in.  

Shape. Wrap. Roll.

See part 1 
See part 2
See part 4

The fundamental concept here is the monad, and Greg has a novel and conceptually simplified explanation of what a monad is and why it matters. This is a very important and required first step in the series since the whole of it is about the application of monadic composition to real world web development. 

In part 2, Greg continues to take us on a monadic journey, en route to the design a composable web system from client to database and back. Tune in. Learn.

Shape. Wrap. Roll.

See part 1 first, if you haven't already...

See part 3

Greg has a very novel and conceptually simplified explanation of what a monad is and why it really matters. This is very important and a required first step in this series since this is all about the application of monadic composition to  real world web development. What does this mean? Why does it matter?

Tune in.

Let's see if Greg's monadic analogies prove helpful for everyday developers in getting their heads around the elusive and beautifully complex monad.

Shape. Wrap. Roll.

See part 2

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

IObservable<Html> q = from fragment in textBox

               from definitions in Dictionary.Lookup(fragment, 10).Until(textBox)

               select definitions.FormatAsHtml();

q.Subscribe(suggestions => { div.InnerHtml = suggestions; })

Exercise 2: go from labeling a tree to doing a constrained
container computation, as in WPF. Give everything a
bounding box, and size subtrees to fit inside their
parents, recursively.

Exercise 3: promote @return and @bind into an abstract
class "M" and make "SM" a subclass of that.

Exercise 4 (HARD): go from binary tree to n-ary tree.

Exercise 5: Abstract from n-ary tree to IEnumerable; do
everything in LINQ! (Hint: SelectMany).

Exercise 6: Go look up monadic parser combinators and
implement an elegant parser library on top of your new
state monad in LINQ.

Exercise 7: Verify the Monad laws, either abstractly
(pencil and paper), or mechnically, via a program, for the
state monad.

Exercise 8: Design an interface for the operators @return
and @bind and rewrite the state monad so that it implements
this interface. See if you can enforce the monad laws
(associativity of @bind, left identity of @return, right
identity of @return) in the interface implementation.

Exercise 9: Look up the List Monad and implement it so that it implements the same interface.

Exercise 10: deconstruct this entire example by using
destructive updates (assignment) in a discipline way that
treats the entire CLR and heap memory as an "ambient
monad." Identify the @return and @bind operators in this
monad, implement them explicitly both as virtual methods
and as interface methods.

The code used in the demo is available at http://blogs.msdn.com/daiken/archive/2007/06/22/hosting-windows-powershell-sample-code.aspx.

Participants:

Chris Avis  – TechNet Presenter

Paul Robichaux – Paul Robichaux is a partner in 3Sharp (www.3sharp.com), a contributing editor for Windows IT Pro magazine, a Microsoft MVP for Exchange Server , and the author of more than a dozen books on Windows and Exchange. When he’s not traveling the world speaking or consulting on Exchange, you can find him at home with family, playing with his kids, or just watching the world go by.

Christopher Budd – Christopher Budd is a Security Program Manager at Microsoft who works on the security team bringing you the monthly security bulletin.

Kai Axford – Kai Axford is a Sr. Security Strategist at Microsoft.

As we close out our Scripting month we thought it only appropriate to bring back everyone’s favorites, the Scripting Guys.  Hear what they are up to these days.  Kevin Remde speaks with them about such topics as PowerShell, VBScript, Compute Cluster Server, Windows Remote Management and Headless Servers.

Participants:

Continuing on our theme of Scripting for the month we speak with Don Jones, a noted guru in the world of Windows administrative scripting.  He breaks it down with Kevin Remde, guiding you on your quest to master scripting.

Participants: