DEV Community: Phillip L. Cabrera M.

How I Optimized an Extremely Slow Oracle SQL Query (Real Case Study)

Phillip L. Cabrera M. — Sun, 23 Nov 2025 00:58:36 +0000

In enterprise environments with large data volumes, SQL queries can go from executing in seconds to taking minutes—or even hours—especially when they involve multiple tables, joins, and functions on indexed columns.

In this post, I want to share a real-world experience optimizing an Oracle query that originally took far too long and how I drastically reduced its execution time by applying practical optimization techniques.

The Initial Problem

It all began with a query that joined several tables across different schemas.

Although the logic was correct, the execution time was unacceptable: Oracle was processing millions of rows without leveraging indexes effectively.

Diagnosing the Bottleneck

After reviewing the execution plan, I identified several issues:

Use of functions on indexed columns (like SUBSTR()), which invalidates index usage.
Missing indexes on columns used for table joins.
Outdated table statistics, causing the Oracle optimizer to make poor cost estimations.
Use of EXTRACT(MONTH FROM ...) in the WHERE clause, also preventing index usage.

Solutions Applied

🔹 1. Remove Functions From Columns Used in JOIN and WHERE

Instead of using SUBSTR, I created physical columns that stored the exact values needed for filtering.

This allowed Oracle to use the indexes directly without performing a function on every row.

🔹 2. Create Optimal Composite Indexes

I then created composite indexes that reflected the actual way the columns were used in the query and added missing indexes on other involved tables.

🔹 3. Update Optimizer Statistics

Before re-running the query, I updated the table statistics so Oracle would have an accurate understanding of data distribution and volume.

The Result 🚀

The execution plan shifted from full table scans to index range scans.
Total cost dropped dramatically.
The query went from taking several minutes to running in under one second.

Lessons Learned

Avoid functions on indexed columns. Whenever you use SUBSTR, EXTRACT, UPPER, etc. in WHERE or JOIN conditions, Oracle cannot use indexes.
Create indexes based on real query conditions. A poorly designed index can be as useless as having none.
Keep statistics updated. Oracle makes decisions based on them, and outdated stats can lead to suboptimal execution plans.
Consider derived columns when needed. In some cases, denormalized data can significantly improve performance without affecting integrity.
Measure, test, and document. Always compare execution plans before and after making changes.

Conclusion

Optimizing SQL queries in Oracle doesn’t always require advanced tricks or more powerful hardware.

Often, it’s simply about understanding how the optimizer interprets your query and giving it the proper structure to work efficiently.

In my case, removing functions from indexed columns and creating the right indexes transformed a slow query into an instant operation. 💪

From chaos to relief: How we solved a critical problem in the telemetered meter disconnection and reconnection system

Phillip L. Cabrera M. — Sun, 17 Aug 2025 15:49:39 +0000

For weeks, our system responsible for remote cut, reconnection, and meter readings was failing consistently. Commands we sent were stuck in timeouts—and this wasn’t a mere technical hiccup:

Customers who had already paid remained disconnected.
An entire department had to submit commands manually.
Service orders (SOs) were being closed outside the normal flow between the Commercial interface and the Remote Management system.

It drained both our internal teams and our customers, and we needed an urgent solution.

Problem Context

Under normal conditions, the process works like this:

The Commercial interface generates the service order.
The Remote Management system, built in Java, sends the command to the meter (cut, reconnect, or read).
The meter responds, confirming the action.
The service order is closed automatically in the system.

However, once the issue began, step 3 never happened. The system sent the command… and then waited until it hit the timeout.

Investigating the Cause

At first, all signs pointed to a network infrastructure problem. We ran multiple checks:

Monitoring communications with meters.
Verifying servers and links.
Reviewing logs for connection errors.

Everything looked fine… yet the failure persisted. That’s when we considered that the real issue might not be technical at the network level, but logical at the system level.

The Key Finding

On deeper review, we discovered that the user configured to send commands in the system had limited permissions. Due to how the interface is designed, those permissions restricted bulk command sending and interfered with automatic SO closures.

In other words, the system wasn’t failing due to connectivity—it was failing because the user account lacked the necessary access level to execute all operations.

The Solution

The fix was straightforward: we requested elevated privileges for the service user used by the Java program so it could send the corresponding commands.

The change had an immediate impact:

