In May 2010, the Internet Committee for Assigned Names and Numbers (ICANN) permitted the first non-ASCII Internationalized Top-Level Domains to be made available.

An Internationalized Domain Name (IDN) is a domain name that includes characters from outside the ASCII character set. IDNs are specified in RFC 3490, and may contain any character from the Unicode character repertoire, meaning that domain names may now contain any writing symbol in use by human-beings anywhere on the planet.

Potential Issues

There are lots of interesting things and potential issues to note about IDNs.

They open up a whole new frontiers for cybersquatters and phishers, by opening up the possibility of Homograph Attacks, where the user is intentionally misguided by the visual similarity of character glyphs from different character sets. For example, is this character β a greek lower case beta or a german eszett?

Will companies like Société Générale find themselves held hostage by cybersquatters who have registered the accented version of their brand name before they even realise that it was possible to register it? In the case of the SocGen, the answer is no.

Solutions

Doubtless, various solutions will be adopted to solve these problems, as national registrars from around the world deal with how these problems relate specifically to the characters in use in their country. For example, the Russian national registrar Coordination Centre for RU TLD only permits Cyrillic characters to be used in the new .рф top-level domain.

Jython support

Unfortunately, jython idna encoding is currently broken, due to shortcomings in the unicodedata module and lack of stringprep support.

But IDNs are now supported when you run jython on a Java 6 JVM, since that version of the JVM has built-in IDN support: I checked in the changes at revision 7198.

There is also a workaround for java 5, where you can use GNU LibIDN to convert domain and host names to punycode before passing them to domain names that expect to receive ASCII parameters. This workaround is documented on the jython socket wiki.

If you’re interested in playing with IDNs, you can obviously download the latest jython. And there are plenty of Online IDN converters.

IPV4 exhaustion

As you are no doubt aware by now (since it’s been covered in all mainstream media), the reign of Internet Protocol Version 4 (IPV4) is coming to an end: the IPV4 address space will run out before the end of 2011.

The problem is a simple one: IPV4 addresses are made up of only 32 bits, meaning that they can only represent a maximum of 2³² different addresses (nearly 4.3 billion). But the internet is so successful and growing so fast that this address space is now too small: there are over 6 billion people on this planet, over 4 billion mobile phones, and over 1 billion PCs. Multi-device ownership is commonplace and growing in the rich world, and networking device ownership in the developing world is growing rapidly.

The decision to use 32-bit addresses was the right decision to make back in the 1960s. At the birth of the Internet, there were only several dozen machines connected to it. Rather than go into this subject in detail, I recommend reading this article: Vint Cerf on the Origins of 32-bit IP Addressing.

But as the Internet expanded and more and more machines connected to it, it became clear in the 1990s that IPV4 addresses would eventually run out, and that something would be needed to replace it: Internet Protocol Version 6 (IPV6) was born.

IPV6

IPV6 solves the address space problem permanently, by introducing a mind-bogglingly large address space: 128 bits, or 2¹²⁸ possible addresses. That’s 340,282,366,920,938,463,463,374,607,431,768,211,456 possible addresses! (Although see below for some caveats).

My favourite way to describe the size of this address space is as follows. If we were to divide the theoretical IPV6 address space between every star in the known universe (estimated to be 10²², or 10,000,000,000,000,000,000,000 stars), every star would have nearly 2⁵⁵ addresses to itself, i.e. an address space that is 8.4 million (2²³) times bigger than our existing IPV4 planetary internet (since 2²³ * 2³² == 2⁵⁵).

That’s a lot of addresses, and once IPV6 is fully in service across the internet, we won’t be running out of addresses for a very long time.

(Actually, the number of addresses available under IPV6 will be less than the theoretical maximum, because various sub-sets of the IPV6 address space have been reserved for special purposes. But the set of addresses available will remain practically unlimited for the foreseeable future).

Java vs. python

As readers of this blog will be aware, jython is an implementation of the python language that runs on the java platform.

