Welcome back, and on to a great feature addition:

Source code? In my API Docs?

It's more likely than you think, thanks to a new feature in the API Viewer. You just need to define the base URI for your SCM's web view (e.g. GitHub, ViewVC, ...) in your library's Manifest.json file and the API Viewer will automatically add links to the source file for each class. For functions, the link can optionally include a line number parameter, so the source view can jump straight to the implementation. See the API viewer manual page for details.

Bugfixes

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

C U around next time.

Just a brief update on bugfixes this time, as there are mostly larger tasks still in the works.

Bugfixes

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

C U again next time.

Welcome to the weekly blog post. This time it's a short one, as we want to refer to and feature community achievements - in individual blog posts. One of those is the LIBERATED project by Derrell Lipman. Check it out to get to know about exciting new ways of client-server communication, with a corresponding, transparent programming model.

There are more individual posts about community projects and real-life app examples to be published in the future, so stay tuned.

Bugfixes

For a complete list of framework tasks accomplished during the last working week, use this bugzilla query.

C U.

Derrell Lipman, a long-term qooxdoo contributor and active supporter of the framework, has been working on a very exciting project for the past year or so, and has already based a complete application on it. We happily share the following information with the community. Great achievement, Derrell, thanks for contributing!

In traditional client-server development...

Traditional web-based client-server application development has been accomplished in two separate pieces: the frontend portion which runs on the client machine has been written in HTML and JavaScript; and the backend portion which runs on the server machine has been written in PHP, ASP.net, or some other "server-side" language which typically interfaces to a database. The skill sets required for these two pieces are different, meaning that sometimes the frontend and backend are developed and tested completely independently, based purely on an interface specification. More recently, server-side JavaScript has begun to gain momentum, allowing for more overlap of skill set, but still requiring separate development and testing of the frontend and backend pieces.

Be LIBERATED from those hassles!

LIBERATED is a new methodology for web-based client-server application development, in which a simulated server is built into the browser environment to run the backend code. This allows the frontend code to issue requests to the backend in either a synchronous or asynchronous fashion, step, using a debugger, directly from frontend code into backend code, and to completely test both the frontend and backend portions. That exact same backend code, now fully tested in the simulated environment, is then moved, unaltered, to a real server. Since the application-specific code has been fully tested in the simulated environment and moves unchanged to the server, it is unlikely that bugs will be encountered at the server that did not exist in the simulated environment.

Be LIBERATED!

LIBERATED is a fully in-browser client and server web application debug and test environment, and qooxdoo-based backend environment. It allows (but does not require) you to write all of your code, both client- and server-side, in JavaScript, using qooxdoo coding style. It has a database abstraction layer, with existing database drivers for App Engine's object datastore and SQLite's SQL-accessed relational database. Additional database drivers can easily be written. There is also a built-in JSON-RPC Version 2.0 server. Additional handlers, such as REST, could be implemented for use instead of or in addition to JSON-RPC.

The real benefit of LIBERATED is that it allows the entire application, both frontend and backend, to be debugged and tested fully within the browser environment, running the backend code in the LIBERATED server simulator. This means you can set breakpoints with Firebug in your backend code, step through to find bugs, etc. Once all of your code is fully debugged and tested in the simulated environment, you simply move the backend code, generally with no changes, to the real server.

Architecture

The figure above shows the architecture of the development and production environment when developing with LIBERATED. The frontend code runs on the client machine (i.e., in the browser). Backend code runs on a server machine and/or on the client machine, with the exact same application code ("business logic") and application communication protocol, e.g., JSON-RPC, REST, etc., code in both environments. The actual database differs in the two cases, but the application's interface to the database is identical regardless of which backend is in use. Similarly, the application communication protocol code is the same regardless of backend, but the messages arrive from web servers unique to the backend, for parsing.

Further details

LIBERATED is simply a "library", in qooxdoo parlance. It is installed like any qooxdoo contrib or other library by referencing its Manifest.json file in the application's config.js "libraries" section. LIBERATED currently runs in App Engine or with the Jetty web server.

As to using it, LIBERATED is described in excruciating detail in Derrell's thesis. Although that document uses the current name of the library (LIBERATED), it predates the renaming of the namespace, so anyplace you see rpcjs in the document is now called liberated.

