Since last year we are offering an Eclipse Plugin that integrates  the JVx workflow into Eclipse. Now that EPlug 1.2 has been released, we believe it's long overdue to give you a guided tour of the experience that EPlug is offering.

Trial

We offer a free trial period so that you can test EPlug without any problems. The first time you start Eclipse with EPlug you will be asked if you'd like to only test EPlug, or if you'd like to select an already purchased Pro license.

When clicking the Trial button, a new trial license will be issued and you'll be able to evaluate EPlug with all features for 30 days.

'First Run' Wizard

One of the biggest usability improvements compared to previous versions is discoverability of how to use and activate EPlug. With the new version we have added a "First Run Wizard" which allows to directly activate EPlug on selected projects.

Usage

EPlug integrates seamlessly into Eclipse, but to use most of its features it has to be activated on each project you want to use it with. This can be done in the previously shown First Run Wizard, or by right-clicking a project and selecting "Activate EPlug" under "Configure".

From there on you will be able to use code completion, compile time checks and all the other features on this project.

Better and extended commands

A handful of commands are added by EPlug, which make it faster to navigate in JVx projects.

Go to complement class

It's often the case that you want to go from the server to the client class, or from the client to the server class. Most of the time in Eclipse this involves expanding trees and looking for the correct class in the Package Explorer. That is why we've implement the command "Go to complement class", which enables you to quickly jump from the server to client, or the other way round.

As you can see the command is available from the context menu, but you can also bind it to a key in the "Keys" preferences.

Open Declaration

The "Open Declaration" command, sometimes known by its key binding "F3", allows you to jump to the declaration of whatever is currently under the cursor. We've extended this command with the possibility to jump to the declaration of event handlers (actions), server methods and storage's. If the item underneath the cursor is not handled by our extension, the default "Open Declaration" command will be invoked.

The declaration:

Because we've extended the "Open Declaration" command, you can bind the "Open Declaration (EPlug)" command also to "F3" and enjoy faster navigating in your JVx files without any downsides.

DataBooks

The biggest and most important feature of EPlug is its support for data books. EPlug offers code completion, compile time checks and more for column names on remote and local data books.

Code completion

Everytime you want to get or set a value, or wire up an editor you will receive code completion suggestions with all column names that are in the databook, it doesn't matter if those are remote or added locally.

Compile time checks

Of course we also added compile time checks, which means that you can never mistype a column name ever again.

With the newest version, these compile time checks are even active while you type!

Text hovers

When hovering above a column name, a simple text hover will inform you about the type of the column.

Storage support

RemoteDataBooks require to have the correct name set so that the server side storage is found, of course we do also offer code completion, compile time checks, text hovers and hyperlinks for this.

The DataBook View

And last but for sure not least, with the newest version a feature has been added which I've been looking forward to for quite some time: The DataBook View. A view similar to the Outline view, which displays all databooks in the current file and all of its columns.

Actions/Events and server calls

Support for actions, events and server calls is the second big EPlug feature. For events and actions we support a very Lambda-like system that uses reflection and strings. Obviously the compiler was never able to understand this system and provide feedback or support for it, but with EPlug this has changed.

Code Completion

Whenever you want to wire up an event, you'll now receive code completion for all fitting methods in the used class.

Action methods:

Remote calls:

As you can see in upper image, we also provide a fast and convenient way to create methods if necessary.

Compile time checks

During compilation the actions, events and server calls are checked for their correctness, and if there is a problem it'll be reported to you.

You can also see the quick fixes for this problem, which do not only offer to create the missing method, but also suggesting methods with similar names in case a typo happened.

Text hovers, hyperlinks and refactoring support

Additionally EPlug provides text hover and hyperlink support, that means that you can now jump to the methods by using your mouse (Ctrl+Left Click) or the "Open Declaration (EPlug)" command. Refactoring support has also been added, which means that you can now rename action/event handlers without having to manually search for all uses and change those.

Resources

Dealing with resources can often be a pain in the neck, especially if you constantly have to look up the path and check if you're now using the correct image. Because we also felt these pains, we've added functionality to EPlug to make sure that working with resources becomes easy and painless.

Support for UIImage

Whenever you use UIImage methods, you can now enjoy code completion, previews of the images and compile time checks.

Preview:

Compile checks:

Generic resource completion

For all other resources, we do only offer a "generic" code completion system and no preview. Still, this is a huge help.

Comments

