DEV Community: Gabriel Palhares

Mountain Bikes & Code: Key Decisions to Senior

Gabriel Palhares — Fri, 19 Jan 2024 11:40:46 +0000

I believe this will be the most fun article I’ve ever written, mainly because I’m putting together the two things that I like the most in my life right now: mountain biking and programming. Well, you’re probably wondering where I hit my head to come up with the idea to write this article, but I promise it will make sense.

Something that I like to do is put together things that I like and things that I want to be good at, making parallels between them. In the same way that we use functions inside other functions and create pointers between them, if you learn something and it’s useful, that skill might help you in other areas of your life too. In a simple manner, it’s about how we evolve and try to get better in every aspect of life.

This time, the chosen ones are mountain bikes and code. Before I start comparing both and saying everything I have in mind, I want to grab your attention for just a few moments and explain a bit more about what defines a mountain bike. After all, what’s the difference between a common bike and a mountain bike? Let me explain this.

MTB world

The standard definition of an MTB bike is: ‘A mountain bike is a bicycle designed for off-road cycling.’ Basically, it’s a bike meant for trails. Mountain bikes share some similarities with other bicycles, but they incorporate features designed to enhance durability and performance on rough terrain, which makes them heavier, more complex, and less efficient on smooth surfaces.

The most common bike options when someone starts in the world of mountain biking are these two: full suspension bikes and hardtail bikes. The main difference is that hardtails only have suspension on the front, while full suspension bikes have suspension on both the front and the frame. The interesting thing is that each type has its own riding style.

Riding patterns: Hardtail and Full-Suspension

When it comes to riding patterns, there’s something important to note: mountain biking is difficult and dangerous. It’s funny, but the truth is that to improve, you need to fall many times on different trails. This way, you'll gain experience and skills. After all, it’s called mountain biking for a reason — there's a degree of difficulty inherent to the sport.

Riding a hardtail means additional challenges because navigating through trails is a bit more demanding, as you only have your arms and the front suspension of the bike. However, with a full-suspension bike, you can avoid some of those struggles, feeling more comfortable and confident when crossing difficult trails and rough terrain.

This means that if you’re on a difficult trail with a hardtail, you always have to look for better and cleaner trail lines, as it fails to provide the same level of confidence and smooth ride as a full suspension bike. It’s common to see people give up, get off the bike, and push it because they think the obstacle is too big.

Evolving as a rider with a hardtail bike requires a lot more effort than it does for someone with a full-suspension bike. So, what then becomes the bottleneck of riding a hardtail bike? If you're not giving your best, you tend to search for comfort in the trails, avoiding rough places and obstacles. And here is where I bring coding into the context.

Coding world

A few days ago, there was a spaces discussion on X, hosted by Jess, to promote Learn In Public. As I listened to the talk, the main speaker Sibelius said something interesting when asked:

“How to evolve from mid-level to senior?”

The answer was perfect for me. He said:

“To learn faster, it's essential to focus on active behaviors. If you want to progress from mid-level to senior, it's beneficial to look at the seniors you admire, or those on your team, and observe everything they do.

Why can't you do their job? What do they do that you don't? Are they better writers? More organized? More disciplined? Do they manage teams and the product? Do they interact with clients? Is their communication better? You need to understand everything they are doing and focus on addressing the reasons why you can't achieve that, thus allowing yourself to evolve.

First, seek more responsibilities, try to solve more complex problems, tackle tougher bugs, and become one of the team's go-to experts. Act like a senior first, and then you'll be considered a senior. Only then will you earn the benefits.”

This got me thinking about how this is undoubtedly a scenario of someone struggling and making their way through adversity — putting in effort, consistency, and avoiding comfort. Just like a rider who doesn’t choose comfortable lines and trails to explore, even on a hardtail bike.

In this way, I believe we can conclude that we have a specific bottleneck in common — the one that blocks a developer from becoming a senior is the same as what prevents a hardtail rider from evolving: comfort.

