The Mozilla community is proud to announce that Firefox 4 Beta 3 is now available for download on Mac, Windows or Linux.

Firefox 4 Beta 3 includes several major features and improvements – by testing them early we’ll be able to respond to your feedback for future versions of Firefox. The included Feedback Add-On that helps you let us know what you think about the new features and technologies in the beta. You can read more about this release on the Mozilla Blog, or at any of the following links:

• Read more about some of the major features in this beta
• Take a look at our big chart o’ technology that’s included in this beta
• Read the release notes for Firefox 4 Beta 3

We want to thank the Mozilla community of nightly testers for the amazing feedback that helped shaped Firefox 4 Beta 3. We appreciate your assistance in testing this preview of the next version of Firefox!

The last couple of days we had some time to use our new qxoo package, which you might already have read about,  and did some experiments with it. All of us here in the core team like it so much we thought we had to write another blog post to show some details on how to use it on the server side.

node.js

So here we go! As a first example I want to show you how to use it on node.js. We are using classes, inheritance, properties, the event system and even single value binding in this example.

var sys = require('sys');
var qx = require('./qx-oo.js');
 
qx.Class.define("Fish", {
  extend : qx.core.Object,
  properties : {
    age: {
      event : "changeAge",
      init : 3
    }
  }
});
 
qx.Class.define("Shark", {
  extend : Fish
});
 
var fish = new Fish();
sys.print("The fish is " + fish.getAge() + " years old\n");
 
var shark = new Shark();
shark.addListener("changeAge", function(e) {
  sys.print("The shark changed its age to " + e.getData() + "\n");
});
shark.setAge(5);
sys.print("The shark is " + shark.getAge() + " years old\n");
 
fish.bind("age", shark, "age");
fish.setAge(7);
sys.print("The fish is " + fish.getAge() + " years old\n");

The output looks something like this.

The fish is 3 years old          // 1
The shark changed its age to 5   // 2
The shark is 5 years old         // 3
The shark changed its age to 3   // 4
The shark changed its age to 7   // 5
The fish is 7 years old          // 6

Surely you've seen that we are creating two classes, a fish and a shark which is a fish of course. Our fishes have one property named age. Properties, in short, are data stores with automatic generated accessors and other goodies like in this example, a change event. We create an instance of each class and play around with the generated setter, getter and events. The second to last line shows the single value binding which synchronizes the two age properties.
This should look familiar to anyone using qooxdoo, the only difference is that its running on node.js and not in the browser (This is the corresponding "browser version", just make sure you check the Log pane to see the same messages).

Rhino

Next up, let's write a script to run in Mozilla's Rhino that demonstrates the use of Mixins:

load(["qx-oo.js"]);
 
qx.Mixin.define("MBar", {
  members :
  {
    bar : function()
    {
      return "bar!";
    }
  }
});
 
qx.Class.define("Foo", {
  extend : qx.core.Object,
  members :
  {
    foo : function() {
      return "foo!";
    }
  }
});
 
qx.Class.include(Foo, MBar);
 
var foo = new Foo();
print(foo.foo()); // "foo!"
print(foo.bar()); // "bar!"

Again, with the exception of the Rhino-specific load and print statements, this is plain qooxdoo. Assuming that js.jar (the Rhino Java archive), qx-oo.js and a file containing the code listed above, named e.g. test.js, are all located in the same directory, this is the shell command that will run the script in Rhino:

java -cp js.jar org.mozilla.javascript.tools.shell.Main test.js

If you want to give it a try you don't have to download the SDK and build it yourself. Just go to our devel applications page and download the precompiled script in either an optimized or unoptimized version. This will be updated usually once a week on Friday, like all other qooxdoo online apps.  While this qxoo package is still in experimental state, the code it contains is rock solid, having been used for a couple of years in the browser. Give it a try and send us your feedback!

Hi all! After an exciting week, here comes the usual round-up.

qooxdoo Releases

This week saw the joint release of qooxdoo 1.2 and 1.1.1. Hope everybody is enjoying it .

qxoo

We have managed to build a single JavaScript file including the whole qooxdoo OO layer which can be used in non-browser environments. See more details in the corresponding blog post.

Framework

You can now set windows to be always on top of other windows (using the Window.alwaysOnTop property) and customize default validator error messages (qx.util.Validate.*). If a widget is disabled and has a tooltip, the tooltip isn't shown anymore.