One of the more simple and not so obvious features of EPlug is that it allows to have code completion of the current class in comments, and also provides the JVx category separators.

Separator:

Action/call completion in comments:

VisionX support

Now we've arrive at the big final, support for VisionX. For all of you who do not know VisionX, it is our product for rapidly building applications from scratch or migrating already existing systems. It allows to build GUIs and the respective database backend within a matter of minutes. Even though VisionX allows you to build whole applications, from time to time you'll want to do something by hand and this is the great thing about VisionX, all projects and applications are automatically and by design already Eclipse projects. So all you need to do is import the project into Eclipse and start working on it. To improve this workflow further EPlug does offer various features.

Selection synchronization

The selection in Eclipse and VisionX can be automatically synchronized, so that whatever you're working on in the one application is also visible and selected in the other

Automatic applying of changes

VisionX will also automatically refresh its current view if you change a sourcefile in Eclipse, allowing to rapidly and verify changes in a workscreen without the need to manually reload the workscreen.

How and where to get it?

EPlug comes in two flavors, EPlug for JVx and EPlug for VisionX, both are available from the Eclipse Marketplace and can be installed and used freely for 30 days. Afterwards a license is necessary to keep using all features.

OpenShift is a PaaS product from Red Hat.
Read further details at Wikipedia or the product site.

It's of interest to us because it's easy to use, supports deployment of pre-created war files and it offers an application server (e.g. Tomcat, JBoss) and a database (MySQL, PostgreSQL) for your applications. OpenShift also has Vert.x as runtime platform if you won't use an application server. The configuration is super easy and your server is ready in around 5 minutes.

The access to your server is protected and you should use a specific client tool from RedHat for advanced configuration or an SSH client like putty.

The PaaS service is so nice because it's the perfect deployment platform for JVx applications. There's a free service for simple tests and maybe smaller applications because there are some limits for memory usage, CPU, and number of applications.

We made some tests with OpenShift and the result was as expected: Our applications did work without problems. Sure, the whole deployment procedure could be more end-user friendly but it wasn't designed for end-users without technical know-how, I guess. It's good enough for software developers or admins.

Our test

We created a new JVx application with VisionX (because it creates the database, has a GUI builder and creates the war file for us) and the application should run with VaadinUI on OpenShift. We didn't have any experience with OpenShift, but with other PaaS products, e.g. Heroku, Cloudbees, Jelastic, AWS.

First steps:

1. Registering an account (what else )
2. Creating a first application
3. Cartridge: Tomcat 7 (JBoss EWS 2.0)
4. Setting application name and domain
5. Adding MySQL 5.5 cartridge

Above steps were enough to run our OpenShift service(s).

Next was accessing the server via SSH client because we didn't install the RedHat client tool (We won't use client tools for cloud services - why the hell). Sure, we had to use another client tool for accessing the server via SSH, but it was working without installation: PuTTY (still strange). A nice web UI would be great... just my thoughts. We found a Java client but didn't test it.

So, what we did:

