DEV Community: Jeffrey Boisvert

Let's Build a Go CLI Business Card

Jeffrey Boisvert — Thu, 23 Mar 2023 00:49:56 +0000

Seems every developer is trying to find a clever way to get noticed. And in doing so you may stumble on a bunch of interesting projects accomplishing all kinds of things. However, one simple and easy project you can do is making a Business Card for yourself (disguised as a CLI program)!

To do this we will be writing our CLI program in Go and be leveraging cobra which is a great Go library to create this card quickly and effectively.

To give our program some character we will be leveraging box-cli-marker in this tutorial which is a great project you should check out!

Before we start why Go?

Go is a great language to use for this project because it is a compiled language which means it is fast and easy to work with since the compiler will catch most errors for you. Since it is compiled it is also easy to distribute your program to others.

Also, Go has article on this but I personally have been working more with Go and have found it a lot of fun to work with. Also the support for CLIs by the community and from the language itself has been really great from what I have found.

But enough about why Go, let's get started!

Getting started

First let's create a new Go project (Go's official documentation is a great place to start).

Then let's install Cobra and its CLI. Cobra is a great CLI library for Go and the CLI is a great tool to get started quickly.

go get -u github.com/spf13/cobra@latest
go install github.com/spf13/cobra-cli@latest

Now that we have the Cobra CLI installed let's get some boilerplate set up by running with 1 simple command.

cobra-cli init businesscard

Note that businesscard is the name of the cli for this example but you can name it whatever you want (ex: jdvert is what I used for my own card).

This will generate a cmd directory for you with a root.go file for you. This is where the bulk of your code will live

To see if everything is working let's install our CLI and run it!

go install
businesscard

You should see the following output (which is the default Cobra output):

A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.

The Actual Card

Once you confirm everything is working we can then get starting on creating our custom card.

Let's update the command to show a box with text in it instead of the current text it shows.

First let's install the box-cli-maker library. This is a great library that allows you to create boxes with text in them.

go get -u github.com/Delta456/box-cli-maker

Now let's update our root.go file to use this library by finding rootCmd and updating it to the following:

var rootCmd = &cobra.Command{
    Use:   "businesscard",
    Short: "A personal business card CLI",
    Long:  "businesscard is a personal business card because who has time to actually spend printing real ones.",
    Run: func(cmd *cobra.Command, args []string) {
        // This is where we will add our box which can be found looking at https://github.com/Delta456/box-cli-maker#usage 
        // and the examples in the README are a great place to start!
        Box := box.New(box.Config{Px: 4, Py: 1, Type: "Double", Color: "Cyan", ContentAlign: "Center"})
        Box.Print(
            "John Doe",
            "Let's build something fun!\n"+
                "\n\n"+
                "Thanks for checking out my card! Happy coding!",
        )
    },
}

Now lets try out our new card by running go install and then businesscard again.

Now you should see the following when running your command!

You can customize your card as you wish and box-cli-marker has a bunch of examples on how you can do this. Change the color, icons, size, etc. The sky is the limit!

Conclusion

In this tutorial we got our Go Business Card CLI program set up and looking great in our terminal.

Happy coding and free to leave me a link to your card so I can check it out!

Here this my post hosted on GitHub

Handling Mutexes in Distributed Systems with Redis and Go

Jeffrey Boisvert — Sat, 25 Feb 2023 23:07:40 +0000

A mutual exclusion lock (or Mutex which is an abbreviation of Mutual Exclusion) is a very important and sometimes overlooked concept when building a thread-safe access to a system's resources. On top of it being overlooked it can be quite challenging to handle and can lead to race conditions in your system if not done correctly.

In this post I will go over how you can use Redis (a popular and widely used key-value store) to help ensure your Go application has mutex on important operations and resources using Redis's implementation of distributed locks.

How does Redis support distributed locks?

Redis supports distributed locks through the use of its SET command. When used with certain options, the SET command can be used to implement a locking algorithm (ideally you make the key something unique so no only 1 thread/request can have the lock at once like a user id for example).

The idea is the SET command used will only succeed if the given key does not already exist in Redis, effectively creating a lock. Once the lock is acquired, other processes will be unable to acquire the lock since they are unable to set that same key being used as described in the distributed locks page.

