Managing User Identity

Handling authentication and user sessions is a foundational requirement for any web application. In the project ProyectoFinal_G14, we recently focused on implementing a robust session management system to track user identity across requests effectively. Managing state correctly is the difference between a seamless user experience and broken authentication flows.

Introduction

In the TomasAbatedaga/Parcial2-Abatedaga-Tomas-Tema-C- project, we focused on organizing data access logic to ensure the application remains maintainable and testable as it grows. By implementing the Repository Pattern, we decoupled the domain layer from the persistence layer, creating a cleaner separation of concerns.

The Problem

When data access code is scattered

Improving Data Accessibility

In the project ProyectoFinal_G14, we recently focused on improving how users interact with spa booking schedules. As our platform grew, the ability to view availability quickly became a bottleneck. Users were struggling to find appointments, leading to a fragmented booking experience.

The Challenge

Previously, searching for a spa service appointment required

Every journey begins with a first step, and in software development, the initial commit is where the architecture finds its heartbeat. This post covers the foundational setup of the AppJavaGuia2_Ejercicio4 project, focusing on establishing a robust environment for future development and testing using Java and JUnit.

The Initial Setup

When starting a new project, the primary goal is to ensure

Managing Application State

Handling user sessions and persistence layers effectively is a core challenge in any robust Java application. Recently, in the ProyectoFinal_G14 project, we revisited how data is stored and how session information is managed to ensure a more consistent user experience.

The Challenge of State Persistence

When building web applications, a common friction point is

Introduction

In the project TomasAbatedaga/Conversor-de-temperatura, I recently performed a maintenance pass to address a logic error. Maintaining clear and predictable data transformations is the backbone of any utility application, especially when dealing with mathematical conversions.

The Challenge of Logic Errors

Even in simple temperature conversion tools, small errors in arithmetic

The Challenge of Data Access

In the TrabajoPractico5 project, we recently identified a friction point in how user information is retrieved. Specifically, our system lacked an efficient way to look up contact information—such as phone numbers—based on a user's surname. Navigating through large datasets without a targeted search mechanism forced users to rely on cumbersome manual filtering or

Building a solid foundation for any application starts with how data is modeled and accessed. In the TrabajoPractico5 project, we recently focused on setting up our core entity structures and the corresponding data access layer, ensuring that our backend remains maintainable as the project grows.

Why Clean Entity Definition Matters

Entities represent the "nouns" of your application.

In the ongoing development of Parcial2-Abatedaga-Tomas-Tema-C-, we recently identified a need to centralize the management of our public works domain. As projects scale, keeping logic organized is key to maintaining a clean and readable codebase.

The Need for Centralization

Previously, logic related to public works was potentially scattered or missing from the core architecture.

Managing state persistence in long-running applications requires disciplined data access patterns. In our work on ProyectoFinal_G14, we recently took a close look at how our service layer interacts with data entities to ensure reliability and maintainability.

The Challenge

When working with service-level data components, it is easy for layers to become tightly coupled to specific database