Commands started sending and completing correctly.
SOs closed automatically within the Commercial–Remote Management flow.
The department that had been doing manual work returned to its normal function.

Lessons Learned

It’s not always the network: sometimes the failure is as simple as user permissions.
Document roles and privileges: knowing what each user can do prevents blockers.
Keep a high-privilege test user: vital for diagnosing critical issues.
Avoid manual workarounds: breaking the automated flow creates more errors long term.

Final Reflection

This case reminded me that in technology, root causes aren’t always obvious. We spent days checking cables, routers, and servers, when the answer was a single permission setting. Thank God we restored the service and spared customers from further, unnecessary delays.

In the end, seeing everything flow correctly again is the best reward for any technical team.

💡 Pro tip: If you work on similar systems, never underestimate the importance of reviewing user configuration before assuming the issue lies in the infrastructure.

Optimizing Transformations in Pentaho: Case Study

Phillip L. Cabrera M. — Sun, 04 Aug 2024 00:55:05 +0000

In my current role as an IT Analyst, I was tasked with verifying and correcting an automatic transformation in Pentaho.

Pentaho is a suite of business intelligence (BI) tools that enables companies to collect, integrate, visualize, and analyze data from various sources to make informed decisions. It offers a range of functionalities, including data integration, interactive and dynamic reporting, data analysis, dashboard creation and management, data mining, Big Data, among others.

The Challenge

The transformation I had to analyze and optimize consists of extracting data from some databases and then inserting them into a single table in another specific database. At first glance, everything seems logical. However, the original workflow presented a critical problem:

Query in three different databases.
Deletion of all data from the target table.
Insertion of data from the three previous queries into the target table.

This approach may seem reasonable, but it becomes problematic as the volume of data increases. Performing a DROP TABLE on every transformation execution (several times a day) can greatly impact the performance of a production database, especially if the table is used as a reference in crucial daily operations.

The Solution

To solve this problem, I restructured the transformation flow. The original flow was: SELECT -> INSERT. I modified it as follows:

Select source table: A data selection is performed from the source table.
Select target table: A data selection is performed from the target table.
Sort rows: The rows obtained from the source table are sorted.
Sort rows 2: The rows obtained from the target table are sorted.
Stream lookup: A data lookup is performed between the two previously sorted sources (source and target). This step combines rows from both sources based on some common key, adding the key field of the source table with that of the target table.
Filter rows: The rows resulting from the Stream lookup step are filtered. Depending on the specified condition, the rows will be split into two streams. This step filters out the records that are already inserted and those that are not (NULL).
- If they meet the condition (key field set to null), they will move on to the Select values step.
- If they do not meet the condition, they will move on to the Dummy (do nothing) step.
Dummy (do nothing): This step does not perform any operation; it is a holding place for rows that do not meet the filter condition.
Select values: Specific values are selected from the rows that met the filter condition.
Insert into target table: The selected values are inserted into the target table.

This procedure ensures that only missing records are inserted into the target table, thus avoiding the need to do an unnecessary DROP on a production database table, which is used by various database processes (procedures, triggers, functions, etc.) in order to provide good service to customers and avoid negatively affecting the business.

Record Keeping

Also, what happens when you need to delete existing records in the target table that are no longer in the source table? The flow is similar to the one mentioned above, except that in step 5 the key field to compare in reverse is added and the last step is changed to a DELETE instead of an INSERT.

Conclusion

This optimization not only improves the performance and efficiency of the production database, but also ensures data integrity and system stability. It is a clear example of how a small modification in approach can have a significant impact on the performance and reliability of IT systems.

If you want to know more about me, don't forget to follow me on my networks and why not subscribe to this blog.

How to Create a Shortcut for an Application in Ubuntu

Phillip L. Cabrera M. — Sun, 16 Jun 2024 00:14:05 +0000

Sometimes, when you are new to Ubuntu and need to manually download applications and run them from an executable file, you may wonder how to create a shortcut similar to those in Windows. Here, I will explain how to do it step by step.

1. Copy the application folder

First, copy the folder containing your application to the /opt/ directory with the following command:

sudo cp -r /path/to/app /opt/

2. Create the `.desktop` file

Check if there is a file with the .desktop extension in the copied folder. If not, you will need to create one with the following format:

