DEV Community: Henry Boisdequin

30 Programming YouTubers You Need to Subscribe To

Henry Boisdequin — Thu, 25 May 2023 15:54:35 +0000

Today's day and age offers us with so many different valuable online resources, but sometimes the best are hard to find. YouTube is an amazing platform to learn how to code, and how to develop your coding skills as it has endless amounts of content and YouTubers, with at least one for your every need. From data science/AI with Python, website development with JavaScript, or low-level systems programming with C, there are wide varieties of YouTubers for it all. Without further talk, let's jump into the list of 30 programming YouTubers that deserve a spot on your subscription list!

1. freeCodeCamp.org

Content: Everything you can imagine!
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

2. Fireship

Content: Tech/Coding News, Almost Every Technology/Language You Can Think Of
Skill Level: Beginner, Intermediate
Personal Favorite Video:

3. Ben Awad

Content: Web Development
Skill Level: Intermediate, Advanced
Personal Favorite Video:

4. Tech With Tim

Content: Python, Web Development, Game Development
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

5. Coder Coder

Content: Web Development
Skill Level: Beginner
Personal Favorite Video:

6. Clément Mihailescu

Content: Industry News, Coding Interviews,
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

7. Jon Gjengset

Content: Rust
Skill Level: Advanced
Personal Favorite Video:

8. John Fish

Content: Programming Projects, College, Productivity
Skill Level: Beginner, Intermediate
Personal Favorite Video:

9. Programming with Mosh

Content: JavaScript, Python, C#, Java
Skill Level: Beginner, Intermediate
Personal Favorite Video:

10. Bro Code

Content: Web Dev, Python, C++, Java, C#, C
Skill Level: Beginner, Intermediate
Personal Favorite Video:

11. Nick White

Content: Coding Interview Prep, Fun Content
Skill Level: Beginner, Intermediate
Personal Favorite Video:

12. Tiff In Tech

Content: Tech News, Python
Skill Level: Beginner, Intermediate
Personal Favorite Video:

13. AstroSam

Content: Game Development, C#
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

14. CS Dojo

Content: Python, Algorithms/Data Structures
Skill Level: Beginner, Intermediate
Personal Favorite Video:

15. Life of Luba

Content: Productivity, Industry Updates
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

16. LearnWebCode

Content: Web Dev
Skill Level: Beginner, Intermediate
Personal Favorite Video:

17. thenewboston

Content: Web Dev, Python, C, Java
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

18. Treehouse

Content: Web Dev, JavaScript, Python, Swfit, Kotlin
Skill Level: Beginner, Intermediate
Personal Favorite Video:

19. Golang Dojo

Content: Golang
Skill Level: Beginner, Intermediate
Personal Favorite Video:

20. Traversy Media

Content: Web Dev, Python, PHP
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

21. Derek Banas

Content: Java, C++, Rust, Python, Golang, Ruby, etc
Skill Level: Beginner, Intermediate
Personal Favorite Video:

22. Syntax

Content: Web Development
Skill Level: Beginner, Intermediate
Personal Favorite Video:
youtube.com

23. Web Dev Simplified

Content: Web Development
Skill Level: Beginner, Intermediate
Personal Favorite Video:

24. Amigoscode

Content: Python, Java, Web Development
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

25. Coding Garden

Content: JavaScript, Web Development
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

26. The Coding Train

Content: JavaScript, Algorithms/Data Structures
Skill Level: Beginner, Intermediate
Personal Favorite Video:

27. edureka!

Content: Python, Web Development, Java, Rust, etc
Skill Level: Beginner, Intermediate
Personal Favorite Video:

28. YouCodeThings

Content: Rust, JavaScript
Skill Level: Beginner
Personal Favorite Video:

29. IAmTimCorey

Content: C#, Web Development
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

30. sentdex

Content: Python, Golang
Skill Level: Beginner, Intermediate, Advanced
Personal Favorite Video:

There we go, 30 programming YouTuber's that deserve a subscription from you! If you have any more, be sure to add them in the comments, and I'll add them to the article. Thank you for reading!

Henry Boisdequin

How to Come Back From Burnout

Henry Boisdequin — Fri, 19 May 2023 08:35:18 +0000

Burnout is tough. When you are burnt out from something, you resent it, and don't want touch it again. This unhealthy relationship with that thing only decreases your productivity and your mental health. Well, this exactly happened with me and programming. Learning to code over 2 years ago, I thought my relationship with code was great. In that short 1 year span that I did code, it was my #1 priority, making a stark imbalance in my life. This imbalance led me to not write another line of code for 2 years, until recently. After a long break, I feel the urge to come back into coding, and rekindle my passion that I used to love. In this article, I will go over the most important things that I kept in mind over this journey of relearning and rediscovering. I hope these help you too :)

1. Address the reasons why you want to come back to coding

