Your Personal Brand Phase at Encora Apprenticeship — Week 1
This post is part of a weekly assignment at Encora Apprentice and in this series, I’ll share my journey as a Software Engineer Apprentice. I hope these stories help and motivate others on their tech journey.
This week at Encora
With the beginning of a new phase comes new challenges and new learnings. Now it is time to work on interviews and how to perform better on them, as well as practicing coding challenges and some CI/CD with Jenkins. Come take a look at this week’s post!
The art of interviews
This week we started to prepare for interview processes. Tech interviews can be more than just theoretical questions, but they can also include some coding challenge/problem for testing the interviewee's ability to solve problems.
When presenting an interview, there are some tips and tricks that can help us to perform better, like:
- Think out loud, let your interviewer know how your train of thought is, and if you’re drifting away from the answer, they can help you get back on track.
- Once you come up with a solution to a certain problem, test it! Create a small scenario and make sure it can also work on edge cases.
- Ask questions! Don’t assume anything, if you don’t have the problems clear, ask and make sure you’re working on solid ground.
- Practice! Practice is key when solving coding problems. It helps us to build a set of tools and common solutions that we can use later.
- Don’t rely on memory. We can’t know exactly what questions will the interview have, but we can prepare for the most common ones, like practicing talking about our previous projects, experiences, and weaknesses.
Composite, adapter, and bridge patterns
While diving into some design patterns, I started to read about three in particular: composite, adapter, and bridge.
The composite pattern is used when we are dealing with a system that takes the form of a tree. Instead of dealing with the complexity of the whole structure, we can delegate this work to each node to take care of its descendants in a recursive fashion.
The adapter pattern helps us when we need to use two classes together. If these classes are incompatible, we can use an adapter class to deal with this. An example of this is the use of two classes, one processes data, and outputs to XML format, and another helps with visualizations but takes inputs in JSON format. The adapter pattern tells us to create an adapter class that takes XML and outputs JSON in order to make these classes compatible.
And finally, the bridge pattern solves the problem of class explosions using composition instead of inheritance. This pattern separates the abstraction from the implementation, so a client can work with the abstraction without having to worry about the concrete implementation. For example, we can work with a remote without needing to know every detail of how interaction with the device is controlling works.
AWS ECR
This week I continued working on developing a CI/CD pipeline using Jenkins for a simple Node.JS application. While doing some research about how to deploy to Elastic Container Service (ECS), I started first to study Elastic Container Registry (ECR). This registry will be the place to store the Docker image that contains the application and from there we can deploy it to ECS.
We can easily create an ECR repository using the following Terraform snippet:
resource "aws_ecr_repository" "image-repository" {
name = "ecr_name"
image_tag_mutability = "MUTABLE" image_scanning_configuration {
scan_on_push = true
}
}
Final thoughts
With the new phase starting I’m feeling positive and excited about the new challenges and learnings! The cool thing about this week is that I got to work not only on tech skills (while solving coding challenges) but also on soft skills (such as practicing for interviews and preparing one in English).
Next week I’ll be practicing how to conduct an interview, so stay tuned to know more about it! See you next week!
