Classic Web App with a Modern Flare


At UDig we pride ourselves on using some of the latest frameworks and industry trends when solving our clients’ problems. A typical solution for us generally includes either a AWS Lambda or Docker based microservices layer using either AngularJS or ReactJS front end solutions and all built with the latest DevOps techniques and tools, but what if a client needed a more classically simple solution?

The challenge: modernize, replace and support

This is a common challenge in consulting. Not all clients are ready to go cutting edge but they want a modern, proven solution that fits the bill. Recently we had two different clients that wanted to modernize and replace older antiquated platforms. They wanted the new systems to be better supported solutions while retaining the ability to easily leverage existing and /or find new talent for supporting / maintaining things long term. While the adoption of front end frameworks are gaining ground and finding their way into enterprise organizations we also understand it can be challenging to find readily available talent for some of those newer disciplines.

So what now? Well the good news is while we have new and exciting ways to architect applications the classics are also continually improving. So we set out to piece together a very modern feel on a more classic overall design. Having a diverse group of engineers in our Studio definitely helps with narrowing our selections but not without some solid subjective arguments for the various sides of the house: .Net vs. Java, server side templating vs. SPA based front ends, etc…so how did we decide? We looked at the specific needs of the client, features, documentation and popularity of the frameworks and talent on hand to deliver. We matched those requirements against the needs of the client and landed on the following stack:

  • Linux (OS),
  • Java 1.8,
  • MVC & Routing & Servicing
    • Spark Framework “Project 1”
    • Spring “Project 2”,
  • Templating
    • Freemarker “Project 1”
    • Thymeleaf “Project 2”
  • Data
    • MySql with jOOQ “Project 1”
    • MySQL with Spring Data “Project 2”
  • Log4j
  • And a few other honorable mentions you’re welcome to ask us about…

First things first.

First things first. The difference between Java and .Net are so negligible that for us it was the flexibility of OS that made the biggest difference. Choosing your java add-on frameworks can be much more dividing but we decided that Spring was best for one of the projects due to existing experience. Spark Framework was the real surprise here and we couldn’t be happier with the super simple Lambda based syntax it provides.

Combining these with templating engines like FreeMarker & Thymeleaf along with data access layers like jOOQ & Spring Data got us not only up and running in minimal time but uses extremely modern techniques to interact with both sides of the application. jOOQ was especially rewarding because it gives a natural SQL syntax with minimal overhead to our applications as it generates very normalized queries while Spring Data’s ability to auto wire data to classes is very simple and rewarding. Using an ORM in general wasn’t a concern in either scenario due to these applications having smaller concurrent user bases and being more transaction heavy. jOOQ alone shortened our development cycles by noticeable margins. Not having to jump between stored procs and services calls was a huge lift not to mention our combined logic was all in one place. FreeMarker and Thymeleaf on the other hand while really robust and capable did require a little finagling to truly simplify our templates and front end designs. If you’re familiar with .Net’s master page setup that is essentially what we were going for. We wanted to be able to define a Master Template and inject our page specific output within its content containers. We were able to achieve this with some thought and planning but it was a little unnatural at first.

Overall we couldn’t be happier with the direction of these projects. While they are still underway and undoubtedly there’s more to learn, I’m proud we could find a modern way to approach classic applications while simultaneously doing the right thing for our customer. It goes to show that not all problems are best solved with the latest and greatest but a little research can help you build a classic app with modern flare keeping both your engineers and clients happy.

About The Author

Andrew Duncan is the Director of Software for Richmond. He is a driven technologist focused on modern technology stacks and best practices. Andrew believes nothing is more rewarding than making software needs a reality with a focus on flexible, scalable and supportable code.