Jeroens blog

I just finished watching the recording of a keynote at the JVM Languages Summit 2009 titled “Are we there yet? A deconstruction of object orientated time“, which I think is one of the most interesting presentations about programming languages, and what they could be doing better, lately.

“In his keynote at JVM Languages Summit 2009, Rich Hickey advocated for the reexamination of basic principles like state, identity, value, time, types, genericity, complexity, as they are used by OOP today, to be able to create the new constructs and languages to deal with the massive parallelism and concurrency of the future.”

Part of a slide from "Are we there yet? A deconstruction of object orientated time"

This recording is 70 minutes long, which includes about 8 minutes of questions, but if you’re interested in programming and design patterns, you should not miss this

Today I released Validator version 0.2, on which I’ve been working the last 2 days. It features massive rewriting to make it more flexible, and has some added functionality. Let’s have a look at what changed.

The most important change is, without any doubt, the new list support. Validator 0.1 had a list type, which allowed you to have enumerations of values and do crude validation on them. This version now supports lists of a type, instead of seeing list as a type. So you can now create lists of strings, lists of integers, and even lists of custom types you add. This new approach also allows per-item-validation and per-item-defaulting. This means you can set an in_array criteria, which will then be enforced for every value in your list. Closely related to this new form of list support are the new list criteria, which allow you to validate lists as a whole. At the moment the only 2 build in list criteria are item_count and unique_items, but like for regular criteria, you can hook into Validator and add your own.

Another important change are the output formats. Output formats allow you to specify additional formatting that needs to be done with the parameter value, before it is retrieved from Validator. There are currently 6 build in types, which are array, list, boolean, boolstr, string and unique_items, but again you can hook into this list via Validator. The awesome thing about output formats is that it greatly reduces the mess you otherwise have with converting your parameters from user input to true data structures. You can even specify multiple output formats, which will then do their formatting one by one.

Other things brought by Validator 0.2 include some new criteria (is_boolean, has_length and regex), a new error level, Validator_ERRORS_MINIMAL, new parameter types (boolean, number and char) and support for Validator_ERRORS_WARN in ValidatorManager.

Equally important as the changes made is that the documentation has been completely updated, to give in-depth cover of how Validator works, and how you should use it.

Both Maps and Semantic Maps 0.5.1 use Validator 0.2, allowing them to throw away a lot of repetitive, dumb manipulation, code that has been their since the initial versions of those extensions

Downloads:

• Validator 0.2 (zip)
• Validator 0.2 (7z)
• Validator 0.2 SVN tag

Over the last few days, I’ve done some work on .Net download library, the successor to my FileDownloader class. I started working on this project about half a year ago, and had quite some difficulties picking up the thread again after GSoC 2009, since I was in the middle of rewriting the code I was simultaneously translating from MyDownloader, mainly with the handling of the worker threads. The core work has been completed now, meaning that you can use the lib to download files, and track their progress. This is still in experimental stage though, and the pause and resume functionality has not yet been adapted to my new worker implementation.

In any case, the first release, which will be 0.1, is in sight now. This release will cover the basic functionality promised by the library; segmented downloads in the background that you can pause and resume, and can track the progress of (percentage, speed, downloaded bytes, remaining bytes, remaining time, elapsed time). After this, I’m planning to do some big rewrites of things that come from MyDownloader I’m not really happy with. This will mainly be making the whole library more OOP and event based. Only after that I’ll start on the other things I originally scheduled, such as prioritizing downloads and bandwidth limitations. By that time, .Net fw 4.0 will probably be released, and it’s a good possibility I’ll start using post .Net 2.0 technologies then, mainly things found in the Task Parallel Library.

Yesterday I help a small party for my 19th birthday with some friends at the local bowling. We did one found of bowling, where I managed to get the score nearest to 42 (I know, I fail at it ). After that we held an airhocky tournament, in the form of me vs everyone. We played a total of 31 rounds (I didn’t manage to reach 42 ), of which I won the first 16, then lost 2, and won another 13. If I don’t count the 5 rather annoying wounds I now have on my right hand, it was an awesome evening

Earlier today, versions 0.5 of Maps and Semantic Maps where released. Some mayor new features where added, and a whole bunch of things have been refactored. I also did some effort to improve the documentation by adding some screencasts and revising the developer docs. Version 0.4.2 proved to be pretty stable, since only 2 bugs have been found and fixed.

Let’s have a look at the new, awesome, functionality:

• Strict parameter validation which allows you to get specific errors or warnings when entering invalid values or parameters. This functionality is obtained by relying on the Validator extension, which saw it’s first release today. This makes Maps dependent on Validator. Every distribution of Maps does include Validator, and Maps will automatically load Validator when it’s not loaded yet, so no extra installation work is required (unless you get the code from SVN).

• Static map support makes you able to display maps as plain images instead of via a JavaScript (or other non-html language, for example flash) mapping API. This is very important since it makes viewing the maps possible for people who are browsing the web with a browser that does not support JavaScript (or this other language), or simply have it disabled for some reason.

• Added a query printer that handles the osm result format.

• Added support for GUI parameter selection of Yaron’s new version of SMW’s Special:Ask page to the query printers.

• Added smart ‘autopanzoom’ like control for Google Maps and Yahoo! Maps.

• Added internationalization to the OSM service, and an extra parameter to define per-map languages.