[Desktop Entry]
Version=1.0
Type=Application
Terminal=false
Name=dbeaver-ce
GenericName=Universal Database Manager
Comment=Universal Database Manager and SQL Client.
Path=/opt/dbeaver/
Exec=/opt/dbeaver/dbeaver
Icon=/opt/dbeaver/dbeaver.png
Categories=IDE;Development
StartupWMClass=DBeaver
StartupNotify=true
Keywords=Database;SQL;IDE;JDBC;ODBC;MySQL;PostgreSQL;Oracle;DB2;MariaDB
MimeType=application/sql

3. Explanation of the `.desktop` file

Here is an explanation of each part of this file:

[Desktop Entry]: Indicates that the file follows the desktop entry (.desktop) standard, which is used to define shortcuts in graphical desktop environments.
Version=1.0: Specifies the version of the desktop entry file. Not always mandatory, but can be useful.
Type=Application: Defines the type of the entry. In this case, it's an application. Other types can be Link or Directory.
Terminal=false: Indicates whether the application should run in a terminal. false means it's not needed; true would open a terminal to run the program.
Name=dbeaver-ce: The name of the application as it will appear in the applications menu.
GenericName=Universal Database Manager: A generic name that describes the type of application. Useful for users unfamiliar with the specific name.
Comment=Universal Database Manager and SQL Client.: A comment that provides a brief description of the application, shown as a tooltip in some desktop environments.
Path=/opt/dbeaver/: The working directory where the application will run. This can be useful if the application needs to run from a specific directory.
Exec=/opt/dbeaver/dbeaver: The command to run the application. Specifies the full path to the DBeaver executable.
Icon=/opt/dbeaver/dbeaver.png: The path to the icon file used to represent the application in the menu and dock.
Categories=IDE;Development: The categories to which the application belongs. Helps to classify it correctly in the applications menu.
StartupWMClass=DBeaver: The name of the main window class of the application. Useful for the desktop environment to correctly associate the window with the shortcut.
StartupNotify=true: Indicates whether to show a startup notification when launching the application.
Keywords=Database;SQL;IDE;JDBC;ODBC;MySQL;PostgreSQL;Oracle;DB2;MariaDB: Keywords that help users search for the application in the menu.
MimeType=application/sql: The MIME types that the application can handle. Useful for associating the application with certain file types.

4. Copy the `.desktop` file to the correct location

Copy the .desktop file to the /home/username/.local/share/applications directory with the following command:

sudo cp /opt/application/application.desktop /home/username/.local/share/applications

5. Assign execution permissions

Finally, give the necessary permissions to the newly copied .desktop file with the command:

chmod +x ~/.local/share/applications/application.desktop

Conclusion

By following these steps, you will have created a shortcut in Ubuntu to easily locate and open your applications. This will allow you to work more efficiently and have your favorite tools always at hand.

Development of a Web Application for Consulting Geographic Information and Printing Maps: A Case Study

Phillip L. Cabrera M. — Sun, 19 May 2024 00:52:54 +0000

Within the framework of my company's Annual Operating Plan, I was assigned the task of developing an innovative web application to consult geographic information of clients and generate interactive maps. This project is crucial to improve efficiency in geographic data management and optimize the relationship with our clients. In this article, I will describe the development process, from the analysis phase to the implementation of the first module.

Analysis and Planning

Description of the Current System

Currently, we have a similar system that has performance failures, request saturation, and slow map generation.

Use Cases

The new system will work when the current one is saturated or has problems meeting user needs.

Requirements

The requirements of the new system include secure access, friendly interface, compatibility with existing data, and reduced response times.

Flow Charts

I have created flow charts to represent the processes of the current system and the new system.

Technologies to Use

HTML
AntDesign
JavaScript (FrontEnd)
Node.js (BackEnd)
Express.js
React.js
Leaflet
React-Leaflet
OracleDB
Sequelize

Entity-Relationship Diagram

I will describe the relationships of the tables that the application will use in the backend.

Development

Creating the API

I use JWT for authentication and secure transfer of information between the backend and the frontend. Endpoints have middleware to ensure authentication and data validation.

FrontEnd

I am creating the frontend using a feature-based folder structure. I use Vite.js as a packager.

First Module

The first module of the application will allow the user to select options from a list, rendering an interactive map with the corresponding elements. Users will be able to interact with the map, consult information and generate PDF files for printing. I plan to deliver this first module to receive feedback from users and report it as evidence of progress.

