Tagger Cat Features

Tagger Cat is a Visual Model Driven Java Application Framework for rapidly building Business applications.

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!

›› tell me more ››

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.

SaaS Savvy

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.

Declarative Business Logic

We think Tagger Cat's declarative business logic is pretty cool because it is declared and tested right from within your running application. Additionally, it:

supports effective From and To dates
can be interactively tested before being enabled live
Uses EL or Sandboxed Rhino scripting
is tenant specific, in multi-tenant deployments
supports Rule Inheritance with OO semantics

The advantages of Model Driven Development combined with Declarative Business Logic are very significant in reducing both development and long term application costs.

›› tell me more ››

So, what does declarative really mean?

Declarative development is based upon the concept that application functionality is derived from model definitions, and that business logic is not buried into application code; as much as possible. In other words, it is getting away from hand-developed code, and business logic implemented in the domain and service layers. But, it augments regular development too. Therefore, the more you can take advantage of declarative development the more you can reduce the amount of code that needs to be developed, tested, and maintained.

With a declarative approach, application administrators can control, and maintain a significant amount of an application's functionality.

Declarative also means that your application’s business rules are implemented so that they can be changed in real time. Therefore, you can change your application's business logic a lot faster, and whenever business needs change.

Declarative business logic should be implemented in a cross-cutting pattern, so that it is applied universally regardless of the application code. This ensures consistent and correct data that meets the business need.

Declarative business logic is typically implemented using business rules in a form that:

Provides Constraints on Entities and Attributes
Provides Derivations on Entities and Attributes
Supports and Integrates with Decision Tables
Supports Event-Condition-Action rules
Can be modified and tested at application runtime
Are time based, with effective From and To dates
Supports a complete programming language for complex rules
Integrates with application security
Can be easily reported on

The benefits of declarative business logic are:

Faster application development
More consistently applied business rules
Significantly more customizable applications
Significantly more maintainable applications
Applications that can have business logic changed in real time
Faster response to changes in business requirements

‹‹ less ‹‹

Declarative Security

Tagger Cat's declarative security allows you to easily specify who can view, search, edit, or delete any entity or change any properties. Of course this totally leverages our metadata system, and is supported in multi-tenant environments.

Add it goes beyond ACLs, letting you use EL and Scripting when needed.

Plug in Change History Module

What business application does not need a Change Auditing or Change History feature?

Our Change History module allows you to simply plug this into your application; with almost no additional code.

Changes are automatically tracked to the system wide change history; detailing who changed exactly what and when.

Native Administration of Security

Administration of security is natively hosted right within your application. Security permissions can be changed in real time; so there's no need to re-deploy or cycle the application to make security changes.

Native Administration of Business Logic

Tagger Cat applications have native administration of business logic. This makes it easy to interactively test it, and validate it. Since your business logic can be changed in real-time, you can respond to business needs faster.

Universal AJAX field validation

All of your application's data fields are automatically validated against your declarative logic and data types via AJAX. No additional code is required.

Clean Logical URLs

It is easy to define clean logical URLs that reflect your application's logical structure, and are completely independent of the application's file structure.

Jump Start Application Builder

One of the hurdles in building Java web applications is just getting all the scaffolding in place. This includes the basic WAR file structure, with all the needed jars and other file artifacts, and getting the basic application up and running connecting to the database.

Our Stub Application builder fills that need with a simple visual form and ANT script that builds your application's scaffolding so that you can have a running application up and working within minutes. Of course, the stub application is itself templated, so that you can build this out and extend it as needed.

Automatic Code Table Functionality

Code tables, AKA look-up tables, are a fundamental unit of any business application model. Therefore, Tagger Cat has significant direct support for code tables built right in.

Code tables can also be Multi-tenant enabled. Therefore, each application's tenant can have their own code table entries.

Our Pro Kit gives you support for color coded code tables, and a generic code table editor.

Page elements automatically reflect security

All page elements automatically reflect the current user's security permissions. If users don't have edit permission on a property, the corresponding form elements are display only. If users don't have insert or edit permission on an entity, then any corresponding action elements are also automatically disabled / or not rendered.

Configuration Light

Tagger Cat is very configuration light, and does not need external XML files. Rather, almost everything is declared in JSP tags, and simple Java annotations.

Super Easy Page based Wizards

We've made Page based wizards super easy. Like other JSP pages, the wizards can leverage our logical URLs, and have data scoped to them.

Tools and MetaData Synchronizer

We've built tools to keep your application's enhanced metadata synced with Hibernate's model. It super simple, and can be scripted as part of the build process.

Of course, the MetaData Tools also support multi-tenant deployments.

Automatically Aliased JSPs

You can enable automatic aliasing of JSP file names. This is a nice feature that pretty much eliminates .jsp file extensions from being included in URLs, and anchors etc.

Although this is mostly a cosmetic deal, it is a nice touch that goes nicely with our clean logical URLs.

Integrated Undo Functionality

We've included Undo functionality into Tagger Cat; much like what is found in most desktop applications.

< Tagger Cat™/>

Dealing with Multi-Tenancy is a complex topic.

So, what does declarative really mean?