To make sure that you will have a healthy relationship with code, you need to make sure that you are coming back from burnout for yourself, and your needs. If you are doing it for other people, or purely for the sake of getting a job, for example, it will be much harder to devote time and effort into coding consistently. This would lead to another burnout, which is the main thing we are trying to avoid! In my case, I felt that I had extra time in my life, that I wanted to dedicate to a hobby. Since programming is something I used to love, I wanted to try it again, as in combination with me finding it very interesting and worthwhile, it is a practical skill for the future. In summary, make sure that you are coming back from burnout for you, and what you want to do. This will keep you motivated and interesting in coding.

2. Make a plan

Learning to code, and relearning to code is no different, you need to make a plan! To make sure you aren't all over the place, scrambling to learn every technology that you knew previously, you need to assemble a plan. Something very common with burnout is feeling overwhelmed with all the things you need to do to get back to where you were prior. To prevent this feeling, you need to take it one step at a time, to make your foundations strong but also to maintain that healthy relationship. In my case, for the past few weeks, I've just been relearning Python, the first programming language I learned. Since Python is easy to learn, I thought it would be a logical starting point for me. Although my main programming language was Rust, I felt like that would be a harder starting point, leading to more roadblocks and possibly being overwhelmed. Before you start getting into coding again, outline the languages/concepts/frameworks you want to relearn, and the resources that you will use. This will keep you on track, but also prevent you from being overwhelmed as you have a clear plan to get back to where you were before. Furthermore, it's rewarding to tick off the tasks that you have completed, giving yourself more motivation to continue.

3. Make it fun for yourself

In my journey of returning to coding, I have been learning by doing. I started off super basic, wanting to make a command-line contact book in Python. I outlined the different things that I would need to do in order to complete this project, and just went into it, attempting to rekindle my knowledge along the way. If you don't know how to do something, AI and documentation is your friend! This made the process of relearning the nitty-gritty of Python more fun and enjoyable for me. Joining communities is another amazing way to make the experience fun. There is a great community here on DEV, and writing blog posts, about your experiences for example, will help you 1) stay accountable to your relearning process, but also 2) engage with the community by asking for questions or just sharing how you have been recovering from burn out. Find a supportive community that will lift you up, and be there if you have any questions or concerns.

4. Take breaks

In order to ensure that you don't get burned out again, you need to take breaks. Maintaining a healthy relationship with code relies on the fact that you have other things to turn too when you get stumped or just need a break. For me, I enjoy physical exercise/sports and spending time with family and friends. These activities take my mind off coding, and allow me to take a break. Finding what works for you is crucial to maintaining that healthy relationship. Here are some ideas of activities you can do to get your mind off coding: physical exercise, spending time with friends/family, meditation, reading, art, music, etc.

5. Check in once in a while, to see if your relationship with code is healthy

For me, this is the most important point to ensure that your relationship with code stays healthy. You need to check in once in a while, to see if your life is balanced and your relationship with code is healthy. Whether this be scheduled breaks or just reflecting on your mental health, taking some time to think about how you can prevent burnout and just enjoy coding is crucial. Two years ago, when I was doing an immense amount of coding, everything seemed perfect, as I flew from language to language, framework to framework. It is not until I was suddenly hit by burnout that I realized that this obsessive learning was unhealthy for me. If I took a pause ever so often in my learning journey, it would've allowed me to prevent burnout and have a healthy relationship with coding.

To conclude, make sure you keep these five points in mind when coming back from a burnout. Reflection and keeping one's relationship with code healthy is something we oftentimes take for granted. That is why it is essential to check in once in a while, stay streamlined, and always have fun. Good luck to all of you coming back from burnout, it's always hard! You can always reach out to me, boisdequinhenry19@gmail.com, for any questions. Thanks for reading.

Henry Boisdequin

Programming Again After 2 Years... | Mental Health & Burn Out

Henry Boisdequin — Mon, 15 May 2023 16:26:04 +0000

Hello! I'm glad to be back on the platform after two years again. The truth is that I took a 2 year break from programming. After learning to code in 2020, I had a great year learning Python, JavaScript/TypeScript, Rust and much more. I built a lot of fun projects and wrote a lot of fun articles on dev.to! However, I think I got burned out from coding every day for hours on end, constantly learning new things and making new projects. This burn out led me to not write a single piece of code for 2 years.

You might be wondering, why am I writing this post? Well, the truth is that I am now interested in programming again, and interested in writing more blogs! I want to keep myself accountable on this journey of relearning all of my skills by writing blogs on my journey and how to come back after a burn out. Stay tuned!

10 Advanced Projects to Build in 2021

Henry Boisdequin — Thu, 28 Jan 2021 05:51:56 +0000

I've curated a list of 10 advanced projects to complete in 2021. Most of these are systems programming projects, but there are a few other AI and networking projects in the list. When I say these projects are advanced, they are advanced. I would recommend being very familiar with the programming language you choose to use to tackle one of these projects. Let's dive right into it!

1. Programming Language

