Jeroens blog

One of the big new features in Maps 0.5 will be strict parameter validation. This means Maps will allow you to get specific errors or warnings when entering invalid values or parameters.

The setting determining the strictness of the validation, which can be changes in your LocalSettings file, currently accepts 4 values:

• Maps_ERRORS_NONE : Maps will not show any errors, and make the best of the imput it got.
• Maps_ERRORS_WARN : Maps will make the best of the imput it got, but will show warnings for omitted coordinates.
• Maps_ERRORS_SHOW : Maps will make the best of the imput it got, but will show a list of all errors.
• Maps_ERRORS_STRICT: Maps will only show a map when there are no errors, if there are, a list of them will be shown.

The underneath example demonstrates an error list that can be generated when the validation level is on Maps_ERRORS_SHOW or Maps_ERRORS_STRICT. In case of the former, it’ll be shown below the map,while in case of the later, it’ll be shown instead of any map. The error messages are of course fully internationalized.

The validation is done via a new class dedicated to parameter validation. To be able to validate anything, you need to feed it two things: an associative array containing the raw parameter names and their values, and a somewhat more complex, nested, array containing the allowed parameter and their meta data, such as aliases and default values. The class also provides a hook for validation types, allowing you to do specific or complex validation that is not build in. The handling of the different strictness levels and generation of the actual error messages is done by another class that uses the first to validate and get the errors. Both classes do not contain any Maps specific code, so can be used to validate the parameter of any parser function. I’m planning to split this code, after it has reached a beta level, into a separate extension, that will probably be named “Validator”. This extension will be bundled with Maps, and will not any additional steps to the installation process.

Together with implementing this new feature, I did a big overhaul of the parameter handling in Maps and Semantic Maps. Instead of the two level system, containing general parameters, and service specific parameters, that was used in Maps, there now is a four level system. The first level are the general parameters, shared by everything. These include things like width, height and zoom. Feature specific parameters make up the second level, while the third one holds service specific parameters. The last level are the parameters specific to a combination of service and feature. Maps goes through these levels, starting with the upper one, and overriding it with the following. This allows more specific behaviour and is required to be able to validate the parameters in some instances.

The changes I made to Maps and Semantic Maps during these rewrites are responsible for what are probably my biggest commits to both extensions yet.

• Changes to Maps (rev 59531)
• Changes to Semantic Maps (rev 59532)

Due to the extend of changes I made, and the lack of thorough tests yet, I expect multiple issues with this code, including several severe ones, so I advice against using the latest SVN code for the moment, except for testing purposes of course. I hope to have the code refined and bug hunted in the coming week, so I can put it in a new extension and release it. During this period I’ll also start working on the other new features planned for 0.5, so you can expect more news on this soon.

Yesterday I made my first screencast ever. [ Check it out! ] It explains how you can display a map using the Maps extension for MediaWiki, how you can customize it, and how to interact with it. I’ve linked it from the Maps extension documentation page. Depending on the feedback I’ll get, I might make similar ones explaining how to create maps with markers, how to aggregate coordinates onto a map with Semantic MediaWiki, and how to use the Semantic Forms hooks of Semantic Maps.

Note: the application I used to create this screencast with does not have build in spellings correction, so expect at least one mistake in every 20 words or so

Two days I go I got the beta 2 of Visual Studio 2010, which is scheduled to be released in the first half of next year. With it, came .Net Framework 4 beta 2. I’ve taken a good look at the changes in these new versions, and am really excited about the new features included in them.

The new WPF interface of VS is obviously cool, but it includes heaps of improvements, making life for the user easier. I’m still in the process of finding all goodies

The changes in the new .Net Framework are even more exciting. It includes a new parallel programming model, enabling you to create multi threaded applications without having to bother the low level work like locks and thread pools that was required until now. Also new are code contracts, a very handy feature allowing you to specify certain conditions for your code state (see this blog post). On top of that, there are various new features that where lacking in previous versions of the framework, like biginteger support, tuples and complex numbers, as well as multiple others.

Yesterday I released version 0.4.2 of both Maps and Semantic Maps. Apart from the version number, this release includes some interesting changes.

As resided in my previous post, Maps now supports Google Maps overlays. Another change in it’s usage is that Maps now holds into account the coordinate and address naming of the main parameter. Although both these and the default (nameless) parameter are basically the same, and all indicate the locations that should be indicated (or shown) on the map, they get handled differently with respect to the new (since 0.4) smart geocoding feature. Here you have an overview of the different behaviours:

• Default (nameless) parameter: Maps will check every item in the list, and determine whether it’s a coordinate or not. In case it’s a coordinate, it’ll be parsed as a coordinate, and in case it’s not, Maps will attempt to geocode it. When this geocoding fails, you will get an error saying the item could not be geocoded.
• Coordinates parameter. As you probably expect, this parameter expects and only accepts coordinates. It works pretty much the same way as it did before 0.4 in display_point. When an item is not recognized as a coordinate, you’ll get an error saying it’s not a valid coordinate and has been omitted.
• Address(es) parameter. Similar to the coordinates parameter, this one expects and only accepts addresses. It works pretty much the same way as it did before 0.4 in display_address(es). Maps will attempt to geocode every item, and show an error listing all items that could not be geocoded. Important to note here is that Maps does not checks for coordinates, and will attempt to geocode any provided ones, valid notation or not, resulting in an error message.

