Rapid, Visual JSP Design
Tagger Cat supports rapid visual JSP development. It lets you template any common page regions using advanced templates.
While, we don't believe in "generate it all" kind of tools; Tagger Cat's approach is "generate as much as you want".
Model Driven Development - not UML
Tagger Cat uses extended Hibernate metadata to support model driven development. The metadata provides you with:
- automation of a huge portion of your application's development
- declarative business logic
- declarative security
Model Driven Development does not mean UML here.
We have nothing against UML, it just that we find most real software development projects can never stay in sync with the UML models.
With Tagger Cat, the extended Hibernate model is the key runtime component, and is always in sync with the running application.
Since the Hibernate model is the canonical form of the application's model, why not leverage that?
Minimal Hand Developed Code
With Tagger Cat most JSP pages require zero lines of supporting Java code.
Most of the needed functionality is provided by the core framework, and via JSP tags.
Hand written Java code is usually only needed to provide custom action handlers. We've made this super clean too. So, your Java code is very predictable, and easy to maintain.
On the presentation side, the generated JSP page regions are a just as clean and as readable as any hand-crafted page.
Multi-tenant Support built in
Multi-tenant support is built right into the framework. Our multi-tenant support is implemented using the All Tenants in One Physical Database strategy.
This is not a trivial implementation. It goes very deep and includes the declarative business logic, security, permissions, metadata, code tables, menus, and model entities.
This is a big deal... please don't under estimate it!
Dealing with Multi-Tenancy is a complex topic.
Implementing Multi-Tenancy with Hibernate really comes down to the choice between two strategies; a separate schema per tenant, or all tenants in one schema.
We looked closely at both strategies. We soon came up against multiple concerns with the separate schema per tenant approach.
Firstly, Hibernate's 2nd Level Cache breaks down with the schema per tenant strategy. There is no facility for appending an additional key to the cache entries that could be use to additionally qualify tenant specific data. So, not having the 2nd level cache would be a very big and unacceptable loss to us.
Secondly, with the database, we did not feel comfortable maintaining and synchronizing potentially thousands of separate physical schemas. This has just too much room for error, and probably a long-term maintenance nightmare. It also complicates backups.
Lastly, there is the additional many-fold resource consumption by the database server as each tenant is created. There is more memory usage for caching of queries, indexes, prepared statements, the system catalogs, connection pools, etc. with each schema.
So, overall, we feel that for applications that need to host thousands of tenants, the single schema per tenant is just not realistic.
However, there is one big benefit of the separate schema approach. This is the physical partitioning of data, and therefore reducing the possibility of cross-tenant hacking or even unintended cross-tenant data access.
But, we decided that if we were really pushed on this, it would be only from a few customers. Our planned solution for it is that we'll spark up a separate application, and database instance specifically for these customers. Additionally we'd only do it at a significant additional service fee since it requires a bunch of extra long-term administration effort.
So, with these concerns and considerations, we decided to use the single schema for all tenants approach. After years of use with it, we are really happy with this choice. It has proven to be very solid, and has almost no additional development or maintenance overhead.
Tagger Cat automates the extra hooks needed to apply Hibernate filters, and setting the appropriate tenant key on all inserts. We also automate the synchronizing of our metadata system across all tenants. In addition, all of our declarative business logic and security is also multi-tenant enabled.
Another benefit with this approach is that you can be selective on what tables are multi-tenant enabled. In other words, not all tables need to support multi-tenant data. For example, we have selective code tables that are global across all tenants.
But, this single schema approach also raised its own issues.
Firstly, each tenant needs separate PKs sequences. We've nicely solved this one with our Pseudo PKs as described over on the PRO Kit page.
Secondly, restoring tenant specific data from backups is a little bit more complicated. We've solved this one with a pretty straight forward procedure using generic SQL.
These two components are part of our Pro Kit offering.
But, the story does not stop at just the data access needing multi-tenant support. We support tenant specific business logic, metadata, field captions, declarative page messages, etc. This means that each tenant can have quite highly customized applications, specific to their unique needs.
So, in a nutshell, we think we've made multi-tenancy really easy.‹‹ less ‹‹
Super Integration with Hibernate™
Tagger Cat was built from the ground up to leverage Hibernate™, and Hibernate's metadata. We've made using Hibernate for business applications really, really easy.
We've also added some pretty cool features to automatically work with Hibernate's lazy loading, and collection management.
Uses JSP based code generation
templates at design time
We've embraced JSP for everything that needs to be, or can be templated. We use JSP to generate:
- JSP - that's right JSP to generate JSP
- AJAX and XML
- Email - both text and HTML formatted
This leverages your teams current skill set.
Using JSP is incredibly powerful since you have complete access to the application's enhanced metadata using our tag library, and any JSTL tags, and expressions.
You've got to see this one in action to appreciate it.
Advanced Query By Form Searching
Advanced Query By Form is built in as a key feature of the framework.
QBF allows you to easily build sophisticated search screens typically needed by most business applications.
Browser Scoped Objects
We support browser scoped objects, giving you one more scope to support your application's needed functionality. This also enables your application to better handle users that need to open multiple browser windows.
Easily Extended - A pleasure to use
This framework has its origins in our frustration with other frameworks that were just not productive enough, and just not fun to use.
We've put a lot into Tagger Cat to make it as easy as possible to use and extend.
We think it is one of the best overall business focused web application frameworks available.
Cool AJAX support built in
There are a lot of frameworks providing AJAX support. We love jQuery and we use jQuery a LOT for all kinds of UI interactions!
But, for AJAX we've developed our own library that is based upon using a markup based command file. It makes it super easy to author Ajax responses using JSP and our tag libraries.
Of course, you can use our AJAX functionality, jQuery's, or anyone else's with Tagger Cat.
Delivering Software-as-a-Service has a ton of advantages, and is probably going to be the biggest market segment in the near future.
Delivering Software-as-a-Service also has a ton of challenges.
Tagger Cat's built in multi-tenant support, and tenant specific business logic let's you easily develop these applications, and painlessly deploy them in the cloud.
Extended Metadata Drives the Development
The Extended Metadata drives the development. It is the key central component of the application. Everything hinges off of, and leverages the Metadata. This includes the rapid page development, declarative security, and business logic.
Here's more insight into how we deliver productivity.