To release the lock, the process that acquired the lock can use the DEL command to delete the Redis key. Once the key is deleted, the lock is released and other processes can acquire the lock if they need to by setting the key again.

Implementing distributed locks in Go using Redis

In this example we will use the Redis client library github.com/go-redis/redis which is a common library many developers use to interact with a Redis instance in Go.

Make a new Go project or pull down the code I wrote.

Ensure to have a local Redis instance running.

package main

import (
    "fmt"
    "time"

    "github.com/go-redis/redis"
)

func acquireLock(client *redis.Client, key string, expiration time.Duration) (bool, error) {
    // Use the SET command to try to acquire the lock
    result, err := client.SetNX(key, "lock", expiration).Result()
    if err != nil {
        return false, err
    }
    return result, nil
}

func releaseLock(client *redis.Client, key string) error {
    // Use the DEL command to release the lock
    _, err := client.Del(key).Result()
    return err
}

func main() {
    // Create a new Redis client
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    mutexKey := "my_lock"

    // Try to acquire the first lock
    isFirstLockSet, err := acquireLock(client, mutexKey, time.Second*10)
    if err != nil {
        fmt.Println("Error acquiring lock:", err)
        return
    }
    if !isFirstLockSet {
        fmt.Println("Failed to acquire lock")
        return
    }

    // Do some work while holding the lock
    fmt.Println("First lock acquired!")

    isSecondLockSet, _ := acquireLock(client, mutexKey, time.Second*10)

    if !isSecondLockSet {
        fmt.Println("Could not get a second lock which is as expected this is where you would force the request out.")
    } else {
        fmt.Println("Second Lock acquired! This should not happen :)")
    }

    // Simulate some work by sleeping and try to acquire the lock again to see that it fails
    time.Sleep(time.Second * 5)

    isThirdLockSet, _ := acquireLock(client, mutexKey, time.Second*10)
    if !isThirdLockSet {
        fmt.Println("Still could not get the third lock since the first lock is still set.")
    } else {
        fmt.Println("Third Lock acquired! This should not happen :)")
    }

    // Release the lock
    err = releaseLock(client, mutexKey)
    if err != nil {
        fmt.Println("Error releasing lock:", err)
        return
    }
    fmt.Println("First lock released!")

    // Try to acquire the lock again to show it has been released
    isForthLockSet, _ := acquireLock(client, mutexKey, time.Second*10)
    if !isForthLockSet {
        fmt.Println("Failed to acquire lock")
        return
    } else {
        fmt.Println("Forth Lock acquired!")
    }

    // Release the forth lock
    err = releaseLock(client, mutexKey)
    if err != nil {
        fmt.Println("Error releasing lock:", err)
        return
    }
    fmt.Println("Forth Lock released!")
}

This when ran will print out the following in the terminal

First lock acquired!
Could not get a second lock which is as expected this is where you would force the request out.
Still could not get the third lock since the first lock is still set.
First lock released!
Forth Lock acquired!
Forth Lock released!

Taking a look at what the code above does

The acquireLock function attempts to acquire a lock on a Redis key using the SET command with the NX option. The NX option tells Redis to only set the key if it does not already exist, effectively creating a lock if our key my_lock does not already exist. We set the value to lock but this can really be anything.

This becomes more obvious as we try to acquire a second and third lock which shown above fails since the acquireLock returns false.

The releaseLock function uses the DEL command to release the lock once done. The DEL command deletes the my_lock key that was created to acquire the lock, effectively releasing the lock.

An important note something that this example highlights is Redis will not raise an exception when doing this so it is up to the application layer to ensure the logic of the locks are applied. Also, it is good to put a default "time to live" on the key to ensure if the application crashes it won't leave the key set forever (in this example we put the expiration time as 10 seconds).

Conclusion

Mutex is an important concept for coordinating access to shared resources in distributed systems and Redis provides a simple, fast and effective way to implement distributed locks.

We have explored how to use Redis to implement distributed locks in Go which can be a great combination if you need a small and quick way to restrict access to certain resources/business flows.

Building an Arduino set up To Play Dino Run: A Fun and Engaging Way to Learn Electronics and Programming

Jeffrey Boisvert — Wed, 22 Feb 2023 03:24:05 +0000

