Do You Know About Servoy?

Never heard of it? You are not alone! There are loads of developers out there who don't even know the platform exists. I stumbled on it myself by chance (basically because it is known in FileMaker circles as THE challenger and my company is doing some FileMaker development... yes, I know!). In fact it is a lot more than a FileMaker clone and it certainly has a lot of potential to seduce most Java developers, which is why I thought of writing this introductory article.

It's never too late to give it a try, and in fact, now would be the best of times: the company recently announced the Open Source version of its award-winning hybrid SaaS platform, Servoy 5.2 - to be released soon.

So what is Servoy?

Quoted from the Servoy web site: "Servoy is a cross-platform application development and deployment environment used to create and deploy applications. Servoy Developer is used to design, develop, test and debug applications and Servoy Server is used to deploy the application, both on Premise or as SaaS."

OK, now that definition might work for your marketing manager, but what exactly is Servoy?

I would say that it is a clever Java RAD platform, based on an Eclipse distribution and a Tomcat server, made to help you write and deploy hybrid applications for Thin clients or Web clients from the same source code using best-of-breed Open Source Java frameworks like Rhino, Hibernate and Wicket, to name a few.

What is it capable of? Most of all, it can reduce your development time by a factor of ten if you are used to develop your applications the good old way in .Net or Java. For a comparison with .Net check out the hilarious 'real world test' they did - for Java, well... you know about it, don't you?

What are the main advantages of an application built with Servoy?

In no particular order:

It is build using standards: SQL, Java, JDBC, JavaScript, HTML, CSS, XML, and some of the most reliable Open Source Java projects: Tomcat, Apache Commons, Hibernate, Rhino, Wicket, Quartz, HttpClient, JasperReports, iText, Log4J...

It is database-agnostic. Because Servoy leverages the power of Hibernate without you even noticing, and generates ANSI-92 compliant SQL, you are only one JDBC jar away from migrating your database from one vendor to the next. Servoy offers automatic data-binding, where all you have to do is declare your data source to get access to your data, using the form editor to drag and drop components that will be bound to it. And of course you can make all your data access fully transaction-aware.

Your code is dynamic. Servoy code is ultimately Java, but you script your Java code using JavaScript. Thanks to Rhino, you have access to all of the advantages of a modern dynamic scripting language: Forget about the write/compile/deploy/run/debug cycle typical of Java development, you can change your code in real time without having to restart your server. And because you develop in Eclipse, you will be able to debug your code in real time using the DLTK tools. The Servoy platform embeds its own Tomcat server to help real time development and debugging.

Your data is dynamic too! Servoy uses a clever system called "DataBroadcasting" that pushes data in real time to all connected clients viewing the same records, this works for thin client (what they call 'smart' client - because it really is smart) but also for web client, using Ajax polling thanks to Wicket behaviors. And Servoy broadcasts only the relevant changes, being nice to your network.

It is cross-platform. This sound obvious being Java, but this point needs to be reminded to .Net proponents. Cross-platform from the server point of view: you can run it on any Java capable server, but from also the client point of view too: the thin client is Java/Swing, the web client is... HTML and JavaScript.

It is cross-client: this one is a huge time saver. Your code will be used by a thin (Smart) client or a web client. Not only your persistence layer or business layer, but your also you UI layer will be done and scripted using the very same code! You UI is done using a form editor in Eclipse, at design-time, but you also have access to run-time scripting using what is called the "SolutionModel", allowing to modify the properties of all UI objects and even recreate your UI dynamically.

It's easy to deploy and maintain. You install your application on a server, using a web administrative access, with its own versioning system, and it will be deployed to your clients using Java Web Start or accessible from a web browser. Servoy also use a tunnel mode where both type of clients can use the same standard ports (80/443), thus it is easy to deploy even behind a firewall.

It is open: the Servoy public API allows you to extend the platform with your own plugins (scripting behaviors coded in Java but accessible from JavaScript code) and beans (regular beans can be wrapped in Servoy-Aware components to alleviate the power of internal databinding), you can also use Java classes directly inside you JavaScript code for extended access to the JVM. And now that the platform itself is going to be open source you will have even more access to extensibility.

It is SaaS ready: you can filter every access to your database based on tenant UUIDs, deploy on a server farm on premises and/or on the cloud (helped by the terracotta distributed layer), all of this with very little configuration.

It has a lot already built-in. The kind of things that takes weeks to build and that you end up doing all over again for each projects, endlessly patching supposedly 'generic' code or writing hundreds of lines of XML configuration: stuff like hibernate mapping, i18n support, fine-grained security, audit-trail for all your data, logging and profiling of your code and your SQL queries, Unit testing and JSDoc generation, CSS styling for web client and swing client as well, cron-jobs scheduling, drag and drop support in swing and on the web...

It is modular: you can build your code out of a set of modules within a main 'solution', or encapsulate critical functionalities in Java plugins and beans.

Now just imagine what it takes to add all this to your own application, starting from scratch, and think that it is already there...

What does it look like?

Servoy adds a "Servoy Design" perspective to Eclipse, and one of the views is the "Solution Explorer" which is where you organize your code and find all the built-in help and objects:

A sample CRM solution in the Servoy (Swing) "Smart" client
- the total weight of this project (code+forms+images) is 280kb:

The same one viewed in Firefox:

What next?

I will soon write a series of introduction articles for those interested, but in the meantime, you can:

1. Go to the official Servoy web site to know more,
2. Download it and try it yourself,
3. Check out some video tutorials (a bit outdated but still a very good introduction),
4. Go to the wiki for the whole documentation,
5. Have a look at the public API,
6. Check the Servoy Stuff web site for extended tutorials on how to build "Servoy-Aware" plugins and beans.

* Note that this article is in no way commissioned by Servoy, nor even endorsed by the Servoy company.
I am a Java developer happy using Servoy in my day to day work and an Open Source developer building free components, tools and tutorials for the Servoy platform.