Creating a programming language, interpreted or compiled, is no easy feat. Some programming languages include: Python, Rust, Javascript, C++, Elixr, and many more. For this project, design and implement an interpreted or compiled programming language from scratch. If you would like this project to not only be a 2-week thing, think about the problems you have with certain programming languages, and how to fix them. For example, Rust is an awesome programming language that has memory safety and speed. The downside to Rust is its learning curve. I would try to create a programming language that is fast, memory safe, but would be easier to learn than Rust.

Tutorials (if you get stuck):

Golang: https://interpreterbook.com/
Rust: https://arzg.github.io/lang/
Python: https://youtu.be/Eythq9848Fg?list=PLZQftyCk7_SdoVexSmwy_tBgs7P0b97yD
General: https://online.stanford.edu/courses/soe-ycscs1-compilers

2. Toy Database/Key, Value Store

For this project, create a toy database or a key, value store. If you would like some more practice with how databases work before building a real one, I would recommend creating a key, value store, a Redis clone, or a Memcached clone. As these projects are smaller than a full NoSQL/SQL database, these would be great intermediate systems projects. Once you feel ready, create a toy database. This database can be whatever you want: SQL or NoSQL, relational or nonrelational, the list goes on.

Tutorials (if you get stuck):

Python (beginner-friendly): https://www.freecodecamp.org/news/how-to-write-a-simple-toy-database-in-python-within-minutes-51ff49f47f1/
General: https://www.coursera.org/specializations/database-systems

3. Implement the TCP Protocol

In this project, implement the TCP protocol from scratch. If you don't know what the TCP protocol is, that would be the first step. I would recommend reading this: https://tools.ietf.org/html/rfc793. As the TCP protocol is a more advanced protocol, if you would like to tackle something a little simpler, I would recommend implementing the FTP protocol which you can learn about here: https://en.wikipedia.org/wiki/File_Transfer_Protocol.

Tutorials (if you get stuck):

Rust: https://youtu.be/bzja9fQWzdA?list=PLqbS7AVVErFivDY3iKAQk3_VAm8SXwt1X
C++: https://youtu.be/WDn-htpBlnU?list=PLZo2FfoMkJeEogzRXEJeTb3xpA2RAzwCZ
Python (FTP): https://www.tutorialspoint.com/python_network_programming/python_ftp.htm
Node: https://www.digitalocean.com/community/tutorials/how-to-develop-a-node-js-tcp-server-application-using-pm2-and-nginx-on-ubuntu-16-04

4. Implement Biometric Authentication

For number 4, implement biometric authentication. If you didn't know, biometric authentication uses a user's unique biological characteristics to confirm their identity. Some examples of biometric authentication include: fingerprint, face recognition, eye recognition, and more. This project requires you to be proficient with AI and machine learning. You could extend this project by implementing biometric authentication in an attendance platform, fingerprint voting system, and more.

Tutorials (if you get stuck):

Python (face recognition): https://youtu.be/535acCxjHCI
Node (fingerprint): https://youtu.be/RLpeBil53bk?list=PLrUF5HNl_xIKDmlYxMXtnQywpbfByH07r

5. Concurrent Data Structure

For this project, create a concurrent data structure. If you don't have any ideas on which concurrent data structure to make, I find looking at old research papers on concurrent data structures useful (usually they have some pseudocode). This project requires you to know what concurrency is and have a general knowledge of data structures.

Tutorials (if you get stuck):

Rust (concurrent hashmap): https://youtu.be/yQFWmGaFBjk?list=PLqbS7AVVErFj824-6QgnK_Za1187rNfnl
General: http://www.cs.tau.ac.il/~afek/ConcurrentDS-MS04.pdf

6. Create an Operating System

This one is a fun one! This project is all about creating your own operating system from scratch. For this project, I would recommend that you use a performant language like Rust, C, or C++ as creating an OS can slow your computer down a little. You could make this operating as simple or as complex as you like. Some extra features you could include are: basic built-in apps like Notes, QuickTime Player, or a text editor, multitasking, and more.

Tutorials (if you get stuck):

Rust: https://os.phil-opp.com/
C: https://github.com/cfenollosa/os-tutorial
C++: https://github.com/SamyPesse/How-to-Make-a-Computer-Operating-System

7. Image Encryption using AES Algorithm

I have to admit, this one is pretty cool, I'll definitely be doing this one for my next project! In this project, create an image encryption tool using the AES algorithm. I found this blog post really helpful for understanding the AES algorithm: https://www.tutorialspoint.com/cryptography/advanced_encryption_standard.htm. You could extend this project by using your image encryption tool in some web applications like an Instagram clone.

Tutorials (if you get stuck):

General: https://link.springer.com/article/10.1007/s11227-019-02878-7

8. Create a Text Editor

For this project, your goal is to create a fully functioning text editor. Some examples of text editors: sublime text, notepad++, and more. You could create a text editor which is mainly focusing on programming (syntax highlighting, keyboard shortcuts, etc) like sublime or just a regular notepad (more subtitle for beginners) like notepad++.

Tutorials (if you get stuck):