The Dino Run game is one of Google's the most popular games around, and it's no surprise why: it's simple, engaging, and addictive. But you know what is even more fun? Getting an Arduino to do it for you. In this blog post, we'll explore how to do just that using the open-source code available on GitHub.

What is an Arduino?

Arduino is an open-source platform for building electronic devices and projects. It consists of a physical programmable board and an Integrated Development Environment (IDE) that allows you to write code and upload it to the board. Arduino boards are commonly used in a wide range of projects, including robotics, home automation, and Internet of Things (IoT) applications.

What is Dino Run?

Dino Run is a popular game that is built into the Google Chrome browser. It's a simple game where the player controls a T-Rex who must jump over obstacles to avoid crashing. The game is played by pressing the space bar or up arrow to jump and the down arrow to duck. You can play the game by typing chrome://dino/ into your Chromium browser (ex: Chrome, Brave, etc.)

How to make an Arduino Play Dino Run Game

If you want to keep it simple feel free to pull down the code I wrote here which also shows how to get set up.

You will need the following:

An Arduino UNO (or really any Arduino should be fine)
Two Servos (one to be tapped onto the keyboard key to jump and one to be tapped onto the keyboard key to duck).
One Light Sensor (Photoresistor/LDR) which will be used to detect objects to know when to jump or duck
Eight wires
One 10k OHM resistor

Here is how you will will set everything up

Once you have everything hooked up ensure to tape the jump servo to the up arrow key and the down servo to the down arrow key (note the code in my project will always be pressing either key and will always default to ducking aka the down key).

Tape the light sensor (used to know when to jump) on the computer's screen (about 1/4 from the left hand side this can vary). The position is important since if it detects an object too late our little Dino won't have time to jump and if it detects it too soon it will have jumped into the object.

Open up your Arduino IDE and paste in the following code (feel free to look at the comments left if you want to better understand the code):

/**+---
 * Used to play Google's Dino run game 
 * with just servos and a LDR sensor. 
 */

// This is just importing the Servo object you will need. 
#include <Servo.h>

// You need to declare you Servo 
// objects here to be able to attach them later on. 
Servo jumpServo; 
Servo duckServo; 

//Pins
const int JUMP_SERVO_PIN = 2; // TODO Change to your pin
const int DUCK_SERVO_PIN = 4; // TODO Change to your pin 
const int JUMP_SENSOR_PIN = A0; // TODO Change to your pin 

//Servo positions
const int JUMP_OFF_POSITION = 10; //Change this based on how your servos are set up 
const int JUMP_ON_POSITION = 20; //Change this based on how your servos are set up 
const int DUCK_OFF_POSITION = 105; //Change this based on how your servos are set up 
const int DUCK_ON_POSITION = 120; //Change this based on how your servos are set up 

//Sensor object values
const int MIN_OBJECT_RANGE = 532; //Change based on your screen
const int MAX_OBJECT_RANGE = 695; //Change based on your screen

int jumpSensorValue = 0; 
const int TIME_BETWEEN_JUMP = 290; //Change based on your placement

// This runs upon turning on the Arduino and is usually where 
// you tell the Arduino where certain electronics are and here 
// we ensure the servos are in the "start position" meaning to 
// always duck. 
void setup() {
  jumpServo.attach(JUMP_SERVO_PIN); 
  duckServo.attach(DUCK_SERVO_PIN); 
  startPosition();
  Serial.begin(9600);
}

// This will run forever as the Arduino is on.
// This is where the actual game is happening and essentially 
// our Light Sensor is going to return a number based on how 
// much light is present (meaning a darker object returns a 
// higher number and a lighter object returns a lower number). 
void loop() {
  jumpSensorValue = analogRead(JUMP_SENSOR_PIN);
  Serial.println(jumpSensorValue); // Just for testing purposes and how you will know what your sensor returns all sensors can be different :) 
  if(jumpSensorValue > MIN_OBJECT_RANGE && jumpSensorValue < MAX_OBJECT_RANGE){
    // It is always good to have a range since as the object will move across the screen the number can change and there will be a delay from when the servo pressing the key and when the Arduino runs the code to do it. 
    jump();   
  }
  else {
    duck();
  }
}

/**
 * Put both keys off the trigger
 */