Contribution Demobrowser

As already mentioned in a separate post, we've published the new Demobrowser for contributions as a showcase for the many cool projects in qooxdoo-contrib.

Community Soap client 0.6.0-beta5

Burak Arslan has released soap client 0.6.0-beta5, which goes together with his Python based soaplib 0.9.1, the server-side SOAP library. Writes Burak:

"i've spent a good chunk of past month working on soaplib, the python soap server library, and qxsoap, the soap client for qooxdoo.

in the 0.9.1 series of soaplib i've implemented multiple namespace support, schema validation, and miscellaneous features like regular expression validation in soaplib, among many other additions and bugfixes.

in the 0.6 series of qxsoap, support for most of soaplib's capabilities is added (except inheritance support, and other misc features) it also comes with a full test suite and a remote table implementation. and no more gpl controversy, i've rewritten it all, it's a bsd-licensed library.

there's still a bit of work to be done in its bowels but it's mostly working.

you can find it in the qooxdoo-contrib/Soap directory, but the code is in http://github.com/arskom . it's fetched to qooxdoo-contrib repo via svn:externals definitions.

you must install the latest soaplib alpha from pypi and twisted.web to run the test server. stock python is enough to run the demo server. it's tested with qooxdoo 1.1.

soaplib exports a wsgi application, so it's a server-agnostic solution.  see here for more info:

http://mail.python.org/pipermail/soap/2010-August/000151.html

by the way, i forgot to add that class generation from wsdl is implemented. this lets you seamlessly export class definitions from your server code to qooxdoo.

the code for tests are good tutorials about new ways you can use qxsoap.

awaiting your feedback!"

Node.js

node.js and similar non-browser JS environments received a lot of attention on the mailing list recently. qxoo plays in this direction. In the course of the discussion Christian Boulanger came up with a new NodeSocket contribution. Christian wrote:

"I just checked in the NodeSocket Contribution into qooxdoo-contrib. This contribution wraps the Socket.IO event transport for use in qooxdoo.
http://qooxdoo-contrib.svn.sourceforge.net/viewvc/qooxdoo-contrib/trunk/qooxdoo-contrib/NodeSocket/trunk/

Here's a screenshot:
http://qooxdoo.678.n2.nabble.com/file/n5379905/Bild_1.png

If you look at the server code:

http://qooxdoo-contrib.svn.sourceforge.net/viewvc/qooxdoo-contrib/trunk/qooxdoo-contrib/NodeSocket/trunk/demo/default/socket/server.js?revision=20608&view=markup

and see how little code is necessary to make this work, you might understand
why I am so excited about this technology.

...

I don't have time to provide a public demo, so if you're interested, you'll
need to download and install the demo yourself.

Known Issues/To Do
==================

- The demo has only been tested with the latest Safari and Chrome, which
both support web sockets. Is is currently not working with Firefox because of
some issues with the WebSocket Flash applet.
- The static file server is fast, but inefficient because it doesn't do any
caching. There are several static file servers for node.js which should be
integrated to make it more efficient.

This is only the first step. Next is getting a JSONRPC server working."

See his mailing list announcement for full details.

That's it for this week - see you around next time.

Thunderbird 3.1.2 is now available as a free download for Windows, Mac, and Linux from www.GetThunderbird.com. We recommend that users keep up to date with the latest stability and support versions of Thunderbird, and encourage all our users to upgrade to this very latest version. If you already have Thunderbird, you will receive an automated update notification within 24 to 48 hours. This update can also be applied manually by selecting “Check for Updates…” from the Help menu.

This releases fixes some stability issues and several user experience concerns.  For a list of changes and more information, please review the Thunderbird 3.1.2 release notes.

Note: All Thunderbird 2 users are strongly encouraged to upgrade to Thunderbird 3.1.2 by downloading it from www.GetThunderbird.com

It has been a topic a couple of times on our mailing list, to bring the OO layer of qooxdoo to non-browser environments. I took some time after the last release to check what's necessary and build a proof of concept. That went so well that I included it into the framework to make it accessible for everyone. You can build your own qooxdoo OO package by just using a new introduced generator job in the framework folder:
./generate.py build-qxoo
That job generates a simple but powerful JavaScript file including all the qooxdoo OO goodness including classes, interfaces, properties, ...
My intention was to build a file which can be used in a web worker, for example for running unit tests. But I did also test the file on Rhino and node.js, which are two JavaScript implementations outside the browser, and it worked there just as well.
It still is only a proof of concept but if you are interested give it a try and give me feedback.