I hope this article has given you a clear insight into the development process of our geographic query application. As we progress, I will share more updates on the feedback received and progress in the upcoming modules. Thank you for your interest and following.

If you want to know more about me, don't forget to follow me on my networks and why not subscribe to this blog.

My university experience

Phillip L. Cabrera M. — Sun, 03 Dec 2023 00:42:45 +0000

This will be a blog different from the others, in which I will immerse you in the great journey of my process to become a computer engineer.

The beginning

In the middle of 2007 I began my journey at the university, everything was going smoothly, I took all my subjects that the term offered me, I started my university life very well, meeting classmates and other majors with whom I began to interact and All of these experiences gave me a certain understanding of what adult social relationships are.

Disruptions and Challenges

So far everything is normal, but for the second year due to personal reasons and things beyond my control (such as living in a third world country and above all because I had little or no financial intelligence) it was not possible for me to continue my studies, I I saw the need to stop them and focus solely on work.

Work experience

At that time I was working as a photo editor in a studio using Photoshop, where I worked for 4 years. Then I had the opportunity to work as a Georefential information data manager in the company where I currently work. At that time I didn't really know the purpose of my work, simply doing what they told me.

As time went by, just like at the university, I began to interact a lot with my co-workers, creating relationships of great intellectual value, which I still have, but I had not yet been able to decide to reintegrate into university life.

Disruptions and Challenges

I fell into the trap that many young people are fortunate enough to fall into, in my opinion, which is working without graduating in an area related to their career. For several years (2010-2020) I remained in that spiral, I went to work, collected my money, went out one weekend more than another and on Monday I returned to the routine. It was until one of my co-workers who had just started in the company and recently graduated from high school asked me for some advice about the registration process, which encouraged me to move forward with the subjects I had left behind, but I was so mentally focused that in Instead of taking all the ones that were offered to me during the quarter, I only took a few to be as loose as possible. It should be noted that even though not being able to take them, my full-time job would be an impediment.

This form of study meant that despite the long time (4 years 2014-2018) I will reach the end of my student curriculum with only three subjects missing, among which was the final project (monographic). Once again I decided (without any reasonable excuse) to stop my university studies, it should be noted that between the periods of time that I lasted without studying I was on the verge of losing my enrollment, in other words I would have to start my degree again and that meant that at a pace of turtle but surely he will advance until he only has three pending subjects to present, on several occasions he only paid for the reactivation of the registration, even so he will not study that quarter just to avoid losing all the progress he had achieved.

Graduation project

After these events, it lasted until 2020 to teach my last subject (my degree project or monograph). It should be noted that due to the events that everyone already knows happened in the world, I carried out all the research work as well as the preparation and everything that The same entailed remotely, all this while working remotely, it should be noted that at that time if it had not been for that modality I would not have been able to finish university, I found it quite comfortable to work from home and luckily much of the research that I I had to do it or much of it was on the web or I could find it a few kilometers from my home.

By December 2020, I had already presented my degree project or monograph and I felt incredible satisfaction knowing that I only needed to complete the last step, which was to graduate. Again, for reasons beyond my control, especially economic ones, I postponed said event. It was not until recently that thanks to the current position I have in the company that I was able to cover the expenses for my graduation which was celebrated this year in the month of October with which I concluded a step in my life, of which I know in advance, a large part of the Latin American population cannot afford (to go to university).

Final thoughts

Even though you see your goal very far away, one step every day is better than many from time to time, in the end you will achieve it.

Going to university is great but leaving it already with experience in the career you chose and working in a company related to it is priceless, that's why I strongly ask you if you can, get experience while you study, in the end it will give you a unmatched plus.
Adversities, whatever they may be (economic, social, etc...) will always be there, it is up to you to decide whether to face them or let them crush you.
The most important thing that you can obtain in my humble opinion from everything that comes with entering and leaving university are the relationships that you can make, in the future they are the ones that will help you find a job, a partner or even partners for your businesses.

Without anything else to add, just thank you reader for taking these valuable minutes of your time to read this small experience of what was one of the most important stages of my life, I say goodbye and at the same time I encourage you to share your story.

If you want to know more about me, don't forget to follow me on my networks and why not subscribe to this blog.

Automate your tasks with Cron and Crontab

Phillip L. Cabrera M. — Wed, 23 Aug 2023 00:25:46 +0000