Rust: https://www.philippflenker.com/hecto/
Java: https://www.geeksforgeeks.org/java-swing-create-a-simple-text-editor/
C: https://viewsourcecode.org/snaptoken/kilo/
Python: https://www.codespeedy.com/create-a-text-editor-in-python/
C#: https://youtu.be/e_ychG719Fk

9. Create a Browser Engine

Create a fully functioning browser engine. Make this browser engine allow for HTML, CSS, and JS files. You could make this project as complex or as simple as you want. For this project, I would focus on the design aspect as that is a big factor when choosing which browser to choose.

Tutorials (if you get stuck):

Rust: https://youtu.be/brhuVn91EdY?list=PLJbE2Yu2zumDD5vy2BuSHvFZU0a6RDmgb
Java: https://youtu.be/anoPsxasIBE

10. Create a Cryptocurrency

For this project, create a cryptocurrency. Some examples of cryptocurrencies include: Bitcoin, Ethereum, Dash, etc. Like all the previous projects, you choose how deep you want to go into this project. If you want to add more advanced features such as smart contracts, mining, and more.

Tutorials (if you get stuck):

Rust: https://youtu.be/vJdT05zl6jk?list=PLwnSaD6BDfXL0RiKT_5nOIdxTxZWpPtAv
Python: https://www.freecodecamp.org/news/create-cryptocurrency-using-python/
Elixir: https://shyr.io/blog/writing-blockchain-elixir
Typescript: https://lhartikk.github.io/

These are some pretty big projects! If you complete any of them, I would love to know how it went! Good luck if you want to tackle any of these projects! Thanks for reading!

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

Cargo (Rust Package Manager) Cheatsheet

Henry Boisdequin — Tue, 26 Jan 2021 06:04:52 +0000

This is a practical cheat sheet to use when using the Rust package manager Cargo. A package manager allows you to install dependencies, update dependencies, modify your project, configure your project, and more. The best package manager for Rust is Cargo which was built by the Rust core team. Let's get right into the cheatsheet!

Installing and updating Cargo

Mac/Linux:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Windows:

Manually install here.

Note: This installs the whole Rust toolchain including cargo, rustup, and Rust itself.

Compiling from source:

git clone https://github.com/rust-lang/cargo

Note: This installs just cargo

Checking the installation process:

cargo --version

If this command executes, tells you cargo's version, without errors then cargo is successfully installed.

General Usage

cargo --version

Gives you the current version.

cargo --help [COMMAND]

Shows help message for the command specified.

cargo

Shows useful commands as well as a help message.

cargo --list

Lists all the available commands.

cargo --verbose

Enables verbose output. Use cargo -vv for more verbose output.

cargo --quiet

Disable output.

cargo --locked or cargo --frozen

Requires Cargo.lock to be up to date.

cargo --color WHEN

Enables colors: always, auto, or never.

cargo --offline

Prevents cargo from accessing the network.

cargo -z

Unstable, nightly-only flags to cargo.

cargo +toolchain

Overrides current toolchain with the toolchain specified (example: cargo +nightly switches to the nightly toolchain).

Creating a new Rust project

cargo new --bin NAME

Creates a new Rust project with the given name.

cargo new --lib NAME

Creates a new Rust library with the given name.

cargo init --bin

Creates a new Rust project in your current directory.

cargo init --lib

Creates a new Rust library in your current directory.

Using Cargo in your projects

cargo build or cargo b

Builds your Rust project.

cargo run or cargo r

Executes your Rust project.

cargo bench

Executes the benchmarks of your Rust project.

cargo test or cargo t

Executes the tests of your Rust project.

cargo check or cargo c

Checks for errors in your Rust project.

cargo doc

Creates your Rust project documentation (use cargo doc --open to open it).

cargo clean

Removes the target directory.

Using crates

cargo search

Searches for crates on crates.io.

cargo install CRATE

Installs the specified crate.

cargo install --list

Lists all the crates you installed.

Pushlishing your crate

cargo login

Logs in to your crates.io account.

cargo owner

Manages owners of your crate (add owners by using the --add flag).

cargo publish

Publishes your crate to crates.io.

cargo yank

Removes your crate from crates.io.

This is a practical cheatsheet on Cargo! I hope you learned a new command or more about Cargo. If you would like to access this cheatsheet, later on, I would recommend bookmarking this page or adding it to your reading list. Thanks for reading!

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

Weekly Update #3 - 24th Jan 2021

Henry Boisdequin — Sun, 24 Jan 2021 11:04:26 +0000

This is my third weekly update of 2021. I'm giving weekly updates to hold myself accountable for coding this year. My goals are outlined in the blog post linked below. Let's get right into it!

My 2021 Learning Plan

Henry Boisdequin ・ Jan 6 '21 ・ 2 min read

#javascript #python #webdev #bash

Weekly Update

