Benefits of Lightweight ORM Technology
Modern application programs are mostly written in object-oriented languages like Java, and the business objects (also known as domain model objects) used in those applications are typically stored (persisted) in an SQL relational database like Oracle, SQL Server, MySQL, Postgres, and SQLite. However, integrating such applications with a relational database is a big programming challenge because it entails bridging the gap between the object-oriented world and the relational world, which are conceptually different; mixing Java programming with SQL relational language is hard; and manually writing the verbose mapping logic between the object-oriented and relational artifacts is tedious and time-consuming. Using Object Relational Mapping (ORM) frameworks has become a preferred method for developers to simplify the programming efforts of integrating object-oriented applications with relational databases.
Software Tree has developed innovative, flexible, and lightweight Object Relational Mapping (ORM) framework products — JDX for Java, NJDX for .NET, and JDXA for Android — with more ORMs in the pipeline. The underlying ORM technology is based on some well thought-out KISS (Keep It Simple and Straightforward) principles. This blog post explains what we mean when we say that our ORM technology is lightweight. What are the different lightweight aspects of our ORM technology in terms of its composition, its specification, its dependencies, and most importantly its usage? From these explanations, you will also learn why those lightweight aspects matter for application developers and the resulting benefits.
The composition (internal implementation) of our ORM frameworks is lightweight.
The internal design and implementation of our ORM frameworks is highly modular, refactored, and compact. These frameworks consist of reusable and easily extensible components which minimize the code size as well as the code path lengths. Consequently, our ORM libraries have small footprints: 493 KB for JDX, 400 KB for NJDX, and 270 KB for JDXA.
The small footprints of our ORM libraries require less memory and enable their faster loading and execution.
The modular design of our ORM frameworks also makes them more robust and easier to evolve.
The design of our ORM frameworks is lightweight.
Our ORM frameworks are non-intrusive to the persistent object model. This non-intrusiveness provides a lightweight feel to the application developers as the ORM-specific artifacts don’t seep into the object model.
- No need to inherit persistent classes from a base class.
- No need to clutter your source code with annotations.
- Every developer need not be concerned with the ORM aspects. Developers can concentrate on the business logic.
- Clean architecture — your POJO code does not need to change because the ORM does not do any code generation or byte code enhancements, so your applications are easy to debug.
- Even JSON objects can be persisted easily.
The ORM specification is lightweight.
The ORM specification is defined declaratively in a simple textual way.
- Compact; most default mapping is automatically deduced; avoids verbosity.
- Easy to specify, modify, comprehend, and share. Only one place to look at the mapping — it is not distributed all over in multiple files.
- Human readable — no XML complexity.
- Mapping can evolve independently without changing the persistent classes (e.g. table names and column names can be changed in the mapping specification without affecting the source code).
- Since the source files need not change, the ORM products can work with pre-existing object classes whose source code may not be available or cannot be changed.
Not being an overarching framework, our ORM technology feels lightweight.
Our ORM technology does not bite into the application architecture, resulting in a clean design and implementation of the data integration layer.
- The ORM system follows a de-coupled approach.
- The ORM does not trap the application in its tentacles.
- The mapping engine is fairly stateless.
- No overhead and confusion because of object change tracking, whose semantics can be complex.
- The objects can be moved around in different application tiers without any ORM implications.
- No complex coding and semantics for detach/attach operations.
- Simple and flexible APIs.
- No separate query APIs to learn.
The steps for development, integration, and deployment with our ORM technology are lightweight.
The development methodology with our ORMs is simple and lightweight — define persistent classes, define a declarative ORM specification, and use a small set of simple ORM APIs.
- No extra steps to pre-process, generate, or augment the source code or byte code.
- No dependencies on other libraries except for a standard database driver.
- Ideal for providing lightweight persistence functionality in the cloud and with microservices.
In summary, Software Tree’s KISS ORM technology frameworks are lightweight in their design and implementation and provide a lightweight feel in their usage. The lightweight aspects of our ORM technology do not compromise on its power and functionality, though. This results in faster development and deployment of modern applications that require flexible object-oriented access to relational data.
The lightweight nature of our ORMs also makes it easy to integrate them with other tools, frameworks, platforms, Docker containers, IoT software, and microservices.
Learn more about the KISS ORMs, including how to get free trial versions, by visiting Software Tree’s website at https://www.softwaretree.com/.
