The UI framework Pivot offers modern UI controls and renders very clean and fast. It has very powerful features and we made a very simple load-on-demand TableView implementation. We used our JVx model, especially IDataBook, for the integration.

The result is a table that loads the data from a database (scroll down to see what happens). The database table contains about 170,000 lines.

Click to start the application

The above example uses the same database as our Showcase application.
The Source Code is Open Source and available via SVN, on our JVx Project page.

We found a nice article about a simple CRUD application, created with JSP/Spring/Hibernate - read more....

This example is great for a comparison with JVx, because JVx is perfect for CRUD applications.

We used our existing app JVxFirstApp as reference because it is comparable to the Spring app. Our app has some extra features like authentication and a specific security manager, but that does not change anything.
Both applications provide CRUD operations on a table called CONTACTS. A big difference is the used technology: Web (JSP) vs. Desktop (Swing), but it is no extra coding effort to start our app as Web application - with our WebUI.

Why the comparison?

A big advantage of JVx is to simplify application development specifically of database applications. We want to show the difference in complexity and compare some statistics.
Let's start with the statistics:

		JSP/Spring/ Hibernate		JVx
Files		17		9
LoC		265		208
Config lines		74		15
JSP lines		230		-
Libraries		37		2

We used the same code formatter for both projects, therefore the Lines of code should be meaningful. The config files do not contain a lot of empty lines and the jsp files are standard html. We counted every line.

As you can see there is a big difference. Less lines of code do not automatically mean less complexity, but in this concrete example is it so. If your application has few lines of code, it is easier to understand how things work together and it is easier to maintain your application. And if you are a beginner it is better to get fast results without losing the control. That is the case if your project contains many files.

And if you are not a beginner it is important that you have the best flexibility with your framework. Both technologies allow the unrestricted use of other frameworks. But more dependencies means more problems if you plan to update to newer versions. The testing effort should not be underestimated. Fewer dependencies are an advantage!

What is your opinion?

Auch auf einem Entwicklungsrechner gehen irgendwann die Ressourcen zu Ende. Einem aufmerksamen Browser wie Chrome, entgeht das natürlich nicht

Die Entwickler dürften dabei sichtlich Spaß gehabt haben.

We proudly present JVx 0.9!

This release of JVx contains about 190 changes

Originally we wanted to move some features to 1.0 because they needed a considerable amount of time, but we kept them for 0.9 because each feature is great and saves a lot of work... And now, some months after JVx 0.8 we have a very powerful JVx with tons of new features, performance improvements and still very simple and small. We don't know a framework with approximately the same features as JVx which is about 900Kb. If someone knows a framework, please let us know!

And before we continue with some new features, many thanks to all the database vendors We had a lot of work with different Standard interpretations (quoting, case sensitive, OS differences, imcomplete JDBC implementations, ... )

What's new? ...too much to describe everything in one post, but let's start:

• Database
  • Manual quoting via DBStorage, if you need specific database features and don't change the database
  • Automatic quoting via DBStorage, if you plan to change your database or if you use a storage for different databases
  • Change your database(s) without changing you client code read more...
  • Use existing java.sql.Connection instances to create DBAccess instances
  • PK, FK, UK detection with or without JDBC driver, when needed (DBAccess dependent)
• Server
  
  • Introduced DBCredentials and DataSourceHandler to change DB connections without changing source code read more...
  • Default storage implementation for automatic caching (AbstractCachedStorage)
  • Default storage implementation for memory data (AbstractMemStorage)
  • Server side triggers and POJO support for storages read more...
  • Use custom SessionManager and ObjectProvider implementations
  • Global meta-data caching read more...
  • Better Exception handling for debugging
• User Interface
  • Simple charting
  • Default layouts for Container
  • Save UIImages
  • Changed automatic (master/detail) link editor visibility
  • Introduced TreePathFinder
  • login/logout event handler for applications
  • Modern Message layout
  • Border on/off option for TextFields
  • Translation for Cell Editors (e.g. Date/Time Picker)
• Utilities
  • Added FileUtil.replace, FileUtil.zip, FileUtil.unzip, FileUtil.copy (directories and files), FileUtil.move, FileUtil.delete (directories and files)
  • Added StringUtil.getCharacterType, StringUtil.getCaseSensitiveType, StringUtil.replace (faster than String.replace)
  • Added <XmlNode>.toString(boolean), <XmlNode>.getXmlValue, <XmlNode>.indexOf (deep search)
  • Added CommonUtil.getFirstCause, CommonUtil.equals (supports null comparison)
  • Added ResourceUtil.getResource and ResourceUtil now supports different ClassLoaders
  • Added simple namespace support for XmlWorker
  • XmlWorker has a new option for writing line-feeds between tags
  • Added <FileSearch>.searchFirstFile and support for file/directory pattern search

The above list contains only some cool changes. You find the complete list in the Changelog.

But that was not all.... We added some new features to our WebUI and released the second beta, which is fully compatible with JVx 0.9.

Our Showcase application is up-to-date and uses JVx 0.9 and WebUI 0.8 beta-2.

And last but not least, we look forward to your feedback!