We started with VisionX as RAD tool because we tried to solve common problems with database development. If you create applications with access to databases, you know what I mean. It's horrible to do the same boring things multiple times. You have to create table definitions, create screens, bind models to controllers or views, use or don't use ORM, implement business logic, ...
The most interesting part is business logic because all other things are not that complex (of course, database modelling is not a trivial task).

Today I'm conviced that VisionX is the evolution of RAD.

Why do I think that?

Usually, RAD tools offer an all-in-one solution for developing applications. They contain IDE features but aren't an IDE. A RAD tool is more like a lightweight IDE with some useful addons like database modeler, GUI editor and debugger. Some RAD tools offer SCM integration, Test automation and other ALM methods.

RAD is not the right definition for VisionX because it's more than that. It doesn't show you the source code directly because an IDE is better for that. Why shouldn't we use an IDE for editing source code? VisionX doesn't offer SCM features because there are enough good tools available.

VisionX primarily supports Eclipse as IDE and all available SCM tools but not directly linked with VisionX. VisionX is not open source but it uses open source frameworks and all built applications are available with their source code. We didn't re-invent the wheel but tried to allow end-users to create their own applications without being a developer.
We think it's better to use the best tools, instead of creating something similar. You decide what's the best tool.

VixionX wasn't designed for developers. It was designed for end users. This is a big difference compared to RAD tools.

But VisionX is not limited to end users, because it creates and reads Java source code. Every Java developer can work with VisionX but with familiar development tools like Eclipse. The tool offers a WYSIWYG editor and has some useful addons, but it goes a few steps further.
VisionX doesn't need a database modeler because an end user doesn't know what a database(model) is. The user knows which data is needed, like Phone number, currency, description. The user also knows if a selection field is needed or an image should be shown. But primary key, foreign key and constraints are totally unknown.

You can compare VisionX with Excel because the user enters data and the application decides what is shown. But there's no hidden magic because VisionX simply works with generated and interpreted source code. If you change the source code, VisionX takes care of it.

And another big difference to RAD tools is, that VisionX creates modern 3-tier applications following single-sourcing approach. It's the only tool that creates an application that runs without source code changes as Desktop application, native HTML5 application in modern web browsers and as native smartphone app. It offers live preview on all targets and it has a unique reporting included. It's not based on XML files or meta information. It's based on Word or Excel templates. Every end user is able to create a word or excel file.

VisionX is a tool, designed for end users but a developer will love it because it helps to do all the boring work and under the hood it's still a modern development tool.

We got a lot of (positive) feedback for our live ticker in Packung! It's great to see actual results depending on the current score

We started our live ticker in 2008 with a simple implementation in Java. The solution simply sniffed results from standard html pages. It was easy to get results because result pages didn't use Ajax. It was harder in 2010 and 2012 because Ajax was heavily used. But we found some pages without Ajax.

What's the problem with Ajax? It's not possible to get the complete html content with one simple http request with Java. You need a "browser" that handles javascript and async calls.

We didn't find a html page with live results this year, which didn't use Ajax or Flash. So we thought about a clever solution because we won't pay for "free content". And of course, our betting game is free and we don't earn money. But what's a clever solution? The task is simple: Grab results from existing live-ticker website (be aware of Ajax) - but how?

The solution is simple: Use a browser

But Java doesn't offer a browser control, doesn't it? Yes, JavaFX does!

In 2008 we played around with QT webkit control of QT Jambi (but the project is not active) because it was a nice browser control. The problem was that it didn't work headless and our application server was a linux box without X-Server. This year, we had the same restrictions because our server is a linux box and still no X-Server. We thought that JavaFX could be the right solution for us...

BUT it doesn't work headless enough - not with latest release. It will be better in upcoming releases and/or custom JavaFX builds because there is a Glass windowing component called Monocle. But this was the right challenge for us.

Our current solution runs on Linux, without a real X-Server. It's a JavaFX WebView/WebEngine that reads data from a public live-ticker.

How our solution works?

Install important linux packages:

optional if available

Download and install ATK

and GTK+

Start Xvfb:

Start application:

The application itself is trivial. It's a class with main method:

We need the JFXPanel because JavaFX needs a scene, otherwise it'll throw Exceptions. We don't need the instance for other things.

The SimpleBrowser class is similar to this snippet:

That's it. We got two "silent" Exceptions

after the application start, because of some scrolling problems, but these Exceptions had no effect (in our solution).