This week, I dived deeper into Rust. I finished the "Crust of Rust" series by Jon Gjengset. This series taught me a lot about intermediate Rust concepts and writing Rust code "for real". I also dove into web programming with Rust. It was very interesting seeing the differences between API development with Rust, Node.js, Deno, and Flask. I thoroughly enjoy using Rocket and Diesel for web development. I plan to create a bigger project with this stack soon. I also started developing my own library/crate which will be a client for the Finnhub API which I enjoy using. One of my main focuses this week was open-source contributions. This week, I made several contributions to the open-source world. I found that doing open source is super rewarding and fun! I'll definitely be doing some more open-source.

Last week I said that I was going to be rebuilding my portfolio and to be honest, I really do need to do that, but Rust is way too much fun! Hopefully, I'll get around to doing that in the upcoming week. Overall, I think it was a successful week. For next week, I would like to at least start my own portfolio, get more progress in my Finnhub API client, work on my web development project with Rust, and maybe dip my toes into systems programming with Rust. Good things are ahead!

Thanks for reading!

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

How to Fetch a Web API with Rust 🦀

Henry Boisdequin — Mon, 18 Jan 2021 05:29:46 +0000

In this tutorial, I will be teaching you how to fetch a Web API asynchronously in Rust. This tutorial is for developers who know the basics of Rust, have Rust installed, and want to learn about asynchronous programming in Rust. If you don't have Rust installed you can download it here: https://www.rust-lang.org/tools/install.

What are we building?

In this tutorial, we are doing to be building a CLI stocks app. We would run our program and specify an argument: the company symbol. For example: cargo run AAPL would give us the price of the Apple stock. We are going to be using the Finnhub API for this project which is completely free. Let's dive right into it!

Setting up our project

Let's create a new Rust project and open it up in your favourite code editor (mine is VSCode).



cargo new stock-cli
cd stock-cli/

Your project should look like this:



├── Cargo.toml
└── src
    └── main.rs

Let's install our dependencies by typing this under the dependencies section in our Cargo.toml. Your Cargo.toml should look like this:



[package]
name = "stock-cli"
version = "0.1.0"
authors = ["Your Name"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
structopt = "0.3.21"
exitfailure = "0.5.1"
reqwest = { version = "0.11.0", features = ["json"] }
serde = "1.0.119"
serde_json = "1.0.61"
serde_derive = "1.0.119"
tokio = { version = "1.0.2", features = ["full"] }

I'll explain what these dependencies are along the way. Next, we need our API key. Go to https://finnhub.io/register and create an account. Once signed in, go to https://finnhub.io/dashboard and you should see your API key. Keep this open, we will use it in this project. With that out of the way, let's get into coding!

Coding our project

Let's first get the argument that the user passes. We can do that by using the standard library's env module. Your src/main.rs should look like this:



use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    println!("{:?}", args);
}

In this code, we are importing the standard library's env module, using the args() function to collect them, and printing them out in the debug format ({:?} means to debug the value). If you run this command: cargo run AAPL, should receive this:



["target/debug/stock-cli", "AAPL"]

As you can see, the value we are interested in is the 2nd element in the vector or the vector at index 1 (Rust is 0 indexed). Let's handle the scenario where a user doesn't enter an argument:

src/main.rs



use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    let mut company: String = "AAPL".to_string();

    if args.len() < 2 {
        println!("Since you didn't specify a company symbol, it is defaulted to AAPL.");
    } else {
        company = args[1].clone();
    }

    println!("{:?}", company);
}

As you can see, if the user doesn't enter the company symbol, it defaults to AAPL. Otherwise, the company is the argument they specified. If we run our program without any arguments, it should still work.

cargo run



Since you didn't specify a company symbol, it has defaulted to AAPL.
"AAPL"

Now, let's fetch the Finnhub API. The API endpoint we are using is /quote which returns the current stock price and some other details.

src/main.rs



use exitfailure::ExitFailure;
use reqwest::Url;
use serde_derive::{Deserialize, Serialize};
use std::env;

#[derive(Serialize, Deserialize, Debug)]
struct CompanyQuote {
    c: f64,
    h: f64,
    l: f64,
    o: f64,
    pc: f64,
    t: i128,
}

impl CompanyQuote {
    async fn get(symbol: &String, api_key: &String) -> Result<Self, ExitFailure> {
        let url = format!(
            "https://finnhub.io/api/v1/quote?symbol={}&token={}",
            symbol, api_key
        );

        let url = Url::parse(&*url)?;
        let res = reqwest::get(url).await?.json::<CompanyQuote>().await?;

        Ok(res)
    }
}

#[tokio::main]
async fn main() -> Result<(), ExitFailure> {
    let api_key = "YOUR API KEY".to_string();
    let args: Vec<String> = env::args().collect();
    let mut symbol: String = "AAPL".to_string();

    if args.len() < 2 {
        println!("Since you didn't specify a company symbol, it has defaulted to AAPL.");
    } else {
        symbol = args[1].clone();
    }

    let res = CompanyQuote::get(&symbol, &api_key).await?;
    println!("{}'s current stock price: {}", symbol, res.c);

    Ok(())
}

