One of the most subtle bugs you can encounter is a UI that displays information meant to be hidden. In the FotazaApp project, we recently discovered that user profile pages were exposing posts that had been marked as inactive or deleted.

The Discovery

While reviewing the data flow for user profile views, we noticed that the application was fetching the entire recordset associated with a user

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

Browser-native form validation is a double-edged sword. While it provides immediate feedback to users, it often conflicts with custom validation logic or dynamic UI requirements, leading to inconsistent behavior across different devices. In the IntegradorWeb project, we encountered this friction when trying to implement a unified validation flow.

The Validation Conflict

When you use standard

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

Focusing on Logic

Working on the AppJavaGuia2_Ejercicio4 project provided a great opportunity to revisit fundamental Java concepts. When building out instructional exercises, the goal is often to transform a set of abstract requirements into a clean, functioning class structure. My recent work centered on finalizing the core logic to ensure the application handles its data lifecycle

Dealing with unexpected roadblocks is an unavoidable part of the software development lifecycle. Working on the ProyectoFinal_G14 project in Java recently reminded me that engineering isn't just about writing code; it's about systematically dismantling the obstacles that arise during the build process.

The Encounter

Sometimes, the biggest challenge isn't a complex feature request or a

The Documentation Gap

Starting a new project often feels like walking into a dark room without a flashlight. For the ApiRestCRUD project, I realized that while the logic was sound, the path to getting started was missing. Without a clear guide, contributors and new developers were forced to guess the setup requirements, leading to unnecessary friction from the very first minute.