The solution would rock with a real headless JavaFX but it's ok for us.

We re-activated our Twitter storage for Packung! 2014. The old implementation was based on twitter4j 2.1.7 and since Twitter API changes, our implementation stopped to work. After a library update to twitter4j 4.0.1 and some smaller changes, everything is fine again.

The storage in action:

Twitter Storage implementation

The storage extends the standard AbstractMemStorage of JVx.

We've released JVx 2.0.2 last friday and you should know that it's available

It's a smaller update with bugfixes and some improvements. One new feature is the support for an additional row in the databook. We use this row for searching records.

Other interesting features, from the changelog, are

• added listener to IConnection for notifications about property changes
• DBAccess isModified introduced
• register value changed of single column
• register key event listener for certain key
• DataBookBuilder introduced
• ICloseable introduced
• Set ORDER BY as property of DBStorage
• new selection modes: CURRENT_ROW_DESELECTED, CURRENT_ROW_SETFILTER
  CURRENT_ROW_DESELECTED_SETFILTER
• CommonUtil.close introduced

Have fun

We didn't have support for Buttons with popup menus in JVx because standard Swing doesn't support this feature out-of-the box. But such a component would be very useful for some UIs.

We didn't change our UI definition but we started with support in Swing. Our JVxButton now has support for showing a popup menu. It could be like this one:

DropDown

We've added some buttons to VisionX, because it reduces the amount of buttons

VisionX with new buttons

It's easy to use the new feature in your Swing application and also in your JVx application (for Swing UIs):

There are some things to know:

• Set the translation because the resource is added and the UIPopupMenu doesn't have a parent.
• Call addNotify to enable translation (same problem because of missing parent)
• You should check if the resource of the button is an instance of JVxButton to be UI technology independent

If you work with above code, you'll have all JVx features like simple event handling or translation.

If you have a lot of work-screens in your application, it's not so easy to find the right screen because VisionX didn't offer search functionality in its open-screen wizard. With upcoming releases, VisionX will have such search functionality:

Screen search

The search fields will be visible if you have more than 5 screens!

Another problem with screens is that you can't search for fields or don't see automatically hidden fields, like ID columns. We have another nice search feature for you:

It will be possible to show hidden fields and also the used column name of your database table. The column names are not visible by default, but will be after you've pressed More...

Do you use a Vaadin application as portlet with e.g. Liferay and does your application create generic downloads (e.g. reports)?

If you want to download generic/dynamically created files from a portlet, you don't have too many options. You could use the FileDownloader extension or you could open a new window with the file resource. But both options are not perfect. The FileDownloader has to be connected to a clickable component e.g. a button and the new window won't be closed automatically (browser dependent). The FileDownloader is a good solution (see recommendations) but it triggers the download from the browser via user interaction. If you have dynamic UIs or if you can't use a FileDownloader because you need a more generic solution, then you could have a problem?

Our JVx Vaadin UI implementation is very dynamic and a developer doesn't use native vaadin components (until he needs to do). The FileDownloader didn't work for us because of UI abstraction. But we have a solution that might help you as well. Its comparable to FileDownloader but it's not user driven.

Simply use our extension with your UI:

The extension is not limited to UI but one Downloader per application is enough.

The source code is available in our repository.

Hello everybody. 1st April is over and no worries, we won't stop JVx

Today is a great day because I'm very happy to announce JVx - version 2.0.

It's an awesome release because JVx 2 contains so many new productivity features. It's still a small codebase and the quality is very high. We made a big step forward and want to show you some details.

First of all, the LoC analysis. Here are some very interesting numbers for you:

This time, we broke the mark of 100.000 LoC (112.507). We thought it would be possible with 1.0 but now it happened! Our code is still well documented with about 42% of the LoC.

Some additional numbers:

Files and Tests

JVx library source files   501 Swing UI source files   132 Test source files   109 Total   742

Still a small codebase and still very easy to maintain.

Unit tests (no UI, without manual perf. tests)   592 Class coverage (without UI)   78% Method coverage (without UI)   66%

TOP 10 classes

This is amazing because we have so many features and so less code. I think our quality standards have been met!

And last but not least, a short overview of new features:

• New metadata cache

  The caching mechanism is now a real killer feature. No ORM library or any other DB API has a similar technique. JVx is unique in this area. What we do? We reduce database calls and requests. We have different cache levels like Global, per Session or per Connection. The cache is a learning cache and your application will be super fast in production mode.