In the context of software engineering, I think this happens because juniors and some mid-level developers tend to prefer tasks they already know how to do. This often occurs without them even noticing. As a result, they struggle when asked to do something different. I have seen people refusing to complete a coding challenge for a job offer simply because it wasn’t in the programming language they preferred.

Trying things you don’t know is the fastest way to evolve. To progress, you need to take risks. If you focus solely on the skills you already possess and the tasks you have already mastered, your progress will be slower, and you might end up stuck in the same place forever.

Conclusion

To wrap things up, I believe that the main message is to avoid comfort zones. It takes a bit of courage and discipline, and you need to have the desire to push beyond them. Your mentor can’t make you a Senior; they can’t code for you or take risks for you. In the end, the responsibility is yours — only you can do the work. To evolve, the rule is the same.

In this way, you will be able to perform at your best, even in scenarios where you are not in full control, by trying new things, whether it’s diving into a different programming language or new project. You need to face it — just like a rider faces a scary trail, you must confront the challenges of your journey.

Photo cover by Anastasia Shuraeva, taken with an X-T4.

Your Tech Career Should be Like a Motorsport

Gabriel Palhares — Wed, 17 Jan 2024 11:55:28 +0000

a parallel between your learning process and Formula One

Last weekend, while watching videos of race highlights from the 2021 Abu Dhabi Grand Prix (Max Verstappen fan here), I felt myself motivated by my ongoing habit of writing articles. This made me reflect on the similarities between motorsport and my learning journey in computer science. I asked myself, ‘Why not write about this?’ So, I began drawing this parallel.

While trying to do that, I realized that embarking on a computer science career can be easily linked to many motorsport characteristics. Both paths are filled with twists, turns, and the occasional need for improvements. In this article, we’ll explore how certain principles of motorsport can be applied to optimize your learning process and career development.

Pit Stops and Maintenance

Just as racers strategically make pit stops to keep their cars in peak condition, learners should recognize the importance of breaks in the learning process. Many people say that a computer science career can be overwhelming and lead to burnout. These pauses allow you to absorb content better, rest, reflect on your progress, and adjust your study strategies. Think of these breaks as opportunities to fine-tune your learning engine, aiming for your best performance.

Adaptability and Course Correction

In both motorsport and tech careers, unexpected challenges arise. The ability to adapt and course-correct is key. Just as a racer adjusts to changes on the track and problems with their cars, software developers must be ready to pivot their strategies when facing difficulties.

In my previous article, I discussed one of these challenges, explaining a bit about Rabbit Holes. However, there’s a lot more that people often forget when coding: code errors you’ve never solved before, deployment crashes, messy codebases, coworker misconduct, strange abstractions… this list can be endless.

Keep this in mind: Your career and learning process are not a straight, ascending line; they involve many ups and downs. Embrace challenges as opportunities to refine your skills, taking the best from your ‘ups’ and enjoying them while staying grounded and resting during your ‘downs’. Everyone makes mistakes and goes through difficult phases, so don’t blame yourself too much when you’re feeling incapable. This mindset will improve your overall performance on your career journey.

Teamwork and Collaboration

Motorsport teams exemplify the strength of collaboration, and the same holds true in the world of computer science. Have you ever heard about Learn In Public? The logic behind Learn In Public relies into the open-source culture, and its motto is to learn faster than privately learning. Although Swyx - Shawn Wang - is not the founder of the idea, he’s one of the most popular advocates of it. He describes Learn In Public as follows:

“You share what you learn, as you learn it. You open-source your knowledge. You build a public record of your interests and progress, and along the way, you attract a community of mentors, peers, and supporters. They will help you learn faster than you ever could on your own. Your network could be vast, consisting of experts in every field, unconstrained by your org chart.” - The Coding Career Handbook.

Seek guidance, learn from peers, and foster a sense of community within your learning process. Collaborative efforts can lead to accelerated progress and the discovery of great solutions to complex problems. It’s your journey, but with the knowledge shared in community, you can drive further.