void startPosition(){
  jumpServo.write(JUMP_OFF_POSITION); 
  duckServo.write(DUCK_OFF_POSITION); 
}

/**
 * Used to press the key to jump
 */
void jump(){
  duckServo.write(DUCK_OFF_POSITION); 
  jumpServo.write(JUMP_ON_POSITION); 
  delay(TIME_BETWEEN_JUMP); 
  jumpServo.write(JUMP_OFF_POSITION); 
}

/**
 * Used to press the key to duck 
 */
void duck(){
  duckServo.write(DUCK_ON_POSITION); 
}

You may need to play around with the variables I indicated with some TODO but once all is set up give it a try and hopefully you will end up with something like this.

Conclusion

Making an Arduino play Dino Run for you is a fun and engaging way to learn about electronics and programming. It's a great project for beginners who want to learn about Arduino and electronics. By following the instructions on GitHub and using the Dino Run code provided, you can build your own Dino Run set up to play the game in no time.

My best score was 1393 can you beat it? Let me know in the comments below!

Account Balance Masking - Because Why Not Have More Privacy?

Jeffrey Boisvert — Wed, 23 Nov 2022 02:41:12 +0000

No one likes it when someone is peeping over your shoulder. This is even more the case when you're logged into your personal banking with all your balance details on display. This is why I decided to build the Account Balance Masker Chrome Extension.

I was quite surprised this was not something some financial sites offered out of the box. My goal with this app was to be able to set it and forget it and not have to worry about doing a lot of set up in order for me to just mask my account balances. Also being a developer I was curious to see what it took to make a chrome extension myself.

But how does it work?

In the spirit of open source software the code is available to review if you wish to dig into it more but this is a basic overview.

All Chrome extensions are defined by a manifest.json which contains information that defines it and my extension is no different. Within this extension we make use of the key content_scripts. Content scripts is how we are able to run javascript files against specific webpages and ensure it only runs in these defined pages. With the help of wildcards this makes it easy to, for example, specify scripts to only one for 1 banking webpage.

Within these javascript files one simply needs to search the DOM and update the elements containing the account balance details. As you can imagine this can vary from site to site but making use of document.querySelectorAll we are able to search through elements using wildcards as well and test if the text contains digits. With the help of the browser's developer tools one can easily find the HTML tag's class and/or id of the element and update the script as needed.

Since this is only loaded once the page loads or whenever navigating around the webpage there is no need to store any data except within the script. You can also always view the details since the initial value is within a closure.

Final thoughts

I hope others will find the simple extension useful and I hope to implement other features and webpages to help your get more privacy from those people wanting to peep at your screen.

Update

Want to give it a try? You can download it on The Chrome Web Store now!

Happy coding!

Crash Course on Git Commands

Jeffrey Boisvert — Thu, 29 Sep 2022 00:14:34 +0000

Welcome to the wonderful word of git where a -f during a git push can cause you so much pain. If you are working as a Software Developer you most likely have to use git at some point. Git is a version control system that many teams use to collaborate and build software together.

In this article I am going to go over what I think are essential git commands you will need to know to get started.
There is more documentation available all for free here and I recommend giving it a read whenever trying out new commands. Atlassian has some great easy to digest tutorials as well.

git clone your-repository-path

This is the command you use to download your remote repository. This can be done via ssh or https.

git checkout branch

Git uses branches to store work and with this command you will will be able to change your local files to match a specified branch.

git checkout -b new-branch

Creates a new branch from the current branch you are working in. If you wish to specify a specific branch to branch from, you can use the u flag. Example: git checkout -b new-branch -u origin/main.

git status

This will simply give the current state of your branch. It will display what changes are staged for a commit, which are not and what is not tracked currently by git. If you are pointing to a specific branch it can also tell how far ahead/behind you are from the the given branch.

git pull

Use this if you wish to "pull" in code from remote repository's branch into your current local branch. By default this will perform a merge commit. If you have conflicts git will be sure to flag them. Once resolved you can just git add and git commit to complete the pull.

git pull --rebase

Similar to the above command but instead of doing a merge commit this will attempt to rebase the commits from the remote branch on top of the local commits in your branch. If you are not sure which to use a merge commit tends to be less dangerous/easier to deal with than a rebase which acts a lot like a more automated/fancy cherry picking.

