Blog Changes

Author: sathishk

content/blog/future-of-java-persistence/index.md

@@ -18,6 +18,62 @@ seo:
   noindex: false # false (default) or true
 ---
 
-Over the past two decades, the way we access relational databases from Java has evolved significantly. Starting with JDBC programming, we moved on to using SQL mappers and later adopted full-fledged ORM frameworks. However, modern architectures, such as cloud-native, microservices, and serverless, present new challenges that traditional persistence technologies may not fully address.
+Over the years, Java's interaction with relational databases has undergone significant transformations. As the backbone of enterprise application development, the way Java applications connect with and interact with databases has evolved to meet the demands of modern software development. These changes have not only influenced the way developers write code but also brought about major migrations and improvements in the database connectivity landscape.
 
-In this presentation, we will explore the history, theory, and technology behind the evolution of persistence technologies for Java applications. We will discuss the challenges posed by modern architectures and how cloud-native persistent technology can solve them. Join us to learn about the future of Java persistence and how you can prepare for it.
+Code migrations are no small feat and often come with considerable costs and time investments. For instance, notable public examples include [Meta's migration to MySQL 8](https://engineering.fb.com/2021/07/22/data-infrastructure/mysql/) and DBS's migration to MariaDB [Ref: https://mariadb.com/wp-content/uploads/2019/11/dbs-mariadb_customer-story_1047.pdf]. These migrations showcase the significance of understanding the change and the value of each generational shift.
+
+In this section, we will explore some of the key changes that have shaped Java's relationship with relational databases, leading to crucial core migrations and advancements. From the early days of ODBC to the emergence of JDBC, SQL mappers, and ORM frameworks, we will delve into the milestones that have redefined Java's role in the world of databases. By understanding these changes and their value, we gain insights into why and when upgrades become essential. Let's explore these significant changes and the value they have brought to developers in each step.
+
+#### ODBC (initial Days):
+
+Change: ODBC enabled Java applications to interact with relational databases.
+Value: Developers gained cross-platform database access and the ability to write database-independent code.
+
+#### JDBC (Abstraction for Multiple Databases):
+
+Change: JDBC was introduced as a replacement for ODBC due to its limitations and platform dependency.
+Value: Unlike ODBC, which was primarily designed for the Windows platform, JDBC provided a platform-independent and standardized API for Java applications to interact with various relational databases. JDBC became the preferred choice for Java developers as it offered improved cross-platform compatibility, allowing applications to seamlessly connect to and work with different databases on different operating systems. The introduction of JDBC brought about greater portability, code reusability, and ease of development for Java-based database interactions.
+
+#### Connection Utilities (Manage Connections and Result Sets):
+
+Change: Connection pooling libraries and result set handlers addressed connection management and resource optimization challenges.
+Value: Developers achieved improved performance and resource utilization through efficient connection and result set management.
+
+#### SQL Mappers (Database First Approach):
+
+Change: SQL mappers, such as MyBatis and jOOQ, introduced a "Database First Approach" to database interaction, simplifying SQL query handling and reducing boilerplate code.
+Value: By providing a database-first approach, SQL mappers enabled developers to write structured and readable SQL queries with automatic mapping of results to Java objects. This approach significantly improved code maintainability, reduced the risk of vulnerabilities, and enhanced overall development efficiency.
+
+#### ORM (Java First Approach):
+
+Change: ORM frameworks like Hibernate and JPA revolutionized Java-to-database interaction with a "Java First Approach," automatically mapping Java objects to relational database tables.
+Value: By adopting a Java-first approach, ORM frameworks eliminated the need for manual SQL generation, reducing repetitive database access code and enhancing developer productivity. The transparent persistence, caching, and lazy loading features provided by ORM frameworks further simplified data access and persistence management, resulting in cleaner, more maintainable codebases.
+
+### Conclusion:
+
+The evolution of Java's interaction with relational databases has been shaped by various factors, including the type of software development and specific project requirements. While we often discuss the changes in Java-to-database interaction, it is equally crucial to understand the underlying reasons driving these changes.
+
+In the early days of Java, smaller-scale applications predominantly used JDBC, which provided a direct and sufficient means of database connectivity. However, as software projects grew in complexity and scale, the need for more advanced approaches became evident. SQL mappers emerged, simplifying SQL query handling and reducing code complexity for larger projects.
+
+As software development shifted towards creating products rather than individual applications, portability became a key consideration. This need for seamless integration with diverse databases, while maintaining code consistency and portability, led to the rise of ORM frameworks. ORM frameworks provided a higher level of abstraction by automatically mapping Java objects to relational database tables, addressing the challenges of database portability and simplifying data access and persistence management.
+
+Understanding our current needs and project requirements plays a crucial role in predicting future innovations in Java's database interaction. By identifying the specific needs and constraints of our projects, we can make informed decisions and anticipate the direction of future advancements.
+
+#### Challenges in the Current Scenarios:
+
+##### Evolution of RDBMS (Distributed, JSON, Custom Types):
+
+- RDBMS systems are evolving to support distributed architectures, requiring new approaches for data storage and retrieval across distributed nodes.
+- Increasing adoption of JSON and custom types in database schemas calls for efficient handling and querying of these data formats.
+
+##### SaaS Products:
+
+- Software-as-a-Service (SaaS) products require efficient data storage and retrieval mechanisms to handle large-scale data, user management, and multi-tenancy.
+- Ensuring data security, scalability, and performance becomes critical in SaaS environments.
+
+##### Cloud:
+
+- Cloud-based databases are gaining prominence, necessitating seamless integration with cloud infrastructure services and leveraging scalability, availability, and data redundancy features.
+- Managing data migration, backups, and disaster recovery in the cloud environment presents new challenges.
+
+By acknowledging these challenges, Java developers can stay proactive and adapt to the evolving database landscape. Embracing innovative solutions that address distributed architectures, support modern data formats, cater to the needs of SaaS products, and leverage the advantages of cloud-based databases will pave the way for successful project outcomes.

content/docs/getting-started/_index.md

@@ -1,5 +1,5 @@
 ---
-title: "Getting Started"
+title: "Get Started"
 weight: 5
 toc: true
 ---

content/docs/getting-started/connection.md

@@ -13,9 +13,6 @@ url: "jdbc:postgresql://localhost:5432/sampledb"
 userName: "user"
 password: "password"
 schemaName: "sampledb"
-
-# Mapping Logic
-rootPackage: "com.example"
 ```
 
 After this, you can build the project with

layouts/index.html

@@ -17,7 +17,7 @@ <h2>{{ .Params.lead | safeHTML }}</h2>
 
       <a class="btn btn-primary btn-cta btn-lg my-3"
         href="/docs/{{ if site.Params.doks.docsVersioning }}{{ site.Params.doks.docsVersion }}/{{ end }}getting-started/installation/"
-        role="button">Getting Started</a>
+        role="button">Get Started</a>
 
       {{ .Content }}
     </div>