[IronPython] IronPython / DLR Direction

Tony Meyer tony.meyer at gmail.com
Mon Aug 9 06:43:58 CEST 2010

On Sun, Aug 8, 2010 at 6:19 AM, Jeff Hardy <jdhardy at gmail.com> wrote:
> if [Iron*] die, doesn't that mean MS made the right choice after all?

I don't think that's true.  .NET isn't just another platform - it's
Microsoft's own platform.  Some thoughts:

Like it or not, and whether it *should* be the case or not, in many
organisations (or even teams) if a technology is from Microsoft then
it's automatically approved, or at least much easier to approve.  The
barrier to using Iron* is much lower because they are Microsoft
products - this is even more the case with Visual Studio integration.

Although Iron* are open-source (which is great, obviously), they
aren't typical open-source communities, because of the (somewhat
understandable) restriction about accepting code, and the leadership
all (AFAIK) being within Microsoft.  Microsoft have created this
environment (which has worked fairly well so far), and it's not clear
how easily that can transition to something that's lead by someone (or
ones) outside of Microsoft.

Leadership (or at least involvement) within Microsoft opens
opportunities for Iron* development to influence .NET.  I'm not overly
familiar with the details, but I gather than the DLR approach is
significantly superior to the IPy 1 CLR approach, and that some of the
new dynamic features of C# have benefited from this.  It's hard to see
how a community IronPython could have developed the DLR, and it seems
unlikely that Microsoft would make changes to the CLR to assist it.
(Does the latest Microsoft Javascript engine use the DLR (Managed
JScript?) - if so, then there's hope, I guess).

Projects often need 'angels', especially in the early stages (and I
would argue that Iron* are still in early stages).  Working on a
project of this size takes a lot of resources, and having corporate
sponsors makes that a lot easier.  Would Python have succeeded if CWI,
CNRI, and BeOpen hadn't supported Guido (and others)'s work in the
early days?  These days the PSF takes this role, but projects need
time to build to that sort of size.

[Iron]Python (I don't really know much about [Iron]Ruby) is a great
language for beginners (students, kids, hobbyists, etc).  The Iron
variants provide a very smooth path into other .NET development (e.g.
C# - which I would say is not at all a great beginner's language).
You could argue that Visual Basic provides this functionality as well
- I personally find Python much superior to Visual Basic, and since
nearly all other BASIC variants are dead now, it doesn't provide an
easy road into the .NET world (you have to start there with an
unfamiliar language).

This last point is the most relevant to me.  Over the last few years,
NorthTec have switched to using CPython as the first-course
programming language, and IronPython as the second-course language.
The students *need* to end up with some .NET and Visual Studio
experience, because realistically that's what they are most likely to
come across in the real world.  Many of the students are not capable
of starting with C#.  If IronPython wasn't a Microsoft project, it
would have been considerably more difficult to adopt it - that would
likely have meant using Visual Basic (possibly in both courses,
because these students struggle learning two languages in their first
year).  Although this is my unique case, I suspect that there are
similar ones, where being a Microsoft product is a deciding factor in
whether Iron* can be used (which then impacts the adoption of the
language, and therefore whether the language survives).

> I think Microsoft is throwing their weight behind JavaScript as their
> dynamic language of choice, and I can't really blame them.

My hope is that Microsoft realises they have enough weight to throw it
in more than once place.

(My longer hope, which I know is quite unlikely, is that Windows 8 or
9 includes some version of Iron* out of the box, like OS X includes
Python/Perl/PHP/Ruby/etc.  Being able to distribute .py[co] files
rather than .exes would significantly help Iron* adoption IMO (and
this is something completely impossible for a non-Microsoft Iron*).  I
know some people must like PowerShell and similar things could be done
with it, but it's not the same as having a language with the power and
cross-platform nature of Python).


More information about the Ironpython-users mailing list