git cherry-pick commit-hash

On the note of cherry picking, if you wish to just grab a single commit and put it on top of your current branch this is where cherry-pick is useful. Give it a commit hash and it will add that commit to your branch.

git fetch --all

Use this command to make sure your local machine is up to date with the remote repository. Try to do this as often as you can to be sure your local branches that you checkout / branch from are up to date. A git status is always helpful to know if you are not in sync with the remote repository.

git stash

This will save your local modifications and reverts the working directory to match the HEAD commit. This can be useful if you do not wish to commit the changes but want to go back to a clean state to checkout another branch. When you wish to get back the stashed changes simply do git stash pop.

git branch -u origin/branch

Sometimes you may want to change the branch your branch is pointing to/comparing to. This command will let you do this and when you run git status it will tell you if you are ahead or behind.

git add filename

This will add a new/deleted/modified file which to be staged to then be committed. If you wish to add all changes from your current directory just run git add ..

git diff

By default this will show you what changes have been done compared to the previous commit. However this command can even be used to compare specific files between commits and branches. This is useful to see what changes you have before committing.

git commit -m "My commit message."

An essential classic. This will create a commit with everything that has been staged after running git add. The -m allows you to add a message to explain the changes. It is good practice to give as much details as you can but every project/organization tends to have their own policy on commit messages.

git push origin branch

Use this command once your branch's commits are ready to be pushed to the remote repository. It is worth noting origin is just the default alias name for your remote repository but it can be called anything.

Earlier I mentioned not to use -f with git push. This is because -f stands for "force" and when used will override the remote repository's branch with what is being pushed. Be careful and avoid -f as much as possible.

Hopefully these commands help you and this small tutorial is useful in your quest to better understand git. Did I miss any commands you think are essential? Let me know but otherwise happy coding!

How do you revert a newly applied Django migration?

Jeffrey Boisvert — Fri, 23 Sep 2022 01:54:25 +0000

So you created a new migration and applied it to your database however after some testing you realize it still needs some work and you need to revert it. With Django this is pretty simple with some built in commands

The Traditional Way

For this example we will pretend we have a polls app and this is the app we wish to manage our migrations in. Django has a lot of great documentation on this topic as well.

Let's first check out which what our current migrations look like using the showmigrations command.

python manage.py showmigrations polls
polls
 [X] 0001_initial
 [X] 0002_question1
 [X] 0003_person

The previous migration that was applied is 0002_question1 so we simply need to tell Django to migrate back to that. This can be done by the migrate command

python manage.py migrate polls 0002_question1 
Operations to perform:
  Target specific migration: 0002_question1, from polls
Running migrations:
  Rendering model states... DONE
  Unapplying polls.0003_person... OK

Now our database should now have reverted back to the state in migration 0002_question1 and we can verify this by using showmigrations again.

python manage.py showmigrations polls
polls
 [X] 0001_initial
 [X] 0002_question1
 [ ] 0003_person

If you want to reset the whole database as well you can use python manage.py migrate polls zero which will revert all the way back to 0001_initial.

But how do I just go back to a previous migration without checking what it is?

And this question is something I asked myself as well. The Django framework does not provide this functionality out of the box.

Let's say you commit migrations to you git repository and are a small team sharing a few servers for other teams to test with. A problem you may run into is different teams having different migrations which are not present in the git main branch. This can lead to some frustrating issues during a deployment and can cause a database to get out of sync with the migration files very quickly (especially if the database is not rebuilt every time).

This is why I made the django-migration-rollback app. With some custom Django commands one can now easily migrate back to a previous migration and even sync with a specific branch in a repository quite easily without having to manually check what the migrations are.

In our previous example, instead of having to do showmigrations and manually input the migration in migrate you can simply use migrateprevious.

python manage.py migrateprevious polls
Attempting to go back to rollback polls to previous migration
Operations to perform:
    Target specific migration: 0002_question1, from polls
Running migrations:
    Rendering model states...
DONE
    Unapplying polls.0003_person...
OK

And if I had deployed my changes to a test server and had forgotten to rollback the migration the deployment sequence can simply use migraterollback before deploying the next branch.

python manage.py migraterollback polls main
Attempting to go back to rollback polls to latest migration on branch main
Operations to perform:
    Target specific migration: 0002_question1, from polls
