More Goodies from the Microsoft

It has been long since last time anything has been posted onto this site. Remaining very busy, I could not resist to share about lectures dealing with the functional programming available on Channel 9.

The lectures are given by Dr. Erik Meijer and are entitled:Functional Programming Fundamentals.

More goodies from MS

My interest in software scalability and performance often leads me to Microsoft's Parallel Framework Extensions team BLOG, which recently published this great presentation from their parallelism tour...

How Does Functional Programming Affect Your Code?

F# has done a lot of good propagating functional programming style into the .NET world. From my experience, once you have used functional language your OO techniques are bound to change. This article by Matthew Podwysocki expresses exactly that. Enjoy!

Paralell Extensions for .NET

In case if you have not noticed Parallel Extensions for .NET got released!

You can check them in action implementing e.g.

• Ray Tracing
• Mandelbrot Fractals
  

Goodies from MS Labs

There are a lot great ideas developing in Microsoft Labs. Inspired by several posts I read I went to check the projects up and found at least two of interest...

Monads Explained

Check this out! After series of video interviews posted on Channel 9 after the JAOO conference, there is this new video post, in which Dr Brian Beckman explains why we should not fear the Monads...

During his brief lecture, Brian explains the most feared MONAD theory in the friendly way to the imperative programmer.

After my own experience with functional programming, I love this video as it managed to explain the hard saleable, good reasons for adopting functional programming styles. The beauty of implementing generic/meta functionality is something close to my heart. So to be able to see the two worlds closing to each other:

1. bottom-up: add necessary abstractions on top of the hardware to perform well
   
2. top-down: extract abstractions from a mathematical model to make things execute not necessarily in the best performing way
   

is a real bless. And the point they meet is F# at the moment.

The things to remember is

Tackle complexity through composability

and

LINQ is monads in action

Concurrency paradigm shift

Check this up - JAOO 2007. Channel9 interviewers highlight the fact that we might be facing paradigm shift. In their opinion hardware has not changed dramatically over past 20 years mainly adding processing speed and decreasing sizes...

This supported statically typed, imperative languages. Now, when the limits seemed to be touched, multicore technology is being rolled out, which will bring the revolution. The era of functional languages and dynamic typing seems to come upon us ;)

Here are the links to follow:

Bob Martin and Chad Fowler - Debating Static versus Dynamic Typing

Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 1

AOO 2007: Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 2

Erik Meijer and Dave Thomas - Objects, Functions, Virtual Machines, IDEs and Other Fun Stuff

PFX, PLINQ and TPL

You must take a look at the Programming in the Age of Concurrency by Anders Hejlsberg and Joe Duffy: Concurrent Programming with PFX posted on Channel 9...

It is great to see this natural, one would think, progression of lambdas into task managing, which no doubt will be simplifying concurrent implementations. Think mutexes, semaphores, critical sections, monitors, locks, threads etc. being hidden behind API simply accepting lambdas expressing your execution requirements. The same with workload control and optimization. This looks fantastic.

Here are some more links to Joe's articles, simply copied from his blog:

1. Parallel LINQ: Running Queries on Multi-Core Processors. An overview of an implementation of LINQ-to-Objects and -XML which automagically uses data parallelism internally to execute declarative language queries. It supports the full set of LINQ operators, and several ways of consuming output in parallel.
2. Parallel Performance: Optimize Managed Code for Multi-Core Machines. Describes the Task Parallel Library (TPL), a new "thread pool on steroids" with cancellation, waiting, and pool isolation support, among many other things. Uses dynamic work stealing techniques (see here and here) for superior scalability.

By being declarative and not over specifying, isn't functional approach way for the future?

PS. Have you tried F#, which just went into production?

Is future functional?

Paul's article made me write this entry, to challenge my long living inner feelings about the future for functional programming.

It is thanks to Luke Evans, that I got introduced to the world of Lambda. He is the author of CAL Haskell like language, which I had a chance to use to evaluate various ideas. My OOP background has not really prepared me well, for a universe, where function has a privilege of being a first class citizen. So after dealing with STL, being under the influence of Andrei Alexandrescu book about Modern C++ Design and his LOKI C++ library; the only thing that came to mind then, that helped me accommodate functional concepts, was partial template specialization...

Ever since, I touched Haskell like code, I must admit - I have been affected and influenced by its consistency, preciseness and re-usability of constructs. I though that

functional was a real progression of dealing with abstractions and generalization in programming

I am not surprised therefore to see functional concepts popping into existence in other languages like:

• JAVA: generics (for support of type classes), closures
• .NET: LINQ
• C++ : concepts
  

I even casted more friendly eye, upon JavaScript, which can be considered functional, as this article nicely shows. Forgive my ignorance, but I am not mentioning here languages like ERLANG , OCAML or Python etc...

So, is future going to look functional?

Some suggestions can be found in this very interesting video lecture by Philip Wadler about "Faith, Evolution, and Programming Languages". , which is made available on Google Tech talks.

Another interesting video discusses "Software Composability and the Future of Languages" and shows recorded conversation of such software gurus like Anders Hejlsberg, Herb Sutter, Erik Meijer, Brian Beckman.

I wonder if the functional languages will bringing a panacea for hyper-threaded / multi-core CPU architectures as book "Programming Erlang" seems to hint.

Another interesting insights can be drawn from TIOBE's website showing programming community index (no surprises for May - it is Ruby on top).