"In the digital age, efficiency and automation are essential to keep workflows agile and streamlined. Often, we find ourselves with tasks that need to be executed on a regular basis, whether it's backing up data, cleaning systems or generate reports.Instead of relying on manual intervention, which can be error-prone and time-consuming, wouldn't it be great to have a tool that allows us to schedule and automate these tasks?If you work with UNIX systems, you're in luck In this post, I'll introduce you to two powerful tools, Cron and Crontab, that can transform the way you manage and schedule tasks on your system. I'll share my recent experience with them and the essential lessons I've learned in the process."

I was recently given an assignment at work to learn how to use what is Cron and Crontab so I immediately began to investigate what these tools are and what they are used for, and here are the conclusions I could reach.

Cron

It is a daemon-type service that comes installed with any UNIX system which is responsible for reading certain types of instructions from Crontab-type files.

Crontab

It is a text file in which each line indicates the frequency and the scheduled script that you want to be executed either once or several times.

Suppose we have prepared a certain bash script that we want to run constantly.

1. Backup a folder recursively

We have the following script that is responsible for compressing the information of a certain folder.

#!/bin/bash
# Folder you want to compress
SOURCE_DIR="/path/to/your/folder"
# Name of the compressed file to be generated
OUTPUT_FILE="/output/path/my_compressed_file.tar.gz"
# compress the folder
tar -czvf $OUTPUT_FILE $SOURCE_DIR
echo "The folder $SOURCE_DIR has been compressed into $OUTPUT_FILE"

We could manually execute said script every day at the times we deem necessary, but this could become somewhat repetitive and, above all, take away valuable time that we could be using in other types of tasks. Here comes what is Cron and Crontab.

Open our terminal.
Run the command vim crontab -e This will open a screen similar to the following or it may show you a file with no text, which makes no difference. Now suppose we have saved the script to backup the information with the name makeBackup.sh and we want it to run every day at 8 am, 365 days a year.
Click the I key to put the VIM editor in edit mode and place the following line of code 00 08 * * * /path/makeBackup.sh

Let's explain this little snippet

00 Will be executed at minute 00
08 It will be executed at time 08
* It will be executed on any day of the month
* It will be executed in any month of the year
* Will run on any day of the week

Here you have in more detail the syntax structure of each line of a crontab file.

Position	Description	Values	Example
1	Minute of the hour	0-59	00
2	Time of day	0-23	08
3	Day of the month	1-31	*
4	Month	1-12 (or names like JAN, FEB, etc.)	*
5	Day of the week	0-7 (0 and 7 are Sunday)	*

Note: The asterisk (*) in the crontab syntax is used to indicate "any value" or "always".

2. Create a DB Backup Script

1. First, write a bash script that backs up your database. of data.

#!/bin/bash

# Variables
DB_USER="your_username"
DB_PASS="your_password"
DB_NAME="database_name"
BACKUP_DIR="/backup/path"
DATE=$(date +"%Y%m%d")

# backup
mysqldump -u$DB_USER -p$DB_PASS $DB_NAME > $BACKUP_DIR/db_backup_$DATE.sql

echo "Backup completed for $DATE"

Save this file as db_backup.sh and grant execute permissions with:

chmod +x db_backup.sh

2. Configure Crontab

To schedule the task, we are going to use Crontab.

Open your personal Crontab with the following command:

crontab -e

To perform a daily backup at 2 a.m., add the following line:

0 2 * * * /path/to/script/db_backup.sh

This line indicates:

0 Minute 0.
2 Time 2 a.m.
* Any day of the month.
* Any month.
* Any day of the week.

3. Verify

After adding the task to Crontab, make sure everything is working correctly. You can set the task to run in the next minute and verify that the backup file is created in the specified location.

This example shows how to automate daily backups of a MySQL database. The key is the combination of the script that performs the backup and Crontab that schedules the regular execution of the script. I hope this example is useful to you and inspires you to explore more about the automation possibilities with Cron and Crontab!

Recommendations

It is important to take into account the following aspects when working with task automation with Cront and Crontab.

Always place an email at the beginning of the crontab file with the snippet MAILTO="yourmail@hotmail.com", this is quite useful for when the Cron daemon have to execute the script if there is an error in the script's syntax, you will receive the error in your email.
Use absolute paths to your scripts
Test your scripts by scheduling tasks to run within 5 minutes, so you can instantly debug any possible errors either in the way the task is scheduled, the script path, or in the script itself .
When creating your .sh scripts give it execute permissions, you can use chmod +x file.sh

