Showing posts from June, 2009

The IronRuby Tutorial

Jimmy Schementi, program manager for the dynamic languages and Silverlight integration plus IronRuby developer, has pushed a new update to the IronRuby github repository . One of the major changes is improvements to the IronRuby tutorial app . "The" IronRuby Tutorial As you can see from the screenshot this is a WPF (Windows Presentation Foundation - which means it won't run on Mono) application which combines a tutorial with an integrated interpreter (REPL) for actually trying out the code: Isn’t he/she/it a bute!? This app makes Ruby-based tutorials interactive, guiding you through the material with a IronRuby REPL console and other visual aids such as another window, or whatever the tutorial writer sees fit. There is also a tutorial runner for the command-line, and a exporter for static HTML. The IronRuby tutorial included covers topics such as using the interactive window, built-in libraries, exploring .NET libraries, generics, events, Windows Forms, and Windows Pr

OS Jam at Google London: C# 4 and the DLR

Jon Skeet, author of the well regarded C# in depth , did a five minute talk on C# 4.0 and the Dynamic Language Runtime at a recent Google Open Source Jam in London. The 'innovative' slides are online, and they touch on details like the dynamic keyword, binders and IDynamicMetaObjectProvider . OS Jam at Google London: C# 4 and the DLR The fundamental point of the DLR is to handle call sites - decide what to do dynamically with little bits of code. Oh, and do it quickly. That's what the caches are for. They're really clever - particularly the L0 cache which compiles rules (about the context in which a particular decision is valid) into IL via dynamic methods. Awesome stuff. I'm sure the DLR does many other snazzy things, but this feels like it's the core part of it. At execution time, the relevant binder is used to work out what a call site should actually do. Unless, that is, the call has a target which implements the shadowy IDynamicMetaObjectProvider inter

New JavaScript Implementation for the DLR

The Dynamic Language Runtime was announced at the same time as Silverlight. Along with IronPython and IronRuby a third, Silverlight only, language was announced that ran on the DLR. This language was Managed JScript, an ECMA compliant version of Javascript that was touted as an easy way to port AJAX applications to run on Silverlight. Unfortunately as IronPython and the DLR developed Managed JScript stagnated. It was only ever released as binaries and hasn't been kept up to date with recent versions of the DLR. Someone called it the Bastard, red-headed step-child in the DLR . However, there is now an alternative implementation of JavaScript for the DLR: RemObjects Script for .NET: The free scripting engine for .NET RemObjects Script for .NET is an embeddable engine for .NET applications that allows developers to let their users introduce written scripts that influence the behavior of the application. The RemObjects Script engine is built in a language-agnostic way, so that diff

Twisted on IronPython

One of the big new features coming in IronPython 2.6 is optional support for Python stack frames (with a ~10% performance hit tracking the frames if it is enabled). With this in place Seo Sanghyeon, maintainer of FePy the community distribution of IronPython, has been looking at getting Twisted working with IronPython. Twisted is an open source event-driven networking engine written in Python. Seo posted this email to the IronPython mailing list: I have started porting Twisted to IronPython. Progress is to be tracked on this Trac ticket . There is a Buildbot running the Twisted tests with IronPython . Just in case you don't know, Twisted is an event-driven networking engine written in Python licensed under MIT license, which aims to destroy the American currency system. See following links for more details. Having frame support in IronPython opens up the possibility for Python debugging APIs, like s

NWSGI: New release and big improvements

NWSGI is " a .NET implementation of the Python WSGI specification for IronPython. It is implemented as an ASP.NET HttpHandler for use with IIS 6 and 7 " created by Jeff Hardy. The goal is to be able to run Python applications like Django, Trac and Pylons on IronPython. It can also be used on the Microsoft Azure (cloud computing) platform. Jeff Hardy has just released a beta of version 2.0, and explained the new features: NWSGI 2.0 Beta 1 This is a major update to NWSGI that makes it easier to install and use and dramatically improves the management story. So, what happened to 1.1? Originally, NWSGI 1.1 was going to be a refresh of v1.0 that supported IronPython 2.6 and fixed a few bugs. NWSGI 2.0 was going to completely overhaul large parts of the management UI and make some deeper changes to the handler itself. However, I got a week off with some rain and v2.0 progressed much quicker than expected; v1.1 was obsolete before it was even released. So, v1.1 was dropped and v

Choosing a DLR language: IronPython or IronRuby?

.NET developers interested in dynamic languages but still wanting to stay within the .NET ecosystem have an interesting choice - IronPython or IronRuby? Simon Segal, who has been adding scripting support to his Entity Framework profiler , has been pondering this question: Which DLR language should I choose? Is it now IronRuby vs. IronPython. For my part so far I have delved into IronRuby and started to employ it for scripting my C# applications. Why did I choose IronRuby over IronPython? It began with curiosity in the Ruby language in general and led inevitably to IronRuby. I quickly acquired a taste for Ruby but there is something nagging in the back of my mind and I can’t get to the bottom of it - “did I choose the right language” and really after all “does it matter which one I choose?” Given Pythons relationship to C and my emotional connection to the C family of languages, would IronPython have been a better choice? Certainly IronPython is further down the track and more mature

IronPython Performance: On Mono, on x64 and compared to C#

Everyone loves benchmarks, even though they are usually misleading at best. Of course I'm no exception. Here are three snippets of news on IronPython performance that have surfaced over the last week or so. IronPython 2.0.1 and 2.6 Beta 1 compared to CPython and Jython ( posted to Twitpic by felipez ) on Mono revision 136556: Using the pystones benchmark IronPython on Mono clocks in faster than CPython or Jython. Nice. One particular bugbear of IronPython performance has been startup time. On 64bit Windows the startup time goes from being merely bad to positively ridiculous. This is because the .NET 64bit JIT is slow to do its job and IronPython generates a lot of code needing to be JITed at startup. A lot of work has gone into IronPython 2.6 to improve startup time (by reducing the amount of rule generation done on startup), and this blog entry Dave Fugate explains something they have done specifically to address startup perf on 64bit Windows - and shows off the results: IronP

Python Support in Visual Studio

Many .NET developers (all too many alas) are not willing (or not allowed) to use any language that isn't integrated into Visual Studio. As IronPython is a dynamically typed language it is much harder to build full support into Visual Studio - although there have been two attempts so far (the SDK for Visual Studio 2005 and IronPython Studio for Visual Studio 2008). In this blog entry Dave Fugate (IronPython tester and infrastructure guy for Microsoft) explains the current state of VS support for Python and as Visual Studio 2010 approaches he looks to the future... Python Support in Visual Studio I think I speak for everyone on the IronPython Team when I say we’d love to see IronPython support in Visual Studio by default without the need for any language service addition. The thing is these types of decisions are made at a much higher level than us and are heavily influenced by business needs. What I’m getting at here is if enough people provided feedback via the proper channels

__clrtype__ Metaclasses: Positional Attribute Parameters

Harry Pierson (the IronPython Program Manager for Microsoft) has been exploring and explaining the new __clrtype__ feature coming in IronPython 2.6 (or already available if you are using the beta). When we last left him Harry had been creating Python classes with simple .NET attributes applied to members. In this post he delves further and applies attributes that take parameters: __clrtype__ Metaclasses: Positional Attribute Parameters The basic infrastructure for custom attributes in IronPython is in place, but it’s woefully limited. Specifically, it only works for custom attributes that don’t have parameters. Of course, most of the custom attributes that you’d really want to use require additional parameters, both the positional or named variety. Since positional parameters are easier, let’s start with them. Positional parameters get passed to the custom attribute’s constructor. As we saw in the previous post, you need a CustomAttributeBuilder to attach a custom attribute to an a

A Good Mix 12: Upcoming Presentations, XML Namespaces, ArcGIS and the Hungarian Phrasebook

Yet another selection of blog entries and articles relating to IronPython from the last few weeks. Upcoming Presentations - Summer Edition The Coding Geekette (Sarah Dutkiewicz) is a regular at .NET and Python conferences speaking, amongst other things, about IronPython. In this blog entry she lists her forthcoming talks: Cleveland .NET group (Python 101 for .NET developer) PyOhio 2009 (Pumping Iron into Python + IronPython Show & Tell) devLink (going cross-platform with C#) There is also quite a bit of IronPython content at the forthcoming EuroPython 2009 in Birmingam (28th June to 4th July): an IronPython tutorial , ArcGIS and IronPython talk , Introduction to IronPython talk , Ironclad talk and a general Python VM panel discussion . IronPython and XHTML A Japanese blog demonstrating how to load and save XML from IronPython - using the .NET APIs and working with namespaces. In this case he is iterating through a directory of XHTML files and adding valid namespace declarations

__clrtype__ Metaclasses: Simple Custom Attributes

One of the exciting new features in IronPython 2.6 is the addition of the __clrtype__ metaclass . This allows you to specify and customize the .NET type that backs your Python classes. This is important because by default new Python classes aren't also .NET classes. This is for various reasons: Python classes are mutable, .NET classes can't be garbage collected and so on. This causes one of the biggest gaps in the IronPython integration; using .NET attributes requires them to be applied to a real .NET class. There are other features, like some kinds of data binding, also a real .NET class. There are techniques to overcome this, but they're clunky at best. In IronPython in Action I demostrate runtime generation, compilation and subclassing of C# classes as one technique. At last the __clrtype__ metaclass provides a better way built into IronPython, but it is a pretty low-level feature requiring a lot of work to build on top of it. Harry Pierson, the IronPython program m

Embedding IronPython as a scripting language

Mark Bloodworth, Microsoft Architect Evangelist, shows how to use IronPython to add scripting to a .NET application. Embedding IronPython as a scripting language A great way of extending an application is to allow users to write their own scripts. Fortunately, with the Dynamic Language Runtime it is fairly simple to provide scripting in your application. Let’s look at how to do it with a simple Windows Forms application and IronPython. ... It’s simple to add powerful scripting support to your applications, while maintaining control over the scripting runtime means that you can restrict what any user entered code can do. I chose to show this example in IronPython, but the principles for doing this with Ironruby are identical (of course you’ll need a reference to IronRuby.) In fact, you could offer users the choice of languages.

IronRuby 1.0 (soon), Inside IronRuby and Professional IronRuby

IronPython 1.0, a complete implementation of Python for the .NET framework, was released in September 2006. The first IronPython 2.0 release (Alpha 1) came in April 2007. IronPython 2.0 was built on the new Dynamic Language Runtime (DLR) which was a framework for implementing dynamic languages in general, which had been abstracted out of the IronPython 1.0 release. Along with the new IronPython 2.0 project IronRuby was announced. IronRuby was an implementation of Ruby for .NET, led by John Lam who had previously been involved in the RubyCLR project. It has been a long road for IronRuby, with the latest release version 0.5. IronRuby 1.0 at OSCON 2009 Following their tradition of conference driven releases (panic-driven-development?) IronRuby 1.0 will be released at the coming OSCON 2009 conference: IronRuby is 1.0! Come and see how IronRuby is used in .NET programs, how well it performs, and how conformant it is. IronRuby is an Open Source implementation of the Ruby programming lang

A Good Mix 11: A Rules Engine, Embedding, SharePoint and NWSGI

Another selection of blog entries and articles relating to IronPython from the last few weeks. Umm... A blog entry from Dave Fugate (IronPython testing and infrastructure guy) on an exception message that shouldn't be visible. Looks like it is actually a bug in Vista, but as it was triggered by IronPython it gets a mention here: IronPython most definitely should not be able to spawn an error message box that's visible when Vista is locked at the username/password screen. Quite annoying yet very interesting at the same time... Use .NET classes in IronPython Another blog entry from Mark Bloodworth (a Microsoft Architect evangelist) on using IronPython. It demonstrates writing classes in C# and using them from IronPython. The entry is short because this is something that IronPython makes trivially easy: It’s really simple to use a .NET class in IronPython. The first thing to remember is that you’ll need to add a reference (just like you would in .NET). To do that you use the A

A New Book on IronPython: Pro IronPython

IronPython in Action may have been the first book (in English) on IronPython but it is no longer the only one. Pro IronPython, by Alan Harris for Apress , is now available. Pro IronPython by Alan Harris IronPython represents a unique direction for developers interested in working with dynamic languages within the .NET Framework. Whether you’re looking to develop applications from scratch or add functionality and maintainability to an existing application, IronPython opens many doors while providing a high–speed, high–performance language that integrates tightly with other .NET languages. Learn to create applications using the benefits of a dynamically typed language. Discover how to leverage the power of IronPython to improve existing applications. Explore interacting with other .NET languages by invoking the common language runtime. What you’ll learn Write IronPython console and forms applications. Integrate IronPython scripts into existing applications to increase their functionali

Mono can now compile IronPython 2.0

If you follow this blog, or the state of IronPython on Mono , you will know that the version of IronPython included in Mono (from the FePy project ) is quite out of date. This is because (for various reasons) Mono has been unable to compile IronPython 2.0 from source which has prevented a new FePy release. This causes a problem with running the IronPython in Action examples from Mono and I wrote a blog entry about how to work around this: IronPython in Action Examples on Mono The intention is that MultiDoc, along with as many examples from the book as possible, run on both Mono and the .NET framework; IronPython isn't just for Windows but can also be used on Linux and Mac OS X or anywhere that Mono will run. Some readers have reported that MultiDoc crashes on exit when run with Mono. The root cause of this is the old version of IronPython 2 that ships with Mono. ... This is reason enough to look at using a more recent version of IronPython 2. Even though IronPython can't b

Why Choose IronPython over C#?

Matthew Harelick just asked (on the Python.NET mailing list of all places) why he should consider using IronPython: My background is primarily UNIX. I have been programming in C, TCL, Perl, and Python in UNIX and Linux for a long time. I recently started working in Visual Studio and C#. Visual Studio and C# make everything very easy. Python was nice when you didn’t have the convenience of Visual Studio and intellisense with a nice debugger. In the windows world I see no major reason not to use C#. Why would I want to use IronPython? A lot of C# developers feel the same way, why should they consider another language? Here is my answer: Both Python and C# are 'general purpose' programming langugages suited to a wide range of problem domains. Choice of programming language is therefore usually a matter of aesthetics, what you are used to, personal workflow, issues within a team and so on rather than a matter of which is more appropriate to the job. Obviously there are

A Good Mix 10: WPF, .NET Introspection, the Solver Foundation, Resolver One and Cobra

Another selection on a wide range of topics from the last few weeks. Resolver One 1.5 Release Resolver One is an IronPython spreadsheet system and is the largest IronPython codebase in production. Normally a new release would be big news but we've already covered the Python console which is the biggest new feature in version 1.5. Other big new features include CSV import / export and a goto line dialog for the code editor. You can read a full list of all the improvements in the changelog . Now that 1.5 is out we're working hard on features for version 1.6. Our latest blog entry has a sneak preview of one of the coming attractions . Introspecting .NET Types and Methods from IronPython For Python methods you can use the inspect module to get information about methods / functions; like what arguments they take and so on. Methods on .NET types don't have the attributes used by inspect (although methods of Python objects defined in IronPython work fine). We can get around th

DateSelector and Excel COM Automation Examples

Greg Bray has been using IronPython since entering (and winning) a round of the Resolver Systems spreadsheet competition . Since then he has had fun experimenting with IronPython has posted a couple of fairly complex example programs to his blog. IronPython Excel Com Automation: Pivot this! I have been playing around with IronPython recently while creating spreadsheets in Resolver One . So far I have been having a lot of fun, but I haven't really been doing anything that would be useful in a work setting. The main reason for this is because most of the spreadsheet work that I do revolves around pivot tables and Auto Filter, which are immensely helpful for visually analyzing data. I thought I might try and use Excel's COM Automation to add Pivot Charts and Auto Filter to any system with IronPython, and here is the code that I have come up with so far. ... The code should be pretty straight forward. The Reload() method is helpful for reloading the whole module when testing fro

Microsoft and Open Source

Microsoft has an antagonistic history with open source to say the least. With posturing on Linux and patents still being in the very recent past the Microsoft of today still has a schizophrenic mindset on the topic. This is hardly surprising; Microsoft has bet the shop on desktop software and its major products have open source competitors (Windows -> Linux, Office -> Open Office, Visual Studio -> SharpDevelop, Eclipse and a thousand others). My experience of dealing with Microsoft and Microsoft employees has been very different, and very positive. IronPython is fully open source and was the first project to be released under Microsoft's OSI approved Ms-PL (Microsoft Public License). The members of the dynamic languages team that I have had dealings with understand open source and are committed to it; hardly surprising given that the project was established by Jim Hugunin a longstanding member of the Python community. Despite this the IronPython development process is

iLove Sharepoint Reads IronPython in Action and Announces IronSharepoint

Christian Glessner is head of development at Data One and a Sharepoint expert. Even before IronPython in Action came out he was experimenting with integrating IronPython with Sharepoint and he has now enthusiastically reviewed the book with this in mind: iLove Sharepoint: IronPython in Action IronPython In Action covers all you need to get started with IronPython for a .NET or Python developer. It is written coherently without needless ballast, well suited to the philosophy of the language itself. My favorite chapters are “ Silverlight: IronPython in the browser ”, “ Agile testing where dynamic typing shines ” and “ Embedding the IronPython engine ”. The book has inspired me to found the CodePlex project IronSharePoint (coming soon) showing how you can develop SharePoint apps with IronPython. I’m convinced that in the near future dynamic languages will get more attention again, just think of the “dynamic” keyword in C# 4.0. Absolutely worth keeping an eye on it!

A Good Mix 9: Cookbook recipes, articles and examples

Another selection of articles on IronPython from the last few weeks. Scripting: Reliably Finding my 32bit EXEs on a 32bit & 64bit OS or Where is IronPython? Saveen Reedy has a problem finding IronPython. More to the point he has an issue reliably finding the installed location when using both 32bit and 64bit versions of Windows (which have different standard install locations). Iron Python: How to talk to the .NET Framework A short blog entry demonstrating how IronPython integrates with the .NET framework by creating a simple GUI with Windows Forms and the interactive interpreter. The steps are virtually the same as I use when demoing IronPython to a .NET crowd. Creating Python Modules from CSharp This one is a bit meta, but still useful. It's a recipe I put on the IronPython cookbook and shows a 'slightly-different-from-the-usual' way to integrate C# with IronPython. It shows how you can use C# to programmatically create Python modules for use from IronPython. Back to

IronPython at Resolver Systems

These videos are from presentations my colleagues Jonathan Tartley and Giles Thomas did for Skills Matter in London. Inexplicably they are filed under Erlang on the Skills Matter website. Skills Matter: Resolver Systems Technology Jonathan Hartley, a developer at Resolver Systems talks about IronPython, and how it is used at Resolver Systems. Resolver Systems's first product, Resolver One, is a desktop and web-accessible spreadsheet aimed primarily at the financial services market. It is written entirely in IronPython, and directly exposes end-users to Python, both as expressions in cell formulae, and as an embedded scripting language which provides programmatic access to spreadsheet content. Resolver One launched in Spring of 2008, by which time the team had grown to fourteen people, and the codebase to 40k lines of product and 140k lines of tests. Here is an article by Jonathan about use of IronPython at Resolver Systems. At the same event my boss, Giles Thomas, spoke abou

IronPython Is it a dead parrot or does it fly?

" IronPython Is it a dead parrot or does it fly? " is the question asked by Mike James in an article in VSJ . It covers Python the language, .NET interop, and an example of using the WPF (Windows Presentation Foundation) GUI library from IronPython. IronPython Is it a dead parrot or does it fly? Python is one of the increasingly trendy dynamic languages and it is now available under the .NET umbrella. IronPython is an open source version of the language developed by Guido van Rossum in 1990. Python has a great many users and they are all passionate about the language and mostly about Monty Python as well. Yes, there are lots of Pythonesque (as in the well-known TV series) references in the Python world, but it is a very serious language as well! It currently runs on most platforms, and IronPython extends this range to .NET and Silverlight. Why bother? Python may be free and it may be a high quality language but so is C#. Why bother with a strangely named language that you p

SharpDevelop: Exploring and Debugging IronPython Code

Matt Ward is the maintainer of the IronPython support in SharpDevelop , a .NET IDE for Windows. His latest entry takes us through the IronPython debugger built into SharpDevelop. This was built using the techniques explored by Harry Pierson in writing his IronPython debugger . Crucial to debugging IronPython is "Just My Code" support (so you don't have to wade through the Dynamic Language Runtime internals when you want to step through Python code) - and this is the name of the feature in SharpDevelop. Debugging IronPython Code in SharpDevelop Ensure that the Just My Code feature is checked and that the Step over code without symbols is not checked. If the Step over code without symbols option is selected then stepping will not work properly and lines of code will be skipped over. There are two ways to debug your code. You can use the Python menu or modify the project options. We will look at both of these alternatives. First open your IronPython project into SharpDevel

.NET Module Testing with IronPython

One of the areas where dynamic languages particularly shine is testing. There is a whole chapter of IronPython in Action on the subject (chapter 7 which is free to download and is a great introduction to unittest and testing topics for both Python and IronPython). The .NET world is starting to realise this, and a new MSDN article by Dr. James McCaffrey explores both 'ad-hoc' testing with the interactive interpreter and writing your own test harness in IronPython for automated testing of .NET classes and libraries. (Personally I think he would have found it much easier to use unittest , but as you can see from the article even writing a custom test harness can be done in very little code with Python.) .NET Module Testing with IronPython The Python scripting language has features that make it an excellent choice for performing several types of software testing. There are several implementations of Python available including CPython, the most common implementation on machines r

Methodist: Make .NET Reflector come alive with IronPython

No, not a reference to a once dynamic spiritual movement that is now largely part of the institutionalised church, but a new plugin for .NET Reflector . Reflector is a tool for exploring and disassembling .NET libraries. From binary assemblies it will show you all the classes and their members including the relationships between them. It will also disassemble them back into C# or VB.NET source code; invaluable for understanding the behavior of objects but a nightmare if you feel the need to protect your source. Ben Hall , UK MVP, C# expert and dynamic languages enthusiast has created a plugin for Reflector which makes it even more useful. Part of the power of dynamic languages is how easy they make exploration from the interactive environment. Ben has brought this to Reflector by embedding an IronPython interpreter (REPL). Whilst you are looking at the available methods and their arguments and return values you can actually instantiate classes and use them from the interpreter. As

Running KirbyBase in IronPython

KirbyBase has a small but warm place in my heart as the first database I ever used in an application. It is a pure-Python single module database that stores its data in plain-text delimited files and has a Pythonic query syntax. Sure you don't want to run a high volume website with it but it is fun to use and experiment with. Krishna Bhargav has been using it from IronPython and has written up a blog entry on how to get it working with IronPython 2.6: Running KirbyBase in IronPython As I was looking for embedded database systems, I came across this pure python database called KirbyBase. So I decided that I would make it run on IronPython. So this post describes on how to make KirbyBase run on IronPython and using ipy.exe. Note that I am not looking at integrating this database into C# application yet. [may be in the future post] Using Python libraries from C# is an interesting topic (covered briefly in IronPython in Action of course) which I don't think enough people have e

An Australian, a Frenchman and an American read IronPython in Action

In the last couple of weeks three new reviews of IronPython in Action have gone online, and by reviewers from three different continents. The first is from Tarn Barford who is an Australian .NET programmer with an interest in IronPython. He has blogged and presented about IronPython, and now he has reviewed IronPython in Action: The Australian: IronPython in Action IronPython in Action is a fantastic resource for anyone learning IronPython and for anyone wondering what this dynamic language IronPython is all about and whether they should learn it. It feels nicely balanced for both .NET users looking to learn about IronPython, and for Python users looking to learn about IronPython on .NET. I prefer software books that have plenty of discussion and can be read from start to finish otherwise I end up skipping through chapters I never go back too. I found this book well written and fun to read with interesting insight all the way through. There is enough about the python language and .N

Davy's IronPython Editor 00.01.71 Released

In a recent entry I listed some of the editors and IDEs you can use with IronPython, but I missed one off the list: Davy's IronPython Editor . This is an IDE for IronPython written in IronPython and is the creation of Davy Mitchell . It comes in installable and mobile versions and the latest release is version 00.01.71. Davy's IronPython Editor 00.01.71 Released Nearly 2 months on since the last release and the project has changed a lot and whilst not a massive update, I seriously recommend this upgrade. Thanks to the IronPython mailing list for support, suggestions and inspiration. Like any other project out there, I am desperate for feedback :-) Also if you have any new ideas for the future, let me know. DIE has had about 400 downloads since launch. With blossoming interest in IronPython, (partly, I suspect, due to IronPython in Action ) hopefully it will hit the 1000 mark soon! So pop along and download. Here's the detail in what has changed in 00.01.70: Mobile Versi

A Good Mix 8: Python 101, Regular Expressions, Silverlight, IronRuby and More

The Coding Geekette is a Python and .NET developer who has spoken on IronPython at many developer conferences including PyCon . Her next adventure is teaching .NET developers Python in Cleveland: Python 101 for the .NET Developer What: "Python 101 for the .NET Developer" with Sarah Dutkiewicz, Cleveland C#/VB.NET SIG When: Tuesday, June 23, 6:30-8:30pm Where: Beacon Place Conference Center, Beacon Place Office Building, 6055 Rockside Woods Blvd, Lower Level, Independence, OH 44131 Python and .NET Regular Expressions at the Interactive Interpreter This blog entry (non-English) shows two interactive sessions using the System.Text.RegularExpressions.Regex class; performing the same task from both IronPython (2.6 beta) and IronRuby (0.4). The interactive interpreter is a great environment for experimenting, and the sessions ably demonstrate this. Of course you could also achieve the same thing with the Python re module . This is true of many things in IronPython, file and p

NWSGI Release and Django on IronPython

Jeff Hardy certainly keeps himself busy. First of all he has done a new release of NWSGI: NWSGI 1.1 Preview 2 NWSGI 1.1 Preview 2 is exactly the same as Preview 1, except linked against IronPython 2.6 Beta 1. NWSGI is an implementation of the WSGI specification (Web Server Gateway Interface) for IronPython. It is implemented as an ASP.NET HttpHandler and is supported on the IIS 6 / 7 webservers (or any ASP.NET capable server). NWSGI allows the integration of Python applications like Trac and Django with existing ASP.NET facilities such as caching, sessions, and user management. NWSGI isn't quite sufficient to get Django running with IronPython. To remedy this Jeff has a project hosted on bitbucket (Mercurial version control repository) with patches to support Django on IronPython. django-ipy project on bitbucket On a casual glance the patches look pretty unobtrusive although I don't know how many of the Django tests pass on IronPython. It would be an important milestone to fina

How to install IronPython 2 with Mono on Ubuntu

IronPython has been included with Mono for quite some time. The versions included are the last releases of the FePy project (IronPython Community Edition), which are a stable version of IronPython 1 and an alpha version of IronPython 2 - both very old. In the FePy status update Seo Sanghyeon (FePy maintainer) explains the difficulty of compiling the latest stable version of IronPython with Mono. It is easier to compile IronPython 2.6 (the up and coming version), so hopefully we will see a new release of FePy - along with an update in Mono - when this is released later this year. In the meantime the latest binary versions of IronPython released by Microsoft work with recent versions of Mono (although they need a terminal with a dark background). In this post Ali Afashar explains exactly what you need to do to get a cooperating version of IronPython and Mono working on Ubuntu. How to install IronPython 2 with Mono on Ubuntu This is just an instructional post with the hope that it mig