Frank Wierzbicki's Weblog

Jython dev notes part I: The Jython Exposer

2012-01-02T13:12:00.006-05:00

One of my new years resolutions is to make Jython more friendly to new developers. One way to do that is to write up some notes on bits of Jython that are particularly mysterious to newcomers. I've boldly titled this post "Jython dev notes part I" to push myself to create more than one of these :)

It should be noted that I'm not shying away from making these notes highly technical - but I'm happy to edit them to make them more manageable later. Hopefully if I write enough of these up they can make up the beginnings of an advanced dev guide for Jython.

Recently I was asked how the Jython exposer works. The Jython exposer is the code that exposes the types that are written in Java as Python types in the Jython interpreter. It does this by rewriting the .class files during build time and adding the special methods that are seen at runtime. The augmented .class files end up in the build/exposed/ directory, and are ultimately built into the jython.jar distribution file. You can run the exposer from the Jython source like so:

ant expose

The exposer reads through each of the classes listed in CoreExposed.include and rewrites each of them. The rewritten classes get new methods generated for the Jython runtime to use as Python classes and methods. The exposer finds the code that it needs to operate on by finding Java annotations that have been defined for this purpose. An example is the easiest way to explain:

The string type in Python is called "str" and is implemented in Jython by src/org/python/core/PyString.java -- at the top of PyString.java is:


@ExposedType(name = "str", doc = BuiltinDocs.str_doc)

Which tells the exposer to expose PyString.java as the "str" type and take its "__doc__" attribute from BuiltinDocs.str_doc. Note that there currently appears to be a bug that str.__doc__ ends up as None right now, but it will show up if you run:


>>> help(str)

Further down in the source of PyString.java:


@ExposedNew
static PyObject str_new(PyNewWrapper new_, boolean init, PyType subtype, ...

Exposes the str_new Java method as the Python str __new__ method. (The __new__ method is a special class level method that acts as a str factory).

Next we'll look at some examples of ExposedMethod, which is the most common annotation that the exposer uses. ExposedMethod exposes general methods for Python classes.


@ExposedMethod(doc = BuiltinDocs.str___len___doc)
final int str___len__() {

The above code exposes the __len__ method, which is how the str method will respond to a call to the builtin len() function. Since the object itself is the only argument, the ExposedMethod annotation only needs a doc.


@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.str___eq___doc)
final PyObject str___eq__(PyObject other) {

The above exposes the __eq__ method. MethodType.Binary indicates that this is a binary method that will take 2 arguments. The exposer has special handling for common types like this.


@ExposedMethod(defaults = {"null", "-1"}, doc = BuiltinDocs.str_split_doc)
final PyList str_split(String sep, int maxsplit) {

The above implements the split method of str, which takes 2 optional arguments. the "defaults" attribute assigns default values to the optional arguments.

There is much more to the exposer, but unfortunately the code is the only real documentation other than this post at this time. The source for the exposer engine is in:


src/org/python/expose/

And the source for the generator and ant task are here:


src/org/python/expose/generate/

Contributing to Jython

2011-11-22T16:08:00.005-05:00

About a year and a half ago my dream job of doing nothing but Jython all day and night came to an end (By the way, does anyone want to pay me to do Jython all day and night? It's about the only thing that could pull me from my awesome job at Canonical which I'm overdue on writing about here). Anyway to re-integrate myself into society I had to go cold turkey on Jython for a while so I could learn how to have a regular job again. I've contributed to Jython here and there by coding some of this and that, but I've failed to take care of the most important part: helping new people that want to get involved in Jython. I've let that go on for too long and I need to turn things around and get back to doing that. Recently a frustrated patch author sent an email about how hard it is to become a Jython contributor. He has some patches that have been sitting around for a long time and I'm pretty ashamed that that is the normal course of things lately. So, as I start giving Jython a bit more of my spare time again, I plan to make it a priority to review patches and try to figure out how to grow the Jython developer community again. So send patches and I promise to look at them. In particular, if anyone wants to put together patches that fix failing tests in the default Jython branch that targets 2.6 compatibility, I'll be right on them. I'll put together another post on contributing to Jython soon.

This Weblog is Now Licensed Under a Creative Commons License

2011-02-18T12:13:00.010-05:00

I've been meaning to add a creative commons license to this site for a long time. Since the default copyright laws are not conducive to any sort of digital sharing, I think anyone that wants to share their work should take the time to find a license that makes sense for them. These days, with the creative commons form, it only takes a few minutes to do. You just pick the rights you want to grant and the chooser gives you an html snippet that you can drop onto your site or weblog or whatever. I encourage anyone that wants their words or work to be shareable to have a look at the great work that the creative commons folks have done.

Jython 2.5.2 beta 2 is released!

2010-09-14T11:32:00.002-04:00

The title says it all! See the details at Jim Baker's blog. There is a reasonable chance that this will become the 2.5.2 final release and that we can start work on the next 2.x version of Jython.

Leaving Sauce Labs

2010-08-24T12:09:00.007-04:00

My time at Sauce Labs is at an end, and so I am looking for a new opportunity. I had a great time at Sauce Labs where I worked on building a cloud based infrastructure for test automation with Selenium. I have been working in software for more than twelve years, often in a lead role. I am well regarded in the Open Source world, where I have participated in and helped build communities. I have been the Jython project lead for six years. I am a committer on the Python project, and a member of the Python Software Foundation. I have done a wide variety of work in recent history: development and leadership work in Java and Python, from parsing Python source and compiling to Java bytecodes, to coding and administrating distributed cloud based web applications. I am able to do work in any of these areas, on either a full time or consulting/contracting basis. My contact information can be found on my Google profile. My LinkedIn profile is a good summary of my credentials.

My New Job at Sauce Labs

2010-02-03T13:15:00.002-05:00

I joined Sauce Labs as of January 3 this year. I met the people at Sauce Labs during the recent startup crawl in San Francisco (what a great way to find an employer, eh?). Sauce Labs is based around support for the open source Selenium functional testing framework. The inventor of Selenium, Jason Huggins is a founder. I joined Sauce Labs at the same time as Jim Baker and Raymond Hettinger, see here for more. The entire team at Sauce Labs is mind blowingly amazing - which is the main reason that I had to join.

As for the technology, there is a very cool Python backend that supports lots and lots of parallel virtual workloads. I am currently working on Sauce IDE, an extension of Selenium IDE that adds support for Sauce Lab's OnDemand service to the IDE. This lets you record your functional tests from Firefox, and then push those tests up to Sauce Labs where they can be run on various operating systems and browsers in parallel. How cool is that?

Readers of this blog are probably wondering what this means for my role as lead maintainer of Jython. First of all, this is nothing like my former role at Sun Microsystems. Jython is definitely not going to be my day job the way it was at Sun. Since Sauce Labs is an early stage startup, I will be very busy helping the company succeed. Having said that, Sauce Labs is a company based on the use of open source software, and has a strong commitment to giving back to the open source community. They support my continued involvement in the development of Jython. What this means in practice will need to evolve over time.

I'm pretty excited to switch focus from implementing a Python to putting Python code into production. I fully expect that this new job will deepen my understanding of real world Python coding and make my Jython work more productive.

Leaving Sun

2009-11-04T14:05:00.004-05:00

I've always regarded working full time on Jython at Sun as a miraculous sabbatical that might come to an end at any moment. Sadly that time has come. I've worked with many amazing people and had a great time: Sun provided me with one of the greatest professional experiences I have had, for which I will always be grateful.

I'm very pleased with how far Jython has come during my tenure at Sun. Jython is now a modern version of Python, and has the momentum to continue its growth. A far larger group of developers than ever before contribute regularly, making Jython a very healthy project. Jython runs many more of the key frameworks and applications that are popular in the Python world. In the future we will be making Jython better, faster, and more complete. I started working on Jython long before I joined Sun, and I certainly plan be a part of Jython's future.

I am looking for a new opportunity, and am open to many possibilities. I have been working in software for more than twelve years, often in a lead role. I am well regarded in the Open Source world, where I have participated in and helped build communities. I have been the Jython project lead for almost five years. I am a committer on the Python project, and a member of the Python Software Foundation. I have done a wide variety of work in recent history: development and leadership work in Java and Python, from the abstract level of parsing Python source and compiling to Java bytecodes, to the more concrete work of web development. I am able to do work in any of these areas, on either a full time or consulting/contracting basis. My contact information can be found on my Google profile and my LinkedIn profile is a good summary of my credentials.

Jython 2.5.1 Final is out!

2009-09-26T14:36:00.003-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1 final is available for download. See the installation instructions.

Jython 2.5.1 fixes a number of bugs, including some major errors when using coroutines and when using relative imports, as well as a potential data loss bug when writing to files in append mode. Please see the NEWS file for detailed release notes.

Please report any bugs that you find. Thanks!

Jython 2.5.1 Release Candidate 3 is out

2009-09-23T21:54:00.003-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1rc3 is available for download. See the installation instructions.

I didn't really want to have an RC3, I was hoping to have a final by now, but a data loss bug was discovered in RC2 and that prompted one more RC. I'm hoping that this is the last one and that we'll have a final shortly. Please see the NEWS file for detailed release notes.

Please report any bugs that you find. Thanks!

PyCon 2010 Call For Talks Ends Soon!

2009-09-16T20:20:00.001-04:00

If you where thinking about submitting a talk to PyCon 2010 you should do it now!

Jython 2.5.1 Release Candidate 2 is out!

2009-09-12T15:04:00.002-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1rc2 is available for download. See the installation instructions.

Jython 2.5.1rc2 fixes bugs that we found when testing rc1, including some db, codec, and locking issues. Please see the NEWS file for detailed release notes.

Please report any bugs that you find. Thanks!

Jython 2.5.1 Release Candidate 1 is out!

2009-09-01T11:07:00.005-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.1rc1 is available for download. See the installation instructions.

Jython 2.5.1rc1 fixes a number of bugs, including some major errors when using
coroutines and when using relative imports. Please see the NEWS file for
detailed release notes.

Please report any bugs that you find. Thanks!

InvokeDynamic and Jython part I

2009-08-17T11:26:00.006-04:00

The invokedynamic work from the Da Vinci Machine Project has come a long way. In fact, it has started to make it's way into OpenJDK 7 builds. To try the bleeding edge version out for yourself, follow these instructions to patch and build your own. But, be warned, it's a bit tricky to get started. You may find that these examples will work with OpenJDK 7 binaries (sooner or later they should!). For those who haven't heard about this work yet, invokedynamic, which is a part of JSR-292, allows a program to dynamically call methods with (potentially) the same performance characteristics as static calls. Here is about the simplest invokedynamic program you can write:


import java.dyn.CallSite;
import java.dyn.InvokeDynamic;
import java.dyn.Linkage;
import java.dyn.MethodType;
import java.dyn.MethodHandles;

public class Example {
    public static void main(String... av) throws Throwable {
        for (String a : av) {
            InvokeDynamic.call(a);
        }
        InvokeDynamic.call2(av[0]);
    }

    public static void foo(String x) {
        System.out.println("Hello, " + x);
    }

    static { Linkage.registerBootstrapMethod("linkDynamic"); }
    private static CallSite linkDynamic(Class caller, String name, MethodType type) {
        System.out.println("linking:" + name);
        CallSite c = new CallSite(caller, name, type);
        c.setTarget(MethodHandles.lookup().findStatic(Example1.class, "foo",
            MethodType.make(void.class, String.class)));
        return c;
    }
}

First notice the linkDynamic method. The static initializer above it registers that method as a special bootstrap method that invokedynamic will use when you want to call a method dynamically. The interesting bit to notice are the two calls to methods on InvokeDynamic. InvokeDynamic has no actual methods of its own. You can call any method on it (here I use "call" and "call2", but it could just as well have been "foo123" or "sasquatch") When you make these calls, control is passed to the bootstrap method (linkDynamic in this case). linkDynamic gets passed the Class of the caller, the name that was used ("call" and "call2" in this program) and the MethodType of the call, which specifieds the signature of the dynamic call.

To compile the above code, execute:

javac -XDinvokedynamic Example.java

To run it:

java -XX:+EnableMethodHandles -XX:+EnableInvokeDynamic Example a b c

Which should produce:


linking:call
Hello, a
Hello, b
Hello, c
linking:call2
Hello, a

Notice that we called "call" three times, but it only needed to be linked once. We then called call2 and it was separately linked. Had we invoked call2 again it would not have needed linking. Next in my exploration, I'll wire it up with some Python internal dispatch logic:


package org.python.compiler;

import java.dyn.CallSite;
import java.dyn.InvokeDynamic;
import java.dyn.Linkage;
import java.dyn.MethodType;
import java.dyn.MethodHandle;
import java.dyn.MethodHandles;
import java.dyn.MethodType;

import org.python.core.Py;
import org.python.core.PyCode;
import org.python.core.PyFunction;
import org.python.core.PyInteger;
import org.python.core.PyObject;
import org.python.core.PyString;
import org.python.core.PyTuple;
import org.python.core.ThreadState;

public class IndyTest {

    public static void run() throws Throwable {
        PyObject result = InvokeDynamic.foo(new PyInteger(4), Py.None,
                Py.EmptyObjects, new PyTuple());
        System.out.println("result = " + result);
    }

    static { Linkage.registerBootstrapMethod("linkDynamic"); }
    private static CallSite linkDynamic(Class caller, String name, MethodType type) {
        System.out.println("linkDynamic...");
        CallSite site = new CallSite(caller, name, type);
        ThreadState ts = Py.getThreadState();
        PyCode func_code = ((PyFunction)ts.frame.getname(name)).func_code;

        MethodType oneArgCall = MethodType.make(
            PyObject.class, //return type
            ThreadState.class, // state
            PyObject.class, // arg1
            PyObject.class, // globals
            PyObject[].class, // defaults
            PyObject.class // closure
        );
        MethodHandle call = MethodHandles.lookup().findVirtual(PyCode.class, "call", oneArgCall);
        call = MethodHandles.insertArguments(call, 0, func_code, ts);
        call = MethodHandles.convertArguments(call, type);
        site.setTarget(call);

        return site;
    }
}

There is a bit more going on here. In short, we look up the current state of the Jython interpreter when this is invoked and look for a function called "foo". We pass the PyInteger 4 (plus some boilerplate at the end -- in the future we should be able to only pass the 4, but MethodHandles.insertArguments can only add three arguments at the moment.) to the foo(), and then print the result out. Again "foo" is bound the first time it is called. When we create a CallSite, grab the current ThreadState and get our "foo" object from the current Jython frame. We then create a MethodType that corresponds to the way that we call Jython methods internally, and use methods off of MethodHandles (insertArguments and convertArguments) to coerce our call to the internal call semantics. Then our "foo" call is permanently bound to the function we found. Ultimately this is not what we will want since "foo" could be rebound in Jython in a number of ways. We'll get to this problem in a future post. To try this code out, we need a Jython program with a foo method:


def foo(x):
print "hello %s!" % x
foo("test")

from org.python.compiler import IndyTest
IndyTest.run()

def foo(x):
print "goodbye %s!" % x
foo("test")

IndyTest.run()

Run it like this (requires a Jython 2.5 install and we need to call Jython with --boot to put the Jython internals into the boot classpath):


jython --boot -J-XX:+EnableMethodHandles -J-XX:+EnableInvokeDynamic indy.py


hello test!
foo = 1
linkDynamic...
hello 4!
result = None
goodbye test!
foo = 2
hello 4!
result = None

The first IndyTest.run() looks great (hello 4!) -- but the second call still emits "hello 4!" even though foo() has been redefined. We'll look at fixing this in the next post.

By the way, to *really* learn about the guts of invokedynamic look to the posts from John Rose and Fredrik Öhrström along with the Da Vinci Machine site.

Jython 2.5.0 Final is out!

2009-06-16T14:10:00.002-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5.0 final is available for download. See the installation instructions.

Jython 2.5.0 brings us up to language level compatibility with the 2.5 version of CPython. This release has had a strong focus on CPython compatibility, and so this release of Jython can run more pure Python apps then any previous release. Please see the NEWS file for detailed release notes.

I want to thank all of the amazing people who have contributed in large and small ways to this important Jython release. For the first time in a long time we have Jython that is a modern version of Python. Enjoy!

Please report any bugs that you find. Thanks!

Jython 2.5.0 Release Candidate 4 is out!

2009-06-08T14:58:00.006-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5rc4 is available for download. See the installation instructions.

This is the fourth and probably final release candidate of the 2.5.0 version of Jython. If no major bugs are found in rc4, we will relabel it as 2.5.0 final. With this version, all of the regression that we follow on Windows now pass.

Please try this out and report any bugs that you find.

Jython 2.5.0 Release Candidate 3 is out!

2009-05-26T15:52:00.004-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5rc3 is available for download. See the installation instructions.

This is the third release candidate of the 2.5 version of Jython. It fixes some threading issues and partially fixes JLine on Cygwin.

Almost every release in the past year has been followed shortly by another release to fix a windows bug. Today I finally got off of my butt and installed Windows on a VM and spent the day testing, so hopefully this one will not follow that pattern.

Please try this out and report any bugs that you find.

Jython 2.5.0 Release Candidate 2 is out!

2009-05-11T14:57:00.004-04:00

[Update:A bug in our build process and jline support caused windows failures, so we have released an rc2 and changed the download link below to point there]

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5rc2 is available for download. See the installation instructions.

It contains bug fixes and polish since the last beta. One especially nice bit of polish is that JLine is enabled by default now, and so using up and down arrows should work out of the box. If no major bugs are found this release will get re-labeled and released as the production version of 2.5.0.

Please try this out and report any bugs that you find.

Jython 2.5 Beta 4 Released

2009-04-28T13:39:00.007-04:00

Jython 2.5b4 is available for download. See the installation instructions.

While no new features have been added since Beta 3, we have fixed a number of bugs. One of the bugs prompted an almost total re-write of our Tuple and List implementations, which is the reason that this is another beta and not a release candidate. Expect a release candidate real soon now.

We also applied a patch that allows Jython to function in a system that does not have write access to the filesystem so that Jython can run unpatched in Google App Engine.

This is a beta release so be careful.

PyCon 2009

2009-04-03T11:21:00.006-04:00

PyCon 2009 was great! For the first time, there where two pre-conference days: one to specifically discuss VMs and another to discuss general Python language issues with implementers. It was great to listen to all of the VM implementers and users talk and to exchange ideas. The language day included the announcement of unladen swallow, a branch of CPython with the goal of a 5x speedup in one year. They plan to send as many changes as possible upstream to CPython, so expect it to get faster.

During the regular conference I was voted in as a member of the PSF. I received a commit bit to CPython in order to work on Lib and Lib/test to help better integrate Jython's corresponding code. In the future, the plan is to logically separate Lib from CPython so that all of the Python implementations become semi-equal partners in that part of the codebase. I say semi-equal because the release cycle would continue to be governed by CPython (no problem from me there :). There where too many great talks to cover, but everything was videoed, so anyone who couldn't make it should be able to see the talks.

The sprints are always my favorite part of the conference, though for some family reasons I was only able to stay for two days. So many people showed up to work on Jython that we needed a bigger room - at one point I counted 14. Thomas Enebo from JRuby worked with John Szakmeiste on ctypes for Jython, with Samuele Pedroni and Maciej Fijalkowski consulting from PyPy. Charlie Nutter from JRuby and Tobias Ivarrson discussed compiler optimizations. Philip Jenvey made amazing progress with Michael Bayer of SQLAlchemy and Glyph of Twisted to get those frameworks working on Jython. SQLAlchemy is quite close to supporting Posgresql and MySQL on Jython! Twisted is able to run its unit tests on Jython, and progress there is likely to accelerate now. I could go on, so much happens during the sprints...

I was also able to discuss moving Jython to the Python.org infrastructure with Martin v. Löwis. We are going to do just that, though it will probably take a while. I am already putting together a skeleton website. Jython 2.5 is going to need a facelift before release time.

Thanks to everyone that made PyCon possible, I had an amazing time!

Jython 2.5 Beta 3 Released

2009-03-10T16:00:00.004-04:00

When I released Beta 2 this Saturday, I said it would be the last beta unless a severe bug was found. Well, a severe bug was found. Under certain circumstances Jython Beta 2 would not start on Windows. Otmar Humbel has fixed it, and we've released Beta 3 with the fix here. See the installation instructions.

This is a beta release so be careful.

Jython 2.5 beta 2 Released

2009-03-07T13:02:00.005-05:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5b2 is available for download. See the installation instructions.

Unless a severe bug is found, this will be the last beta before we start putting out release candidates. The modjy project has been pushed into the core, there have been many bugfixes. I attempted to get all of the bugfixes out of the tracker and into the NEWS file. Hopefully we can get more disciplined about change logs in the future.

Note: if you have been running Jython with --verify, we have removed that option and defaulted to that classpath behavior. We now have a --boot option for the previous 2.5 classpath behavior (jython.jar gets loaded into the boot classpath). If you don't know what I'm talking about, then you probably don't need to worry about it :)

This is a beta release so be careful.

Hoffstadter's Law and Jython 2.5

2009-02-28T12:22:00.004-05:00

Hoffstadter's Law states: "It always takes longer than you think, even when you consider Hoffstadter's Law."

I thought by now I'd have a Jython 2.5 release, but alas I do not. I keep wanting to get just one more feature in, but I think the time has come to freeze things and get to release candidates. Most of 2.5 is quite solid, and it's time to get it out. I plan to put together what I think will be the last beta for Jython 2.5 this Friday.

Some things are not going to make it in, for example I don't think ctypes will make it for 2.5.0. I looked over what we have so far and what I think it would take me to implement it. I don't feel confident that I can really get it together as quickly as I would like and still have it be solid. My C skills are just a little too rusty to whip it together quickly. I may make ctypes my personal sprint target for PyCon 2009 since there will be lots of ctypes knowledge floating around, particularly from the PyPy folks. Jim Baker has started a ctypes implementation which uses the PyPy work.

I'm going to try to get modjy integrated into trunk, but if I don't make it by this Friday it will just have to stay separate for this release. Jythonc work has moved to the "clamp" project that Charlie Groves started on github. Hopefully we can get that together at the same time or shortly after 2.5.0 releases.

If any committers have something they would like to get in at the last moment, now would be the time!

Progress with Mercurial on Jython: part 2

2009-02-19T15:17:00.004-05:00

So yesterday's foray into Mercurial's test engine started with much excitement, but the excitement was short-lived. It turns out that the Mercurial tests are mostly shell scripts, and some blundering on my part permitted some CPython to bleed through and run some of the tests (so they appeared to succeed, but did not).

Since I really want to at least assess the scope of getting Mercurial to run on Jython, and it really is a bit closer, I decided to start reading the Mercurial book. At the same time, I am gearing up to play around with the Da Vinci Machine project, which is hosted on a Mercurial repo. So I'm doubly motivated to get a good understanding of hg. So, going along with the book, I first tried "hg version" (I have a local hg that points to Jython -- and I am quite sure it points to Jython this time). Woohoo! -- version works (you have to start somewhere...):


[frank@pacman ~]$ hg version
Mercurial Distributed SCM (version b8d750daadde+20090218)

Copyright (C) 2005-2008 Matt Mackall  and others
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Next I find that "hg help" works:


[frank@pacman ~]$ hg help init
hg init [-e CMD] [--remotecmd CMD] [DEST]

create a new repository in the given directory

  Initialize a new repository in the given directory.  If the given
  directory does not exist, it is created.

  If no directory is given, the current directory is used.

  It is possible to specify an ssh:// URL as the destination.
  Look at the help text for the pull command for important details
  about ssh:// URLs.

options:

-e --ssh        specify ssh command to use
  --remotecmd  specify hg command to run on the remote side

use "hg -v help init" to show global options

The next bit in the book uses "hg clone". Unfortunately "hg clone" uses buffer(), which Jython lacks. Jython has never supported the buffer() protocol from CPython, and almost certainly never will. For one thing, buffer() is very C-oriented, and buffer() did not make the cut into Python 3.0, so implementing buffer makes little sense for us. We may very well look into the buffer() replacements defined for 3.0, but that is something for another time. So I used regular hg to execute the clone.

Next "hg log" revealed a bug in Jython that was pretty easy to fix: we where
not handling writes past the end of the buffer in our cStringIO. That's a nice benefit of trying out larger apps on Jython -- they are good exercise :)

And so now "hg log" runs:


changeset:   4:2278160e78d4
tag:         tip
user:        Bryan O'Sullivan 
date:        Sat Aug 16 22:16:53 2008 +0200
summary:     Trim comments.

changeset:   3:0272e0d5a517
user:        Bryan O'Sullivan 
date:        Sat Aug 16 22:08:02 2008 +0200
summary:     Get make to generate the final binary from a .o file.

changeset:   2:fef857204a0c
user:        Bryan O'Sullivan 
date:        Sat Aug 16 22:05:04 2008 +0200
summary:     Introduce a typo into hello.c.

changeset:   1:82e55d328c8c
user:        mpm@selenic.com
date:        Fri Aug 26 01:21:28 2005 -0700
summary:     Create a makefile

changeset:   0:0a04b987be5a
user:        mpm@selenic.com
date:        Fri Aug 26 01:20:50 2005 -0700
summary:     Create a standard "hello, world" program

So Jython's mercurial story isn't quite as good as I thought it was yesterday, but it is certainly much better than it was in 2007. If you are interested in Mercurial, I am finding the book to be extremely well written and easy to read, again you can find it here.

Progress with Mercurial on Jython

2009-02-17T19:21:00.008-05:00

Back in 2007, Charles Nutter posted a suggestion: get Mercurial (also called hg) running on Jython. At the time I downloaded hg to give it a try. This was before Jython 2.2 was released, and it did not go well. Mercurial would not even compile, and if you know much about compiling Jython or Python, you might know that getting something to compile is about 1/4 of the battle.

Much has happened in Jython since 2007, 2.2 is out, and we are a getting very close to a release of 2.5. Recently, Dirkjan Ochtman has been making changes to Mercurial to better support other implementations of Python . For example, the parts of Mercurial that where implemented in C have pure Python fallbacks now [Update: Dirkjan tells me that the specific work of re-exposing pure Python fallbacks from hg past was done by Martin Geisler]. To avoid performance issues in the default case, these pure python fallbacks need to be compiled in.

To test this out in Jython (you need trunk, or at least beta1), get a copy of the latest mercurial

hg clone http://selenic.com/repo/hg

Go to the hg directory and compile hg with the "pure" option (thanks to mohbana on #jython irc for the recipe used):

jython setup.py --pure build_py -c -d . build_ext -i build_mo

[Update: the patch below was applied by Dirkjan Ochtman last night with the comment "use same popen strategy for jython as for nt"]
then cd to the "tests" directory and (for now) apply this change to run-tests.py and run

jython run-tests.py --pure

This should start the hg test harness. There are *lots* of failures, but also plenty of heart warming success dots.
[Update: at least some of these success dots are leaks to CPython... I'll do another weblog post when I know more]

mohbana (again from #jython irc) says that he has had success with "hg init", "hg tip", and "hg add".

We are getting closer!

Jython 2.5 Beta1 Released!

2009-01-09T16:14:00.005-05:00

Happy New Year! On behalf of the Jython development team, I'm pleased to announce that Jython 2.5b1 is available for download. See the installation instructions.

Jython 2.5 Beta1 continues a code cooling period where the number of new features should significantly slow as we concentrate on solidifying Jython 2.5 for an eventual release. I would guess that we will put out about two more betas before we start pushing out release candidates, hopefully in February.

This is a beta release so be careful.

Tor Norbye Finds Bug in Jython Lib With NetBeans

2008-11-13T15:40:00.003-05:00

Tor Norbye has been working on nbPython, which will bring Python support to NetBeans 6.5. As anyone that has ever worked with me will know, I am one of those "You will pry my Vim from my cold dead fingers" kind of developers. I work at Sun, and nbPython is directly using the ANTLR parser that I developed for Jython, but these are not sufficient reasons for me to abandon my beloved Vim. Having said that, Tor recently posted a weblog where he demonstrates the tool by simply pulling up datetime.py right out of the Jython distribution and immediately finding an ancient typo ("ValueError" was misspelled as "ValuError" in an exception block). The fix is checked into trunk, but it had been there for a long time. Maybe these "IDE"s I keep hearing about are worth looking into after all :). Certainly I will be trying out NetBeans on the Jython Lib to see what else I can find soon. An nbPython early access should be appearing soon after NetBeans 6.5 is released.

Jython 2.5 Beta0 Released!

2008-10-31T17:36:00.001-04:00

Happy Halloween! On behalf of the Jython development team, I'm pleased to announce that Jython 2.5b0 is available for download. See the installation instructions.

Jython 2.5 Beta0 is the beginning of a code cooling period where the number of new features should significantly slow as we concentrate on solidifying Jython 2.5 for an eventual release. There are still a number of features that we will squeeze in (like jythonc).

This is a beta release so be careful.

Updated Jython Roadmap

2008-10-20T13:45:00.005-04:00

The Jython roadmap is a bit dated now -- I thought I'd put an updated version here first, take comments, and then update the official roadmap. BTW there is a more detailed roadmap on the wiki which I'll also need to update. Also, if you have dependencies for a Python project that you want working in Jython, please put an issue in our tracker so we can get a chance to fix it before we release!

Summary

Note that Jython's version numbers represent the version of CPython from which Jython pulls most of its libraries that are written in pure Python (as opposed to the parts that are written in Java).

Jython 2.2.1

Jython 2.2.1 has been released. We will produce additional point releases for bug fixing as necessary. We are close to having enough fixed in the 2.2 maintenance branch to put out a 2.2.2 in the somewhat near future.

Jython 2.5 Beta
We are closing in on a beta at the time of this writing. We have a pretty good implementation of Python, passing more than 99% of the unit tests that we pull in from CPython. We have implemented all of the 2.5 language features and many of the libraries that are new since the 2.2 release of Jython. A couple of features that I would like to get in have not quite made it for this beta, but I think we will sneak them in slightly post-beta. Those features are: some kind of replacement for jythonc, ctypes, bz2, elementree, and ast.py (which is the exposed _ast.py added in CPython 2.6 -- _ast.py is already in Jython 2.5) I hope to have the first beta out in October.

Jython 2.5 Final
After sneaking in the features above, we need to get all of the unit tests either passing or consciously skipped. We also need to make sure that all of the issues and patches in the Jython tracker have been carefully looked at and either fixed, closed, or marked for the next version. I hope to have a Jython 2.5 out in January.

Next Jython 2.x
I think we are going to skip 2.6 and target 2.7, mainly because we can coordinate much better with upstream CPython if we are working on the same version. Also, according to this thread on Python-Dev, 2.7 may be a shorter "cleanup" style release, which should make it easier to track.

Jython 3.0
I believe the time is very close for us to start seriously discussing what Jython 3.0 will eventually look like. I think, like CPython, we want to try to be realistic and not go too crazy with the scope of change, but at the same time this will be a chance to re-think some very old design decisions and perhaps make new decisions more in line with modern Jython and JVM realities. That's about all I'm willing to officially say on Jython 3.0 this point.

Jython 2.5 Alpha3 Released!

2008-09-10T21:22:00.002-04:00

On behalf of the Jython development team, I'm pleased to announce that Jython 2.5a3 is available for download. See the installation instructions.

Jython 2.5 Alpha3 fixes a bug that caused installation problems for many Windows users, so Oti Humbel and Leo Soto came to the rescue with an assist by Geoffrey French. Oti also fixed standalone mode while he was there. Yay!

As before, this is an alpha release so be careful.

Djangocon day 2

2008-09-07T21:30:00.001-04:00

Mark Ramm spent his talk urging the Django community to reduce the coupling between the various parts of Django. He fears that Django might be (partly) going down the same path that historically hurt Zope 2. Zope 2 was a self contained web framework that had no external dependencies. On the surface this sounds like a good thing, it makes installing, deploying, testing etc very easy. *But* Zope 2 created an environment where there where two communities: Python developers and Zope developers, and this surely contributed to its decline. It would be sad if the same thing happened to Django -- and it is not hard to imagine how that could happen. Note that Zope 3 has made amazing strides in decoupling itself which (as Mark pointed out) may make Django the largest open source monolithic web framework in Python.

Next up was a panel of Django committers. Among other things they talked about Mark's concerns. There is a tension between being a "Don't make me think" and "Let me choose" framework. The important thing to note is that the Django developers do care about being a composable framework with a certain set of defaults, and very much want to have good interoperability with the greater Python web development community. For more hope see Django Ticket #8929 titled "Reduce the divide between Django and the rest of the Python web world".

The lightening talks, as always, where fun to watch. There is something compelling about a series of 5 minute talks that anyone can sign up to do at the last minute.

Jim Baker and Leo Soto spoke about Django on Jython. They worked with some Pinax folks to get some of their extensions to Django running on Jython. Pinax on Jython demoed very nicely.

Adrian Holovaty and Jacob Kaplan Moss finished off the conference with a talk on the future of Django. In particular I respect their call for the community to "tell them when they suck". The ability to listen to criticism, and to even welcome it is a huge asset. They also want to start getting releases out on a regular schedule. Good stuff.

Djangocon day 1

2008-09-07T01:22:00.003-04:00

The first day of the inaugural Djangocon took place at the Googleplex today. Since I wasn't madly writing a presentation at this one (as I have been for every conference I've been at in recent memory), I actually took some notes.

Some highlights:

Leslie Hawthorn (of Google Summer of Code fame if you don't recognize the name) is here at Djangocon and was apparently a big part of making it happen. As always she was cranked up to 11. It's hard to believe just how much stuff has her involvment. Perhaps there is more than one LH?

Guido van Rossum talked about Google App Engine. I am *really* going to need to take it for a spin in my copious spare time. He hinted that more languages beyond Python are being audited for use in App Engine, but there was no promise of a time frame (apparently even the audit of Python -- probably one of the best known languages at Google -- took forever). He didn't say which one. I will place my bets at 60% on Ruby and 40% on Java -- though I wonder what MVC framework would make sense from Java...

Adrian Holovaty reminisced about some of the bad times with early Django code, but also how much of the original concepts remain almost unchanged. He then went on to describe the current state of Django. My favorite bit was this quote from the tracker around August 2005:

I can't think of any other backwards-incompatible changes that we're planning before 1.0 (knock on wood). If this isn't the last one, though, it's at least the last major one.

Jacob Kaplan Moss continued on Django history and the current cool features of modern Django, also with some pretty funny anecdotes. He also plugged Jython on Django :). Which by the way was very much a two way effort. The Django folks where incredibly supportive of our efforts to get Django working with Jython.

Justin Bronn talked about GeoDjango and gave a fascinating talk that started with the fundamentals of GIS and then went into how to use GeoDjango to map-enable your code. It relies on ctypes, which may not be too hard to get running on Jython. GeoDjango demoes very well so that's one more reason for us to take a look at getting ctypes supported.

Carl Henderson was hilarious in his "Why I hate Django". It was a combination of interesting survey of what makes a site like Flickr scale so well and a sort of loving roast of Django. There's no point in trying to convey it -- I think they recoreded all of these talks if you are a fan of Django I'm certain you would enjoy his talk.

I also released Jython 2.5 in the middle of all of this, met Leo Soto (our Django google summer of code student), and talked over some co-routine issues with Jim Baker. All in all a very good day.

Jython 2.5 Alpha 2 Released!

2008-09-06T17:37:00.011-04:00

[Update:] Use Alpha3.

On behalf of the Jython development team, I'm pleased to announce that
Jython 2.5a2+ is available for download. See the installation instructions.

Django runs pretty well on this release. I am attending Djangocon where Jim Baker and Leo Soto will be presenting on Django on Jython, and I wanted them to be able to tell people to grab a release instead of telling them to grab Jython from svn.

There are many bug fixes, but also many bugs that have not yet been fixed. This is an alpha release so be careful!

Jython's Trunk Now Targets 2.5

2008-08-19T14:56:00.005-04:00

This post is mainly of interest to those that like to follow the development path of Jython. I just merged our development branch called "asm" to trunk. This marks a nice milestone on the path to getting 2.5 out. So if you are interested in grabbing bleeding edge Jython out of the svn repository, the asm branch is now closed, so use trunk instead. Trunk is located at:

https://jython.svn.sourceforge.net/svnroot/jython/trunk

Stay tuned, once I feel like things have settled down in trunk, I'll put together another alpha.

Code Review with Rietveld

2008-08-06T13:32:00.010-04:00

So I've been playing around with the online code review tool called Rietveld. You can find a live instance of the tool here. Since the tool is available to any project with a subversion repo, and it was authored by Python's First Interim Benevelant Dictator for Life Guido van Rossum, I had to check it out. Many serious Python developers are afflicted with a quasi-religious zeal to follow whatever the BDFL does or says, and I'm no exception :).

Still, that only gets me to try it out. So what do I think of Rietveld? So far I like it! My workflow with Rietveld goes something like this:

1. Make some changes in my local copy of the svn repository.
2. Call upload.py from the root of the local copy (which inolves authenticating and a comment).
3. Navigate to the issue url (the upload.py tool spits out a URL when it completes). Here is an example.
4. Take a look at the visual diffs (much easier on the eye when compared to a universal diff from email).
4a. Sometimes step 4 prompts me to delete the issue, change some code, and start again at step 1. This may be reason enough to use the tool.
5. Post the issue URL to #jython irc.
6. Check it in.
7. See what comments I get from #5 and act on them.

[Update:] Guido van Rossum pointed out that step 4a is much better accomplished with "upload -i" (This will let you add a new patch set to the same issue. Your reviewers can even see what changed between different patch sets. -- cool!)

So step 6 is probably premature if this was a traditional code review, but I *am* still evaluating, and of course any feedback is still likely to cause future changes (maybe even a rollback if I missed something really bad). Also, so far I am only using it for bigger changes -- again this is just better for evaluation purposes.

Overall I really like the tool, and I plan to continue using it. I am pondering a requirement for patch submissions from non-committers to go through Rietveld, but I still want to try it out for a while before I get serious.

Open Sourcing Science

2008-07-29T10:04:00.008-04:00

I just read Michael Nielson's fascinating weblog post The Future of Science. In it he describes the current state of collaboration typical of modern science:

These failures of science online are all examples where scientists show a surprising reluctance to share knowledge that could be useful to others. This is ironic, for the value of cultural openness was understood centuries ago by many of the founders of modern science; indeed, the journal system is perhaps the most open system for the transmission of knowledge that could be built with 17th century media. The adoption of the journal system was achieved by subsidizing scientists who published their discoveries in journals. This same subsidy now inhibits the adoption of more effective technologies, because it continues to incentivize scientists to share their work in conventional journals, and not in more modern media.

I remember the excitement that I had when I entered the PhD program in Neuroscience at Baylor College of Medicine. I was going to become part of Science where I was going to take part in the expansion of human knowledge in the most collaborative environment that has ever been seen. Or so I thought. It turned out that success as a scientist hinged on keeping much of what you do a secret until you can get to a place where you are ready to publish. If you reveal too many of your secrets you could get scooped. Scooped!? A term taken from newspapers -- a term that underscores the need to guard your secrets lest you lose everything for which you have worked.

Disillusionment with the system was definitely one of the things that helped me decide to leave science. Another was that I was just not all that happy doing "bench work" which is scientist slang for doing experiments in a lab. In the Schultz lab where I worked, Paul Schultz was about the best mentor that I could have asked for. I don't think I've ever met anyone who worked as hard as Paul does, and it's hard to think of a nicer guy. Still, I found that I had much more fun working on the software that ran our experiments than on the experiments themselves, and so my future path was decided. In fact, in open source software I have actually found an environment where collaboration really is open and easy. Hopefully the world of science can learn from the success of open source. Again from Nielson:

We should aim to create an open scientific culture where as much information as possible is moved out of people’s heads and labs, onto the network, and into tools which can help us structure and filter the information. This means everything - data, scientific opinions, questions, ideas, folk knowledge, workflows, and everything else - the works. Information not on the network can’t do any good.

If the tools and the cultural changes discussed in The Future of Science become reality, science can again become the most collaborative endeavor that the world has ever seen. It would become a place that I probably would not have left -- of course that is if I could have found a way to get past my bench work problems.

Wow -- bug reports already!

2008-07-15T14:57:00.004-04:00

Literally within minutes of posting the Jython 2.5 alpha, I started receiving bug reports. I'm really excited that so many people are watching and ready to try it out!

On the other hand I am chagrined that I did not test on Windows before I uploaded. Luckily my wife is still holding out and sticking to Windows, and in this case I'm glad. I applied a quick fix (plus a couple of extra fixes that where easy enough) and uploaded another version.

So if you have tried and failed to run the alpha, especially on Windows, please give it another try. By the way I incremented to 2.5a1.

Jython 2.5 Alpha Released!

2008-07-15T12:44:00.002-04:00

[Update:] Use Alpha3.

On behalf of the Jython development team, I'm pleased to announce that
Jython 2.5a1+ is available for download. See the installation instructions.

This is the first alpha release of Jython 2.5 and contains many new features. In fact, because we have skipped 2.3 and 2.4, there are too many to even summarize. A few of the features are:

generator expressions
with statement
exceptions as new-style classes
unicode support more in line with CPython
decorators

Under the hood Jython 2.5 has a new parser based on ANTLR 3.1 and the compiler has been refactored to use ASM.

There are so many more changes that I have missed more than I have listed. This is an alpha release, so there are known and unknown bugs, so be careful.

Update: there was a bug that caused a failure on Windows, so the version and download info has been updated.

EuroPython 2008

2008-07-10T06:09:00.012-04:00

EuroPython 2008 was a very eventful for Jython this year.

Jython had four sessions comprised of one tutorial, two talks and one panel. I participated in the panel and in half of one of the talks with Jim Baker. The other talk and the tutorial where done by Jim Baker and Tobias Ivarsson. All of the sessions where well attended, and the attendees where very interested. They asked plenty of great questions and even stayed past the time limit on a couple of occasions :)

Jython got so close to an alpha that I spent time on it when I should have been preparing for a presentation, but a couple of bugs made me hold off. Stay tuned: an alpha is within days, possibly hours if I can find the time today. I may not find the time as I am currently in Prague working with some NetBeans folks discussing the issues involved in getting NetBeans to support Python and Jython.

Ted and I announced Sun's intention to start working on the support of NetBeans at EuroPython by supporting the NBPython community. For more on that see the weblogs from Ted Leung and Allen Davis and the NetBeans news post. This is a project that is just beginning, so if you have an interest in Java, Python and IDE work, you should take a look.

Perhaps the best part of EuroPython for me was all of the interaction that I had with the PyPy folks. Pretty much one entire track at the conference was shared by Jython and PyPy. Best of all was a thirty minute session where all available PyPy and Jython folks got together to find some places where we might be able to collaborate. Details about that conversation can be found on Holger Krekel's weblog post on the subject.

Welcome Leonardo Soto, Jython's Newest Committer

2008-06-27T10:14:00.005-04:00

I just flipped Leonardo Soto's commit bit this morning. Leo has been working with the Jython project for about a year now. He was instrumental in getting Django running on Jython, submitting patches to both the Django project and to the Jython project. Many of the patches to the Jython project fixed features in the very core of Jython that prevented Django from running. Leo continues his work on Django on Jython this summer with a Google Summer of Code grant.

Please join me in welcoming Leo aboard!

EuroPython - Anyone have some cool demos?

2008-06-21T10:40:00.005-04:00

So Jim Baker and I have a talk at this years EuroPython Cool Stuff With Jython and I was hoping that some of you have cooler stuff than I do :). I'll be sure to give credit for demos I show -- and I'll promise a t-shirt for any demo code that I use -- though I have yet to have any made (stealing the idea from the JRuby guys) -- you'll have to wait until I have them :). The best place to send demo ideas and code is to the jython-dev or jython-users mailing list. I'll watch the comments here too of course.

Jython 2.5 Approaches an Alpha Release

2008-06-21T10:06:00.003-04:00

Jim Baker just published some great analysis of the remaining issues that are left before releasing an alpha of Jython 2.5. I'll add that we need to get re/sre support fixed so that we can run the 2.5 Lib tests and pull in CPython's 2.5 Lib. I just checked in some grammar changes that make the asm branch interpreter much better. So close... stay tuned!

Jython and Django Progress Part II: GlassFish and modjy

2008-04-24T10:16:00.009-04:00

In part I I showed you how to run the Django dev server from Jython. In this post I will demo Django on GlassFish. So starting with the app you had running from part I:

Download a preview build of GlassFish. I am using this snapshot, but a more recent snapshot will very likely work just as well.
Unzip the snapshot somewhere and put the resulting glassfish/bin in your PATH.
Download modjy and unzip it somewhere (you will only need modjy.jar)
Create a directory that will house your webapp. I'm calling mine "webapp".
Create a WEB-INF directory under webapp and a lib directory under that.
Copy jython-trunk/dist/jython.jar into webapp/WEB-INF/lib
Copy the whole jython-trunk/dist/Lib directory into webapp/WEB-INF/lib so that you end up with a webapp/WEB-INF/lib/Lib directory with all Jython's .py files.
Copy modjy.jar from modjy_0_22_0/modjy_webapp/WEB-INF/lib/modjy.jar into webapp/WEB-INF/lib.
Copy your postgres jdbc driver jar into webapp/WEB-INF/lib
Copy django-trunk/django into the webapp directory so that you end up with webapp/django/
Copy your mysite directory into the webapp directory so that you end up with webapp/mysite
Copy django-trunk/django/contrib/admin/media/ into glassfish/domains/domain1/docroot/ so that you end up with a glassfish/domains/domain1/docroot/media directory (this is so the admin css and js files can be found by Django).

Create a webapp/WEB-INF/web.xml file like this [Update: I've added a new init-param block with param-name=python.home and param-value=the home dir of my Jython dist - Thanks to Tristan for pointing out this omission]:


<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>

  <display-name>Django and modjy</display-name>
  <description>
    Djagno on Jython through WSGI with modjy
  </description>

  <servlet>
    <servlet-name>modjy</servlet-name>
    <servlet-class>com.xhaus.modjy.ModjyJServlet</servlet-class>
    <init-param>
      <param-name>reload_on_mod</param-name>
      <param-value>1</param-value>
    </init-param>
    <init-param>
      <param-name>python.home</param-name>
      <param-value>/path/to/jython-trunk/dist</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>modjy</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

</web-app>

Create a file application.py (note that it must be called application.py as this is the default that modjy expects. If you want to give it a different name see the modjy docs) directly under webapp with these contents:
```
import os

from django.core.handlers import wsgi
os.putenv("DJANGO_SETTINGS_MODULE", "mysite.settings")

def handler(environ, start_response):
h = wsgi.WSGIHandler()
return h(environ, start_response)
```
Now fire up GlassFish by issuing the "startserv" command
Then deploy our webapp with "asadmin deploy webapp"

Navigate to http://localhost:8080/webapp/admin and you should see the django admin app -- note the 8080 instead of the 8000 from the dev server.

This works pretty well -- though I've noticed that there is still a redirect problem when trying to log into the admin app from GlassFish. If you log in using the dev server from part I and then try the GlassFish version, it works fine. I will look into this bug when I can, but I really wanted to get this post out since it will be a while before I can come back to this (JavaOne is too close and I am on several panels (two with major demos) and doing a one hour talk :)

Start of an _ast Module in Jython's Trunk

2008-04-10T20:54:00.000-04:00

Philip Jenvey has a mako branch that uses _ast for its parsing. _ast is the module, new in Python 2.5, that exposes Python's internal parsing implementation. I have been using _ast to compare my antlr work with the real Python _ast. Philip's work on mako has motivated me to start on a real _ast for Jython. I just started it, and it is not yet sufficient for the mako work, but it's getting there.

The new _ast module relies on the new antlr parser which is now in trunk. For now you must put antlr-runtime-3.0.1 (which is in the extlibs dir) in your classpath to use it. Using it looks like this:


>>> import _ast
>>> compile("a=1", "<unknown>", "exec", _ast.PyCF_ONLY_AST)
tree: (Module (Assign (Target (Name a)) (Value (Num 1))))

Which outputs a tree representation for now.

If you do not use _ast or the PyCF_ONLY_AST flag, you should not need antlr-runtime-3.0.1.jar in your path.

Jython and Django Progress Part I: Dev Server

2008-04-08T11:36:00.006-04:00

Jython and Django are working better and better together. About six months ago I took a crack at it. I had a little success and put together a list of problems and some workarounds that I found. Leo Soto, Jim Baker and others did a much better job at getting Django trunk and Jython trunk working together. I am currently working on getting Django to run on GlassFish through the WSGI interface provided by modjy.

So here are the steps to get Django's dev server running on Jython:

Get postgresql installed, get a postgresql jdbc driver and put it on your classpath

Get Django from svn:

svn co http://code.djangoproject.com/svn/django/trunk/ django-trunk

Get Jython from svn:

svn co https://jython.svn.sourceforge.net/svnroot/jython/trunk/jython jython-trunk

Get patches for Django that haven't made it in yet from svn:

svn co https://jython.svn.sourceforge.net/svnroot/jython/trunk/sandbox/jbaker/django django-patches/

Copy patches over django-trunk:

mkdir django-trunk/django/db/backends/postgresql_zxjdbc/
cp django-patches/db/backends/postgresql_zxjdbc/*.py django-trunk/django/db/backends/postgresql_zxjdbc/
cp django-patches/dispatch/robustapply.py django-trunk/django/dispatch/robustapply.py

Create a shell or batch file to run jython with django on the path. I created the file below and named it "run"

#!/bin/sh
JYTHON_HOME=jython-trunk/dist
JYTHON_JAVA_ARGS="-classpath $JYTHON_HOME/jython.jar:$CLASSPATH"
$JAVA_HOME/bin/java $JYTHON_JAVA_ARGS -Dpython.path='django-trunk' -Dpython.home="$JYTHON_HOME" org.python.util.jython "$@"

Now create a new project. This is the start of the django tutorial except that I've explicitly used my "run" script and the full path to django-admin.py
```
./run django-trunk/django/bin/django-admin.py startproject mysite
```
Try it out! Note the --noreload directive. Reloading does not work yet.
```
./run mysite/manage.py runserver --noreload
```
Navigate to http://localhost:8000 and you should see the django default page.
Now edit mysite/settings.py. For DATABASE_ENGINE use postgresql_zxjdbc, and add 'django.contrib.admin' to the bottom of the INSTALLED_APPS as outlined in the django tutorial. Of course, also put the database username/password etc into the right spots in settings.py.
Edit mysite/urls.py and uncomment the admin app line.
Now sync the database
```
./run mysite/manage.py syncdb
```
Stop and start the app again (as in step 8) and navigate to the admin app at http://localhost:8000/admin/

Now if you want you could try out the Django tutorial with Jython. If you do let me know how it goes -- I haven't tried it all yet and I have to get back to Glassfish and modjy. Leo Soto has proposed Django work for the Google Summer of Code, and Jim Baker is likely to be the project mentor, so the remaining issues should get cleared up quickly followed I expect by more amazing stuff. At the very least I or perhaps Leo will get the MySQL backend I started up and running pretty soon.

Come back for the next post -- it will be on Glassfish and modjy. I've already had some pretty good success there.

PyCon 2008 and Jython

2008-03-21T13:42:00.000-04:00

I knew that the Python community contained fans of Jython, but at PyCon this year I was just blown away by all of the encouragement and positive feedback on Jython's recent progress. Particularly nice was the encouragement that I got from many core Python developers. The main input I get is: "When will Jython 2.5 be out?" and "How can we get our framework/app working on Jython?". It is too soon to give a solid date for Jython 2.5, but I am willing to say that it will come out in 2008. Also an alpha should come out soon -- I'm going to try to get one cut before JavaOne.

I also got plenty of congratulations on my new job at Sun. Almost everyone I talked to felt positive about this move from Sun. One individual whose experience with Sun dates back to the nineties expressed some doubt about Sun's ability to play well with open source. I can say with some confidence that, at least in the corner of Sun that I live in, they really seem to get it. As an example, read the bottom of this post from Vice President Jim Parkinson where he tells us that Ted and my roles in the open source community are not changing. It is nice to get that kind of statement from that far up the chain. For further reassurance look no further than the way Sun has handled the JRuby project.

This was the first time I met Ted Leung in person. Be sure to read his notes on PyCon 2008 as they contain much more detail than mine. Ted was hired by Sun at the same time that I was hired. His job description ranges wider than mine: He is tasked with helping Sun become a good member of the Python community. Mine of course is just to make Jython succeed, a task that is quite a bit easier to define.

I got to meet some IronPython folks, Jim Hugunin and Dino Viehland. Jim Hugunin is of course the original inventor of Jython as well as IronPython. Dino is the lead developer of IronPython. They have also managed to get Django running in their world, and they are doing some pretty cool stuff with Microsoft technologies like Silverlight. I feel for them in that they are completely forbidden from looking at even a line of CPython code, and it is fairly difficult for them to send patches to outside projects (to, for example, make some part of Django work better on IronPython). They are working with the lawyers to get them to ease up a bit, but that's tough going. I'm not sure how they can work like that... ouch.

At PyCon, Jeffrey Yasskin started an effort to get a concurrency memory model written for Python (Similar to the way Java and C++ have such models). I have high hopes that this can be accomplished as it should make it simpler to think about concurrency in Jython (Something that Jim Baker has been spending a lot of time on lately).

So on to my favorite part of PyCon: the sprinting. Last year the Jython sprint consisted of three guys at a table with me as 1/2 a sprinter while I was working with Trac. This year Jython took up a room with around 11 sprinters. Sprinters from other projects came in throughout the week asking about how to get Jython working with their projects which was very nice. A particular moment where the value of the PyCon sprints stood out to me is when brand new Jython committer Nicholas Riley was working furiously on getting parts of Twisted working on Jython while surrounded by about six Twisted core developers giving him pointers. Awesome.

A partial list of Jython sprint accomplishments:

Start of Twisted on Jython
New compiler/New parser work
Better threading support for Jython
Collaboration with SQLAlchemy to get JDBC support
Work on writing decimal.py as a wrapper around Java's BigDecimal
Work on porting mmap to jython

I'm sure I missed some of the work that was done on Jython at PyCon -- there was so much!

Jython and Google Summer of Code 2008

2008-03-07T12:16:00.006-05:00

Google Summer of Code is starting up again! That means it is time to start thinking of gsoc projects for 2008 and time for folks to start thinking about proposals. We keep some ideas in the Jython wiki under PotentialProjects. The overview of Jython's Summer of Code participation is here. Those who think they might like to mentor a Jython project please put your name on the list of potential mentors on that page. I resurrected the Jython help system idea from Brian Zimmer. I would be very willing to mentor that one. Other ideas should go on the aforementioned PotentialProjects page.

Last summer was a great success for us, particularly the work of Tobias Ivarsson mentored by Jim Baker producing I very nice prototype for a new compiler. Let's make this one even better!

So Long Gary Gygax

2008-03-05T12:05:00.003-05:00

Gary Gygax died yesterday. His games brought me lots of enjoyment as a kid. It's funny just how many programmers I've met also played those games. It's also funny just how much nostalgia I get from the cover of the first version of D & D that I owned. Thanks for the memories and the games Gary, and so long.

Jython's Future Looking Sunny

2008-03-03T10:30:00.003-05:00

Sorry for the title. There is something about Sun that makes it almost impossible to avoid solar puns. I just didn't have sufficient willpower to resist. I will try to be stronger in the future.

So by now you've probably guessed it: Sun Microsystems has hired me to work full time on Jython. They have also hired Ted Leung to represent the wider world of Python at Sun.

I don't think I can overstate just how excited I am about this. For a long time now I've been obsessed with Jython. Now I will be able to let my obsession take over completely.

So what does this mean for Jython? First off, just in case anyone is worried: Jython is going to remain completely open source. Sun has applied for membership to the PSF and the PSF will continue to be the steward of Jython's code. This move by Sun means that Jython is going to get some of the attention that it needs to move forward.

The JRuby folks have already been working with the Jython folks to find those places where we can share code. The fact that they work for Sun was no barrier at all to cooperation, but being in the same company means that I am going to interact with them all the more. Close cooperation with JRuby has no downside for Jython whatsoever.

I have to especially thank Tim Bray, who has been pushing the dynamic language thing at Sun for quite a long time. I'm sure the warm welcome that I got at Sun was in no small part due to the enormous success of the JRuby work that has been going on there, so thanks to Charles Nutter and Thomas Enebo for their work. Also thanks to the many folks at Sun who have been pushing for this, including Eduardo Pelegri-Llopart.

And of course thanks to all of you who use, contribute to, and talk about Jython. Jython is above all things a community effort. We should all share in the excitement. Hurray!

setuptools now runs on Jython trunk

2008-02-10T12:10:00.000-05:00

In his work to get Pylons running on Jython, Philip Jenvey had to first get setuptools running on Jython. I gave it a try with SQLAlchemy, by running

jython setup.py install

In my local copy from SQLAlchemy's svn repository, and it worked! After running the above command, I now have a site-packages directory with:


README
easy-install.pth
setuptools.pth
SQLAlchemy-0.4.3dev_r4149-py2.3.egg
setuptools-0.6c3-py2.3.egg

And I can

import sqlalchemy

successfully without any further work. Getting SQLAlchemy to run well with Mysql and JDBC will be next, but that's for me to do :)

Great work Philip!

PyCon 2008 in Chicago

2008-01-31T12:37:00.000-05:00

Registration for PyCon 2008 is now open. It will be held in Chicago March 14-16, 2008.

My talk is #70 on this page and is one of three talks on Jython this year. Hope to see you there!

A Proof of Concept ASM Compiler for Jython

2008-01-21T00:31:00.000-05:00

Now that I have a reasonable parser in Antlr, I'm back to thinking about the compiler again. Currently Jython has a hand crafted bytecode emitter. It was built in a generic fashion and is actually a very nice implementation. For an earlier Jython this was a necessity, because there where no good open source frameworks out there that could be used for bytecode emission. These days, there are a number of good open source frameworks for this task. ASM stands out as a particularly good one if you are looking for a small, fast, and well documented framework with a vibrant community of users and developers. The advantage of using a framework like ASM over a hand rolled implementation is that the developers of Jython can let the ASM folks worry about new JVM features like annotations, backwards compatibility issues, etc, leaving Jython developers more time to make Jython a better implementation of Python.

A few months ago I did a one for one translation of the current compiler into ASM and found that this was a straightforward (if a bit tedious) task. This translated compiler lives in the svn branch asm_compiler. The asm_compiler branch's build.xml uses jarjar to bundle the asm libraries together into a jython-complete.jar. I called it jython-complete mirroring the jruby project's jruby-complete.jar vs a jruby.jar that requires dependencies. I think Jython will eventually follow suit with one jar that bundles everything together and another that does not. asm_compiler currently passes all but four of the regression tests that trunk passes on my machine.

Since I did not try to go beyond the current functionality of 2.3, this is just a proof of concept step. The next steps will be to start re-writing the "newcompiler" work in Java. The newcompiler work which sits in the svn trunk and sandbox prototypes an improved compiler that implements 2.5. newcompiler is the impressive outcome of a Google Summer of Code project by Tobias Ivarsson mentored by Jim Baker. Having said that I'd still like to see if I can make asm_compiler the compiler of Jython's trunk -- it may work better to incrementally move to newcompiler compared to trying to replace the current strategy all at once.

A First Cut at an Antlr Based Parser for Jython Finished

2008-01-10T07:57:00.000-05:00

The majority of my Jython time for the last couple of months has been spent working on a new parser for Jython. This parser is being written in Antlr3 and lives in the Jython sandbox.

CPython 2.5 introduced a new library called _ast that allows direct access to its internal parser. Jim Baker wrote some python that pretty prints the _ast results, and I extended it to do a diff with the output of the new parser. The current results of this comparison with all of the .py files in CPython 2.5's Lib directory is a perfect match for just over 75% of these files (there are 1230 of them). The majority of the remaining problems are mismatches in the representation of floats and unicode, although there are plenty of real bugs remaining, especially in the lexer pass. The sandbox project has a README that lists the bugs that I know about.

There are two grammars, a combined lexer/parser in grammar/Python.g that emits a simple parse tree which is a reasonable representation of the code in an AST form. The real work occurs in the tree grammar grammar/PythonWalker.g. This one walks the output of Python.g and emits a tree of Java classes that will later be consumed by a future Jython compiler. PythonWalker does a fair amount of processing on the parse tree to shape the AST so that it matches _ast.

The code for the nodes that PythonWalker.g emits is also generated. This is done using asdl_antlr.py. asdl_antlr.py uses the same core code that CPython uses to create their parser, which is copied into the Jython sandbox (asdl.py and spark.py).

Plenty of work remains. First I will need to get the ASTs to match better -- I'm hoping to at least get a 100% match for the Lib of CPython 2.5. Once that is done Python.g and PythonWalker.g are going to need a cleanup pass -- there is plenty of kludginess in there to get it up and running. And of course then there is the compiler, but that is a topic for another day.

Django Beginning to work on Jython

2008-01-04T08:05:00.000-05:00

Work on Jython since 2.2 has been proceeding at a blistering pace. Commits are coming in so fast that I have been having trouble keeping up at times. Recently some Jython folks got together with some Django folks and together figured out what was missing. I participated in the early work (and I still have a mysql backend that I need to contribute to the effort) but then I got too caught up in rewriting Jython's parser in antlr and so lost track. More on that another time :).

Jim Baker has a nice write up of Django on Jython and the news was picked up by The Server Side.

This is just the beginning -- we are also looking at Pylons, TurboGears, and much much more. Exciting times.

Jython 2.2.1 released

2007-10-14T19:11:00.001-04:00

Jython 2.2.1 is out.

Here are the directions for installation.

This release keeps file reading and writing from going through the JVM's default charset, and fixes a problem with importing Java code from multiple threads among many smaller changes. See the NEWS file for full details.

Jython 2.2.1rc2 Released

2007-10-05T10:10:00.000-04:00

Jython 2.2.1rc2 is out.

Here are the directions for installation.

This is a bugfix release, see the NEWS file for details.

If no new problems are found in this candidate, 2.2.1 will be released
a week from now.

One Laptop per Child: Give one, get one

2007-09-24T14:38:00.000-04:00

If you are like me and you've been wanting to get an OLPC for your child (or more likely you are a hardware geek and you want one for you -- hopefully my daughter will let me play with it too), your chance has come.

Jython 2.2.1rc1 released

2007-09-24T08:00:00.000-04:00

A release candidate for Jython 2.2.1, a bugfix release of 2.2, is available for download. See installation instructions. I think this is an important release in that it shows that Jython continues to move forward even after the release of 2.2.

The biggest change in this release is that file reading and writing will no longer be run through the current JVM's default charset. In the 2.2 release, the bytes read in from a file opened in text mode would be decoded by the default charset and then when written out, bytes would be encoded using the same default charset. In 2.2.1rc1, read returns unadulterated bytes and write doesn't automatically encode the bytes it is writing.

A full list of changes is available in the NEWS file.

If no new problems are found in this candidate, 2.2.1 will be released a week from now.

-Frank

Work towards Django on Jython

2007-09-06T09:40:00.000-04:00

A couple of weeks ago I worked on Django on Jython for a Jython sprint. I found some places where Jython could use some improvement, and I've been poking around with that. In the meantime, Leo Soto M. took Jython on Django further than I did and there was a nice discussion on the Django list about all of this. It looks like the Django folks are as excited to get their framework working on Jython as I am, which is great because it will go so much faster that way.

Jython 2.2 released!! Woohoo!!

2007-08-23T07:53:00.000-04:00

On behalf of the Jython development team, I'm pleased to announce that
Jython 2.2 is available for download. See the installation instructions.

This is the first production release of Jython in nearly six years,
and it contains many new features:

new-style classes
Java List integration
PEP 302 implementation
iterators
generators
__future__ division
support for running on modern JVMs
a new installer
ssl and non-blocking support for socket

This gives Jython the same set of language features as Python 2.2.
For a more complete list of the additions from 2.1 to 2.2, see the
NEWS file in the release. Only the version numbers changed in the
code from 2.2rc3 to this release.

Woohoo!!

Speaking on Jython in Chapil Hill, NC next Tuesday

2007-08-21T09:40:00.001-04:00

I'll be giving a talk on Jython 2.2 and current Jython development on Tuesday, August 28, 7pm at 328 Phillips Hall, UNC-Chapel Hill in North Carolina for the Triangle Zope and Python Users Group. It will be a basic introduction to Jython targeted at Python developers, but since I learned my lesson at PyCon, I'll be sure to do more demoing.

Jython 2.2 rc3 is out!

2007-08-02T11:42:00.001-04:00

The Jython development team is pleased to announce that Jython 2.2rc3
is available for download.

Here are the installation instructions.

A few new pieces of functionality have been added since 2.2rc2:

Added telnetlib from CPython
Added cpython_compatible_select to select. See here for information on when to use it.
Several more java.nio exceptions are mapped to their corresponding Python error codes when thrown.

The following bugs are also fixed in this release:

recv on closed sockets threw an exception instead returning the empty string
A PySystemState being garbage collected caused System.out and System.in to be closed. This would cause 'print' to stop working.
Closing a FileWrapper on a socket closes its underlying socket
Sockets just have their [In|Out]putStreams closed instead of being properly shutdown by shutdown()
SO_REUSEADDR is reset on sockets from a server socket's accept call causing later binds to the server socket's port to fail.
Client sockets that have bind called before connect don't respect SO_REUSEADDR
execfile() throws a NullPointerException in the interactive console

Enjoy!

SQLAlchemy, MySQL, and Jython

2007-07-17T07:43:00.001-04:00

I tried the 2.3 branch of Jython with SQLAalchemy against MySQL and found
that it wasn't that hard to get it to work for a (very) simple test.
This is by no means complete or even good, but I am keeping the code
here: http://jython.svn.sourceforge.net/svnroot/jython/trunk/sandbox/wierzbicki/sqlalchemy/

The three files are a simple test (sqla.py), a monkey-patched version of database/mysql.py (mysql.py) and the "svn diff" against the sqlalchemy repository as of today (mysql.diff), so I can keep track of the changes I made to get things to work. mysql.py can be pasted on top of the real one, then you can run jython (latest from the 2.3 branch) and it works, at least on my
machine :)

The table I'm testing against on mysql:


mysql> select * from users;
+----+-------+
| id | name  |
+----+-------+
| 1  | user1 |
| 2  | user2 |
+----+-------+

The test code looks like this:


from sqlalchemy import *

db = create_engine('mysql://username:password@localhost/mydb')
metadata = BoundMetaData(db)

users_table = Table('users', metadata, autoload=True)

s = users_table.select()
r = s.execute()
print r.fetchall()

And produces output that looks like this:


[(1L, 'user1'), (2L, 'user2')]

One thing I had to do was switch "re" to "sre" because our "re" is
missing at least one method. I'll file a bug or fix it (maybe
tonight).

I posted this to the sqlalchemy list -- and Michael Bayern
sounded very enthusiastic about helping to get sqlalchemy running on
Jython.

Jython 2.2 RC2 is out!

2007-07-10T09:39:00.001-04:00

The Jython development team is pleased to announce that Jython 2.2rc2
is available for download.

Here are the installation instructions.

This is a bugfix release.

Enjoy!

Jython 2.2 RC1 is out!

2007-06-25T20:35:00.000-04:00

The Jython development team is pleased to announce that Jython 2.2rc1
is available for download.

Here are the installation instructions.

This release candidate features a new socket module with support for
non-blocking sockets and SSL as well as many bug fixes.

Enjoy!

JVM Languages: The Future (via Headius)

2007-05-29T14:11:00.000-04:00

Charles Nutter has announced a new Google Group to (in his words):

talk shop about language implementation strategies, pain points on the JVM, and what we can do to build a common set of libraries, frameworks, and patterns to ease and improve the Java platform's support for many languages.

This is a very exciting time to be involved in language development on top of the JVM. There have already been posts from the worlds of JRuby, Groovy, Jython, and even a JVM Lisp ~~dialect~~ implementation called ABCL. If you are interested, please sign up.

NailGun correction

2007-05-24T07:56:00.000-04:00

Careful readers of the last post will have noted that my NailGun run did *not* perform better than the native Python run. It looks like the results vary. I ran the test once while doing other things (and noticed that ng/Jython did better), and then ran the tests as a group so that I could paste them in unchanged. I didn't notice that Python had moved ahead. Anyway, you'll just have to trust me or try it yourself to find that ng + jython can outperform Python in this fairly silly test. I say the test is silly, since a "print 'hello'" is almost entirely dominated by startup time and so shows the most improvement. In any case NailGun looks like it should help with those little Jython scripts that I use for testing, and will help me get to an interactive session faster.

Playing with nailgun

2007-05-23T10:38:00.001-04:00

From following the JRuby development list I found NailGun which is described on the website:

NailGun is a client, protocol, and server for running Java programs from the command line without incurring the JVM startup overhead.

NailGun runs as a server that listens on port 2113 by default, and takes requests from the ng client, which is written in C. Note that no attempt has been made to make this secure (so beware). Since I use Jython from the command line fairly often for testing and for inspecting Java libraries, and the JVM startup time is an annoyance, I thought I'd give it a try. I set up a script for launching NailGun with the Jython options:


#!/bin/sh
JYTHON_HOME=/Users/frank/src/jython/2.3/dist
JYTHON_JAVA_ARGS="-classpath $JYTHON_HOME/jython.jar:$CLASSPATH"
$JAVA_HOME/bin/java -server $JYTHON_JAVA_ARGS -Dpython.home=$JYTHON_HOME \
com.martiansoftware.nailgun.NGServer

And a launcher for jython that I called ngjy:


#!/bin/sh
ng org.python.util.jython "$@"

So a simple test shows some promise:


[frank@dhcp239-29 bin]$ time jython23 -c 'print "hello"'
hello

real 0m0.961s
user 0m0.845s
sys 0m0.082s
[frank@dhcp239-29 bin]$ time ngjy -c 'print "hello"'
hello

real 0m0.179s
user 0m0.002s
sys 0m0.009s
[frank@dhcp239-29 bin]$ time python -c 'print "hello"'
hello

real 0m0.052s
user 0m0.015s
sys 0m0.034s

Very cool! Though an unfair test, it is pretty cool that Jython can be made to out-perform Python on the command line.

Jython beta2 is out!

2007-05-17T09:30:00.000-04:00

The Jython development team is proud to announce the release of Jython 2.2's second beta.

Much like the last beta:
Get it here:

Install like this:

java -jar jython_installer-2.2b2.jar

Cheers!

-Frank Wierzbicki

Jython 2.2 beta1 Released!

2007-02-08T20:42:00.000-05:00

The Jython development team is proud to announce the release of Jython 2.2's first beta!

Get it here:

Install like this:

java -jar jython_installer-2.2b1.jar

Cheers!

-Frank Wierzbicki

Jython Roadmap

2007-02-03T21:28:00.000-05:00

I have posted a new roadmap page for Jython here. It is primarily a reiteration of an earlier email to the jython-dev list.

My Talk Was Accepted at PyCon!

2006-12-01T07:04:00.000-05:00

My proposal, Jython for Python Developers, see #93, has been accepted, so I'll be doing a Jython talk at this year's PyCon. Hope to see you there!

JRuby folks reach out to Jython

2006-11-26T13:15:00.000-05:00

Charles Oliver Nutter recently posted on the Jython-dev list with offers of help and advice. He has a weblog entry on the subject. It is very exciting that Sun has shown support for dynamic languages by hiring him and Thomas Enebo to work on JRuby full time. Even more exciting is the offer from Charles to collaborate on some internals, with an eventual goal of making cross language support on the JVM easier, especially cross-language calling (so, for example, objects written in JRuby could easily make a call directly against objects written in Jython).

Very exciting times.

I now work for Red Hat

2006-11-26T12:55:00.000-05:00

As of November 20, 2006 I am a permanent employee at Red Hat. I've been contracting with them for several months, but I didn't think a contract job was worth mentioning.

So, what does this mean for Jython? Well, working on Jython internals is still an after hours thing, but I've been making some great connections with JBoss folks and with some others at Red Hat that can probably help Jython in the future. Post 2.2 release I plan on making sure the 2.2 version finds its way into Fedora and then eventually on to RHEL, at least as a simple yum or up2date call. Also, at least one JBoss guy I've talked to is interested in making sure that JBoss is a hospitable place to run Jython.

I'm through the initial ramp-up that comes with working at a new company, and I think I'm going to have more time to work on Jython beginning in early December. Meanwhile, the other developers that are now working on Jython have made great progress, with Charlie Groves committing the last show-stopping feature (slots) just a few days ago. I know I've said this before (I think I've learned my lesson about making promises too quickly, at least as far as Jython is concerned) but we really are closing in on a beta this time.

New Website is Live

2006-06-01T21:13:00.000-04:00

The new jython website is finally live. Some new developer docs are the main reason I decided to switch it over -- the old docs only talked about cvs, but the code is now hosted on subversion.

Migration to Subversion

2006-04-08T21:48:00.000-04:00

The good people at SourceForge now provide Subversion repositories. I just used their migration tool to move the Jython repository data from CVS to Subversion, and the new repository is located at https://svn.sourceforge.net/svnroot/jython/. If all went well this will be the Jython repository from now on. Soon I will finally be able to re-arrange the repository with no loss of project history (something that would have been very hard with CVS).

Jython Wiki is back!

2006-01-01T14:02:00.000-05:00

It looks like the Jython wiki can be edited again. I just randomly decided to try to edit my home page and it worked! From the history logs it looks like we have Andrew Kuchling to thank.

More Jython Web Design

2005-12-13T20:30:00.000-05:00

The web site mockup has received (mostly) positive feedback. Here are the main criticisms:

The left navigation bar is too small.
Some of the fonts do not show up well in some browsers (and are often too small).
There needs to be some kind of clear status section on the front page.

So to address these concerns I plan to:

Widen the left nav bar.
Remove the font specifications from the borrowed css (so the browser uses the default fonts). Make sure the font sizes in the css make sense.
Once live, there will be a clear "status" section on the front page that will give an indication of the project's progress towards a release.

Jython Website Re-Design

2005-12-11T22:21:00.001-05:00

I've been working on a re-design of the Jython website for the last few weeks. I've put the latest version of the re-design up here. [Update mockup link removed as the mockup is gone (having been applied to the real site)]

Here is a summary of the design ideas that are in the mockup:

Documentation source code: The reStructured Text format from the Docutils project was used for all of the documentation "source code", even the FAQ. Each page has a "View Document Source" link at the bottom if you want to look at the reStructured Text.
Webpage format: I used a "long page" form for much of the site. That is, I've combined related web pages into single web pages with a table of contents at the top. This way, a simple browser-based search can be used on the pages (cntl-F on most browsers).
Stylesheets: I used a more modern css based approach for the look and feel of the site. The stylesheets are mainly borrowed from various apache projects, especially the Lenya project. If anyone knows the name of the person (or persons) who wrote the css for the Lenya website, please let me know so I can give credit. The logo used was created by Jesse Ross.
Navigation: I removed most of the top level navigation, and replaced it all with 2 tabs, one for the main project and another for "related projects". Note that "related projects" doesn't have any content yet.

Please let me know what you think. This is still just a mockup, so there are dead links, missing content, etc. I'll put up a better mockup soon, and then transition to the real site (given community approval).

[Update: this went live long ago -- I should have updated this post when that happened]

Weblog Announcement

2005-12-06T12:30:00.000-05:00

Since Brian Zimmer has passed Jython's "primary maintainer" baton to me, and I would have at least one reader, I've decided to start a weblog. I'll try to write about Jython related topics on a reasonably regular basis. I especially hope to use this weblog as a place to keep readers informed about the progress of Jython development.