Did you find this tutorial on Cron and Crontab helpful? Task automation is just the tip of the iceberg when it comes to maximizing efficiency on UNIX systems. If you want to learn more and keep your skills up to date, subscribe to my blog!. And if you think this article can help someone else, don't hesitate to share it on your social networks! Remember, sharing knowledge is a way to empower our tech community.

How to recover an application in production.

Phillip L. Cabrera M. — Tue, 08 Aug 2023 02:35:19 +0000

What to do when production goes down: Two weeks ago in my new job one of the applications that the company uses to serve a large part of its internal customers stopped working, this is an application that uses GIS services to represent, consult and print georeferential information corresponding to electrical entities. When the affected departments reported the incident, I realized that within the server that managed these applications, the folders with the necessary files were empty.

I immediately set about trying to recover as much information as I needed, in order to put back the necessary applications and bash scripts that should be running in the background.

One of the applications consisted of a Java Glassfish application server and within that server two more applications were deployed which had the following task:

One consisted of the application, that is, the web application itself developed in Java with the standard of JavaServer Faces (JSF).
The other is an API to serve information corresponding to maps and render said maps. The application use this API within its modules.
And another that consisted of a GIS server for its in a module of the application (JSF) where the users have the possibility of interacting online with the geographic entities.

Scrutinizing the server I found the source code of the three applications, I immediately set me to work to deploy them and put them into production, but here things got complicated.

The first two (The Web Application and the API) are both applications deployed by the Glassfish server that we mentioned earlier, and the files I found were apparently corrupted or missing information so I asked a member from the development team the source code of the Web application (JSF) in the company's repositories, as well as the API and eureka but there was another problem, when testing the application in a local environment it worked correctly, but when I tested it in production trying to move between the modules (links or menus of the Web Application) the server threw error 500. So I came to the conclusion that the files corresponding to the glassfish server that I found could be equally damaged so download a new one, configure bash files to change environment variables such as JAVA_HOME, etc to deploy the server.

Done, glassfish server installed, apps and APIs deployed, but happiness was short lived 😔. When trying to search for geographic entities in the application, the application did not return anything, so I had to learn the basics of the JSF application workflow and reading the source code I realized that the SQL queries that the application made to the DB had a parameter that was no longer being used, so I had to decompile that package from source, change the SQL queries, compile the app, package it, deploy it with Glassfish, and that's it.

This whole process of testing, error, reading code, consulting my colleagues and so on took me almost two weeks, thank heavens there were alternative methods by which other internal clients could continue with their operations, although not at the same speed and fluidity as before but now everything is back to normal and what I have learned in these two weeks is priceless, being able to recover applications from a production server, configure them from scratch without having the slightest idea was an amazing trip.

With this I want to invite you to lose your fear of breaking things while doing tests, but always do them locally😅 production is not touched. 🚫

If you liked this article and want to continue learning from my experiences in the world of technology, please subscribe to my blog. Also, if you think this article may be useful to someone you know, feel free to share it.

My first assignments at my new Tech job

Phillip L. Cabrera M. — Mon, 26 Jun 2023 12:18:33 +0000

Recently in the previous post I have indicated how you must act in an interview for a job related to technology, it is my pleasure to inform you that I am already working as an information technology analyst and part of the new things I have learned in this new position are:

Obtain a deeper understanding of the company's databases.
Learn to run programs developed in Java.
The most used commands in Linux to work with servers.
Among others that I will continue posting here.

Despite being a role that is not entirely involved with development, the responsibility is high, since it depends on me to manage and give suggestions to teams such as Infrastructure, DBA, Windows Admins/ UNIX, etc..., on how to proceed to resolve any event that is affecting the normal operation of the company.

My first assignment was to automate some changes at the DB level that constantly had to be done manually, thanks to constant research and the use of AI (only for script correction) I have achieved create this procedure. Working on what you like and above all the challenges give incredible satisfaction. Tomorrow one of the seniors will review my script so fingers crossed that everything goes well.
Having only been in this new position for two weeks (IT Analyst), I still don't have enough context and information with which to share with you, but don't worry, the best will come later.

I will be thank you to suscribe to my personal blog.