Make sure to replace "YOUR API KEY" with the API key in your dashboard. In this code, we are outlining the response which is the struct CompanyQuote. In the implementation of CompanyQuote, we have an asynchronous function called get which returns a Result with a CompanyQuote or an error. This function expects the company symbol and API key as parameters. First, we are formatting our URL to contain the symbol and API key. Next, we are parsing the URL and getting it using the reqwest module. We are awaiting the response and then turn it into JSON. The ? operator just means the same as unwrap. Finally, we are returning an Ok with the result inside of it.

Firstly, before the main function, we are putting this: #[tokio::main]. That means that we can use await in our main function. Towards the end of the main function, we are getting the company quote and passing the symbol and API key as parameters. We await the response and then (using the println! macro) we print out the current stock price. Then we return an Ok saying that everything went as planned.

You might be wondering, what does async and await mean?

Async/await

In this section, I will give you a quick overview of async and await.

Async - allows you to do await
Await - waits for the command to execute before moving on to the next command

Why do we need to wait for the command to execute?

Fetching a web API takes some time, as you can imagine. If we don't wait for the data to be fetched and then do something with the response (like turning it into JSON) we will get an error because the result is a future (waiting to fetch the data). Further reading on async/await in Rust can be found here: https://dev.to/gruberb/explained-how-does-async-work-in-rust-46f8.

Running the code

Let's run the code by running cargo run {the company symbol you want the stock price of} (I did cargo run TSLA). As you can see, it works (the stock price is at the time of writing this article)!



TSLA's current stock price: 826.16

I hope you learnt how to fetch an API with Rust and have a general understanding of async and await. More Rust tutorials coming soon! The final code is on GitHub. Thanks for reading!

henryboisdequin / stock-cli

A simple CLI app that gives you the current stock price of a company.

stock-cli

CLI app to get the current stocks for the company specified.

For: https://dev.to/hb/how-to-fetch-a-web-api-with-rust-1390

View on GitHub

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

Weekly Update #2 - 17th Jan 2021

Henry Boisdequin — Sun, 17 Jan 2021 10:19:51 +0000

This is my second weekly update of 2021. Two weeks ago, I made a post about my goals for 2021 and as promised, I will give you an update on how I'm doing. Let's get right into it!

My 2021 Learning Plan

Henry Boisdequin ・ Jan 6 '21 ・ 2 min read

#javascript #python #webdev #bash

Weekly Update

I would say that this week was the week of Rust. I dived into Rust much further, building some bigger projects and going into more advanced syntax. I started off the week by following an awesome tutorial which teaches you how to build a text editor in Rust. I extended this project by adding Python support for the text editor (which I named Lynx).

henryboisdequin / lynx

A basic text editor in Rust.

lynx

A basic text editor written in Rust. Lynx was made following this awesome tutorial and adding more features.

Current Features

Open/edit/save file
Syntax Highlighting - Rust, Python support
Warn when quitting editor without saving file

Todo

Open folder
Typescript, Javascript, TSX, JSX support
Copy and paste ability

Run Lynx

Make sure you have Rust, rustup, and cargo installed. You can do so here: https://www.rust-lang.org/tools/install.

Clone this repository

git clone https://github.com/henryboisdequin/lynx.git

Run the project

cargo run <file>

<file> is the file you want to edit in Lynx.

View on GitHub

I also learnt more about lifetimes, borrowing, and unsafe code in Rust. A couple of days ago, I found a YouTube channel which is very helpful for people looking to learn intermediate Rust. I mostly followed the "Crust of Rust" streams, looking at Lifetimes, macros, unsafe code, and more. I also experimented with using async/await and Tokio in Rust by building multiple CLI applications which fetch 3rd party APIs. Towards the end of the week, I created my own Git CLI tool in Rust which can initialize a repository, add files, and commit files.

henryboisdequin / git-cli

A git CLI tool which can initialize a repository, add files, and commit files.

git-cli

Created a git cli tool which can initialize a repository, add files, and commit files.

Usage

Clone this repository

git clone https://github.com/henryboisdequin/git-cli.git

Initialize a gitcli repository

cargo run init

Add the files you would like to add

cargo run add <files>

Commit the files

cargo run commit

View on GitHub

To finish off the week, I did some open source contributions for various different types of stuff. Overall, I think it was a successful week! For the upcoming week, I will focus on more Rust by building some more applications. Hopefully, I can also create a portfolio with Tailwind, and do some more open source contributions.

I also started my own newsletter, if you would like to get some more content from time to time, be sure to sign up!

Thanks for reading!

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

Snake Case vs Camel Case

Henry Boisdequin — Fri, 15 Jan 2021 02:34:33 +0000

Hello DEV Community!

I'm curious to know whether you prefer snake case or camel case? If you could create your own programming language would you have snake case or camel case as the standard? In case you don't know what snake/camel case is here is an example:

Python example (Python uses snake case):

def snake_case():
   print("Snake case is all words are separated by a '_'")

