Entries tagged with programming languages - Channel 9

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

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

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

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

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

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

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

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 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 5 of 13

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

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

E2E: Erik Meijer and Don Box - Perspectives on SOAP, Programming Data and M

Charles — Wed, 28 Oct 2009 16:52:00 GMT

Don Box is a Distinguished Engineer at Microsoft and has a rich history in the general purpose programming world. You remember SOAP, right? Don was one of the Gang of Four who designed SOAP. Don was also instrumental in the design and implementation of WCF. Don is currently building a new model-based data programming platform, code-named Oslo, along with a new language for describing data, M.

Erik Meijer, programming language and library designer, chats with Don about the history of SOAP, model-based programming, data and M. Don will be at PDC09 and in addition to giving his usual stellar performance as a session speaker, he will be part of the Future of Programming panel (a view into Microsoft's perspective on trends and possibilities for general purpose programming in the age of many-core and cloud computing).

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

Charles — Thu, 22 Oct 2009 18:34:00 GMT

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

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 3 of 13

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

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

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

Expert to Expert: Rich Hickey and Brian Beckman - Inside Clojure

Charles — Tue, 06 Oct 2009 17:29:00 GMT

Clojure is a dynamic programming language created by Rich Hickey that targets both the Java Virtual Machine and the CLR. It is designed to be a general-purpose language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming. Clojure is a compiled language - it compiles directly to JVM bytecode, yet remains completely dynamic. Every feature supported by Clojure is supported at runtime. Clojure provides easy access to the Java frameworks, with optional type hints and type inference, to ensure that calls to Java can avoid reflection.

Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.

Astrophysicist and Software Architect Brian Beckman interviews Rich Hickey to dig into the details of this very interesting language. If you don't know much about Clojure and the general problems it aims to solve, well, watch and listen carefully to this great conversation with plenty of whiteboarding and outstanding questions. Expert to Expert simply rocks! Thank you for spending time with us, Rich! Clojure is great!

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

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 and Paperback.

Hardback:

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

Paperback:

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

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

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!

Andrew Kennedy: F# Units of Measure

Charles — Tue, 22 Sep 2009 21:00:00 GMT

Floating point values in F# can have associated units of measure, which are typically used to indicate length, volume, mass, and so on. The built-in type float takes an optional unit-of-measure parameter, written in angle brackets, in a similar way that types such as IEnumerable take a type parameter, as in IEnumerable<int>.

By using quantities with units, you enable the compiler to verify that arithmetic relationships have the correct units, which helps prevent programming errors like the one that led to NASA's Mars Climate Orbiter being lost in September 1999. This was due to confusion between metric and so-called "English" units of measurement. The accident could have been prevented if the NASA engineers had been able to annotate their program code with units, and then employed static analysis tools or language-level type-checking to detect and fix any unit errors.

Andrew Kennedy is an MSR research scientist who implemented units of measure for F#. What did this involve? How does it work, exactly? What's next? Meet Andrew and learn all about F#'s latest language feature, units of measure.

Enjoy.

Information sources: http://msdn.com and http://blogs.msdn.com/andrewkennedy/

C# 4.0 Dynamic with Chris Burrows and Sam Ng

Charlie Calvert — Tue, 22 Sep 2009 19:10:00 GMT

In this video Microsoft developers Sam Ng and Chris Burrows discuss the new Dynamic feature that is part of the next version of C#. This feature provides enhanced interoperation with dynamic languages such as Ruby and Python, with dynamic models such as Silverlight JavaScript, and with COM objects, particularly those that you find in the Office APIs. With the addition of Dynamic to C# 4.0, it is now much easier to access Microsoft Office APIs from C#. Sam and Chris are both developers on the C# compiler team and both helped design the implementation of Dynamic found in C# 4.0.

Peter Villadsen and Gustavo Plancarte: X++ to MSIL

Charles — Tue, 01 Sep 2009 16:27:00 GMT

Dynamics Program Manager Peter Villadsen and Software Developer Gustavo Plancarte teach us about a new tool they've developed that translates X++ byte code into MSIL. We learn a lot of history along the way and gain insights into the process of taking X++ into the .NET age.

Microsoft Dynamics features a proprietary language called X++ (basically a superset of Java, with some strong data primitives added) and a complete stack (compiler, interpreter and debugger) that goes with it. The new feature Peter and team have developed is a tool to generate managed code from the X++ intermediate language produced by the X++ compiler. This will have profound impact on the performance of the business applications written in X++, and it very clearly points to where they'll be going in the next few releases of Dynamics Ax.

Tune in.

Expert to Expert: Web Programming, JavaScript with Types and Flapjax

Charles — Tue, 23 Jun 2009 18:21:00 GMT

Flapjax is a new programming language designed around the demands of modern, client-based Web applications. Its principal features include:

Event-driven, reactive evaluation
An event-stream abstraction for communicating with web services
Interfaces to external web services

Flapjax is easy to learn: it is just a JavaScript framework. Furthermore, because Flapjax is built entirely atop JavaScript, it runs on traditional Web browsers without the need for plug-ins or other downloads. It integrates seamlessly with existing JavaScript code and other frameworks. [Source = http://www.flapjax-lang.org/]

Shriram Krishnamurthi is one of the authors of Flapjax and was in town recently giving a series of lectures to fellow programming language researchers in MSR. Shriram is a professor of computer science at Brown University. Expert to Expert host and programming language designer Erik Meijer is also doing some interesting things with event driven reactivity (you'll learn all about this soon...) so the two language guys just had to chat and we had to film it. Tune in to see what happened in Erik's office over the course of an hour or so. A fair amount of time is spent discussing the reasoning behind and benefits of adding types to a language like JavaScript. It's an interesting idea, but what does it mean for web developers (who, potentially, adopted JavaScript for its wide open and highly dynamic characteristics in the first place).

As usual, there's no editing here. It's as though you just came along and watched the magic unfold. Much thanks to Shriram for taking the time to chat with us. Flapjax is impressive. Do give it a try, Niners.

Jimmy Schementi: Inside IronRuby

Charles — Wed, 10 Jun 2009 21:31:00 GMT

Jimmy Schementi is a Program Manager (and developer) on the IronRuby team. IronRuby is an Open Source implementation of the Ruby programming language for .NET, heavily relying on Microsoft's Dynamic Language Runtime. IronRuby is Ruby, but implemented on top of the DLR (which of course provides the capability for dynamic languages to interact with the BCL and CLR).

You've learned about the details of the DLR here on 9, which provides dynamic runtime support for .NET. IronRuby targets compatibility with the 1.8.x branch of Ruby modulo continuations. IronRuby is an implementation of Ruby version 1.8.6.

Here, Jimmy explains the thinking behind the IronRuby project. Why are we doing this, anyway? When/Why would Ruby developers use IronRuby? What's the current status of the project? What's the future hold for IronRuby? Tune in and learn about the past, present and future of IronRuby.

Useful Links:

IronRuby Homepage: http://ironruby.net/

CodePlex project (downloads, issue tracking): http://ironruby.codeplex.com/

Developer info (source code, developer docs): http://github.com/ironruby

VC 10: Stephan T. Lavavej and Damien Watkins - Inside STL

Charles — Thu, 21 May 2009 15:43:00 GMT

Visual Studio 2010 Beta 1 introduces a number of exciting new features for the C++ developer as we include a selection of goodies from the upcoming C++0x Standard. We have already heard about many of the language improvements (auto, decltype, lambdas, rvalue references, …) all of which can be put to good use when using the Standard Template Library (STL). Here, Visual C++ team members who work on the STL – Stephan (Dev), Damien (PM) and a cameo appearance by Usman (QA) – Usman works in our Canadian Development Center and unfortunately could not be onsite for the video - tell us all about the latest version of STL. We talk about how the language features are enabling many improvements to the STL, with performance being a big beneficiary. To realize these benefits we needed to update our STL implementation to leverage these new techniques, for example adding “move” semantics to STL containers. Additionally when users of our STL implementation add “move” semantics to their types that they store in our STL containers then we hook into these as well.

Learn more:

http://blogs.msdn.com/vcblog/archive/2009/04/22/decltype-c-0x-features-in-vc10-part-3.aspx

http://blogs.msdn.com/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx

http://blogs.msdn.com/vcblog/archive/2008/10/28/lambdas-auto-and-static-assert-c-0x-features-in-vc10-part-1.aspx

We did also mention lambdas, decltype, auto (and C++0x, generally) in a C9 PCP video from a while back:

http://channel9.msdn.com/shows/Going+Deep/Parallel-Computing-in-Native-Code-New-Trends-and-Old-Friends/

Luke Hoban: Latest version of F# Released - What's the story? What's next?

Charles — Wed, 20 May 2009 22:24:00 GMT

With the release of VS 2010 Beta 1 today, F# is officially a part of the in-box VS family in the sense that it ships with VS 2010 as a first class language for use in building your .NET projects that require the power and flexibility of the functional approach to program composition. For VS 2008, a great IDE and toolset that you have at your disposal today, you can install the equivalent version of F# that ships with VS2010 Beta 1 as an add-in install. Right on!

Here, F# Program Manager Luke Hoban talks with me about F#, generally and what people have been doing with it, the current state of the technology, what F# enables, etc. You'll even see some code Luke's written, but this is mainly an Old School Channel 9 conversation. You know the drill.

Enjoy.

Learn more:

Don Syme's announcement of the F# 2010 beta release: http://blogs.msdn.com/dsyme/archive/2009/05/20/visual-studio-2010-beta1-with-f-is-now-available-plus-matching-f-ctp-update-for-vs2008.aspx

The F# Dev Center: http://fsharp.net/

Luca Bolognese: C# and VB.NET Co-Evolution - The Twain Shall Meet

Charles — Wed, 13 May 2009 15:45:00 GMT

For most of their lifetimes, C# and VB.NET have evolved at their own pace and in their own ways (C# added iterators, VB.NET didn't. VB.NET added XML Literals, C# didn't. etc, etc...). Today, Luca Bolognese and team have embarked on a new approach to how .NET's premiere languages will evolve going forward: Co-Evolution. Essentially, new language/compiler features will be developed for each language concurrenly. No longer will C# get new language construct X while VB.NET adds Y. They will both get X (and they will both get Y). Anders Hejlsberg, the father of C#, now oversees both languages and will make sure that language innovations are developed for C# and VB.NET at the same time.

I visited Luca recently to get a sense of the rationale behind this new co-evolutionary approach to two very different languages. Why is co-evolution important? Why not just have the languages, which target different demographics (do they?), evolve in ways that match the needs their users? What's the story here? What's next?

Expert to Expert: Martin Fowler and Chris Sells - Perspectives on Domain Specific Languages

Charles — Mon, 11 May 2009 19:14:00 GMT

Microsoft Olso Program Manager Chris Sells and DSL expert Martin Fowler discuss the history and future of Domain Specific Languages (DSLs). This was filmed at DevCon 2009, which took place on the Microsoft campus in Redmond, WA, USA. For those of you who don't know, Martin Fowler is a legendary software engineer and one of the industry's most accomplished speakers. For the past few years Martin has spent a great deal of time thinking about and implementing DSLs. He's viewed, by his peers and the industry at large, as the de facto DSL guru. You should most definitely watch his talk from this year's DevCon.

Joe Mistachkin: Eagle - Extensible Adaptable Generalized Logic Engine

Charles — Thu, 07 May 2009 21:46:00 GMT

Eagle (Extensible Adaptable Generalized Logic Engine) is an implementation of the Tcl scripting language for the Common Language Runtime (CLR). It is designed to be a universal scripting solution for any CLS based language.

Joe Mistachkin, the creator of Eagle, sits down with me at Lang.NET 2009 to discuss the thinking behind Eagle, its history and future. Eagle is an open source project (here's the Codeplex project) with a Tcl-like license. Joe wants some help building more features into Eagle. If you're so inclined, Niners, give him a hand!

Enjoy!

Axum Published! Tutorial: Building your first Axum application

Charles — Thu, 07 May 2009 17:45:00 GMT

Not familiar with Axum? Here's a C9 interview with the Axum team to refresh your memory (it's a domain specific language for concurrent programming, formerly known as "Maestro", developed by the Parallel Computing Platform team).

Here, Axum PM Josh Phillips walks us through building a simple Axum application in just over 5 minutes. Josh builds a simple “math library” on agents and shows how easy it is with Axum to focus on your code and get parallelism and safety implicitly.

Axum Team Blog: http://blogs.msdn.com/maestroteam

-->Get Axum<--

Philip Wadler and Erik Meijer: On Programming Language Theory and Practice

Charles — Mon, 04 May 2009 17:02:00 GMT

Lang.NET Symposium 2009 was held on Microsoft's campus (make sure you watch the talks, which are available for your viewing pleasure). We were of course there and conducted several interviews with some of programming language design's brightest thinkers.

Here, Erik Meijer and Philip Wadler discuss the theory and practice of programming language design with C# program manager Mads Torgersen.

Philip is widely known for his significant contributions to functional programming (including Haskell and a classic book - Introduction to Functional Programming(Prentice Hall publisher) that is one of the best introductions to functional programming you can find) and programming language theory. You've learned about Mondas on Channel 9. Well, Philip is the guy that is in part responsible for their wide adoption in FP.

Erik, as you know by now, is co-creator of LINQ, functional programming master, creator of the now unnamed "Volta" technologies, and much more.

This is a great conversation on how theory winds its way into practice and how principles take time to embed themselves into modern language design (most modern languages are built on the ideas formed many years ago, as theoretical principles). Phillip and Erik also touch on langauge history and futures. Tune in.

Jason Olson: Composing Programming Languages, F# and OO

Charles — Fri, 01 May 2009 17:15:00 GMT

Jason Olson is a programming language evangelist in addition to his duties as a managed (.NET) tools evangelist. You know him from C9. He's a long time Niner and has always been passionate about languages. I've known Jason for a long time and it's great to see him take his passionate intelligence and apply it to both learning several languages and writing his own. This is awesome to see! I caught up with Jason at Lang.NET 2009 where he gave two very interesting talks, one on F# and one on modern object orientation. Here, we talk about his presentations and his perspectives on object orientation, F# and his own language.

Enjoy!

Gilad Bracha: Inside Newspeak and Objects as a Service

Charles — Thu, 30 Apr 2009 23:41:00 GMT

Lang.NET Symposium 2009 was held on Microsoft's campus (make sure you watch the talks, which are available for your viewing pleasure). We were of course there and conducted several interviews with some of programming language design's brightest thinkers.

Here, language design master Gilad Bracha discusses his Newspeak programming language. What is Newspeak and why was it created? What general problems does it solve that can't be done with already existing languages and tools? What does it facilitate, really? We dig into the fundamental ideas, history and future of Newspeak. Gilad was kind enough to keep the discussion at a level appropriate for a broad technical audience and not just for his fellow scientists.

Newspeak People say: "Like Self, Newspeak is message-based; all names are dynamically bound. However, like Smalltalk, Newspeak uses classes rather than prototypes. As in Beta, classes may nest. Because class names are late bound, all classes are virtual, every class can act as a mixin, and class hierarchy inheritance falls out automatically. Top level classes are essentially self contained parametric namespaces, and serve to define component style modules, which naturally define sandboxes in an object-capability style. Newspeak was deliberately designed as a principled dynamically typed language. We plan to evolve the language to support pluggable types."

If you want to understand the thinking behind the thinking of Newspeak, then tune in. Please go ahead and play around with Newspeak, Niners, and provide Gilad and team with feedback.

How far could the notion of Internet-distributed synchronizable objects, or objects as a software service, be taken?

Enjoy

Emmanuel Stapf: Eiffel and Contract Oriented Programming

Charles — Wed, 29 Apr 2009 18:43:00 GMT

The Eiffel programming language is an object-oriented language that is based on a fixed set of powerful principles like Design by Contract and Command-Query Separation. It's a very powerful language that has impacted the evolution of the more popular general purpose OO languages such as Java and C#. Here, one of the developers of Eiffel, Emmanuel Stapf, sits down with one of the C# language designers, Mads Torgersen, to discuss the language level code contracts in Eiffel and the general principles of contract oriented programming.

Anders Hejlsberg and Gilad Bracha: Perspectives on Programming Language Design

Charles — Tue, 28 Apr 2009 17:33:00 GMT