Articles

Arthur Strang - Software Developer

Hi, I'm Arthur! :)

Recently, I found myself needing to clean up some commits in a branch I was working on. Interactive rebase came to my rescue - it's a powerful command that helps organize commits before that final push. This experience inspired me to research and share the best Git practices for smooth branch management.

## Essential Git Commands for Daily Use
Before diving into advanced techniques, let's review the fundamental commands that form the backbone of branch management:

```bash
# View all branches including remote tracking ones
git branch -a

# Delete local branch (-d for safe delete, -D to force)
git branch -d feature-branch

# Delete remote branch
git push origin --delete feature-branch

# Create and switch to new branch in one command
git checkout -b new-feature
# Or using the modern Git syntax
git switch -c new-feature

# Rename current branch
git branch -m new-branch-name

# List merged/unmerged branches
git branch --merged
git branch --no-merged

# Update branch with latest main without switching
git fetch origin main:main

# Clean up local references to deleted remote branches
git remote prune origin

# See full branch history with graph
git log --graph --oneline --decorate --all
```

## Using Interactive Rebase

Interactive rebase is a powerful tool for maintaining a clean Git history. While the command line interface works well, using VS Code (or your preferred IDE) can make the process more intuitive and easier to navigate.

First, set up VS Code as your default Git editor:
```bash
git config --global core.editor "code --wait"
```

To start an interactive rebase:

```bash
# Rebase against a specific branch
git rebase -i <branch-name>

# Or rebase the last N commits
git rebase -i HEAD~N
```