How to act in a job interview

Phillip L. Cabrera M. — Tue, 06 Jun 2023 19:15:27 +0000

I recently made the decision to check out a more technology related job position at the company I work for.

When I attended said test, the first thing I noticed was that one of the members of said department was programming in JavaScript 😁 which I already started to like.

As I began the interview with the head of the department with all professionalism, she asked me if she had any idea of the nature of the position for which she was applying. I immediately told her that I vaguely understood that it was a position for a development team, to which she replied: No, here we develop a few solutions for the areas of the company that we provide service to.

It is a position whose main function is to provide support in the face of any inconvenience or situation that the systems present. In short, the position has more to do with part of DevOps but mostly it tries to be technical support, ensuring a continuous delivery of high quality in regards to solutions to possible problems that the systems present, that is. incidentally they are georeferential systems (with satellite positioning).

After having clarified that point, the young woman proceeded to do the behavioral interview on site, which she always recommends to be totally honest. I remember right now that one of the requirements for the job was to have solid knowledge of Java, unfortunately I told him that I had knowledge but in JavaScript, but if he gave me the opportunity I could learn the language and give me time for that process and so on with a technical test to check my progress.

she Finally she gave me a small technical test (exam) with the following points:

Carry out an SQL query to find out the number of records from a location whose contracts have been made as of a specific date, (it should be noted that all these data were in separate tables joined by a foreign key).
The second point was to put in my own words an analysis and solution to the scenario in a SQL statement was taking more than 30 seconds to complete.
The last point consisted of making the necessary script in the language of my choice and that said script would do the following:
- Read from table A records with a specific condition.
- Enter these records resulting in table B.
- In table B update the records with a specific condition.
- Finally, display the square root of the highest value in table B on the screen.

After a few days, the manager of the department I was applying for wrote to me and told me, I just reviewed your technical test and as far as I'm concerned, if you are fully committed to learning Java you are more than welcome in my team.

You can already imagine my answer.👍🏽💪🏽

With this experience I encourage you to apply for any job in spite of not meeting all the requirements. The experience gained in these interviews, especially with the feedback they give you, is invaluable. So don't be afraid and apply, you never know what might happen.

Understanding ReactJS Lifecycle

Phillip L. Cabrera M. — Tue, 02 May 2023 14:35:44 +0000

ReactJS, a popular front-end library, is known for its efficient rendering of user interfaces. One of the key features of ReactJS is its lifecycle methods. The lifecycle methods provide a way for developers to manage components and their behavior throughout their lifecycle. In this article, we will dive deep into the ReactJS lifecycle and understand how it works.
What is ReactJS Lifecycle?

ReactJS components have a lifecycle which consists of different stages. The lifecycle methods are functions that get called at different stages of a component's lifecycle. The lifecycle can be divided into three main phases: Mounting, Updating, and Unmounting.

Mounting

Mounting is the first phase of the ReactJS lifecycle. In this phase, the component is created and added to the DOM. There are four methods in this phase:

constructor()

This method is called when the component is created. It is used to initialize the component's state and bind event handlers.

getDerivedStateFromProps()

This method is called after the constructor and before the render method. It is used to update the component's state based on changes in its props.

render()

This method is called after getDerivedStateFromProps(). It returns the JSX that defines the component's structure.

componentDidMount()

This method is called after the component is added to the DOM. It is used to perform any initialization that requires access to the DOM.

Updating

The updating phase is the second phase of the ReactJS lifecycle. In this phase, the component's props or state changes and the component is re-rendered. There are five methods in this phase:

getDerivedStateFromProps()

This method is called again when the component's props change. It is used to update the component's state based on changes in its props.

shouldComponentUpdate()

This method is called before the component is re-rendered. It is used to determine whether the component should be re-rendered or not.

render()

This method is called after shouldComponentUpdate() and returns the updated JSX.

getSnapshotBeforeUpdate()

This method is called before the updated JSX is added to the DOM. It is used to capture the current state of the component.

componentDidUpdate()

This method is called after the updated JSX is added to the DOM. It is used to perform any post-rendering operations.

Unmounting

The unmounting phase is the last phase of the ReactJS lifecycle. In this phase, the component is removed from the DOM. There is only one method in this phase:

componentWillUnmount()

This method is called before the component is removed from the DOM. It is used to perform any cleanup operations.