Setting Goals and Milestones

Just as racers aim for specific lap times and podium finishes, set realistic goals and milestones in your journey. Nobody wins a grand prix without training, studying the track, and planning how to achieve the fastest lap first. This is strategy. Achieving smaller milestones contributes to overall progress and keeps you motivated. Instead of aiming for one big, specific goal, break it down into smaller objectives. Map out your learning route, and celebrate each milestone as a step closer to mastering your stack or achieving your dream job.

Endurance and Long-Term Commitment

View your learning journey and tech career as a marathon rather than a sprint. The winner of the race isn’t determined by the car that reaches maximum speed, but rather by the one that completes the lap most efficiently and consistently. It’s about being fast when necessary, executing proper gear shifts, slowing down when required, and changing tires at the right moment. All of these aspects are associated with endurance and long-term commitment. Understand that setbacks are part of the journey, and staying committed to your goals is essential. Day by day, you’ll get there.

Finish Line

These are the principles that explain why your tech career should be like motorsport: strategic pit stops, adaptability, teamwork, mastering skills, setting ambitious goals, and building endurance. As you rev your engines by incorporating these ideas, I believe you’ll navigate the twists and turns of your tech career like a pro. Consistent effort, coupled with a long-term perspective, will ensure that you cross the finish line.

I have no idols. I admire work, dedication and competence. - Senna

Cover photo by Maria Geller, taken with an ILCE-7M3.

Rabbit Holes and When to Avoid Them

Gabriel Palhares — Thu, 11 Jan 2024 12:35:40 +0000

If you're a programmer or aspiring to become one, we can likely agree that one of the earliest realizations in our journey - and also a point of near-universal consensus in the tech community - is that we are all destined to be constant learners. Continuous learning, reviewing what we know, exploring concepts in different contexts, and regular practice become almost daily rituals for those committed to a career in tech.

With this unique characteristic related to the field, many problems emerge in our learning process. One of them is the occurrence of rabbit holes — a situation where a developer spends a significant amount of time delving into a specific topic related to the main subject they're currently addressing. The problem lies in the fact that this time is often "robbed" from other important tasks and comes at the cost of neglecting what really matters, or worse, getting lost in unrelated subjects.

The term originates from Alice in Wonderland, where Alice falls into a rabbit hole and finds herself lost in a bizarre and confusing realm. Similarly, when a developer descends into a rabbit hole, they may get entangled in an complex and time-consuming inquiry.

In my opinion, there are two different scenarios that make it easy to understand and face rabbit holes:

A - when you’re a total beginner or junior dev;
B - when you’re a mid-level or senior dev.

This way, the approaches will be completely different from each other. Let’s begin with scenario A.

When you're a junior dev

In this case, you need to understand that rabbit holes are really dangerous for you, and you need to avoid them whenever you can. The reason they pose a danger to you is that, as a beginner, it’s much easier to get lost between a lot of topics and concepts. This can lead you to spending time trying to learn all about a subject that you aren’t ready for or that won’t benefit you much.

It can be tempting to go deep into a topic and feel like you need to become an expert immediately. Try to avoid these feelings; otherwise, you’ll just end up overwhelmed. Follow learning guides or roadmap paths like this one provided by roadmap.sh.

It’s important to understand that many people put effort into structuring these guides, including everything that matters, in an order and a way you can evolve. This ensures that the things you need to know about web development will be covered exactly when you need to know them. Don’t get out of the trails; stick to these roadmaps as much as possible. Monitor yourself and avoid spending time going down rabbit holes because getting sidetracked can ruin your learning process and flow state.

When you're a mid to senior dev

If you’re a more experienced software engineer, rabbit holes don’t represent danger as in situation A. This statement relies on the fact that your experience will act like a lighthouse in the dark, guiding you. This way, you can have a power that doesn't exist in scenario A because your experience makes the difference and can turn a rabbit hole into a truly worthy journey. With more knowledge, it’s easy to discern whether diving into a rabbit hole is productive and will be beneficial or not. However, if you get distracted, it’s easy to gain nothing valuable from a rabbit hole.