The API documentation should be quite complete, so running ./generate.py api from the top level will provide the normal API viewer with a fair amount of useful information. In particular, for database manipulation, see liberated.dbif.Entity. Some additional and better user-level documentation would definitely be useful, and might be added over time. Derrell invites you to get familiar with LIBERATED and appreciates your feedback.

Hi and hello from the qooxdoo news desk! I hope you all had a nice and refreshing holiday season, and we all wish you luck and success for the new 2012. Hack away!

The new year is taking up slowly, with a couple of colleagues still away from the office. But, lo and behold!, we got some news to share nevertheless.

qooxdoo Book

We are happy to report that the first dedicated text book on qooxdoo has materialized . Rajesh Kumar Bachu and Mohamed Raffi have written the qooxdoo Beginner's Guide, published by Packt Publishing. Thank you, guys! It focusses on RIA development and takes the reader through all the stages, from the basic OO foundations, over widgets, containers and layouts, to backend communication, theming and custom widgets, featuring a Twitter application for the demonstration. It covers qooxdoo version 1.4, but should be helpful for anybody starting with qooxdoo, even with the current 1.6 kit. If you ever longed for a comprehensive introduction into the qooxdoo framework in book form (one of those three books you would carry onto the island ), by people coming from the application development field, this book should be interesting.

Changes in rest.Resource

In qooxdoo 1.6, the body of a request sent by invoking a resource’s action included all parameters not associated to a URL placeholder. This works when the service expects URL encoded parameters or JSON, but the automatic distribution of parameters also has its limitations. For instance, it is not possible to populate the request body with an array (or any kind of none namespaced value). Therefore, we decided to introduce another parameter to invoke() and associated methods which allows to set the request’s body directly. For better consistency, we dropped the automatic distribution, so if you've been relying on it please make sure to split the parameters. For more details, please refer to the API doc.

Bugfixes

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

Github via SVN

Since we switched to Github for our main qooxdoo repository we recommended the "old-ish" SVN gateway that Github offers (svn.github.com), for those that used to follow our old SVN trunk and that were not ready to jump boat and embrace Git as their client VCS. Although there were new offers for SVN access from Github at that time, we found that the new interface was less reliable and often a lot slower. Meanwhile, Github has been busily working on the new interface, and recent tests show that the new interface is performing much better, even being faster than the old. So, if you are stuck with reading qooxdoo sources through SVN for the time being, you may want to give the new interface another try. Please report back how it is working for you.

To recap, here are the two interfaces again:

old: svn co http://svn.github.com/qooxdoo/qooxdoo.git
new: svn co https://github.com/qooxdoo/qooxdoo/trunk

The new interface also features checking out branches or subpaths of the repository.

Real-life Example: MeetAndSpeak

MeetAndSpeak is an advanced but lean chat tool for groups. It is currently completely free for everyone to use. The user interface mimics classic desktop IRC clients.

Included are secure HTTPS connections, logging and always online functionality. Users can't miss messages. The creator of a group has full control over it. It is also possible to use MeetAndSpeak as an IRC client, connections to Freenode and IRCNet networks are possible. The main view is window-based and allows the user to easily follow several parallel discussions in different groups.

That wraps it up for this week - be in touch next time.

Here comes another weekly status update, a rather short one this time.

Regression in 1.6

Just after the 1.6 release, we discovered a bug that slipped through testing. To our knowledge only Opera is affected. And only if the method getStackTraceFromError() is being used, which mainly happens in a development/debugging context, typically not in a regular app context. Due to these special preconditions, we decided this did not warrant a bugfix release. Please let us know if you notice this problem in the deployment version of an application.

Now for some detailed information: As mentioned above, it affects qx.dev.StackTrace.getStackTraceFromError: This method will throw an exception if called with a qooxdoo exception object (qx.type.BaseError, qx.core.WindowError, qx.core.GlobalError or qx.dev.unit.RequirementError) in a browser that supports the stacktrace property on error objects - apparently only Opera.

Bugfixes

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

That's it for today. C U again next week, then already close to Xmas.

Welcome to the weekly status update. Of course, we have to refer to the top news of the week:

Releases

qooxdoo 1.6 and the accompanying patch release qooxdoo 1.5.1 shipped on Wednesday as planned. We hope you enjoy both releases, particularly version 1.6 with all the great new features.