We are happy to announce another joint release of the qooxdoo framework. You can download versions 1.2 and 1.1.1, the corresponding release notes and manuals are online as well.

The qooxdoo 1.2 release comes with substantial improvements in almost the entire range of the framework. Here is a brief overview:

• The entire manual is now in SVN, using reStructuredText as markup. It is delivered with the SDK as HTML and also as a PDF document for offline reading (about 400 pages).
• A new virtual List was added, which can handle really large numbers of items. It takes full advantage of qooxdoo's data binding layer, so another demo shows how you can create an extended list with custom renderers. The virtual List is marked as experimental, and we look forward to include user feedback as we continue with the development of additional virtual widgets.
• As another preview we added a Selenium window to the cross-browser Inspector to aid in developing automated GUI tests for qooxdoo applications.
• The API Viewer API Viewer now allows you to open distinct tabs for any class or package description. Just press “shift” or “ctrl” when mouse-clicking on a reference.
• Many handy features made it into the release to support your work as app developers, e.g. generating API doc files for dedicated classes by a single command, including child control info with the API reference, several optimizations in the toolchain, more configuration options for the generator, experimental Jython support, real-time logging in the Playground, and so on.
• More than 200 bugfixes and enhancements over the previous release.

At the same time, and following our release scheme, we're releasing an 1.1.1 version, which is a regular patch release of the 1.1.x branch and contains only bug fixes. It can be used as a drop-in replacement for anybody using 1.1, and users of these versions are encouraged to upgrade, i.e. if they don't upgrade directly to 1.2.

Many thanks from the core developers to the community of contributors and users, who helped making these versions the most advanced releases to date. Enjoy!

As you surely all know, qooxdoo-contrib is the project's place for hosting various contributions and therefore a vital part of the qooxdoo ecosystem. We always try to improve things there, so here's a preview of a feature we've been working on for quite a while now.

There's a lot of great projects in qooxdoo-contrib, but the only way to try them out for yourself is to check out the repository and build the demo application (if the contribution provides one) or, failing that, to include the library in a project of your own. Fairly time-consuming for a quick evaluation.

That's why, as another step towards making qooxdoo-contrib easier to use, we created the Contribution Demobrowser, which is exactly what it says on the tin: A variant of the qooxdoo framework Demobrowser that lists contribution demos.

If you're a contribution maintainer, here's what you can do to have your project showcased in the Demobrowser if it isn't already:

• Reorganize your project so that its directory structure conforms to that of a contribution skeleton. This will allow the Demobrowser's build process to find your demos.
• Make sure the project's Manifest file is correct. For the "qooxdoo-versions" key, it's good practice to list the latest stable qooxdoo release the contribution is compatible with instead of just "trunk". If you need to refer to development versions between releases, use the appropriate "pre" notation like "1.3-pre". If there are multiple versions of the project, make sure they each have a unique entry for the "version" key, corresponding to the unique folder each contrib version is in.
• Somewhat obviously, make sure that your demos will build and work as expected.

Eventually, we plan to have the contrib Demobrowser automatically update and publish itself at regular intervals. Please note that currently we limited the demos to contribs that are in a fairly consistent and up-to-date state. For the time being we also focus on demos that have purely visual frontend content, so none of the typical utility classes, backends or tooling contribs are included, which are a separate topic.

Starting with a subset of contribs we can continue to work closely with their contributors to further improve the contrib demobrowser and the consistency and completeness of contribs. All (prospective) contributors are welcome to try out the demobrowser themselves, see the readme file in the qooxdoo/contribDemobrowser checkout of qooxdoo-contrib.

We hope such a contribution demobrowser allows to bring contribs to more people's attention, helps authors to improve their existing contribs and encourages users to provide more high-quality contribs. As it is an early preview there obviously is much that could be improved, we're well aware of that. But if you could give specific feedback to the current state of the contribution demobrowser, what you like about it and how well you're doing in getting your contribs to run in it, that would be much appreciated.

OpenLaszlo 4.8.1 is now available for download at http://www.openlaszlo.org/download.