How it looks like with VSCode:
![avatar-rebase.png](https://admin.artcodes.dev/uploads/avatar_rebase_330f070b47.png)

Available Rebase Options
- **pick**: Keep the commit as is
- **reword**: Change the commit message
- **edit**: Stop for amending - useful when you need to modify the commit's contents
- **squash**: Combine with previous commit and merge commit messages
- **fixup**: Like squash, but discard this commit's message - great for "fix typo" commits
- **drop**: Remove the commit completely
- **exec**: Run a command after each line - useful for running tests

## Handling Rebase Conflicts
Sometimes rebases don't go smoothly. Here are the commands you'll need:
```bash
# Continue after resolving conflicts
git rebase --continue

# Abort the rebase and return to original state
git rebase --abort

# Skip the current commit
git rebase --skip
```

## Efficient Git Aliases

Here are some cool git aliases:
```bash
# .gitconfig file
[alias]
    # Logging
    ll = log --oneline
    lg = log --graph --oneline --decorate --all
    
    # Quick commits
    c = commit -m
    a = add -A
    ac = !git add -A && git commit -m
    
    # Work in progress
    wip = !git add -A && git commit -m 'wip' 
    unwip = reset HEAD~1
    
    # Branch management
    list-merged = "!git branch --merged | grep -v '*'"
    cleanup = "!git fetch --prune && git branch --merged | grep -v '*' | xargs git branch -d"
    sync = !git fetch origin && git rebase origin/main
    
    # Status shortcuts
    s = status -s
    b = branch --all
```

### Important Note About Branch Cleanup
The `cleanup` alias is powerful but should be used with caution. It will:

1. Remove all local branches that have been merged into your current branch
2. Delete references to remote branches that no longer exist

_Cannot be undone once executed_

Before running `git cleanup`:

- Check which branches will be deleted using `git list-merged`
- Ensure you're on the correct branch (usually main/master)
- Verify that all important work has been pushed to remote

## Best practices for branch management

1. **Use Descriptive Branch Names**
   - Follow a consistent naming convention aligned with conventional commits:
     - `feat/` - New features
     - `fix/` - Bug fixes
     - `docs/` - Documentation changes
     - `chore/` - Maintenance tasks
     - `refactor/` - Code refactoring
     - `test/` - Adding or modifying tests
     - `style/` - Code style changes
     - `perf/` - Performance improvements
   - Include ticket numbers if applicable: `feat/TICKET-123-user-auth`
   - Use kebab-case for readability: `feat/add-user-authentication`
   - Maybe add some [emojis](https://gitmoji.dev/) 😜

2. **Keep Branches Updated**
   - Regularly rebase feature branches on main to avoid complex merges
   - Use `git fetch` frequently to stay aware of remote changes

3. **Maintain Clean Branches**
   - Keep branches focused on single features or fixes
   - Avoid `wip` commits, and use of interactive rebase to maintain clean commit history
   - Delete branches promptly after merging

4. **Establish Clear Branch Lifecycle**
   - Short-lived feature branches (1-2 weeks maximum)
   - Regular cleanup of stale branches
   - Document branch purpose and status

I believe that these are the commands that you might use for 80% of the time. Maybe you'll need `git reflog` at some point, but that's for another article.

To be honest, when we work with good workflow you won't be needing to do a lot of branch management. If you can break User Stories into small meaningful tasks, your branches probably will follow the pattern and flow correctly.

I hope this git tricks can help you! 
Thank you for reading this far.

Bye,

branch-management.jpg

A simple guide for good Git Branch Management

Below is a selection of my main sources of content, courses, and tutorials. It's still a work in progress. I intend to categorize them better and provide a brief description for each source, explaining what I find good about each one.

### Youtube

- [Academind](https://www.youtube.com/c/Academind)
- [Andy Sterkowitz](https://www.youtube.com/c/AndySterkowitz)
- [Bóson Treinamentos](https://www.youtube.com/c/bosontreinamentos)
- [CS50](https://www.youtube.com/c/cs50)
- [Curso em Vídeo](https://www.youtube.com/c/CursoemV%C3%ADdeo)
- [Dave Gray](https://www.youtube.com/c/DaveGrayTeachesCode)
- [Fabio Akita](https://www.youtube.com/c/FabioAkita1990)
- [Fireship](https://www.youtube.com/c/Fireship)
- [Jack Herrington](https://www.youtube.com/c/JackHerrington)
- [James Q Quick](https://www.youtube.com/c/JamesQQuick)
- [Kevin Powell](https://www.youtube.com/kepowob)
- [Level Up Tuts](https://www.youtube.com/c/LevelUpTuts)
- [Mango](https://www.youtube.com/c/MangoDeveloper)
- [OneBitCode](https://www.youtube.com/c/OneBitCode)
- [PedroTech](https://www.youtube.com/c/PedroTechnologies)
- [Rodrigo Branas](https://www.youtube.com/c/RodrigoBranas)
- [The Net Ninja](https://www.youtube.com/c/TheNetNinja)
- [Traversy Media](https://www.youtube.com/c/TraversyMedia)
- [Web Dev Simplified](https://www.youtube.com/c/WebDevSimplified)
- [Willian Justen Cursos](https://www.youtube.com/c/WillianJustenCursos)

### Udemy

- [JavaScript: Understanding the Weird Parts](https://www.udemy.com/course/understand-javascript/)
- [Modern React with Redux](https://www.udemy.com/course/react-redux/)
- [React - The Complete Guide (incl Hooks, React Router, Redux)](https://www.udemy.com/course/react-the-complete-guide-incl-redux/)
- [Typescript: The Complete Developer's Guide](https://www.udemy.com/course/typescript-the-complete-developers-guide/)
- [Understanding HTML and CSS](https://www.udemy.com/course/understanding-html-and-css/)
- [Web Components & Stencil.js - Build Custom HTML Elements](https://www.udemy.com/course/web-components-stenciljs-build-custom-html-elements/)

### Blogs

- [Bossabox](https://blog.bossabox.com/)
- [CSS-Tricks](https://css-tricks.com/)
- [Josh Comeau](https://www.joshwcomeau.com)

### Newsletters

- [Bytes](https://bytes.dev/?x=1652285056&ck_subscriber_id=1652285056)
- [Deschamps](https://filipedeschamps.com.br/newsletter)
- [Frontend Mentor](https://www.frontendmentor.io/)
- [Josh Comeau](https://www.joshwcomeau.com/subscribe/)
- [Kevin Powell](https://www.kevinpowell.co/newsletter/)
- [LevelUp Tuts](https://leveluptutorials.com/newsletter)

### Platforms

- [Codeacademy](https://codeacademy.com)
- [CodeWars](https://www.codewars.com/)
- [Dev Projects](https://www.codementor.io/projects)
- [Free Code Camp](https://www.freecodecamp.org/)
- [Frontend Mentor](https://www.frontendmentor.io/)
- [HackerRank](https://www.hackerrank.com/)
- [Sololearn](https://www.sololearn.com/home)
- [Treehouse](https://teamtreehouse.com/)

dev-library-ds.jpg

Dev Library 

### My Journey with Programming

It all began in the second half of 2013 when I was 24 years old. At the time, I was working in marketing and had started my digital marketing agency just a few months earlier. I was working for small businesses in Rio de Janeiro, providing services like social media management, sponsored link campaign management, and occasionally some design and creative services with the help of partners and colleagues.

During this time, I noticed that many of my clients lacked a strong digital marketing strategy. Most of them wanted to invest in advertising and social media, but they didn't have a website to consolidate their products/services and converge traffic from these channels. It was then, identifying an opportunity to offer website development services, that I began to consider learning programming.

I had always been the go-to person in my family for solving technology-related problems. I had often been "hired" by my parents and sisters to explain why a program wouldn't open or why the computer was running slowly. But until then, despite my strong interest in IT, I had the perception that the field was very scientific and required extensive knowledge of mathematics. Since I hadn't excelled in these areas in my school life, it never occurred to me to work in IT.

However, a little research was enough to dispel that misconception. Yes, there was a technical aspect to programming, but most developers weren't doing complex calculations all the time. So, my preconceptions faded away and turned into great curiosity and interest. I started studying  JavaScript, HTML, and CSS on YouTube and also studied on [Codecademy](https://codecademy.com) platform.

Learning on my own at that time was quite challenging. Occasionally, I had questions, and I didn't know how to find answers, nor did I have anybody close who worked in the field who could help me. That's when I decided to enroll in an on-site course at a specialized school.

I took a web design course where I learned the basics of HTML, CSS, JavaScript, and PHP. After that, I was able to make my first commercial proposal applying programming work. At that time, Facebook had the feature of allowing business pages to have tabs (I don't know if they still do), which were essentially HTML documents within fan pages. My first job was to create a digital menu in one of these tabs for one of my clients. The work was simple and not portfolio-worthy, but I vividly remember the satisfying feeling of seeing the finished code and the menu published. That feeling sparked a desire to continue doing more and more website and programming work.

The agency grew, and I had new business partners and more clients, which was great for my marketing career and my company. Over time, we closed some website projects. During that time, we used WordPress extensively, which was a quick and effective way to solve most of our problems and those of our clients.

WordPress is a very good content management platform for creating simple institutional websites. It has a large marketplace, and its code is written in PHP, JavaScript, HTML, and CSS. Since there are many templates available, my role was mostly making some CSS and JavaScript adjustments, and I rarely needed to do any PHP logic. Throughout this time, my desire to work with code remained strong.

I continued studying online while juggling my work at the agency. Some excellent resources I found were [Brad Traversy's YouTube channel](https://www.youtube.com/c/TraversyMedia), [Curso em Vídeo](https://www.youtube.com/c/CursoemV%C3%ADdeo), the [Tree House](https://teamtreehouse.com/) platform, and some instructors on Udemy, where I collected dozens of courses. I consumed these sources as a hobby and only when there was a need for a project at the agency.

---

### The Turning Point

The turning point came in mid-2020 when I decided to make a career transition. At the time, I was 30 years old and no longer working at my agency but at a company in Florianópolis: RD Station a MarTech startup. Working there was an extremely positive experience that changed my career. I worked as a Customer Success Manager (CSM), providing consultative support to agencies that used their software.

Working in a SAAS (Software as a Service) business made me excited about programming again. Even though it was in a different area, I was able to absorb some of the dynamics of teams, squads, and agile methodologies. This atmosphere made me want to switch to the product and engineering area. I even considered working as a Product Manager for a while - it made more sense given my experience and background. But in the end, what I really wanted was to become a developer.

My motivation was primarily the desire and pleasure of building things, scripts, pages, and products. The same feeling I had when I completed my first project. Additionally, there was a shortage of developers in the market. The high demand was evident, and I saw more and more schools and boot camps offering courses in the field. I also thought a lot about how I was "getting older" and that this might mean fewer opportunities in the market (more on that later), making a career switch more challenging. To add to it, although I liked RD a lot, I no longer found as much pleasure in working with digital marketing and the agency market. All of this created a sense of urgency that led me to make the decision and, most importantly, create a plan to change my career.

### The Plan

I needed a strategy. I studied a bit about people who pivoted their careers, read posts like the one I'm writing now, watched some videos, and outlined some actions to take:

1 - Communicate my decision and ask for help, including at my job

One of the most important things I did was verbalize my career change decision and ask for help from people who were in the same process as me or were already developers. This helped me in two ways:

- It created a sense of commitment and a clear goal. By making my goal public, my team, friends, and family supported me on this journey. This step was fundamental to my success (more on that later).
- At 31 years old, I didn't have as much time to make mistakes anymore, so asking for help was a way to find shortcuts more quickly.

I know it sounds obvious, but sometimes we tend to try to solve everything on our own, whether out of shyness or some form of pride and ego. Well... Spoiler alert: as a developer, you will need to ask for help many times, especially early in your career (just like in any other career, I would say).

During this stage, many friends and people gave me study tips, advice on what to do to stand out, and what mattered to become a developer. I am very grateful to all of them 🙏🏻

With this information, I was able to outline the next steps more clearly.

2 - Go back to studying. But what to study?

What really makes a developer good? One of the things I applied here was the Pareto principle, the famous 80/20 rule. I wanted to find the 20% of topics that I needed to study that would give me an 80% chance of doing well in a job interview, finding the levers - as Renato Martins, my coordinator at RD at the time, taught me (thanks, Rê ❤️).

Most of the content I found and advice I received pointed to (no surprises here):

- Programming logic
- Data structures
- Algorithms
- HTML, CSS, and JavaScript

In the past, I had already studied a bit of the last topic, so I focused on the first three. That's when I rediscovered an excellent learning resource, Harvard's [CS50x course](https://cs50.harvard.edu/x/2022/). I had heard about it in 2015 and watched a couple of lectures, but didn't continue with the study at the time. Now it would be essential.

CS50 is an introductory course in Harvard's Computer Science curriculum. The course is free and of high quality! It is very didactic, with lectures lasting about 1 hour and 45 minutes and practical exercises that are done online in an integrated development environment (IDE). The code you write in these exercises is validated by a series of automated tests, but what's cool is that the answers are not provided anywhere (although you can find them if you really want on their Discord channels and forums... but that's not the idea, right?). The professor discusses the exercises but does not give the answers (at least at the time I took it). The course covers basic topics in Logic, Data Structures, and Algorithms, using the C and Python languages.

I focused on this course for about three months, which helped me a lot. Learning how to fend for yourself and, most importantly, knowing how to research your difficulties is a fundamental part of being a developer.

In addition to CS50, I also studied a bit of CSS and Ruby. Here's why:

Ruby is the main language used in RD's systems. At the time, I wanted to try to transition from the CS field to Engineering, so I also watched some videos from [OneBitCode](https://www.youtube.com/c/OneBitCode) to learn Ruby and Ruby On Rails (a framework). I recommend getting to know the language. I found it really cool at the time, but I ended up focusing on JavaScript because it had a much larger job market.

CSS was a significant area of improvement for me. Despite having studied and worked on some projects where I wrote a lot of CSS, I didn't feel confident. That's when I discovered [Kevin Powell's YouTube channel](https://www.youtube.com/kepowob) and [Josh Comeau's blog](https://www.joshwcomeau.com/). These guys are awesome and still help me to this day.

3 - Projects and Portfolio

After a few weeks of studying, I needed to put into practice everything I was learning. Looking for project ideas, I found some platforms that helped me practice:

- [Frontend Mentor](https://www.frontendmentor.io/) - This site is excellent for creating projects for your portfolio. The idea is to replicate the layouts they provide and then publish your solution on the platform. There, you can receive feedback on your code and also see solutions from other developers.
- [Dev Projects](https://www.codementor.io/projects) - Similar to Frontend Mentor, but it's not limited to front-end; you'll find ideas for back-end and mobile projects too.
- [CodeWars](https://www.codewars.com/) and [HackerRank](https://www.hackerrank.com/) - Two platforms for practicing logic and algorithm exercises. Very cool, I still use them for studying and practice.

4 - Job Applications

After a few months, toward the end of 2020, I started looking for opportunities within RD. I wanted to transition from the CS field to Engineering or Support to work as a developer. Both my team and my managers were supportive (lots of love 😍). I even participated in an internal job application process, but I wasn't successful.

Shortly thereafter, I started applying for positions outside of RD. In early 2021, my sister Gabriela referred me to a job at one of the companies in the group where she works, [Puzzl Software House](https://www.puzzl.com.br/). The hiring process was quite straightforward. I sent my resume and GitHub with some projects, then had a few interviews.

And then, in April 2021, after approximately a year of executing my plan, I officially began my career as a junior front-end developer 🎊🎊🎊

### Conclusion

It's important to emphasize that the entire transition process was neither quick nor easy. I felt anxious and distressed for several months, and I had to learn to cope with these emotions and try to alleviate them. As I mentioned earlier, communicating my career change was crucial. Thanks to this action, I was able to find a position at a wonderful company because my sister knew what I was looking for.

If you're in a career transition phase, build your support network and seek out the levers that will propel you forward.

My only expectation with this post is that I can inspire other people who are trying to become developers, whether they're just starting their careers or transitioning. However, the plan I outlined and described here in this article considers only my scenario. Please don't take the steps listed here as a definitive guide, although they may serve you. Think about your situation, your strengths and weaknesses, and create your plan.

### One more thing...

#### English

In the IT field, English is indeed important. It's not just another item to add to your resume. You will really need to read and write in English daily. Fortunately, I had the tremendous privilege of being able to study English early in my life, and that gave me a significant advantage in my studies, as many high-quality resources were not yet available in Portuguese.

#### About Age

In practice, age doesn't matter. It doesn't matter if you're starting at 30, 40, or 50. If you have the desire, go for it! Take it easy and with soul (as a good friend once said). In my journey at Puzzl, I was able to use my age and other professional experiences as leverage. Being more experienced and having other professional backgrounds allowed me to advance in my career plan, and I even got promoted (but that's a story for another article).

#### Beware of False Promises and Advertising

The IT and Product fields are in high demand. I see many courses and influencers promising to take you from zero to a high-paying job in a short time. For the vast majority, this won't happen.

#### Leave Your Ego Behind, Especially If You're Coming from Another Field

The fact is that you will work with younger people who are much better than you, especially in technical terms. Instead of competing, try to add value and complement it with your knowledge from other areas and your life experience.

#### [Access here](dev-library) a list of my learning sources with the content I used in this career transition process and still use today. ;)

I hope I have helped! Thank you for reading this far.

Bye,

Hi, I'm Arthur! :)

Articles

A simple guide for good Git Branch Management

Dev Library

Career Transition at 31: How I Became a Front-End Developer