The ramp-down towards the releases was again quite smooth. Many things keep paying off: the well-structured, agile development process, continuous QA with tons of unit tests and GUI simulations, intermediate manual app tests, efficient bug triage, a strong team performance and last but not least the collaboration with a great community of contributors, bug reporters and users. Thanks again to all of you for your support!

Support

Talking of support: As a community member you can do your share to support the project even more with some public statements and votes. For instance, leave a comment at the announcement, (re-)tweet at Twitter or "like it" on Facebook. Additionally you could vote or comment at the following social sites: Digg, reddit, Echo JS or Hacker News.

You'll certainly have your own ideas on how you spread the news to other JS enthusiasts and web developers. Your help in promoting the new framework releases is much appreciated, thanks.

Kameleoon

Jean-Noël Rivasseau let us know about a slick new web application based on qooxdoo: Kameleoon Analyst. From the application summary:

"Kameleoon is a web intelligence solution that allows marketers to improve their conversion rates through A/B testing. First, you easily create variations of your website. Then these variations are randomly presented to your website's visitors. Eventually, each variation's performance is measured using accurate statistics. Our approach takes out the technical complexity of creating variations for testing: everything can be done via a JavaScript layer, without ever touching the server-side code. A marketing team is thus free to conduct A/B tests without worrying about the technical details."

Kudos, Jean-Noël!

It has been a busy but also very successful week. Have a nice weekend, and have fun with the latest qooxdoo versions!

We are happy to announce a regular full release of the qooxdoo framework. qooxdoo 1.6 is available for download. Checkout the detailed release notes and the manual.

The qooxdoo 1.6 release comes with many substantial improvements and exciting new features. In fact more than 300 bugfixes and enhancements made it into the release. Checkout some of the highlights:

Highlights

Offline Feature

Offline usage is an increasingly important topic in modern apps, and is now supported by the framework. New technologies like local/session storage and offline events allow for such offline capabilities in all current browsers. To bring those features right into your apps, an offline event handler has been added and also a convenient offline data store to leverage qooxdoo's powerful data binding.

To see the offline store in action, open the enhanced feedreader demo app, load some feeds and then switch your browser to offline mode. The app continues to work even in offline mode, thus after a reload of the feeds it will be able to show the previous content.

Animations and Transforms

Animations and Transforms are great new features introduced by CSS3. While both features are covered by CSS3 specs, they are not easy to use for developers working on cross-browser applications. For instance, vendors often support such features only via vendor-specific prefixes, so it becomes tedious and error-prone without proper framework support.

So with qooxdoo's new wrappers for both feature sets, animations and transforms, amazing dynamic behavior can be brought to the elements of your website-oriented applications. For future releases it is planned to extend animation even to qooxdoo's high-level widget set for targeting rich internet applications (RIAs).

Check out the following three demos to see what the differences are between the available feature sets: Animations, Transforms, 3D Animation.

Please make sure you use a browser capable of those recent CSS features, for instance a Webkit-based browser like the latest Safari or Chrome. For more details about the new animation layer you might want to read the corresponding blog post.

Website-oriented Apps

Creating and maintaining website-oriented applications can significantly benefit from existing features of the qooxdoo app framework. For instance, data binding for a clean MVC design of your app, or the comprehensive toolchain. Many improvements have been made for low-level applications that want to build upon technologies like HTML, CSS, DOM rather than the traditional qooxdoo GUI toolkit.

One milestone along that way was to create a website-oriented view on top of the existing feedreader demo app. A handy feature for creating such HTML snippets is to allow for a smart templating engine, so the popular mustache.js solution was adopted. With data binding being a key ingredient for any decent app design, a new list controller for templates was added to perfectly match the low-level requirements. Working on a DOM-oriented level, the new animation layer could also be used right away for some nice effects.

An additional low-level app was created to particularly feature the new offline data store: the todo app is a simple app to manage your tasks, leveraging offline storage and data binding. For more details about the todo app, read the corresponding blog post.

REST Layer

A sophisticated REST layer complements the state-of-the-art transport layer that was introduced with the last release. Guided by REST principles we will see an increasing number of well-designed, service-oriented apps in the future. As a first practical building block towards that vision the new REST wrapper comes with support for URI Templates, better handling of concurrent requests, auto-serialization of the request body based on the indicated content type and more flexible ways to define required parameters. In order to showcase some of the features of the REST wrapper a new Github demo app was added that accesses the Github REST API.

Mobile Widgets