Conclusion

So, in the end, can we conclude that rabbit holes are bad? Well, no!

I believe that rabbit holes aren’t always a negative thing if you can recognize where, when, and why you’re diving into them. Similar to a game story, try not to perceive them as traps, but as side-quests around the main story. Start thinking that every time you delve into a rabbit hole, you’re embarking on a side-quest. Some side-quests can help you, while others exists just to consume time. The more experienced you become, the easier it will be to identify which rabbit holes are worth exploring and which ones are not.

Cover photo by Ray Bilcliff, taken with an SLT-A77V.

Why I Personally Decided to Bet on JavaScript

Gabriel Palhares — Fri, 05 Jan 2024 14:20:04 +0000

and some junior developer mistakes

In my previous post, I shared my opinion and some details about why Woovi Bets on JavaScript, but I focused more on an enterprise context. In this article, I will discuss why I personally decided to bet on JavaScript.

Few people know me, but I’m not special or different from anyone that’s trying to land a job in web development nowadays. What I really want to say is that I made ALL the most common mistakes that every beginner makes. All of them. In my opinion, the biggest mistake was floating around my learning process with different programming languages.

I remember the first time I completed a Grasshopper challenge, when I knew absolutely nothing about programming (not that I know much now). After that, I started searching for some online courses and ended up studying HTML, CSS, and JavaScript - the most common path that probably everyone has taken, does take, and will take.

However, I began to notice that many people in social networking and tech communities were talking about how JavaScript was saturated, how the junior roles were disappearing, and “if you kick a tree, hundreds of JavaScript developers would fall”. Later, I discovered that maybe all of that was true, but in a positive way (yes).

So, I decided to leave JavaScript and started studying Java, Spring, focusing on backend development. It seemed like a solid path, more complex for a beginner, but I was convinced that doing so would help me land my first job sooner, as I was taking a less common route.

The Reality

I was just increasing my learning curve and slowing down my study rhythm, adding an even greater load of knowledge to learn, and also discarding everything I had studied about JavaScript before, as I stopped practicing and logically forgot. Needless to say, the job never came, and I ended up frustrated and sad.

Another mistake was that when I started studying Java, I limited myself to only backend concepts. As a junior developer, you must study about everything first. It doesn’t matter if you prefer front-end or back-end; you have to know a little bit of everything. After that, you can decide which path to focus on or continue with both. This was the core consequence of experiencing these learning stages: I realized that every junior must be full-stack.

Final result: JavaScript

I believe that JavaScript is the best programming language for beginners. With JavaScript, you can tackle almost every computer science concept and engage in diverse practices. Whether you aspire to become a full-stack developer, delve into front-end, back-end, testing, or explore other areas, JavaScript provides a versatile foundation.

Nonetheless, it offers nearly infinite possibilities. You can code and create anything, from a mobile app with React Native to a desktop application with Electron.js. Furthermore, JavaScript provides excellent frameworks and libraries that can be applied in various approaches, such as React, Three, Vue, Meteor, and Astro.

To enhance its appeal, JavaScript has a great and active developer community. As a multi-paradigm language, and with the introduction of TypeScript, you can delve into type systems and functional programming. This versatility and wealth of resources are the primary reasons why I returned to and decided to invest mainly in JavaScript.

But hey, you said earlier that you gave up on JavaScript because everyone said it’s saturated and many other negative things. What happened?

Nothing happened. And yes, it could be true that there are a lot of JavaScript programmers (after all, JavaScript is on the entire internet), but I truly believe that if you put effort into something, you’ll exceed yourself, others, and prevail. Someday, you’ll see the results of your hard work - that’s a fact. Also, you should learn to avoid negative stuff that plenty of people on the internet often say.

