Runar Bjarnason is a software developer at Capital IQ, a global provider of data and analytics for financial professionals. Runar is a contributor to the open source Scalaz library, and co-author of "Functional Programming in Scala" (Manning, 2013).

Here, we discuss - what else - functional programming. Tune in!

Has Erik changed his mind about rampant side effects and imperative programming? What's going to happen to the poor monkey Rich Hickey made reference to several times in his excellent talk The Database as a Value (which he presented after Erik's talk)? Is Erik still a functional programming fundamentalist? Watch and decide. As you'd expect, it's high energy, brilliant Erik all the way.

Get Erik's slides.

Tune in. Enjoy.

Here is C9's recording of Rich's most recent talk on a new approach to database design and general purpose programmability. This happened at GOTO Chicago Functional Programming Night, sponsored by Dave Thomas.

You can see Rich and Erik Meijer discussing Clojure and Datomic here.
Read the "Out of the tar pit" paper Rich mentions at the beginning of the talk.

Rich Hickey - The Database as a Value

Abstract:

Proponents of functional programming tout its many benefits, most of which are available only within a particular process, or afforded by a particular programming language feature. Anything outside of that is considered I/O, dangerous and difficult to reason about. But real systems almost always cross process and language boundaries, and most require, crucially, a very gnarly bit of shared state - a database. In this talk we will examine how Datomic renders the database into that most prized and easy-to-reason-about construct, a value, and makes it available to multiple processes in multiple languages, functional and not.

Along the way, we'll discuss the importance of immutability and time in representing information, the reification of process, and the mechanisms of durable persistent data structures. No knowledge of functional programming is required.

Thanks to Dave Thomas for hosting C9 at this affair. We're lucky to have such a great supporter!

PS: The GOTO conference is coming to Chicago in 2013. Erik and Rich will be there along with several other great speakers.

Tune in. Enjoy. Learn.

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!

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!

It's been WAY too long since we've had Brian Beckman sharing knowledge, insights and perspectives on Channel 9. This changes now!

Needless to say, I was incredibly happy to spend an hour with Brian learning all about what he's up to these days. Not surprisingly, he's writing code and employing Rx and monads to solve very interesting problems. In this conversation (a code lesson, algorithm survey, a splash of random topical diversion), Brian explains and demonstrates his latest endeavor: implementing the Viterbi algorithm in C#. What's the Viterbi algorithm, Brian? What are hidden Markov models? What are you using this stuff for? Where does Rx fit into this? What's going on? By the way, it's awesome to learn that a Niner has been sharing C# monadic implementations with Brian (state monad, maybe monad).

Of course, no conversation with Brian - a physicist by training and a software architect at Microsoft - is complete without talking about some current physics problem: Finding the elusive Higgs Boson is all the rage these days, so we talk about what it means.

Brian also shares insights on Haskell, functional and hybrid programming languages (C# is imperative, but it provides functional capabilities like LINQ, for example, upon which Rx is built (Rx is LINQ-to-Streams or observable sequences of events, really)...). We also finally discuss his previous work at MS that we never got a chance to talk to him about while he was doing it. Before joining the Bing Mobile team, Brian was working on a project to create a new functional programming language. What was it?

Thank you, Brian!

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


Notes and More:

The code Brian demos (download it, unzip it, launch VS, open the solution, then watch this video and play along): https://github.com/rebcabin/DotNetExtensionsImproved

From Wikipedia - information on Markov and Viterbi:

A hidden Markov model (HMM) is a statistical Markov model in which the system being modeled is assumed to be a Markov process with unobserved (hidden) states

The Viterbi algorithm is a dynamic programming algorithm for finding the most likely sequence of hidden states – called the Viterbi path – that results in a sequence of observed events, especially in the context of Markov information sources, and more generally, hidden Markov models.

Thanks again for creating and continuing to evolve LINQPad, Joe!!

Joe'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!

(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!

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.

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

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

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

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)

Herb Sutter is an Architect on the VC++ team, chair of the C++ Standards Committee, a polished technical speaker and a super capable programmer. He is an ardent advocate of native code and works with the industry to move C++ in the direction it needs to go as general purpose computing evolves. As you know, Erik Meijer is a functional programming fundamentalist, a C9 celebrity, a master of mathematical duality and an unusually productive innovator (LINQ, "Volta," and Rx, are a few of his recent accomplishments). Erik is also the Chief Interrogation Officer for C9's Expert to Expert series. In this case, given functional programming's conceptual fingerprint showing up in almost all general purpose programming languages, including C++ with the addition of lambdas, putting Erik and Herb in the same room was sure to create some geeky technical magic. This post captures exactly what happened, unedited and raw. It's one of the best E2Es to date! Thank you, Erik and Herb! Keep pushing the envelope.

Tune in. Enjoy. Learn.

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

"Hey Bart, what is MinLINQ, exactly?"

"MinLINQ is an implementation of the LINQ to Objects Standard Query Operators using a function-oriented layered approach. Based on three essential operators called Ana, Bind and Cata, others are implemented. While the current implementation focuses on IEnumerable<T> exclusively, the same layering can be used to a dual IObservable<T> implementation."

Sit back, relax and jump into the layered functional rabbit hole where we meet some interesting characters named Ana, Bind and Cata. It's all about the essence, Alice.

Happy New Year!

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