The list of all things that have been refactored is rather long, so I’ll only cover the most interesting things here:

• Complete rewrite of the parameter handling. To make Maps work with Validator, this was required. The result is that Maps does not have a whole mess of specific validation and defaulting functions any more, since that’s now handled by Validator.

• Moved the geographical coordinate data type handling from Semantic MediaWiki to Semantic Maps. This will make the SMW codebase smaller by moving the geographical coordinate data type out, which is logical, since if you use coordinates, you very likely also want maps.

• Added code to unload any services from the service hook that are not present in the list of allowed services. This ensures they don’t get initialized, and makes any check to see if the service is one of the allowed ones further on unneeded.

As for documentation, I created 2 screencasts, both covering a different aspect of Maps. This way people can learn how to work with Maps in a more interactive way then just reading the documentation.

• Screencast: display_map

• Screencast: display_point

The developer documentation on how you can extend Maps using it’s hooks has been completely rewritten. This was needed since the previous version was created for Maps 0.3.3, since which a lot has been changed to the hook systems of Maps.

For a complete list of changes, see the Maps change log, and Semantic Maps change log.

Downloads:

• Maps 0.5 (includes Validator 0.1) [zip, 7z]
• Semantic Maps 0.5 [zip, 7z]
• Maps and Semantic Maps 0.5 (includes Validator 0.1) [zip, 7z]
• Maps 0.5 SVN tag
• Semantic Maps 0.5 SVN tag

I’ve created a new Maps screencast that covers the use of the display_point parser function of Maps as it works in version 0.5. I’m assuming you have seen the display_map screencast before you watch this one, although the basic syntax is covered again quickly.

I’ve also made the projects for both screencast publicly available. If you have wink, the application I used to create the screencasts, installed, you can simply modify the projects, add your own stuff, and render your own version. I’m hoping some fans of Maps use this possibility to improve the screencasts and help their fellow Maps users.

• Download display_point screencast project (~33MiB)
• Download display_map screencast project (~10MiB)

Yay – I just entered the top 50 of MediaWiki committers, based on commit count over the last 5 years :p Next stop: #42

It has been over a week since I posted about any MediaWiki stuff, which can very well be a record since I started my blog. The reason for this is cause I’ve been busy with a lot of projects. You’ll hear about them all later on, but now I just want to provide an overview of the work I’ve been doing on my new MediaWiki extension: Validator.

Validator is an extension that makes parameter validation functionality available to other extensions. This enables other extensions to validate parameters, set them to their defaults, and generate error messages, while only defining the parameters and their criteria. The goal of this extension is to facilitate the handling of parameters in other extension, and generalize the error output. By itself, it does not add any functionality to the user end.

The main functionality is:

• Parameter validation: Parameters that are provided in an array where the keys represent their name, and the values their value, can easily be validated against a set of criteria. During this validation, errors and their types will be stored, and invalid parameters will be separated from valid ones. The only thing an other extension needs to do is define the criteria to validate against. A set of criteria types (which include check to see if something is a number, is within a range, or in an array) is provided by Validator, and can be used without any extra coding. When a criteria type that is not supported is required, you can hook into the Validator criteria types and add your own validation functions.

• Default value handling: Parameters that are invalid, or simply not provided, can be set to their default values. These default values need to be specified by the extension the parameters belong to.

• Error handling: Since the errors and their types are stored during validation, you can create error messages by retrieving this data and parsing it. Validator also provides a manager class that can provide you with a list of internationalized and specific errors. Via a validation level setting Validator provides, you can determine how the errors should be reflected on your wiki page. This can go from completely ignoring any errors to showing a complete list of all errors underneath the regular output, or even hiding the regular output and only showing the errors.

Validator has not yet been released, but will be soon. Although not all documentation is ready yet, most of the information needed to use it can already be found in the implementation section of the documentation. Both the development versions of Maps and Semantic Maps are currently using Validator for their parameter handling. The next release of those extensions, 0.5, will therefore feature strict parameter validation, and be dependent on Validator.

Oh, and I got the 60000th MediaWiki commit with the changes I made to Maps to work with the last alpha of Validator – wooot!

Last week I went to a VISUG and MSDN event in Brussels where Scott Guthrie held 3 talks about VS2010, Silverlight 4, asp.Net and MVC. The event was very interesting, but I’m not going to dwell on the contents.

Everyone got a red tshirt to wear, as can be seen on the underneath photo.  Somewhere near the end of the second session, I got to warm wearing the tshirt, and put it in my bag. I had no idea that my blue Google Maps tshirt would be so visible though. Setting in the middle of the room, this wasn’t really subtle if I look at it now, esp since it says “I am here”

This is the model of tshirt I was wearing:

Yesterday I spend about an hour creating the most useless application I’ve ever come up with. The main motivation for this was proving to a friend that solving a certain problem can be achieved with an algorithm containing only 1 loop and 1 if else structure. (And no GoTo’s! :p) It was also a nice opportunity to freshen up my C# skills and mess around a little more with the Beta 2 of Visual Studio 2010.

The application allows to generate a list containing random indexes of that list as values, and with a few special values. The application then allows you to find out whether by following the indexes route, you’ll end up with a special value (and which one), or get into an infinite loop. It also allows to slow down each step, enabling you to track the followed route.

You can has downloads:

• Application executable (requires .Net 2.0 or above)
• Source code (Visual studio 2010 C# WinForms solution)