Version 0.4.2 includes a lot of important bug fixes, and is more a release aimed at stability, then at adding new features. Depending on the amount of issues to be discovered in the coming weeks, a version 0.4.3 might be released before 0.5.

Downloads:

• Maps 0.4.2 (zip, 7z)
• Semantic Maps 0.4.2 (zip, 7z)
• Maps and Semantic Maps 0.4.2 (zip, 7z)
• Maps 0.4.2 SVN tag
• Semantic Maps 0.4.2 SVN tag

The last 2 days I’ve been fixing a whole bunch of issues in Maps and Semantic Maps that surfaced since 0.4.x. I’ve also taken some time to implement a new, and IMO pretty awesome, feature for Google Maps.

You can now specify overlays for any Google Maps map. These overlays will be held in a new ‘overlays’ control you can add to the map, by which the user can select and deselect the available overlays. ATM there are 4 supported overlays: Wikipedia, Webcams, Photos and Videos. A new setting in Maps allows you to set the default overlays that should be selectable on a map, and also which of them should be shown on page load. A new ‘overlays=’ parameter allows you to override this default behaviour. This example demonstrates the use of this parameter:

|overlays=wikipedia-1,webcams-1,photos,videos

The additional -1 for the first 2 overlays indicates they should be shown at pageload. The underneath image is a screenshot of a map generated with this parameter:

Using this feature together with the Google Earth plugin, which is also supported by Maps, results in awesome interaction with the map. This screenshot gives you a glimpse, but you should try it out for yourself to get all awesomeness.

As you can see, the overlays control will not be shown when viewing the Earth view. You can change the overlays by switching to another map type, changing them, and then changing the map type back to Earth.

Like the title of this blog post indicates, this feature is new in Maps 0.4.2. This version of Maps has not been released yet, but an RC is available for download (click here for Maps & Semantic Maps 0.4.2 rc1). This release will include some other changes, and a load of big bug fixes. I’ll post more about this after the release, which will probably be tomorrow, or Saturday.

I’ve just released Maps and Semantic Maps 0.4.1.

These new versions mainly increase the stability of both extensions and address a few minor, but very annoying bugs. The only new feature is that the centre parameter for the map result formats and map form inputs in Semantic Maps now support the smart geocoding that was added to Maps in 0.4.

Downloads:

• Maps 0.4.1 (zip, 7z)
• Semantic Maps 0.4.1 (zip, 7z)
• Maps and Semantic Maps 0.4.1 (zip, 7z)
• Maps 0.4.1 SVN tag
• Semantic Maps 0.4.1 SVN tag

Last weekend I attended Semantic MediaWiki Camp (SMWC) 2009 in Karlsruhe, Germany. Both days of the event contained very interesting presentations about SMW and various related extensions. The most exciting aspect of the event for me was perhaps getting to know other SMW developers, including Markus Krötzsch and Denny Vrandecic, the two lead SMW developers. And of course, I finally met Yaron Koren, my GSoC 2009 mentor, which was really nice. He also brought my long awaited Google T-shirts – yay!

On Saturday, I gave a presentation about Maps and Semantic Maps, after which I did get quite some nice feedback about the extensions. I also got some interesting proposals for new functionality.

During the two nights I was in Karlsruhe, I stayed at Robert U, a student working at Ontoprise, the company hosting the event, his place, sparing me the rather expensive hotel costs.

This picture is from during one of the first talks. Yaron is explaining Semantic Forms. I’m the guy with red training right in front of the camera.

Last few days I had some time (while sitting on the train) to have a good look at the second part of the Python docs tutorial. I’ve now got a good understanding of everything up to classes, and know the most important language specific notations, behaviours and features.

So far, Python strikes me as a really nice language, with quite some features I haven’t come across before. Especially the data sequence types are neat, and you can do multi inheritance. There are a few things that I find rather odd though. These include the ability to simply add methods and fields dynamically to classes, and the inability to make class fields private, or write-only. This obviously goes against the encapsulation principle. A minor, but really awkward behaviour difference to the other languages I know is the working of the ‘whole division’-operator (in Python this is //). It works by doing a normal division and then math.floor’ing it. For positive numbers, this is no problems, but for negative numbers, you end up having a value that’s 1 off. For example, -7 // 2 will return -4, instead of -3.

Anyway, the final part of my Python studies will be to get a closer look at the Standard Library, how I can best compile applications into executables, and what GUI (and other) libraries I can use.

I’ve stealthed all songs of Breaking Benjamins new album Dear Agony on Audiosurf. All runs are done with the Ninja Mono character, and options as-bankcam and as-steep enabled. Have fun watching

Today I made quite some progress learning the basics of Python. After doing a traditional  “O hai earf”, I went over the different core data types, control flow and data structures. Next in line are modules, I/O, exceptions and classes (yay!).

I’m testing my understanding of the language in Aptana Studio, which I now have completely mobile, together with the Python 3.1 interpreter. Aptana Studio is so nice it also offers build in support for Jython and Iron Python, which I’m planning to mess around with later on. And, not to forget, LOLPython!!!