1. Creating private/public RSA keys with PuTTYgen
2. Configuring OpenShift (used the key from PuTTYgen TextArea because OpenShift didn't like other formats)
3. Testing connection

   Username was displayed in Application settings under SSH Code, e.g. ssh://<username>@app-domain.rhcloud.com/....
   Used the private key file for putty as key (Key authentication, without password)

Next task was, configuring the access to the database because SSH access was already working. It wasn't possible to access the database without tunnel - means, no direct (Internet) access from your client. This wasn't a real problem and PuTTY had support for port tunneling. Simply detected the IP address of the MySQL server. The hostname was set as environment variable and the command export displayed all variables. The variable OPENSHIFT_MYSQL_DB_HOST had all information and our tunnel was working. There's also a property for the MySQL Port but 3306 is default.

What was next?

Deployment.

This wasn't trivial because the platform expected source code and a maven project for automatic deployment. Wrong for us. But there's an official documentation for manual war deployment.

Short summary of steps

1. GIT clone
2. Delete src folder and pom.xml
3. GIT commit & push
4. Copy WAR file into webapps folder
5. GIT commit & push

You don't need git on your client, it's available in your terminal. But... as a developer, git is one of those standard tools...
It's also possible to upload the WAR file via SCP or SFTP...

Done...

Not really because our application was deployed without problems but it didn't work because the JDBC URL was wrong. We set the MySQL servername to localhost because of the tunnel!

Here's the original config.xml:

JVx has a nice feature which allows environment dependent settings and VisionX sets the environment automatically to prod. So, we simply changed the datasource to:

VisionX sets the environment to prod, if it creates a WAR file:

Sure, the solution isn't perfect because the MySQL hostname should be read from the environment variable.
Would be better:

But JVx doesn't support this syntax (right now) -> Feature Request.

Done. Really done.

The application works fine (Login as admin with password admin).

Here's a screenshot, for the case that our OpenShift service isn't running:

OpenShift ERP with JVx and VaadinUI

We've good news for you. Since our JavaFX UI has reached version 1.0, we thought it might be a good idea to integrate the UI into VisionX. It wasn't that easy because JavaFX needs Java8 and VisionX runs with Java7. It wasn't enough to switch the JVM because VisionX had Eclipse JDT under the hood and the used version wasn't Java8 ready and also some other libraries had problems with Java8.

It was a lot of work to support JavaFX but now it's done. We have Java8 support in VisionX and all referenced projects were updated. We don't have a public version for you right now because the new features need some additional tests. But we're very happy with the current status. Our development version is very stable and all features are still working.

We have a short screencast for you:

JavaFX with VisionX

Our current VisionX releases have built-insupport for Eclipse, because every new application is also a complete Eclipse project. Simply import an application in your Eclipse IDE and use all features of your IDE to develop/modify the application.

We didn't support other IDEs like NetBeans or IntelliJ IDEA because Eclipse was our preferred IDE and it's still the most used IDE. But nowadays it makes sense to support the big 3. So, why not

Our next VisionX release will come with support for NetBeans and IntelliJ IDEA. Simply open the application and run it. No more manual project creation!

We made a short video which demonstrates our upcoming IDE support. First, an application was created in 1 minute and this application was used with NetBeans, IntelliJ and Eclipse - Open.Run.Done.

Here's the preview video:

Multi-IDE support for VisionX

Above video was made with current development version of VisionX and the next release, with version number 2.2, will be available in this summer.

The current update release of VisionX 2.2.135 is available for our customers or as trial. It's a smaller update release with two important new features:

• Vaadin 7.4.2

  We've bundled vaadin 7.4 with our application and you can use all available features of vaadin 7.4. We currently don't use new Grid component of vaadin 7.4 because it's not implemented in our vaadin UI. We'll replace the Table with Grid as soon as possible.

• Corporation view

  This awesome view is now available out-of-the-box. Simply enable the design via web application settings screen.

The rest are fixes for smaller bugs:

• Support for username/password in Oracle JDBC Url
• protected access instead of public, for DBAccess
• Support all web setting in live preview (corporation design, navigation, mobile)
• Support for loading resources form public content area
• Don't delete unknown events from source file
• Designer update for better free-form layouts

Have fun with VisionX 2.2.135.

We had a lot of fun this week - with JavaFX

My last article was about JavaFX on mobile devices with JavaFXPorts. It was awesome that JavaFX worked without bigger problems on mobile devices but the number of needed re-deployments was high. The app build process needs some time (~2-3 mins) and if you do a lot of UI related changes in your application (CSS, layout, ...) you lose development time.

How to save deployment time?

Simply don't deploy!

We have our product VisionX and it has a Live Preview for applications while developing. Our idea was that we could use the existing functionality to show changes on mobile devices immediately. It should work with Android devices because dynamic class loading is possible with custom classloaders.

But as so often, things won't work as expected.

Android has support for URLClassLoader but it doesn't work because the implementation is "legacy" . This means that loading classes with URLClassLoader didn't work. Android has a DexClassLoader!

The DexClassLoader works great if you have the archive on the device. But it has no support for remote class loading. The other thing was that DexClassLoader needs a jar that contains a classes.dex archive. The classes.dex contains all class files (in dex format).

The first problem was: How to create the DEX archive?

Not too hard because Android comes with dx.bat and dx.jar. It's super easy to convert a jar file or a classes folder to a dex archive. After the hardest part was solved, it was simple to implement remote class loading with Android, for our JavaFX application! If you need more information, leave a comment!

Here's the result of our Live Preview experiment as Video:

Window shutter web control

It works great and reduces deployments to a bare minimum: 1

The next release of JVx is coming!

It'll be version 2.2. We have 2 open tickets for this release but both are refactoring tasks, nothing too important. We're already feature complete.

It'll be an awesome release because we have a lot of performance improvements and some really cool features like lazy loading of BLOBs (binary content). The server implementation is now IoT ready and it's pluggable. Support for Lambda expressions with full backwards compatibility for our listener handling. And we have support for application monitoring, style definitions, streamed upload of large files, and much more.

We plan the release for the end of this week.

Our VaadinUI was based on vaadin 7.1.15 and 7.4 was released some days ago. We're happy to announce support for vaadin 7.4.

The repository of JVx' vaadin UI already contains 7.4 libraries and everything is available for you. We don't have an official release right now, because we do some tests and afterwards we'll release a new version of our UI. We don't have a date for you but hopefully in March.

We currently don't use the new Grid component, but we'll replace the current table implementation asap.

The last information is about the next release of VisionX 2.2 preview. It will contain JV' vaadin UI for vaadin 7.4 and some new features like exporting an application for embedded devices (run the application on embedded devices like Raspberry Pi, without application server - "Micro applications").

Oh, finally... Check our github page, because we have new projects for you.

The first preview release of VisionX 2.2 is available. The exact version number is 2.2.41.

It available as trial version or for our customers via download area.

The preview release contains updates of all dependent frameworks like JVx and vaadin UI.

Here's a list with more details:

• Responsive web applications
  

  Window shutter web control

• Browser navigation
• Application styles
• Support for embedded devices
• Style definition with VisionX
  

  Style definition

• New EPlug support
• Custom Database connection strings (e.g. Oracle TNS entry)
  

  Custom connection string

• Live Template support for work-screens
• XLSX reports instead of XLS
• Ready for application monitoring
• UI improvements
• Ready for native Android client

Sure, we fixed some bugs and we also improved overall performance because of improvements in JVx. The most interesting thing is the support for embedded devices like RaspberryPi.

Have fun with VisionX

What is HANA?

It's the In-Memory database system of SAP, developed in 2010 for, or togehter with some customers to handle big data. You'll find all details here.

The system should be super fast and brilliant... That was the reason why we thought it might be interesting for VisionX and of course, VisionX could be useful for HANA customers.

So what?

We have a lot of experience with most important database systems like Oracle, SQLServer, DB2, PostgreSQL and MySQL but we had absolutely no idea what HANA was. But it has a JDBC driver . We also have a lot of experience with JDBC drivers.

So we had the Know-How to do some cool things with HANA. Our simple idea was the integration into VisionX via JDBC driver like all other databases which are already supported. We tried to find out how we could start.

The starting point for HANA development is: http://hana.sap.com/abouthana/developers.html.

To be honest... We didn't read a lot of documentation because we are Researcher. Simply clicked on Try SAP HANA and... found more information.

The first thing we had to learn was, that it's not too easy to start and there's a lot of information about everything and nothing. We tried the "SAP HANA Cloud Platform Developer Edition" but got an error...

After Googling around, we found another starting point: http://scn.sap.com/docs/DOC-31722.

But what about development tools?

We love using Eclipse and SAP has HANA studio and Eclipse plugins. Sounds great, and we found a strange site. A really simple site with minimal information but we didn't find information about the JDBC driver. We read about HANA client which should contain the JDBC driver, but it also was available here. It was another place for downloading HANA software.

Did I tell you that we are Researcher? We love to solve complex and tricky software problems but why are there so many different download sites. All sites are different with more or less information.

Did I tell you that we're tough? You're right, we found the little pieces.

• Eclipse Plugin for Luna
• HANA JDBC Driver
• Dev registration

After we found the right path, we made progress because Plugin installation was as simple as it should be. The registration of a dev account was not big problem.

The next "problem" was using Eclipse because we didn't find a simple web site with configuration details. After some googling we had some stackoverflow hints but no complete guide. But it wasn't that hard to find out how it works. Oh I forgot to mention that we tried to get direct access to the DB and not to create a hello world example.

The SAP HANA Administration Console perspective was our friend and we tried to add a new System. After we saw that there's an option for Cloud system, we made some progress But don't think it's that easy. Don't forget to create a schema via online system, called Cockpit!

To shorten the story: It's NOT easy to start and too much documentation doesn't help if someone forgets to KIS.

After we had access to our HANA schema and understood how the cockpit worked, we tried to create our first application with VisionX. The next problem was that it's not allowed to connect to HANA instances directly via Internet, without tunneling (as usual). To create a standard JDBC connection via VisionX, we had to create a tunnel. What do you think: An easy task for about 5 minutes or a job for Google?

Long story short:

Learn using NEO (console client). It's part of the HANA SDK.

Working command:

(The URL is important! We found other URLs which didn't work)

Used the result of the command to create a JDBC connection and we were back in the game.

What was next?

Our dev environment was up and running and VisionX could connect to HANA but we had to do some laborious tasks because HANA had some specifics (not surprisingly). We solved most problems in HanaDBAccess which is now available in JVx.

One of the biggest problem was the JDBC driver. Especially if you try to find some answers in the HANA forum about getting generated keys. The driver developers should listen to their community! (Don't ignore defacto standards)

But ok, that was only one thing. A big problem was the performance of metadata operations. If you try to get a list of unique keys, a list of colum names for a table or foreign keys, be sure you have some extra time because such operations can take a minute or more. Not sure if trial accounts are the botleneck but we thought HANA is always super fast.

We're not sure if no one needs metadata or if we have special requirements, but especially metadata access should be fast in any case!

We learned to live with slow performance and we're pretty sure that SAP will solve this problem.

Did we reach our goals?

What do you think about this:

HANA application with VisionX

This video demonstrates the creation of an application based on HANA. The application was developed with VisionX and deployed as JVx' Vaadin application. I'm not sure if there's a tool which can do it like VisionX but I don't think so because SAP doesn't have one

One hint

If you have problems with locked accounts because of invalid connection attempts. Use Eclipse, connect to your schema and execute:

Our Eclipse was blocked with this command, but everything worked fine after restart.

It's done. We proudly present an awesome VisionX release. It has the version number 2.1.905 and has doubled its features.

Here are some of them:

• Undo & Redo

  It's now possible to Undo and Redo Actions and Reports. Simply add an action to a button undo the creation if you want. The action will be removed from the screen. It's also possible to add the action again, via redo.

  In VisionX 2.0, only UI elements could be deleted but not actions or reports.

• Eclipse integration

  It's a developer feature and allows bidirectional communication between Eclipse IDE and VisionX. Simply select an editor in VisionX and the source code in Eclipse will be selected. The integration allows faster development because you jump exactly to the source file and code line of your screen. Don't was time for searching properties and files. More...

• Layout Assistant
  

  The Layout assistant (designer) of VisionX 2.0 was column oriented and it wasn't possible to create free-form layouts without fixed positioning. The new layout assistant still is column oriented but you can use it free-form. You have all features of a layout manager (preferred size, automatic size calculation) but it's easy to create individual layouts which are not column oriented.

• ActionEditor

  It's a small feature, but the action editor now allows Finish without explicite validating the action. It save so many unnecessary klicks.

• PDF Reporting

  We have built-in support for toPDF in VisionX. With VisionX it's possible to create PDF reports as Document and Spreadsheet with Word and Excel. Create your report templates with Word or Excel and create PDF reports out-of-the-box. More...

• Mobile and Web
  

  VisionX got wizards for mobile und web settings. They allow styling of web and mobile applications like background color, background images, ... Simply define which image should be used in web or mobile applications instead of the original image, e.g. the mobile application should use flat images but the desktop shouldn't.

• Developer features

  It's now possible to set the name/ID of components. This feature is a developer feature and useful for automated GUI tests or styling via CSS. More...

• License options

  We offer subscription based VisionX usage. You can use and pay on a monthly base. We don't offer SaaS. VisionX will run in your environment.

  Also new is the support for SAP' Hana. If you work with Hana, you could use VisionX to create Hana based applications.

• Popup menu

  It's very easy to create custom popup menus for a component. Simply use the new customizer and define the action.
  More...

• Manual dropdown-list configuration

  We allow the creation of custom dropdown lists directly with VisionX. Create your own statements or storages and use the data wizard to configure the editors. More...

• Solution store

  The solution store offers ready-made solutions. We offer free and demo applications for learning purposes and also commercial solutions. The solution store is also available for your environment. You can install the store for your intranet, if you need a distribution platform your your applications, addons or modules. More...

• Responsive application

  Your new web applications will be responsive - out of the box. The styling of the application will be changed dependent of the browser size. We have an API for software developers to create responsive work screens. More...

• Desktop application

  Create a desktop application per click. Use VisionX to create a desktop application package.

• Other features

  Repeating frames
  QR Codes

Our customers should check their download area to get access to the new release.