OpenLaszlo 4.8.1 is an incremental release of OpenLaszlo 4, and contains almost 20 bug fixes (see the JIRA report 4.8 Release Notes for details). In addition to the bug fixes, two new features have been added: support for incremental compilation for SWF10 applications; and a compiler option that lets you store pre-compiled platform-specific object code for both the DHTML and SWF10 runtime in a binary library format.

OpenLaszlo continues to be grateful for the significant contributions by André Bargull, whose numerous bug fixes and exacting techical reviews make OpenLaszlo more robust. We also want to thank Ono Keiji, Jaco Botha, Alexander Pakhunov, Chen Ding, Clint Dickson, Gioacchino Mazzurco, John Olmstead, Justin Hunt, Pasqualino 'Titto' Assini, Raju Bitter, and Rami Ojares, who took the time to isolate and report important bugs for us to address in this release. Thank you! We would also like to thank the entire OpenLaszlo community for your support in so many ways, like submitting bug fixes, helping users on the OpenLaszlo forums, and participating in discussions to help make OpenLaszlo a better platform.

Another weekly status report right before the releases planned for next week.

Upcoming Releases

This week we continued and intensified our efforts towards the upcoming releases. According to our release scheme, it is again a joint release of a minor release (qooxdoo 1.2) and a patch release (qooxdoo 1.1.1). The ramp-down plan has already be announced on the mailing list, with a preliminary target date Aug 4, 2010 for both releases. We are currently in the phase of testing the two release candidates thoroughly, adding reports to the bug tracking system, and trying, if feasible for the releases, to resolve issues. As we are busy testing and finalizing the releases, attendance to the mailing list might decrease. Anybody on the list is encouraged to help out by trying to answer other people's questions.

Deprecations

We took the time to remove all old deprecated code before the upcoming 1.2 release. If you are interested in details about what has been removed, take a look at the corresponding bug report. Special thanks to all people who tested their apps with the latest trunk and reported back that they didn't find any issues: Fritz, Burak, sub, Daojun, Werner. Much appreciated!

Windows, Validation, Tooltips

Some of the work on the framework included fixing and/or enhancing certain features: You can now set windows to be always on top of other windows (using the alwaysOnTop property) and customize default validators' error messages (see qx.util.Validate.*). If a widget is disabled and has a tooltip, the tooltip isn't shown anymore. Particularly nice about those improvements is, that they were done by our new Romanian colleague Adrian, who just recently joined us for framework development. Keep it up!

Bugfixes

Quite naturally for the last coding week before a release, we achieved to resolve quite a number of open bugs. For a complete list of bugs fixed during the last working week, use this bugzilla query. No need to worry, though, there are enough issues left for future releases.

So, keep your fingers crossed for some successful release ramp-down, and stay tuned for more info.

During a recent class I taught on ICEfaces, one of my students asked me why the calendar was often one day off from what got posted back to the model managed-bean setter.

For example:
// Facelets XHTML Markup:
<ice:selectInputDate value="#{modelManagedBean.dateOfBirth}">
    <f:convertDateTime pattern="MM/dd/yyyy" />
</ice:selectInputDate>

// Java Code
import java.util.Date;
public class ModelManagedBean {

  private Date dateOfBirth;

  public Date getDateOfBirth() {
    return dateOfBirth;
  }

  public Date setDateOfBirth( Date dateOfBirth) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy hh:mm z" );
    // The value printed here during postback was often wrong by 1 day
    System.out.println("dateOfBirth=" + dateFormat.format(dateOfBirth));
    this.dateOfBirth = dateOfBirth;
  }
}

Basically, the JSF DateTimeConverter Javadoc states that if the timeZone attribute is not specified, then the default is GMT. But when you create an instance of java.text.SimpleDateFormat, the default TimeZone is equal to TimeZone.getDefault() which (for me) was EST. So the solution I explained to my students was to make sure we were comparing apples-to-apples the whole way through, by using GMT for the SimpleDateFormat printing, like this:

dateFormat.setTimeZone(TimeZone.getTimeZone("GMT" ));

And of course, I think it's the recommended practice to run your application server JVM in GMT. That would eliminate the problem entirely. But when you're using Eclipse and Tomcat for development, that's typically not the case.

 

In our 30th episode, we talk with Chris Coyier of CSS-Tricks. Chris also works for Wufoo, an online form builder service.  Chris talks about his inspiration for writing for CSS-Tricks and we look at his jQuery snippets, freebies and screen casts.  We learn what Wufoo is and talk about the new API for Wufoo.  Chris shows us the new Wufoo jQuery API Wrapper and we talk about  the choice of putting the plugin on the jQuery namespace verses making it its own global object.  Finally, we talk about how designers and developers responsibilities are becoming more blurred as it evolves and changes.