Running migrations:
    Rendering model states...
DONE
    Unapplying polls.0003_person...
OK

However just note this does require a .git file present to be able to call the git commands.

Conclusion

I hope you found this article useful and if you wish to check out the package I talked about it is open source and the repository can be found here. Happy coding!

Working at a Startup as a Developer

Jeffrey Boisvert — Tue, 28 Sep 2021 02:46:08 +0000

You are job hunting and stumble on several postings for companies you never really heard of before. You then find out one is a startup. You think their product is interesting but are unsure if you should apply. Well, I will discuss why I think it is always a great option to try.

To give some context I have worked in small to medium size companies working in various IT-related roles.

What I Have Liked

Creative Freedom

I think this is a big one you will see in many other posts but since a startup is moving fast and everyone usually is quite busy managing several different things at once you end up being given the freedom to build and implement things how you want.

What this means is you may be given a problem to solve and if you have an idea of how to solve it and others agree with the solution (and you have the budget for it) you more than likely get to do it your way. Being able to lead projects and own the feature you develop can be quite exiting. You have the chance to work on something you are truly passionate about which makes the creative freedom even better.

Learning

I personally love learning be it new technology, new processes, best business practices, etc. At a startup, you are always on your toes and usually will have to learn very quickly since may be the first to solve a given problem within the company. Working in cross-functional teams will also let you have a better understanding of things outside of your everyday work.

For example, you may be tasked with automating some reporting and as you gather the requirements for the project you will learn about how there are certain regulations you must adhere to and ensure are part of the reporting process. Sometimes you my need to even learn things that are not related to your role like how to interview people or estimating feature points for a sprint.

The Team

By working in a small cross-functional team you end up getting to know your co-workers better than you would in a larger more focused team. What I like about this is you get learn everyone's strengths and weaknesses which helps everyone move forward. This is a big reason why I like working at startups since the team dynamic makes me feel like I am not doing a job but rather working on something I am passionate about with other like-minded people.

Things to Consider

Startups move FAST

By fast I mean really fast. You may work on something one day and end up never working on it again to start a new project the next day. For some this is exciting but for others, this can be somewhat disorienting. Having to switch context often can be hard however is a great skill to improve on since you end up learning time management skills and how to handle obstacles like feature creep.

Work-Life Balance

Startups attract go-getters and are a group of usually like-minded people who believe in the product and where it is going. So, naturally you end up having to deal with quite tight deadlines to reach your company's goals. This can sometimes make you feel like you work a lot more than what you are use to.

However, what is important is that you care about what you are working on and making sure you still take time to enjoy your personal life. Putting in the long hours to then reap rewards later down the road can be hard and equally rewarding but ensuring proper work and life balance is also important. This will greatly vary at every startup so it is always worth asking about during an interview.

Conclusion

Startups are a great way to not only accelerate your career with creative freedom, chances to learn, and work with like-minded people but are also not for everyone (and that is okay). I personally have really enjoyed my experiences working at startups however what I can say for sure is they were all different. So even if you or someone else did not enjoy a past experience I still think it is worth trying another one. I hope this helped you get a better idea of what to expect working at a startup so you can take that leap and see for yourself.

My Experience Developing for a Non-Profit

Jeffrey Boisvert — Wed, 02 Dec 2020 03:02:19 +0000

Has someone told you that “You should really start doing side projects to build your portfolio” and deep down you really want to but are not sure how to go about it? I think we all want to build something useful and when we start learning about software development we just have this desire to build something. However, as we sit there rattling our brains we cannot seem to come up with an idea and end up stuck in tutorial hell.

My friend and I got an email about a non-profit organization called Raison d’art who was looking for volunteers to help develop an internal tool to help them manage their image assets in their S3 bucket. A key thing that drew us to this project was that the organization wanted to make the project open source and the thought of starting an open-source project seemed really exciting to us! We had never used S3 before but we both had this desire to build something and thought this was a great opportunity to test our problem-solving skills while also helping others. So we decided to go ahead and start the project.

If you do not know about Amazon Web Services (AWS) or what S3 is here is a quick summary. AWS is a platform that supports many secure cloud services for just about anyone to use. As you probably guessed, S3 is one of these services. It is primarily used as storage on the cloud for just about anything. You can read more about it on AWS’s S3 documentation.