Decide for yourself what you want and pursue your goals. JavaScript is a programming language that offers numerous opportunities in various ways and scenarios. It doesn't matter at which level you currently are; right now, I believe it's the best way to secure your first job in web development or to advance your career in this field.

If you are a junior developer like me, my final advice is to study a lot of other things rather than just how to code with programming languages. Computer science concepts like algorithms and data structures matter a lot. At the end of the day, the truth is that being a software engineer is much more than programming languages, and the sooner you realize this, the sooner you will evolve.

Maybe this can help you: A good overview intro JavaScript and Functional Code

Cover photo by Carissa Strickland, taken with an Canon EOS 5D Mark II.

Woovi Bets on JavaScript, Should You?

Gabriel Palhares — Wed, 03 Jan 2024 15:13:36 +0000

This article was written right after the lecture Why Woovi Bet on JavaScript?, and I want to provide you with some additional perspective on that.

As most of you may know, Woovi is a growing Startup that enables shoppers to pay as they like. Many people associate Woovi as "Sibelius’s company", and there's no reason to judge them because Sibelius is one of the most relevant and well-known individuals in Brazil’s tech scenario, especially on social networks. This also means that many people are looking at his work and what he's doing. Personally, for me, this is a great way to influence people.

So, let’s go straight to the point: Woovi and Sibelius bet on JavaScript. Should you? The obvious answer is: only you can know that.

Dawn, so why did you decide to write this article? Sibelius has already covered all the tech details about JavaScript and their decision. Well, as I mentioned in the beginning, there are some additional points to make.

It’s not an easy and personal choice when a company's business is at stake

Every senior developer knows that this kind of decision has a lot of details behind it, and it’s not always an easy choice. It’s also not always something that is solely in their hands. In most cases, it's the company's decision that prevails in the end. However, as a CTO, Tech Lead, or Senior Developer, you can argue and help them decide which technology will be better for the company’s goals, based on your experience and the team's skills.

In 95% of cases, it's initially better to focus on the product and company rather than the tech stack

One significant mistake often made by junior developers (and sometimes by many seniors) is that, instead of focusing on understanding the company and its product, some developers end up getting stuck in discussions about why a specific programming language is used. This distraction is less relevant when you initially join a company compared to the importance of grasping the nuances of the company and its products. Additionally, it's crucial to remember that changing your personal career stack is much easier than changing a company's stack.

Changing the stack in a mid-to-large-sized product or company is not easy

For a company that has many years in the market or perhaps a particular growth product, it’s challenging to change the stack without breaking it. We see many companies in the market changing their stack and working on legacy code. This is a typical bottleneck caused because, in the early stages, they weren’t able to decide which stack would be best for the company or because it wasn’t deemed important at that time. Sometimes, the only goal was to make the product work and sell it, although they knew many problems would arise in the future. That's fair, but at some point, it decreases the evolution of the company because everyone will be fixing technical debt and working on legacy code.

Thoughts

This is why JavaScript prevails a lot, as @jessilyneh always says: “In the end, everything is JavaScript.” And it’s true; with JavaScript, we can do anything. You don’t need different programming languages for each product or code aspect when you can have one that performs well in almost every scenario. If you encounter a specific problem, you can use other programming languages that perform best. However, choosing JavaScript as your main is choosing intelligence, simplicity, and scalability.

Conclusion

It is important to have an understanding of all these aspects when it comes to a company's tech stack. Regardless of your level as a developer and the environment in which you are working, it is crucial to focus on improving the quality of the ecosystem as a whole, no matter which technology your company relies on. It is also admirable to see companies like Woovi that, since the early stages, already have this vision and know how to balance the importance of growing quickly and staying ahead of competitors while maintaining a comprehensive technological plan. This ensures that the environment is resilient to future failures and easy to maintain, so that the ultimate goal of serving the customer is always being fulfilled.

Cover photo by Shashank Brahmavar, taken with an X-S10.