You can subscribe to the show in iTunes or via the raw RSS feed or you can download the MP3.

Links from this show…

• CSS-Tricks
• Anything Slider
• jQuery Snippets
• jQuery Tweetify Text Snippet from CSS-Tricks
• Wufoo – online form builder
• Wufoo jQuery API Wrapper
• Dig into WordPress

Plugin of the week

jQuery.Validity

Very light weight Validation plugin for simple forms with simple validation rules. Here’s an example of the jQuery needed to make a couple of fields required and match a specific format.

$("form").validity(function() {
    $("#vehicles")                      // The first input:
        .require()                          // Required:
        .match("number")                    // In the format of a number:
        .range(4, 12);                      // Between 4 and 12 (inclusively):

    $("#dob")                           // The second input:
        .require()                          // Required:
        .match("date")                      // In the format of a date:
        .lessThanOrEqualTo(new Date());     // In the past (less than or equal to today):
});

We still feel that Jörn Zafferer’s Validation plugin is the best as it will provide the most robust and customizable solution to your needs but felt that this light weight plugin would work well in smaller forms.

Tutorial of the week

Enterprise jQuery

A site, from appendTo, geared to help corporations that are just now adapting jQuery. It helps them learn how to use jQuery with best practices in mind so that their code is easy to maintain in a team environment.  We mention a few articles from the site:

• Mock Your Ajax Requests with Mockjax for Rapid Development
• Configuring UI widgets and interactions with .live() and .delegate()
• Multipart Series articles

We want to thank MediaTemple for hosting jQuery and the podcast files and we’d like to thank BrandLogic for the podcasting studio.

Follow the show on twitter for up to date information regarding upcoming guests at http://twitter.com/jquerypodcast. Follow Ralph and Rey on Twitter as well.

You can send feedback about this episode or send in questions to podcast@jQuery.com or use the call-in number (804) 4jQuery, (804) 457-8379.

“jQuery Theme” created by Jonathan Neal

Community Highlights: Using Cappuccino to build the MemoryMiner Web Viewer

Back with a second post is John Fox, creator of MemoryMiner, a digital storytelling application for Mac OS X. John writes about the steps he took to localize his Cappuccino application, a web viewer for MemoryMiner.

The post comes complete with sample code, and its worth a read if you’re interested in localizing your own applications.

The Mozilla community is proud to announce that Firefox 4 Beta 2 is now available for download on Mac, Windows or Linux.

Firefox 4 Beta 2 includes several major features and improvements – by testing them early we’ll be able to respond to your feedback for future versions of Firefox. The included Feedback Add-On that helps you let us know what you think about the new features and technologies in the beta. You can read more about this release on the Mozilla Blog, or at any of the following links:

• Read more about some of the major features in this beta
• Take a look at our big chart o’ technology that’s included in this beta
• Read the release notes for Firefox 4 Beta 1

We want to thank the Mozilla community of nightly testers for the amazing feedback that helped shaped Firefox 4 Beta 2. We appreciate your assistance in testing this preview of the next version of Firefox!

Are you developing jQuery hotness so fast that the slow-poke server team can't supply you AJAX services fast enough?  If so, you might be interested in the JavaScriptMVC-extracted jQuery.Fixture plugin.  Fixtures simulate AJAX responses so you can keep developing JavaScript functionality even if the server's services aren't working.  The fixture plugin is easy to setup and remove once the services are online.

Download

jquery.fixture.js  - works with jQuery 1.2 and greater

Features

• Easy to toggle fixtures on and off (just remove the plugin)
• Dynamic fixtures
• Pre-made REST fixtures
• Fixture helpers

Demo

Fixture Messages Demo

Documentation

JavaScriptMVC's jQuery.fixture documentation

Use

It's easy to use fixtures.  Just ...

1. Add the script to your page.
2. Set the fixture parameter to your simulated response file.

For example ....

$.ajax({url: "/task.json",
  dataType: "json",
  type: "get",
  success: myCallback,

  fixture: "fixtures/task.json"
});

... uses "fixtures/task.json" as the response instead of "task.json". The "fixtures/task.json" file might look like:

{
  "name" : "take out trash",
  "description" : "to the curb",
  "id" : 5
}

When the tasks service comes online, just remove the fixtures script tag and jQuery will make requests as normal.

Methods

The fixture plugin overwrites $.ajax, $.get and $.post to accept a fixture parameter or argument.

//... a property with $.ajax
$.ajax({fixture: FIXTURE_VALUE})

//... a parameter in $.get and $.post
$.get (  url, data, callback, type, FIXTURE_VALUE )
$.post(  url, data, callback, type, FIXTURE_VALUE )

Dynamic Fixtures

Services almost always return different results depending on the data sent to the service.  Sometimes a single static file is unable to approximate the result of these services.  In these cases, by providing a function as the fixture object, fixtures can dynamically generate the result of the request from the data passed into the service (just like your server would do).

$.ajax({
  type:     "get", 
  url:      "tasks",
  data:     {limit: 1000},
  dataType: "json",
  
  fixture: function( settings ){
    var tasks = [];
    for( var i=0; i < settings.data.limit; i++ ) {
      tasks.push({id: i, name: "task "+i})
    }
    return [tasks]
  }
})

Dynamic Fixtures are really helpful for performance testing your app. Wan't 10k tasks? Make the fixture return 10k tasks. Want requests to take 5 seconds to return, set jQuery.fixture.delay to 5000.

Rest Helpers

The fixture plugin includes several pre-made fixtures (-restUpdate, -restCreate, -restDestroy) that simulate a REST interface.  The following example uses -restCreate to simulate creating tasks.:

$.post(
  '/messages.php',
  messageData, 
  function(){ ... },
  'json',
  '-restCreate')

Fixture Helpers

$.fixture.make is used to create fixtures that retrieve JSON data from the server.  The fixtures it generates supports limit, offset, filtering, and sorting.  The following creates a fixture for 1000 threaded messages and then gets 100-150th child messages of message 5.

//makes a threaded list of messages
$.fixture.make(
  ["messages","message"],
  1000, 
  function(i, messages){
    return {
      subject: "This is message "+i,
      body: "Here is some text for this message",
      date: Math.floor( new Date().getTime() ),
      parentId: i < 100 ? null : Math.floor(Math.random()*i)
    }
})
//uses the messages fixture to return messages 
// limited by offset, limit, order, etc.
$.ajax({
  url: "messages",
  data:{ 
     offset: 100, 
     limit: 50, 
     order: "date ASC",
     parentId: 5},
  },
  success: function(messages){  ... },
  fixture: "-messages"
});

Conclusions

Fixtures are a big part of Jupiter and JavaScriptMVC's "secret sauce".  In our years doing JavaScript consulting, rarely is the back-end complete. Instead of waiting around, we use fixtures to keep moving forward. The back-end teams can use these fixtures as documentation of the service they need to build.  

Even after services are built, fixtures are useful for error, performance, and usability testing.  And when new features are added, you can easily start developing from the fixtures again.

Fixtures kick ass.

We’re having a SproutCore meetup in Paris on Tuesday, August 3th at 8:00 pm (EDIT: we originally planned to do it on the 5th but we had to reschedule). Charles, the creator of SproutCore, will be here, as well as members of the core team. Whether you’re already familiar with the framework of just curious to know more about it, join us for a beer at the Café Léa.

Hope to see you there!

I've just returned from Birmingham where EuroPython, the European Python conference, has been held for the second time in successive years. The organizers have done a tremendous job to make it a friendly and productive conference. I attended the preceding tutorial days, taking a full-day tutorial on py.test by Holger Krekel, a half-day introduction to Google App Engine by the venerable Wesley Chun, author of Core Python, and a half-day tutorial about TextTest held by Geoffrey Bache. All of them were excellent.

During the main conference which lasted from Monday through Thursday I focused on presentations relating to code quality and performance. Highlights for me were Raymond Hettinger's Idiomatic Python who was given another free time slot to cover more material, and the talks about virtual machines (PyPy, HotPy). Guido van Rossum, Python's "Benevolent Dictator for Lifetime", gave a very insightful questions-and-answers keynote session, where he addressed many issues both interesting and relevant for Python's future. Concerning one of them, which is also very close to my own heart, he mentioned that he is interested in high-level concurrency constructs and is attending all CSP-related talks in the conference (e.g. [1], [2]). There was also a CSP-related sprint in the days following the conference. I think this is a very important field, and has to be covered in good manner in Python. One other thing that struck me was the way people twist and bent Python, using its meta programming facilities, as e.g. Kay Schlühr demonstrated with Langscape, a framework to define language extensions which get translated to standard Python. There were also two lightning talks sessions which were a very good way of presenting interesting topics to a large audience in a few minutes.