• Improved Constraints check

  Our linked cell editors (comboboxes, drop-downs) now shows columns from tables referenced via Foreign keys. Now the master table shows columns from tables referenced with Foreign keys. And also the resulting comboboxes show columns from referenced tables. If you have a clean database model, simple use your master table and the GUI is ready. If your database model isn't as clean as it could be, simply define your references with our APIs.

• Cache mode for Security Managers

  Before JVx 2, a security manager was cached globally per application. Every session was checked with the same security manager. With JVx 2.0 it's possible to have a security manager per client. Every client could have its own security manager instance.

• Focus listener support

  This is not rocket-science but important for all kind of UIs. Now JVx has support for it.

• IController and IControllable

  This is completely new because it allows data navigation with centralized controls. Read more.

• NO more session blocking

  Before JVx 2 the server implementation blocked simultanuous calls via DefaultObjectProvider. This wasn't a real problem for Desktop applications and with few users but it was in Web environments - especially with our Vaadin UI - or with e.g 500 users. This blocking is gone.

• Session isolation

  Usually, a session has a specific Life-cycle object with business objects and actions. Such Life-cycle objects have direct access to the MasterSession of an application for convenience. If you want Life-cycle objects without access to the MasterSession this is the right feature for you.

• New layout: UIGridLayout

  The layout is row/column oriented like good old AWT GridLayout.

• Super-lazy-loading

  If you use down and up keys to navigate in tables with details, you'll be surprised. The standard lazy-loading mechanism loads data in blocks and on-demand. If you had master/detail relations in your screens this wasn't enough because every master record change did load the detail records. With JVx 2. this will happen if you release the down or up key. This is a nice productivity feature.

• CheckBox CellEditor

  We now support "real" Checkboxes as cell editor. Our choice cell editor is image based and it doesn't support LaFs. Of course, with the right images it might look like a native Checkbox. Now you can use native Checkboxes. We recommend the choice cell editor for columns with multiple possible values, e.g. Yes, No, null. The Checkbox only has two states Yes or No.

• MetaData customization

  With JVx 2.0 it's possible to set/change MetaData per Storage, e.g. add a Primary Key.

The list is not complete but shows biggest changes and all details are available in the Changelog.

Please download JVx 2 and send us your Feedback.

Our upcoming release of JVx - version 2.0 will provide a nice new feature. It's a special record navigation for databooks. If you know Oracle Forms applications you should know what I'm talking about. For all others, a snippet from an Oracle Froms application:

Oracle Forms Navigation

We'll support similar navigation via JVx for our databooks without changing your whole application:

JVx Navigation

To support this old-school record Navigation, we introduced two new interfaces (IController and IControllable). If you need more details, read the Feature Request.

You should know that your existing applications won't change automatically. JVx has full support for new navigation but doesn't implement a UI for it. If you want to use it, you have to add your own controls like:

In your application init method:

And that's all you need. Don't change your screens or your UI controls. Everything will work out-of-the-box.

The event receiver should be an instance of javax.rad.application.genui.ControllerContent. Our Application javax.rad.application.genui.Application and javax.rad.application.genui.WorkScreen are ControllerContents. So it's very easy to use existing actions. All available actions are defined and implemented in ControllerContent, like

If you want to know the current state of an action command, simply ask:

If you want a different handling than already implement, simply overwrite the method

and do whatever you want, e.g. hide buttons instead of disabling:

No worries, we still prefer record navigation directly on the UI control:

Control Navigation

because it's easier for end-users to find the right buttons.
But especially Oracle Forms users will love the new Feature

First of all, we don’t have JVx 2.0 for you. We planned it for 2013 but it wasn’t possible to finish everything.

We made some smart design decisions and put more time in our vaadin UI (especially push support) and our Liferay integration. Especially LR integration is now incredibly good. We support Live Preview of work-screens without deployment. It makes developers happy!

Sorry for the delay, but we have some nice extra features for 2.0 in the queue like buffer caching for queries.
Our plan is that JVx 2.0 will be released together with VisionX 2.0. This will happen in Q1/2014.

But don’t be sad. We have a new JVx release for you. It’s 1.2.1 (see Changelog). We also have Vaadin UI 1.1 for you (see Changelog).

VaadinUI 1.1 was built with vaadin 7.1.7. The current vaadin version is 7.1.9. We'll update to the latest vaadin with vaadin UI 1.2.

Both releases will be available on 24.12.

Merry christmas