DEV Community: Chrissy Vinco

Journey to Becoming a Software Engineer: Navigating Challenges and Staying Consistent

Chrissy Vinco — Mon, 21 Aug 2023 14:37:25 +0000

Embarking on a career as a software engineer can be a daunting journey, especially when faced with challenges such as imposter syndrome and limited experience. In this article, I will be sharing my own pursuit of landing a job as a software engineer - highlighting the strategies, experiences, and lessons learned along the way.

My journey began as a student in the Philippines. I found myself at a pivotal moment, transitioning from a math major to the wonderful world of computer science. Determined to make my mark in the highly competitive field of software engineering in the United States, I understood that exerting extra effort was imperative. Despite harboring imposter syndrome and comparing myself to peers, I recognized the importance of self-awareness and channeled it into working a bit harder than anyone else.

Projects

While good grades can play a role in securing a first job, other factors like experience and projects are equally important. During my school breaks, I seized the opportunity to engage in diverse projects - encompassing various programming languages and stacks, including Django, MERN, and Java, among others. In these moments, YouTube became my ultimate best friend making it a great source of knowledge - one that can be an invaluable resource for you as well.

I made a conscious effort to develop my own projects tailored to my personal interests. Being an avid user of Twitter and an enthusiast of food and restaurants, I crafted a Twitter clone application focused specifically on showcasing diverse restaurants, employing the powerful Django framework. Additionally, my love for cinema propelled me to create a theater booking application utilizing the MERN stack (a stack that is very useful as of the time I'm writing this article). Further expanding my horizons, I used my love for books and literature by collaborating with my groupmates to develop a book rental/store application using Java and Android Studio. It is best to discover something that sparks your interest and find innovative ways to intertwine it with your passions. With this, you are able to keep a motivational spark that will enable you to create projects that are not only technically compelling but also personally fulfilling.

Leetcode

When it comes to gaining knowledge in logic and algorithms, one resource that played a significant role for me was LeetCode, particularly with the assistance of Neetcode's website (https://neetcode.io/practice). It allows me to keep track of the problems that I have already solved, and ones that I have yet to encounter. Right after graduating, I made it a habit to tackle at least two LeetCode problems each day, gradually increasing the count whenever time permitted. I allocated around 30 to 45 minutes to solve each problem on my own. If I found myself feeling stuck and losing hope, I turned to YouTube for solutions. Again, Youtube is your best friend!

Once I finished a problem, I refrained from immediately checking the provided solution. I also don't mark the problem as done. Instead, I would set it aside for two to three days and then revisit it, aiming to solve the problem once again. Only when I successfully solved the problem on my own, without relying on external help, would I consider it truly accomplished and mark it done on the website.

I also found it beneficial to focus on one data structure at a time as it allowed me to become familiar with the patterns and challenges associated with each specific data structure. Initially, I started solving these problems with the use of Python, however, I highly recommend trying to solve LeetCode problems using Java. This is due to the fact that Java is a strongly typed language allowing you to show that you have a good understanding on the concept of variable types and data structures being used.

Mock Interviews

Another crucial aspect to consider is engaging in mock interviews. I personally struggled with shyness and initially avoided them altogether. However, if you can muster the courage, I highly recommend participating in mock interviews. If you, like me, feel hesitant, turn to our trusty ally, YouTube, and watch as many mock interviews as possible. Pay close attention to how interviewees handle technical questions and articulate their thought processes. Remember that behavioral questions are just as vital as the technical aspects, and they often recur. Familiarize yourself with these types of questions and strive to provide authentic answers that reflect your true personality.

Apply, apply, apply

Lastly, don't underestimate the power of applying for job positions. Leverage LinkedIn to its fullest extent. As a personal challenge, I aimed to apply to at least ten different positions each day. While it is important to carefully read the job descriptions, don't hesitate to take a leap of faith and apply even if you don't perfectly fit the requirements. Surprisingly, I landed my current job when I unknowingly applied for a position that demanded seven years of experience. As it turned out, they were actually seeking a junior software engineer, and here I am! Remember, the path to success often entails facing more rejections than acceptances. Stay consistent in your efforts. I personally submitted nearly 200 applications, underwent 2 interviews, and ultimately received 1 offer.

The central message of this article is to emphasize the significance of consistency. Even now, as I have secured a job, I continue to tackle LeetCode problems, embark on new projects, and stay updated with emerging technologies. Consistency is the bedrock of becoming a skilled software engineer. Always nurture your curiosity, persist in your endeavors, and trust that you will eventually arrive at your destined destination.

Maven for Spring Boot

Chrissy Vinco — Sun, 20 Aug 2023 20:10:31 +0000

I have recently decided to dive into the world of Spring Boot to expand my backend knowledge. A part of this process was also learning about Apache Maven which serves as a build automation and project management tool. This concept could be quite difficult to grasp for beginners (just as I initially found it a bit tough to understand too) which led me to write an article that could make it more approachable for fellow newcomers.

One could imagine Maven as a task master or project manager of Spring Boot. With Spring Boot as the application framework, it relies heavily on Maven to handle the building, testing, and packaging the whole application.

Spring Boot and Maven

As developers, we have the power to create great applications with Spring Boot which includes the process of designing the architecture, writing logic, defining endpoints, configuring components, and implementing features that elevate the application's performance, utility and efficiency. Yet, as software engineers, we must understand that crafting code is just a piece to a puzzle considering that we must also need to build and manage the projects being worked on. This is where Maven comes in. Its role is to understand which steps to take to transform the source code to a fully functioning application. In order for both Spring Boot and Maven to function together, they both communicate through a pom.xml file - the Project Object Model which includes the set of tasks from Spring Boot that Maven needs to do. This file acts as the bridge to make sure that these two important tools collaborate seamlessly to create a fully-functioning application.

Task Delegation with Maven

Just as I first started, determining what type of tasks I could assign to Maven could be quite puzzling. So, allow me to give you a list in order to provide some clarity:

Dependencies

Let me start with dependencies. A dependency is the secret sauce needed to make the project shine. It is something that we need in order for our project to work properly.

Technically, it is a code or a specific library that we could use to perform specific tasks. Sometimes, to implement a feature, we would need to write multiple lines of code from scratch. However, thanks to the pre-made code that are covered by the dependencies, we are able to save time and effort.

Maven then steps in as the project manager by overseeing the project's dependencies through the pom.xml file which outlines the project's initial needs including essential libraries and frameworks such as Spring Boot.

Here are some of the different examples of the common dependencies being used by Maven and where they come into play:

spring-boot-starter-web is our all-in-one package for web applications. It includes Spring MVC which is one of the most important factors as it handles HTTP requests, and embedded web server configurations to name a few.

spring-boot-starter-security is used when security is a concern for our web application (which it definitely should be) and is in charge of the authentication and authorization, strengthening the security of the project.

spring-boot-starter-test is used for unit tests and integration testing in Spring Boot just to name a few.

spring-boot-starter-data-jpa is used to simplify the Java Persistence API (JPA) to interact with databases.

A code block below shows how we can add a specific dependency to our pom.xml file:

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
</dependencies>

Structure

Organization is one of my favorite things about maven as it follows a specific convention with its predefined directory structures and naming conventions for building the project. Here are some examples of the defaults for project management:

src/main/java is the home for your Java source code

src/main/resources is the designated spot for non-Java resources which includes the configuration files and static assets.

src/test/java is where test code is placed to ensure a clear separation between production and testing code.

Lifecycle

Maven also takes care of defining the lifecycle that includes the multiple phases of the program that span from code compiling, testing, packaging, installation and deployment. Each phase is aligned to a specific task which will be executed based on the specific Maven command.

Here are some specific tasks that we can ask Maven to perform:

compile triggers the build lifecycle as it compiles the source code in src/main/java directory. This also check our code for errors.

test Maven executes the tests that are found in the src/test/java directory and uses frameworks such as JUnit or TestNG to execute unit tests, integration tests, and other tests that we've written.

run Running the application is simplified by executing spring-boot:run which instantly starts the Spring Boot application.

debug Spring Boot relies on Maven's plugins by executing spring-boot:run --debug. The --debug flag will instruct Maven to run the program in debug mode which is essentially useful in code tracing and in-depth analysis of the application's execution.

Consistent

Maven's remarkable consistency shines through its single pom.xml file, maintaining uniformity across diverse environments, and effectively reducing the risk of build-related issues. However, errors in the development process are very much inevitable. When these are found, Maven acts as the intermediary by alerting the developer and providing valuable feedback on how these errors could be approached. Moreover, Maven is designed to be flexible and consistent as it can adjust to any specified Java version for any project and will still have the same functionality and dependencies. One can configure the JAVA version being used through the pom.xml file and set the properties <maven.compiler.source> and <maven.compiler.target>.

For example, if we would want to set the JAVA version to JAVA 11, we can use the following configuration:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version> 
            <configuration>
                <source>1.11</source>
                <target>1.11</target>
            </configuration>
        </plugin>
    </plugins>
</build>

Task Master

Once the pom.xml file has been set-up, it all comes down to what Maven is asked to do. Maven assumes the role of the Task Master, following the commands being asked by the developer. To execute these commands, we have to open the terminal or command prompt to the root directory of the Maven project where the pom.xml file is found. We are then able to compile code with mvn compile command, tackle test source code with test-compile, execute tests via test, package your application as a JAR or WAR with package, and deploy the package to a remote Maven repository using deploy.

In conclusion, developers can solely focus on the development of their core application while
Maven handles the nitty-gritty of managing the build process effectively making a developer's working process to be more productive and development-focused.

What are Materialized Views?

Chrissy Vinco — Tue, 25 Jul 2023 20:40:35 +0000

I have come across materialized views for the first time at my job. This was something that was never discussed in school as my courses covering databases just simply focused on creating tables, deleting tables, adding data, and my ever-so-favorite JOINS. However, there are yet more concepts that we have to discover which could eventually help the efficiency on how we use these databases, and learning about them is a great way to start.

First, what are views?

Before I rush to the definition of materialized views, let us discuss the definition of a VIEW. Views are virtual tables that aren't stored in any disk hence, it doesn't occupy any type of memory which will eventually have zero costs. When accessing data from a VIEW, the time complexity depends on the efficiency of the underlying query. If the query involves multiple JOIN statements, it's better to avoid using a view since it will execute the query each time the view is accessed. Instead, views are most suitable for infrequently accessed data. Here is an example of creating a view that displays the order details of a specific order:

CREATE OR REPLACE VIEW order_details AS
SELECT o.order_id, o.order_date, o.amount, c.customer_id, c.customer_name
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id
WHERE o.order_id = order_id;

Views are best used for this query as we might need to access an order detail during packing and delivery, and once it's successfully delivered, we rarely need to access this type of information.

But why do we use views instead of just simply querying them? To start, some queries such as the one above can be complex which allows us to have a single, and easy-to-understand object. Then, it also improves data security because users won't be able to access schemas within the database but can instead access these views which consist of data that we have control of choosing. This can further be enhanced by using GRANTS which is a keyword that can be utilized in granting permissions on who can access the views and tables that you have within the database.

Here's a small tip: if you really want to make use of views but queries that you may have used seem to be complicated, it would be best to use indexed foreign keys most especially when using JOINS. Also, one could consider caching these views avoid repeated computation.

Materialized Views

Now that we have some background knowledge with views, we're off to Materialized Views. Materialized views are normally viewed as a cache as it is a virtual table within memory. And when is it best used? You guessed it - it's for data that are frequently accessed and yet infrequently changing. These are essential for cutting cost as they are only updated when needed and querying is much more efficient when compared to a View or when queried directly. Though, one must keep in mind that these copies are read-only and cannot be changed. Here is an example of creating a materialized view that displays the employees and on which department they belong in:

CREATE MATERIALIZED VIEW employee_details AS
SELECT e.employee_id, e.employee_name, d.department_name
FROM employees e
JOIN departments d ON e.department_id = d.department_id;

Materialized views could be used for this scenario as we don't hire and let go of employees in a daily basis, unless you have an unstable company which means you need to do something quick! But, there will always be situations wherein we will be hiring more employees and we'll let go of some. This then leads to changing the employees table from which we are selecting from. So, how do we update our own materialized views?

Refreshing materialized views

Refreshing a materialized view is essential when you want to update a materialized view once changes have been made to its underlying tables or data. For example, we will be hiring two more employees for two different departments. So if we initially run,

SELECT COUNT(*) FROM employee_details;

This will be returning 70 which is the number of employees within the company when the materialized view employee_details was created.

But upon checking the number of employees we have within the database after adding the two newly hired employees with this query:

SELECT COUNT(*) FROM employees;

It returns 72 which is the actual number of employees within the company at present.

Types of refreshes
To update the employee_details we must need to refresh it, and this can be done in three different ways:

COMPLETE - This creates the materialized view straight from scratch by dropping all the contents within the materialized view, and reruning the query all over again in order to repopulate the materialized view with the right data. This however, can reduce efficiency as it will be slow most especially when working with large databases.
FAST - This only updates the rows in the materialized view that have changed based on the last refresh. This can be found through the materialized view logs provided by Oracle that store information about the changes that were made to the base tables. When a fast refresh has been requested, the materialized view logs is accessed in order to identify the rows that have been inserted, updated or deleted.
FORCE - This performs a FAST refresh on the materialized view if possible but will perform a COMPLETE refresh if needed based on the nature of the data or the query.

For Oracle, we can instantly refresh a materialized view with the use of DBMS_MVIEW.REFRESH() to refresh a materialized view on demand. It accepts two parameters - list which is the name of the materialized view, and method to specify what type of refresh we want to perform. An example below is how we can perform a COMPLETE refresh on the employee_details materialized view:

BEGIN
  DBMS_MVIEW.REFRESH(
    list => 'employee_details',
    method => 'COMPLETE'
  );
  DBMS_OUTPUT.PUT_LINE('Materialized view employee_details has been refreshed.');
EXCEPTION
  WHEN OTHERS THEN
    DBMS_OUTPUT.PUT_LINE('Error occurred during refresh: ' || SQLERRM);
END;

But this is not ideal, as we won't know the exact time that we need to refresh these materialized views. This is where the ON COMMIT keyword comes in and is used if we want the materialized view to be refreshed every time changes are made to its underlying tables or data. The materialized view is then refreshed once the changes have been committed. This is most useful as we want to our materialized views to be up-to-date with the latest changes made within our database. An example below is how to create a materialized view and performs a FAST refresh whenever new employee data has been committed to the employees table:

CREATE MATERIALIZED VIEW employee_details
REFRESH FAST ON COMMIT AS
SELECT e.employee_id, e.employee_name, d.department_name
FROM employees e
JOIN departments d ON e.department_id = d.department_id;

By understanding the differences and capabilities of views and materialized views, database administrators and developers can leverage these features effectively to optimize data retrieval, enhance application performance, and ultimately unlock the full potential of their Oracle databases. Embracing the right combination of views and materialized views empowers users to harness the power of data, making informed decisions and driving business success.