During the conference there was also the first meeting of the PSF ever to be held outside the US. The PSF, the Python Software Foundation, is the non-profit legal entity behind Python that holds the intellectual property rights and tries to promote and protect the language. Twenty non-members where invited to attend and I managed to slip in. It was an interesting insight into the inner workings of an international open-source organisation. All in all it was a very interesting and enjoyable conference, with lots of contacts and chats during breaks and in the after-conference evenings. Way to go, EuroPython! (Ah, I wish they would rename it into PyCon Europe).

The new Get Tree from List example demonstrates how the Uize.Node.Tree.getTreeFromList static method of the Uize.Node.Tree module can be used to build a tree data object by analyzing the structure of a nested list defined by an HTML ul tag. A tree data object like this can be supplied to a tree menu widget, or can otherwise be used to build UI for navigating to different sections of the document (a contents tree, for example).

The new Uize.Node.Tree module provides convenience methods for generating a tree data object by analyzing HTML on a page. A tree data object is an array, where each element of the array is a Tree Item. Because a Tree Item may itself contain a child Tree Data Object, specified by its items property, a Tree Data Object can be used to represent an arbitrarily complex, hierarchical structure for information. A Tree Data Object can be used in any number of ways, but is commonly used for building tree-based user interface elements such as contents lists, structured dropdown menus, etc. A number of widget class support data in the Tree Data Object format, such as the Uize.Widget.Tree.List, Uize.Widget.Tree.Menu, and Uize.Widget.Tree.Select classes. Outside of widgets, tree data objects can be used to drive the generation of HTML, in build scripts or Web applications, using JavaScript Templates.

Firefox 3.6.8 is now available as a free download for Windows, Mac, and Linux from www.firefox.com. As always, we recommend that users keep up to date with the latest stability and support versions of Firefox, and encourage all our users to upgrade to the very latest version. If you already have Firefox, you will receive an automated update notification within 24 to 48 hours. This updates can also be applied manually by selecting “Check for Updates…” from the Help menu.

This release fixes a stability problem that affected some pages with embedded plugins. For a list of changes and more information, please review the Firefox 3.6.8 release notes.

Note: All Firefox 3 and 3.5 users are strongly encouraged to upgrade to Firefox 3.6 by downloading it from www.firefox.com or by selecting “Check for Updates…” from the Help menu and clicking on “Get the New Version”, then checking for updates again once Firefox 3.6 is installed.

Welcome back to another weekly status update.

RingBuffer

Carsten Lergenmüller, one of our fellow colleagues that work as qooxdoo application developers here at 1&1, took some time and refactored qooxdoo's RingBuffer appender. He stripped out a generic RingBuffer class, which can now be used to store any kind of data. If you ever had the feeling that you need to save a specific amount of data and you only want to keep the latest data sets, the RingBuffer is a good choice now.

What are selectables?

During researches on a bug we discovered some inconsistency in the selection API. The getSelectables() method of the tree for example only returned items selectable for the user, which means hidden tree folders or files were not included in this list of selectables. But what if a developer wants to select something different in the tree programmatically? So we added a parameter to getSelectables() to determinate if the method should return only selectables for the user or just all selectables.

Disabled selection

With the changes of the selectables API it was possible to fix bug #3344 and enable all widgets to select disabled items with the given API. Don't worry, the user of the application is still not able to select a disabled item.

Bugfixes

For a complete list of bugs fixed during the last working week, use this bugzilla query.

User app with new looks

Some of you may already know the di-lemmata app, which has been around as a real-life example for quite some time. Hardly noticed, its creator Norbert Schröder updated the description this week and also added a new screenshot:

Looks quite stylish, congrats! When considering jazzing up your own app, you might want to look into qooxdoo's advanced (and fully cross-browser) theming capabilities. They allow to create any kind of custom theme, e.g. to resemble your corporate design.

Online apps

You certainly know that each Friday we publish the latest devel versions of the apps that come with qooxdoo. Well, not this time. Today we noticed some technical issues with the publishing process, so we decided to put them online next Monday.

Have a nice weekend!