Since this project was during the start of COVID-19 pandemic, everyone in the team only met virtually. During the first meet up in June 2020, we discussed what exactly we wanted to develop and how it would solve the problem Raison d’art was having. We decided to build a React application since both my friend and I knew Javascript and were both somewhat familiar with React.

I remember being unsure since we did not know if the design decisions we would make were the best ones. There is a lot of imposter syndrome when you try developing any bigger feature in a project and this was no exception.

I think the best way to overcome imposter syndrome is to just try something out and then share your ideas with others to get feedback.

This way you have something to show and learn from while building momentum in the project. We would meet every two weeks to discuss the key features we wanted to tackle in the coming weeks and where we were at in the project. It was great to see how the project kept growing every time we met and to hear others' feedback. I think something I would suggest to others is to write down the problem you are trying to solve and break it down into smaller high-level parts. This way you have something to refer back to you while you are developing.

Something we started learning quickly about AWS was just how much there was to read. The sheer amount of documentation AWS has about their products can be overwhelming. But you should 100% read this documentation. This is how we discovered that Tags were better suited for the organization’s assets instead of using Metadata (which was the original plan). Since an object’s metadata is tied to the object in the bucket it means if you wish to edit this piece of information you need to re-upload the object every time you edit just a single piece of metadata. In layman's terms, there was a lot of overhead to edit just a single piece of data (since the metadata cannot be edited after the initial upload so you have to replace the existing object). However, tags are not stored with the object so if you wish to just modify a single tag of an object you can simply edit that tag without having to reupload the whole object. Check out the documentation about metadata versus tags for reference.

Another feature we wanted to develop was to make it possible for several objects to have similar tags and defaults without having to manually add each one. S3 has no sort of inforced structure when it comes to tags and is very similar to NoSQL databases (more specifically a Key-value database) meaning as long as a unique key is provided the value can be anything. So this where the idea of the schema file came from. We essentially uploaded in a folder a JSON file we called bucket-buddy-schema.json (an example of the contents can be seen below) which would store what tags should be applied to each object in a given folder.

[
   {
      "key":"Name",
      "Value":"default name",
      "type":"text"
   },
   {
      "key":"Age",
      "value":"23",
      "type":"number"
   },
   {
      "key":"DateOfBirth",
      "value":"2020-09-30",
      "type":"date"
   },
   {
      "key":"Validated",
      "value":false,
      "type":"flag"
   }
]

This file specifies the key (the tag name), value (the default value for the tag), and the type (which could be Numeric, Text, Date, or Flag) that each object should contain, and when viewing an object we clearly identify that these are the values needed to be added to follow the schema in a given folder.

As the project was coming to an end and we began polishing the app. A key thing we wanted to do from the start was to build an app for developers and non-developers could use and this meant trying to build a README.md that was as easy to understand. We even added gifs showing all the features and a brief explanation on how to get started. Something I think is often overlooked in documentation is examples. As the saying goes, “A picture is worth a thousand words.”

We even got the app set up so it can be wrapped as an Electron app so our React application could behave like an actual desktop app! Once everything was ready we were invited to a local meet-up called JS-Montreal to present our project and get feedback. It was a lot of fun to present our project to other developers in the community and get their feedback and it really showed how supporting the development community can be.

If I learned anything from starting an open-source project from scratch is this, you learn more than just how to code. I discovered how to be creative while helping others and it felt so good to be able to solve a problem when I had trouble coming up with an idea for my own project. Knowing your weaknesses can be one of your greatest strengths! There are so many problems non-profit organizations and people are facing on a daily basis so if you are unsure on what project you should do and work on early in your career try to ask and listen to those around you.

At the end of the day being a developer means being a problem solver and being able to interpret someone’s problem so you can then design and present a solution.

Not only will you feel like you are building something useful that will help others reach their goals but you will be able to build that portfolio that everyone keeps suggesting you should have. Making a product open source makes it so you are not just helping the original person having the problem, but others too and gives the project the chance to turn into something you never thought it could be (and that thought is truly exciting).

Thank you for reading this blog post and if you want to check out the Bucket Buddy repository I talked about in this post please check out the GitHub repository here! Happy coding!