Both python and java have been moving towards IPV6 for a number of years. Both are multi-platform languages, and attempt to provide APIs that work seamlessly across all operating systems.

Cpython, the most well known version of the python language, that is written in C, first provided IPV6 facilities back in version 2.2, released in December 2001. This support, although complete in design, did not initially work on all platforms on which cpython is used, because underlying operating system support was variable and patchy.

Simiarly, java introduced IPV6 support in version 1.4, released in February 2002. But this support suffered the same problems as with cpython: underlying operating system support was variable, particularly on older OSes such as Windows 2000, XP and 2003.

Fortunately, most operating systems have caught up with the present, and provide excellent IPV6 support, including most open-source operating systems, MacOS and Windows since Windows Vista.

Jython and IPV6

As is always true when using jython, there are two different approaches one can take to using IPV6 on jython: 1. Use the Java socket API or 2. Use the python socket API.

The java socket API

Users of jython have always had access to IPV6 though the java socket API, because of the seamless integration between java and jython. However, jython users often avoid using java APIs, particularly the more over-complex ones. And the java socket API is probably one of the worst examples of over-complexity, since it comprises two entirely different APIs, with different designs, to provide the full range of socket functionality: the java.net APIs and the java.nio APIs.

The python socket API

Long term users of jython networking libraries, which rely on the socket module, will be aware that the jython socket module has a particularly difficult task implementing the python socket API, since it must implement the cpython API, which has a C language philosophy, on top of the java API facilities, which have a different, more object-oriented philosophy. And as described above, the java socket API is really two completely different APIs, both of which must be used if you want the full range of functionality, e.g. asynchronous networking.

Implementing IPV6 has been problematic, for several reasons, including that operating system support has been patchy, thus making it difficult to reliably test on a cross-platform basis. Also, the cpython socket API is not without problems when it comes to IPV6.

Still, it has always been my stated intent that any python code written which uses the socket module should behave identically on jython and cpython, wherever possible. And now that intent extends to IPV6, final support for which I checked in recently (revisions 7191 and 7193), and which should be included in the next release of jython, due any day now.

I am particularly satisfied with this step forward, since I believe that IPV6 opens up a whole new world of networking possibilities.

Reliability

I won’t yet make the claim that the new IPV6 support is 100% defect free, since there are so many different java-version and operating-system combinations on which jython is used. There will always be some combination of operations on some JVM on some operating systems where it just won’t work, for example this java IPV6 defect on Windows. But the jython socket module has a very large set of unit-tests, currently 133 separate tests, and growing. As and when bugs are uncovered, I will document them, provide work-arounds, and unit-tests for the work-arounds.

Happy IPV6 networking!

Our conference venue, the Dublin School of English in Temple Bar, was a great success. Their classroom layouts proved ideal for talks and tutorials. The rooms for our three tracks were all accessed from a large foyer, where our sponsors set up their tables (and beanbags!). Open spaces rooms were also close, so the amount of traffic through the foyer gave a sociable and affable atmosphere.

Local restaurateurs Botticelli’s did a great job on the daytime catering, supplying tasty food and drink, and excellent coffee: we had a dedicated coffee machine and barista all day!

Just as I’ve experienced with other python conferences, there was a significant presence from the third-level education, both researchers and students. There were computer scientists interested in python as a language for teaching (the original purpose for which python was designed). There were research groups who were either already using or learning python in order to apply it to their programming needs, for analysing and visualising data, controlling equipment, etc. Work areas of third-level conference participants included genetics, electronics, and space hardware.

The venue for Saturday evening was the very modern Radisson Blu hotel on Golden Lane. The hotel staff were very professional and helpful: they made our entire experience there seamless and relaxed. What better way to end the evening than to retire to the bar for informal chats, the odd beer and the fine artistry of 3 piece blues band, Left, Right and Centre.

