🦾How to automate your resume using R, R markdown, and GitHub Actions
Tags: beginners, tutorial, devops, career
Published: 2023-08-18 14:29:37

⚡ Original [repo](https://github.com/girordo/data-driven-cv/)
Please leave a star⭐ on the project and follow me on Github

## Overview

Automating the creation of your resume is a smart way to save time and keep your information up to date. In this article, I will guide you through a simple process using tools like Rmarkdown and GitHub Actions to automate the generation of your resume.

## Understanding the Tools 🧰

Before we dive into the process, it's important to understand the tools we'll be using:

**R:** A programming language focused on statistical analysis and data visualization. We'll use R to create and manipulate our resume.

**Rmarkdown:** An extension of R that allows combining code, text, and visual elements into a single document. We'll use Rmarkdown to create a structured resume.

**GitHub Actions:** An automation service provided by GitHub that allows us to create custom workflows. We'll leverage GitHub Actions to automate the resume generation.

**Docker:** A platform that enables packaging, distributing, and running applications in containers. We'll use Docker to create a consistent environment for executing our resume generation process.

Now that we understand the tools involved, let's proceed to the automation process:

## Getting Started

First and foremost, you'll need a GitHub account. If you don't have one yet, you can create one here. You'll also need access to a web browser to configure a few things.

**Step 1: Prepare the Repository 📦**

1. Create a new repository on GitHub for your project.
2. Clone the repository to your computer using Git.

**Step 2: Add the Resume File 📄**

1. Create a file named data-driven-cv.Rmd (or use any name you prefer, just remember to change it in the action and it should be .Rmd) in the root of your repository.
2. Open the file in your favorite text editor.

The file should have this header:

```yaml
---
name: Your name
surname: Your surname
address: "Your address"
profilepic: "./imgs/zero-cool.jpeg"
position: "Software Engineer | Frontend Developer"
www: "yoursite.dev"
email: "youremail@email.com"
github: yourgithub
linkedin: yourlinkedin
date: "`r format(Sys.time(), '%B %Y')`"
headcolor: 7d34eb # Here you can choose your favorite color
aboutme: "I am a software engineer with over 6 years of experience in developing modern web applications. My passion lies in creating incredible and functional user interfaces."
docname: Resume
output: vitae::awesomecv
---
```

Note that in the last attribute of the YAML, you have the vitae::awesomecv.

This is just one of the mentioned templates, the others are available here.

In this section, personal information and resume formatting are defined. This includes name, surname, position, website links, contact information, resume creation date, header color, and a brief description about you.

The file should follow this structure:

```yaml
---
name: Your name
surname: Your surname
address: "Your address"
profilepic: "./imgs/zero-cool.jpeg"
position: "Software Engineer | Frontend Developer"
www: "yoursite.dev"
email: "youremail@email.com"
github: yourgithub
linkedin: yourlinkedin
date: "`r format(Sys.time(), '%B %Y')`"
headcolor: 7d34eb # Here you can choose your favorite color
aboutme: "I am a software engineer with over 6 years of experience in developing modern web applications. My passion lies in creating incredible and functional user interfaces."
docname: Resume
output: vitae::awesomecv
---

{r setup, include=FALSE}
knitr::opts_chunk$set(echo = FALSE,
                      warning = FALSE,
                      message = FALSE)

require(xfun)

packages <- c('vitae', 'tibble', 'magrittr', 'here', 'readr', 'glue')

xfun::pkg_attach2(packages, message = FALSE)

# In this part, we set the path and the file we want. If you're following the step-by-step tutorial, you'll need to change the second parameter to data.R
source(file = here("data","data-generic.R"))

# Experience

{r EMPLOYMENT}

work %>%
  detailed_entries(
    with = title,
    what = unit,
    why = detail,
    when = glue::glue("{startMonth} {startYear} -- {endMonth} {endYear}", .na = ""),
    where = where
  )

# Education

{r EDUCATION}

edu %>%
  detailed_entries(
    with = inst,
    what = degree,
    why = detail,
    when = glue::glue("{startYear} -- {endYear}", .na = ""),
    where = where
  )


\pagebreak

# Skills

{r SKILLS}

skills %>%
  detailed_entries(
    with = area,
    what = skills,
    why = detail
  )

\pagebreak

# Projects

{r PROJECTS}

projects %>%
  detailed_entries(
    with = accomplishment,
    what = area,
    when = glue::glue("{year}", .na = ""),
    where = where,
    why = detail
  )

# Certifications

{r CERTIFICATIONS}

certifications %>%
  detailed_entries(
    with = accomplishment,
    what = area,
    when = glue::glue("{year}", .na = ""),
    where = where,
    why = detail
  )

# Honors and Awards

{r HONORS}

honors %>%
  detailed_entries(
    with = accomplishment,
    what = area,
    when = glue::glue("{year}", .na = ""),
    where = where,
    why = detail
  )
```

**Step 2: Creating data.R 📝**

1. Create a folder named "data."
2. Create a file named data.R with the following structure:

```r
skills <- tribble(
  ~area, ~skills, ~detail,
  "Technology", "Javascript", "Experience with Javascript in front-end projects using React",
  "Technology", "Javascript", "Redux, Redux Toolkit, and Context API for state management",
  "Technology", "Javascript", "Jest and React Testing Library for unit tests",
  NA, "Typescript", "Using Typescript with Prisma for database access.",
  NA, "Elixir", "Exploring Elixir in personal projects using Phoenix and Ecto.",
  NA, "Elixir", "Using LiveView for fullstack applications.",
  NA, "HTML", "Creating semantic and accessible web pages.",
  NA, "CSS", "Styling projects using SASS and BEM methodology.",
  NA, "Rust", "Learning Rust for secondary projects.",
  NA, "Rust", "Following the zero2prod book.",
  NA, "DevOps", "Experience with virtualization and containers using Docker.",
  NA, "DevOps", "CI/CD with Github Actions and TravisCI.",
  NA, "Databases", "Working with SQL and NoSQL databases.",
  NA, "Databases", "MongoDB for non-relational databases.",
  "Languages", "Portuguese", "Native language.",
  "Languages", "English", "Fluent.",
)

edu <- tribble(
  ~degree, ~startYear,

 ~endYear, ~inst, ~where, ~detail,
  "Bachelor's in Computer Science", 2015, 2019, "Imaginary University", "Fictional City, Fictional State, Fictional Country", "Studies in algorithms, data structures, and object-oriented programming.",
  "Master's in Software Engineering", 2020, 2022, "Fictional University", "Fictional City, Fictional State, Fictional Country", "Research in software development, focus on agile methodologies and scalable architectures.",
)

work <- tribble(
  ~title, ~unit, ~startMonth, ~startYear, ~endMonth, ~endYear, ~where, ~detail,
  "Software Engineer", "TechSoft", "January", 2020, "December", 2022, "Fictional City, Fictional State", "Worked as part of a team in developing web applications using React and Redux.",
  "Full Stack Developer", "WebTech", "March", 2018, "November", 2019, "Fictional City, Fictional State", "Participated in the development of a full stack application using Node.js, React, and MongoDB.",
  "Development Intern", "ByteCorp", "July", 2017, "December", 2017, "Fictional City, Fictional State", "Gained practical experience working on software development projects.",
)

honors <- tribble(
  ~area, ~accomplishment, ~year, ~where, ~detail,
  "Hackathon", "Best Computing Student", 2021, "Wall Street", "Awarded 1 billion dollars.",
  "Academic Recognition", "Best Computing Student", 2019, "Imaginary University", "Recognized for academic excellence in the field of Computing.",
  "Programming Competition", "1st Place in Algorithms", 2018, "Fictional Programming Event", "Achieved first place in the algorithm programming competition.",
)

projects <- tribble(
  ~area, ~accomplishment, ~year, ~where, ~detail,
  "Software Development", "Task Management System", 2022, "TechSoft", "Led the creation of a task management system using React and Redux.",
  "Software Development", "E-Commerce Platform", 2021, "Fictional Company", "Participated in the development team of an e-commerce platform.",
)

certifications <- tribble(
  ~area, ~accomplishment, ~year, ~where, ~detail,
  "Professional Certifications", "React Certification", 2021, "Fictional Online Learning Platform", "Obtained React certification to showcase skills in the library.",
  "Professional Certifications", "Docker Certification", 2020, "Fictional Online Learning Platform", "Achieved Docker certification to demonstrate container knowledge.",
)
```

**Step 3: Setting Up Automation 🤖**

1. On GitHub, go to the "Actions" tab in your repository.
2. Click on "Set up a workflow yourself" to create a workflow file.
3. Paste the following code into the file and save:

```yaml
name: CI for CV
on:
  push:
    paths:
    - .github/workflows/ci.yml
    - 'markdowns/**'
    - 'data/**'
    branches:
      - main        
permissions: write-all

jobs:
  build:
    name: Creation of resume in en and pt-br
    runs-on: ubuntu-latest
    container:
      image: mlampros/mycvitae:rstudiodev
    steps:
      - name: Set up Git repository
        uses: actions/checkout@v3

      - name: Installing texlive
        run: |
          sudo apt-get -y update
          sudo apt-get install -y texlive-base texlive-latex-base
          sudo apt-get install -y texlive-latex-recommended
          sudo apt-get install -y texlive-xetex
          sudo apt-get install -y texlive-fonts-extra

      - name: Render the resumes
        run: |
          Rscript -e "rmarkdown::render(input = file.path(getwd(), 'data-driven-resume.Rmd'), params = list(work_dir = getwd()))"
          Rscript -e "rmarkdown::render(input = file.path(getwd(), 'data-driven-resume-pt-br.Rmd'), params = list(work_dir = getwd()))"
      - name: Commit files
        run: |
          git config --local user.email "actions@github.com"
          git config --local user.name "GitHub Actions"
          git add .
          git commit -am "add the cv in english and pt-br files to the directory of the repository"
          git push
```

## Wrapping Up

If you've followed all the steps correctly, you'll likely see the resume with a header similar to the one above.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/oka87mdk18ki14dtb4yk.png)

PS: Yeah, I know that the image is in pt-br but I'm lazy and I'm not redo all the steps just to generate one image.

## Conclusion

Automating the creation of your resume using Rmarkdown, GitHub Actions, and Docker is an effective way to keep your information updated and relevant. The benefits range from saving time to showcasing your technical skills to employers.

If you have any questions, feel free to reach out!

Also, if you have any contributions, please fork the repository and open a pull request. I'll be happy to review them.

I hope this article has been helpful and that you're ready to automate your resume. **Happy hacking! :)**