The mobile framework has been improved further. In particular, the mobile widgets come with a number of enhancements: widgets can now also be put into a disabled state, and frequently requested mobile widgets were added: Popup, Blocker, Loading Indicator, Dialog (along with a manager), Atom (a combination of label and image). The toolchain of the mobile SDK helps in developing and deploying apps, e.g. CSS files are now optimized automatically. Click the "Toolbar" buttons in the mobile showcase to see the new features in action (requires Webkit-based browser). The qooxdoo mobile framework is still labeled experimental to allow for ongoing testing and advancement, so any feedback of yours when creating mobile apps with it is appreciated.

Extended Playground

The interactive Playground is one of qooxdoo's most popular apps. Many features of the new framework release were employed to enhance it. For instance, the offline data store was used to replace the Gist feature in order to more reliably work with individual code samples. Custom samples can now be loaded and saved via local storage. The playground's layout was adjusted to host a corresponding toolbar (see bottom left).
Another brand new feature to boost developer productivity is the ability to try out qooxdoo's mobile widget set interactively. Just use a Webkit-based desktop browser (Safari or Chrome) to check out the new mobile samples in the playground!

Releases

At the same time, and following our release scheme, we are also making available qooxdoo 1.5.1. It is a regular patch release of the 1.5.x branch, thus only contains bugfixes, no feature enhancements. It can be used as a drop-in replacement for qooxdoo 1.5, and users of this previous version are encouraged to upgrade their apps at least to 1.5.1, i.e. if they don't migrate them directly to 1.6.

Many thanks from the core developers to the community of contributors and users. Please help spreading the news, get people excited about the most advanced releases to date, and show them how to leverage qooxdoo as a truly universal JavaScript framework.

Enjoy!

As planned a regular patch release of the framework is available!

qooxdoo 1.5.1 includes about 150 bugfixes. It is meant to be backwards compatible, i.e. nothing needs to be changed in your existing apps, if they are based on the previous 1.5 release.

Download version 1.5.1. Checkout the detailed release notes and the manual.

Many thanks from the core developers to the community of contributors and users.

Enjoy!

PS: A regular release qooxdoo 1.6 is also to be released today. Unlike the patch release 1.5.1 it also comes with many substantial improvements and exciting new features ...

ISO 8601 has the notion of a "week date" (also known as "week numbering date"). qooxdoo supports this notion in its DateFormat class, e.g. when you use the Y format specifier for the year.

Now, the term "format specifier" might be slightly misleading, as it implies you basically get the same date with its elements (day, month, year) shuffled around a bit. But it's actually better to think of the week date as a separate calendar, alongside to our Gregorian calendar. Of course they both represent points in time, and they are close enough mostly, but can differ significantly in specific cases.

The best way to think about the difference between the two calendars is to realize that the week date calendar has no concept of months. Yes, read that again! It's only about years, weeks and days of the week. This becomes apparent with the canonical representation of week dates, e.g.

2011-W49-3

is the third day (weeks start with Monday) of the 49th week of year 2011, which amounts to being Wednesday, December 07th, 2011.

This becomes particularly tricky on New Year's change. As week date is week-oriented, it allocates the entire week to one year or the other. The pivotal day is Thursday.  If the Thursday of the week which contains January 01st belongs to the new year, the whole week is considered week 01 of the new year. If Thursday still belongs to the old year, the whole week with all its days belong to the old year.

As an example, 2011 started on a Saturday. That means the Thursday  of the week of the year change still belonged to the previous year. Hence the entire week is considered to belong to 2010, and e.g. Sunday, the 2nd of January in 2011, a day of this week, has to be represented in week date as

2010-W52-7

What?! A day undoubtly belonging to 2011 has a 2010 coordinate in week dates?! - Yes. Don't blame me. Java's SimpleDateFormat class has it all the same.

(To confuse you even further, 2009 was a very special year for the week date calendar, as it contained two January 01st - 2009-W01-4 and 2009-W53-5!! ).

So, as a summary you wouldn't want to use the Y format specifier with DateFormat unless you absolutely have to (e.g. when reading in strings in that format). In that case make sure you only use it in an ISO-conformant format string, like

"YYYY-'W'ww-e"

(ISO is rather strict about this format, and there is very little variance allowed for week date representations). Specifically, do not combine Y with any of the month specifiers (M, L), as this can be totally confusing and doesn't make much sense. Otherwise, you should stick to y for year formats, which does what most people expect.