Conclusion

ReactJS lifecycle methods provide a way for developers to manage components and their behavior throughout their lifecycle. Understanding the ReactJS lifecycle is essential for writing efficient and optimized code. By using the lifecycle methods, developers can control the behavior of their components and improve the performance of their applications.

In this article, we covered the three phases of the ReactJS lifecycle: Mounting, Updating, and Unmounting. We also discussed the methods that are called in each phase and their importance. With this knowledge, you can write better ReactJS components and create better user interfaces.

The workflow with Git

Phillip L. Cabrera M. — Wed, 08 Mar 2023 19:25:44 +0000

Git is a control version system created by the creator of the Linux Kernel (Linux Tolvard), it allows to users working within a copy of a local repository, make changes and then sync them with a remote central repository. Also it offers features as branching and merging, what give to the developers the advatanges to work in deferents versions from a project simultaneously and combine the changes ordered and controlled.

Through the time collaborating with Open Source projects I've can see that over all that to work in a well structured way, Git save a lot of headaches and allow that the collaborations from others programmers as well as the project evolution be the more efficiently possible.

Through my experience developing and collaboration in projects, I've can collect this tips.

Update your local copy with the current in the remote repository.

A git pull is an operation that updated the local version of a repository including the changes that has been made in the remote source (repository) since last time it was synced.

That is to say, if somebody has make changes in the remote repository and it has been uploaded, the way you can have that changes in your local version is neccesary to use the git pull for sync your version with the remote one.

This way, every team member have the same code version and they can work in the project avoiding conflicts with others one.

Make small commits.

Make small commit is a good practice in Git due to several reasons, in which the most outstanding (in my opinion) is.

Facilitate the revision and comprehension from the repository history. When doing small commits, every of them represent an specific and concrete change in the code. This way is easier understand what changes were make, when, who made it and why.

Make commits with well descriptive titles.

Within the advantages from this good practice we can mention: Help to quickly understand the content into the commit, To allow to realize efficient searching in the repository historial, To help to maintain a good documentation and facilitate the collaboration in the team.

These and others reasons (that you sure know to work with Git) are part of the advantage this standard offers.

To see more of this content suscribe to my blog in this link

DEV Community: Phillip L. Cabrera M.

How I Optimized an Extremely Slow Oracle SQL Query (Real Case Study)

The Initial Problem

Diagnosing the Bottleneck

Solutions Applied

🔹 1. Remove Functions From Columns Used in JOIN and WHERE

🔹 2. Create Optimal Composite Indexes

🔹 3. Update Optimizer Statistics

The Result 🚀

Lessons Learned

Conclusion

From chaos to relief: How we solved a critical problem in the telemetered meter disconnection and reconnection system

Problem Context

Investigating the Cause

The Key Finding

The Solution

Lessons Learned

Final Reflection

Optimizing Transformations in Pentaho: Case Study

The Challenge

The Solution

Record Keeping

Conclusion

How to Create a Shortcut for an Application in Ubuntu

1. Copy the application folder

2. Create the .desktop file

3. Explanation of the .desktop file

4. Copy the .desktop file to the correct location

5. Assign execution permissions

Conclusion

Development of a Web Application for Consulting Geographic Information and Printing Maps: A Case Study

Analysis and Planning

Description of the Current System

Use Cases

Requirements

Flow Charts

Technologies to Use

Entity-Relationship Diagram

Development

Creating the API

FrontEnd

First Module

My university experience

The beginning

Disruptions and Challenges

Work experience

Disruptions and Challenges

Graduation project

Final thoughts

Automate your tasks with Cron and Crontab

Cron

Crontab

1. Backup a folder recursively

2. Create a DB Backup Script

1. First, write a bash script that backs up your database. of data.

2. Configure Crontab

3. Verify

Recommendations

How to recover an application in production.

My first assignments at my new Tech job

How to act in a job interview

Understanding ReactJS Lifecycle

Mounting

constructor()

getDerivedStateFromProps()

render()

componentDidMount()

Updating

getDerivedStateFromProps()

shouldComponentUpdate()

render()

getSnapshotBeforeUpdate()

componentDidUpdate()

Unmounting

componentWillUnmount()

Conclusion

The workflow with Git

2. Create the `.desktop` file

3. Explanation of the `.desktop` file

4. Copy the `.desktop` file to the correct location