For the sprints on Sunday, the most remarkable project was certainly the project to code a solution finder for the fiendish Bedlam cube puzzles that sponsors Google had brought along. The effort even continued after the sprint was over, with the crew retiring to the TOG Hackerspace to work further on it.

One very successful outcome from the conference was that there is now a Python Ireland meetup in Cork city, which will be meeting on the first Thursday of each month. With the Galway Python meetups happening on the first Wednesday of the month, and the Dublin meetups on the second Wednesday, it is clear that Python Ireland is an active and growing community. Watch this space!

Many of the presentations given and media recorded at the conference are now available: See the following links

• Talks, slides, sourece code, etc
• Videos of talks
• General conference information

An enormous amount of organisation goes into making an event like a python conference work, and all of the committee are delighted that their work has all been worthwhile. One person deserves very special mention, Python Ireland’s Chairman, Vicky Lee, who was dedicated, untiring and endlessly patient through the whole process and put in more work than the rest of us put together: Massive kudos to Vicky!

Looking forward to PyCon Ireland 2011!

So I’ve decided to expand the database to encompass the other language that I regularly use, java, and publish a database of open source HTTP proxies written in java.

While carrying out a web development project a few years ago, I needed a HTTP proxy to help with development and debugging. Rather than write my own, I decided to research what open source options were already available.

However, Python is such an easy language to write web servers and proxies in that a lot people had written and puiblished HTTP proxies, so making the decision wasn’t easy. It required a lot of research, which basically meant a code and architectural review of all of the open source python proxies available.

Since most web programmers use a HTTP proxy at some stage, I thought it would be a useful exercise to compile a complete list of the available options, with a comparison table to enable a feature by feature comparison.

The result of that was this comparison table of open source HTTP proxies written in python, which became quite popular, because it saved python programmers going through the same complex comparison and review process I had undertaken.

Since I’m currently working on another proxy-related project, I needed to review available open source HTTP proxies written in java. And I thought I’d save someone some research time by publishing a similar comparison table of open source HTTP proxies in java.

I hope you find it useful.

As you may know, JSON is used extensively in modern web development, particularly to communicate data between servers and clients in Rich Internet Applications, or Web 2.0 applications. JSON is commonly the preferred choice for data interchange between clients and servers which use a Respresentational State Transfer (REST) based architecture.

JSON is often the preferred choice because it is a fat free alternative to XML. Although we use XML all the time, we fully recognise that it be both complex to work with and inefficient to generate and parse. JSON, on the other hand, is both simple and fast.

Jyson is written in pure java, and should be highly performant. So, if you’re using jython and JSON, we recommend you check out jyson.

On the portal you will find source code, documentation, issue trackers, etc, for open source software that we have published.

To run our open source portal, we use the excellent Redmine, an open source project management system written with Ruby on Rails. One thing we particularly like is that the Ruby community uses Redmine extensively, meaning that they subscribe to the philosophy of eating their own dog food, an admirable trait in the open source world.

We host our instance of Redmine on jruby, running on Apache Tomcat 6.0.

We chose Redmine because it is a highly functional and well architected piece of software. Browsing the source code for redmine shows that it is well designed and highly extensible, with a range of plugins for different tasks. Moreover, it has a rich feature set, including

• Multiple projects
• Hierarchical projects
• Forums
• Issue trackers
• Wiki
• File and Document areas
• News
• lots of other great features

Many thanks to the Redmine developers for their great software!

Being avid pythonistas, we normally like to use python or jython software when possible. In the case of project management, the obvious choice would be Trac, which was the first software of it’s type in the market, and in many ways defined the space that Redmine occupies.

But Trac has many problems, the most restrictive being that it can only support single projects (unless one is willing to do a fair amount of hacking). Furthermore, the Trac code base is getting a little crufty, a problem which is exacerbated by the fact that authors focus on changing the technologies on which Trac is built, rather than on adding new functionality that is useful to the end user.

So we invite you to visit the xhaus.com open source software portal.