Javascript example (Javascript uses camel case):

const camelCase() => {
   console.log("Camel case is every word except for the first one is capitalized.")
}

Let me know which one you like best!

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

Top 5 IDEs/Code Editors for Web Development

Henry Boisdequin — Thu, 14 Jan 2021 06:38:35 +0000

I have curated a list of my top 5 favourite IDEs/Code Editors for web development. This list is my personal opinion. If you have another IDE/Code Editor you think should be on the list or higher/lower on the list, I would love to know in the comments. Firstly, I would like to address the difference between an IDE and a Code Editor.

What is an IDE/Code Editor?

IDE stands for Integrated Development Environment. IDEs usually come with more features (e.g. debugging, extensions, built-in terminal, and more). Think of an IDE as a code editor with superpowers.

A code editor is simply a place to write code. Usually, a code editor will only come with syntax highlighting and a few other minor features. As a code editor is lightweight and doesn't have too many features, I would definitely recommend it for a beginner or someone who doesn't want to install any heavyweight programs.

With that out of the way, let's dive right into my top 5 IDEs/Code Editors for web development.

5. Vim

My 5th favourite IDE/code editor for web development is Vim. Vim has the steepest learning curve on the list even though it is a code editor. This is because Vim has an endless amount of keyboard shortcuts to make you more productive while coding. At first, it can seem as though Vim is just a waste of time to learn but after you master the commands and keyboard shortcuts Vim has, it is the most productive editor on this list. I would highly recommend Vim for any developer looking to increase their coding productivity and is willing to spend a week or so learning how to use Vim. This is a great tutorial for getting started: https://youtu.be/IiwGbcd8S7I.

4. Sublime Text

At number four on this list is Sublime Text. Sublime Text is an extremely lightweight code editor which is blazing fast. Sublime Text has a beautiful user interface and little to no learning curve. Just download Sublime and you are up and running. Sublime Text is a great choice for any developer looking to get started with programming or a developer who wants a lightweight and fast editor.

3. Atom

My 3rd favourite IDE/editor is Atom. Atom is: "A hackable text editor for the 21st Century". This means that almost everything in Atom is customizable. One of my favourite things about Atom is its ecosystem. There are countless extensions/packages (e.g. themes, debugger, terminal) that you can get to increase your productivity when using Atom. Also, GitHub created Atom which means that it has flawless support for Git and GitHub. Atom would be a great choice for a developer looking for a customizable editor, all things you expect from an IDE, and flawless Git/GitHub support.

2. WebStorm

WebStorm is the most powerful IDE on this list. It has a built-in terminal, debugger, seamless tool integration, perfect unit testing, integration with VCS, and more. Why isn't number 1 you ask? WebStorm is a paid IDE ($129 USD per year). Since WebStorm is unaffordable for a lot of people, it's not first on this list. This doesn't mean that there is no use for WebStorm though! Try the 30-day free trial to see if you think it's worth the money. I would recommend WebStorm for any professional developers or anyone who is willing to spend the money.

1. VSCode

This one is no surprise. At number 1, we have VSCode. Like Atom, VSCode has all the features you would expect from an IDE and more. My favourite thing about VSCode is the extensions. There are tens of thousands of open-source, community-made extensions which you will love. VSCode is also very customizable and hackable. Also, if you love Vim, there is a Vim extension in VSCode where you have all the Vim commands inside a powerful IDE like VSCode. VSCode is also 100% free and open source! I would recommend VSCode to any developer!

This has been my top 5 IDEs/code editors for web development. If you have another IDE/Code Editor you think should be on the list or higher/lower on the list, I would love to know in the comments.

Recently I have hit 1500 followers on DEV! Thanks for all your support! Because of that, I have started my own newsletter where I will be posting some more web development, Python, and Rust content. Feel free to subscribe to my newsletter if you would like to receive that type of content! Thanks for reading!

Henry

📰 Newsletter
🐱 GitHub
🐦 Twitter

Rust: Initial thoughts

Henry Boisdequin — Tue, 12 Jan 2021 04:52:08 +0000

Recently, I have started to learn Rust. Why Rust you ask? Well, it's one of the best programming languages in each of these categories: performance, reliability, and productivity which we will discuss later. Also, coming from a Python/Javascript background, I thought it would be a challenge to learn a low level, statically typed language. Let's dive right into my initial thoughts on Rust and how it compares to other languages!

Learning Rust

Before I started learning Rust, I thought that it would be hard to get started and I was even wondering if I would be able to find good resources to learn Rust. I was wrong, big time. There are countless resources for learning Rust. I decided to take a Udemy Course and follow the offical Rust Programming Language book. The Udemy course and book were awesome! I would highly recommend looking at both when you're learning Rust. After that, I decided to play around with Rust, creating a simple command-line calculator application. To conclude, ~~learning~~ getting started with Rust is as simple as ~~learning~~ getting started with Python.

Rust is hard to learn

