Archives for posts with tag: Erik

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

November 26, 09 //

Comments Off

We’ve kicked 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).

We will release a new chapter in this series every Thursday.

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

in reply to C9 Lectures: Dr. Erik Meijer – Functional Programming Fundamentals Chapter 9 of 13

C9 Lectures: Dr. Brian Beckman – Covariance and Contravariance in Physics 1 of 1

November 25, 09 //

Comments Off

By now, you know Brian Beckman given how many times he’s been featured on Channel 9 and, well, just how amazing he is. Brian is an astrophysicist and software architect currently working on a technology we can’t talk about…yet… :) Stay tuned for that. Dr. Beckman is the perfect choice for a new lecture in the C9 Lectures series. This is a single lecture, but there will be more interesting conversations to come on this deep and beautiful topic (in some sense, this is all about symmetry).

In the Rx interview with Brian and Erik Meijer, a short discussion on covariance and contravariance took place as a tangential topic (which often happens in real conversations – and we love that!). The concepts of co/contravariance can confuse and confound. Also, they are not just related to programming.

Here, Dr. Beckman teaches us about covariance and contravariance in physics. Are these universal properties? Do they apply to the mathematics of physics (from quantum mechanics to black holes) in the same basic way they do for general purpose programming with objects and lists, for example?

Tune in. This is a deep dive lecture and quite mathematical. Don’t be scared. As usual, Brian explains complex things in a readily understandable fashion for mere mortals. If you have no experience with math and physics, this may be a bit challenging, but certainly not entirely over your head.

Enjoy.

NOTE: You should download the supporting document and slides. This will help you learn faster!

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

November 19, 09 //

Comments Off

We will release a new chapter in this series every Thursday.

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

E2E: Erik Meijer and Dave Campbell: Data, Databases and the Cloud

November 14, 09 //

Comments Off

Dave Campbell is a Technical Fellow at Microsoft and long time database architect. Today, Dave works on the hardest problems facing SQL’s foray into the new world of cloud computing. His latest project in this space takes the form of SQL Azure. What is SQL Azure? What’s the different with the cloud and what we already experience with SQL server running in a clustered environment and reachable via the Internet? How does this focus on cloud computing and impact the evolution of database design? What’s going here? What’s next? Erik Meijer, de facto E2E host and language designer, interviews Dave to ge answers to some of these questions. Erik works for Dave, by the way, and as you can see that doesn’t stop Erik from asking more than softball questions.

Dave will be presenting at PDC09 in the Technical Leaders track. His talk will focus on ambient data and what this means for the evolution of ways to understand and shape the data this all around us using software. You should attend his session and come with questions if you are going to be at PDC. If you’re not going to be there, then make sure to ask Dave questions when he appears on Channel 9 Live!

Enjoy!

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

November 12, 09 //

Comments Off

We will release a new chapter in this series every Thursday.

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

Now, we do have a textbook and you should go buy it: The great Graham Hutton’s Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don’t need the book to learn a great deal from this lecture series since Graham’s website has all the slides and samples from the book as well as answers to the exercises. That said, it’s highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

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

November 5, 09 //

Comments Off

We will release a new chapter in this series every Thursday.

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

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

E2E: Erik Meijer and Burton Smith – Concurrency, Parallelism and Programming

November 3, 09 //

Comments Off

The great Burton Smith, Microsoft Technical Fellow and an international leader in high-performance computer architecture and programming languages for parallel computing joins functional programming purist and language design guru Erik Meijer to discuss several major themes of parallel computing and distributed programming. As always, you will get a lesson in history, present trends and future possibilities. This is simply an awesome and deeply wonderful conversation. Burton is a treasure.

Erik shows up for the conversation only after Burton begins to talk about a potential definition for functional programming. Right on queue, Erik arrives!

Burton will be presenting his thinking on parallel and concurrent programming at PDC09. He will also be a panelist on the Future of Programming panel (and Erik will be the panel moderator - you won’t want to miss the panel if you are attending PDC!).

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

October 29, 09 //

Comments Off

We will release a new chapter in this series every Thursday.

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

Now, we do have a textbook and you should go buy it: The great Graham Hutton’s Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don’t need the book to learn a great deal from this lecture series since Graham’s website has all the slides and samples from the book as well as answers to the exercises. That said, it’s highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

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

October 22, 09 //

Comments Off

We will release a new chapter in this series every Thursday.

In Chapter 4, Dr. Meijer teaches us about the art and practice of defining functions. Functions can be defined using conditional expressions and in Haskell conditional expressions must always have an else clause. Functions can also be defined using guarded equations and pattern matching. You will learn about list patterns and integer patterns. Today is also the day that you will learn about lambda expressions and sections.

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

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

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

October 15, 09 //

Comments Off

We will release a new chapter in this series every Thursday.

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

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

Tags