Rust is hard to learn because its a low-level programming language. If a programming language is considered a low level, it means that the language provides little difference from a computer's set architecture or in simpler terms it's closer to machine code (basically 0s and 1s). Especially coming from a high-level programming language background, Rust was not something I was used to. Learning about lifetimes, borrowing, and more (memory management) was something I didn't even have to look at in Javascript or Python. But being a low-level programming language comes with its perks.

Rust is extremely powerful

There is a reason why some programming languages (particularly targetted towards speed) are low level. To put it simply: since low-level languages are closer to machine code it's faster for them to compile to machine code and get executed then higher-level programming languages. Aside from being low-level, Rust also has some more very powerful features which make it memory safe, fast, and a productive environment. Let's have a look at these features.

Rust is fast

Rust is fast for two main reasons: it's statically typed and there is little to no overhead (garbage collection). I will get into garbage collection in a little bit but first I want to talk about how Rust is statically typed and compiled. Being statically typed and complied means that a type of a variable is known at compile time (before running your code). This means that instead of figuring out the type of your variable at run time, all Rust needs to do is execute your code. This is one less step needed at run time which makes Rust that much faster than other dynamically typed languages like Python or Javascript. Let's have a look at an example:

fn main() {
  let message: &str = "Hello World";
  println!("{}", message);
}

As you can see, in the main function, we are defining a variable which has a type of &str. Instead of trying to figure out the type at compile-time, Rust already knows that our message is of type &str. Let's have a look at the equivalent in Python:

def main():
  message = "Hello World"
  print(message)

main()

As you can see, we don't provide a type for our message variable hence the variable type is unknown until the program runs.

No garbage collection

Next, I want to talk about garbage collection. Most languages which are memory safe use a garbage collector to achieve this. What is a garbage collector? A garbage collector attempts to reclaim memory occupied by objects which are no longer used by the program. This prevents memory leaks and memory issues. This is how languages like Python, Javascript, or Java achieve memory safety. It's not all pros with a garbage collector. Having a garbage collector in your programming language makes it slow. Why is it slow you ask? For a garbage collector to collect its garbage, it stops the program, does its tasks, and then the program continues. As you can see, it stops to ensure memory safety which is why it is slow. Instead of implementing a garbage collector, Rust implements a concept called ownership. There are 3 rules to ownership in Rust:

Each value in Rust has a variable that’s called its owner.
There can only be one owner at a time.
When the owner goes out of scope, the value will be dropped.

If one of these rules is not followed at any given time, the program will stop which eliminates all memory safety issues. Let's have a look at an example:

fn main() {
  let var = 1;
  {
    let var1 = var; 
  }
  println!("Var: {}, Var 1: {}", var, var1);
}

In this example, we are defining a variable called var and variable called var1. Since var1 is defined in another scope and its value is var, var is no longer valid (rule 3), hence this program results in an error.

The compiler is my best friend

The Rust compiler output is beautiful. It doesn't only tell you what the problem is, it tells you how to fix it. No more sleepless nights waiting for a response on StackOverflow, just implement what the compiler tells you what to do and no more bugs.

Should you learn Rust?

Rust is definitely something worth looking at. Even if you don't plan to use Rust for your future projects, for any developer coming from a higher-level programming language background to have a look at Rust. With that said, now I will be focusing on backend web development with Rust. Who knows, it might replace my Node.js backend (I'll keep you posted).

In conclusion, my experience thus far with Rust has been awesome. I would highly recommend playing around with Rust. Thanks for reading.

Henry

Weekly Update #1 - 10th Jan 2021

Henry Boisdequin — Sun, 10 Jan 2021 09:09:31 +0000

Hello! This is my first weekly update of 2021! Around a week ago, I posted an article specifying my goals for 2021:

My 2021 Learning Plan

Henry Boisdequin ・ Jan 6 '21 ・ 2 min read

#javascript #python #webdev #bash

As promised, I will be giving weekly updates on my progress and how you can learn these stuff too. Let's dive right into it!

Weekly Update

I started off 2021 very strong, knocking a couple of things off my list. Firstly, I played around with Node.js, Typescript, Svelte, authentication with Passport.js, and JWTs by creating a VSCode extension. Since all these things weren't that new to me, it wasn't that hard to create a project with these technologies. Next, I decided that I wanted to learn Rust. Why Rust you ask, well its memory safe and FAST (like close to C++ fast). Also, Rust is a low level, statically typed language which I thought would be a challenge to learn coming from a Python, Javascript background. I took this course on Udemy, learning the basics of Rust and creating my own HTTP server from scratch. After 2 days of following that course, I wanted to experiment with the language further. I created my own command-line calculator in Rust (GUI tutorial coming soon).

henryboisdequin / rust-calculator

Simple command-line calculator in Rust.

To Run

Clone this repository
Make sure you have Rust and cargo installed
Cd into the project directory and type cargo run
To test: run cargo test

View on GitHub

Overall, I think it was a successful week! Next, I will focus on getting a better grasp on the Rust syntax and start experimenting with it further. Thanks for reading!

Henry