DEV Community: Frank Lawrence

Building a Rust Crate Recommender:

Frank Lawrence — Sun, 16 Mar 2025 20:16:56 +0000

Introduction

Finding the right libraries (crates) in Rust can be time-consuming. To solve this, I built a Rust Crate Recommender, a command-line tool that helps developers discover and save Rust libraries based on keywords. This project aligns with the Codecademy Recommendation Software Project, requiring skills in data structures, algorithms, Git version control, and command-line navigation.

In this blog, I’ll walk you through the design, implementation, and skills used to build this project, as well as how it can be extended further.

Project Overview

What Does This Program Do?

Users enter a keyword (e.g., async, web, database).
The program fetches matching Rust crates from crates.io (Rust’s package registry).
It displays results, including:
- Crate name 📌
- Description 📖
- Download count 📥
- Documentation link 🔗
Users can select dependencies, which are saved to a file (dependencies.txt).
The program continues running until the user decides to exit.

This tool helps Rust developers quickly find and store useful crates instead of manually searching crates.io.

Key Features & Implementation

1️⃣ Storing Data in a Data Structure

We use a Vec<CrateInfo>** (vector of structs)** to store fetched crate data.
Each crate is represented as a struct:

  #[derive(Debug, Deserialize)]
  pub struct CrateInfo {
      pub id: String,
      pub description: Option<String>,
      pub downloads: u64,
      pub documentation: Option<String>,
  }

This allows for fast iteration, sorting, and filtering of the results.

2️⃣ Using an Algorithm to Sort and Search Data

The results are sorted by downloads (highest first) using Rust’s built-in sort_by():

  crates.sort_by(|a, b| b.downloads.cmp(&a.downloads));

Users can filter results based on available documentation.

3️⃣ Implementing User Interaction (Command-Line Navigation)

The program runs continuously, prompting the user for input until they exit.
Users select crates using numbered options, and their selections are saved.

Example interaction:

Enter a keyword to search for crates (or 'exit' to quit): web

Recommended Rust Crates:
1. tokio - An async runtime for Rust (287M downloads)
   📖 Docs: https://docs.rs/tokio
2. warp - A web framework for async Rust (98M downloads)
   📖 Docs: https://docs.rs/warp

Enter the number of a crate to add to your dependencies: 1
Added 'tokio' to your dependencies.

4️⃣ Saving Data for Future Use

The program stores selected dependencies in dependencies.txt:

  fn save_dependencies(dependencies: &[(String, String)]) {
      let mut file = OpenOptions::new()
          .create(true)
          .append(true)
          .open("dependencies.txt")
          .expect("Failed to open file");

      for (crate_name, doc_link) in dependencies {
          writeln!(file, "{} - Documentation: {}", crate_name, doc_link)
              .expect("Failed to write to file");
      }
  }

This allows developers to keep track of their selected crates.

Skills Demonstrated in This Project

✅ 1. Data Structures & Algorithms

Vector (Vec<CrateInfo>) for storing crate data.
Sorting algorithm (sort_by()) to rank results by popularity.
Filtering (retain()) to remove crates with missing descriptions.

✅ 2. API Requests & JSON Handling

Uses reqwest to fetch data from crates.io:

  let response = reqwest::get(&url).await?.text().await?;
  let crate_response: CrateResponse = serde_json::from_str(&response)?;

Parses JSON using serde to extract relevant information.

✅ 3. Git Version Control

The project was managed using Git with regular commits.
The repository is available on GitHub.

✅ 4. Command-Line & File Navigation

Uses standard input (io::stdin) for user interaction.
Writes to a file (dependencies.txt) to store user selections.

Possible Future Improvements

Although the current implementation works well, here are some potential enhancements:

🔍 Fuzzy Search → Improve keyword matching for better recommendations.
📂 Auto-Add to Cargo.toml → Instead of a text file, directly modify Cargo.toml.
📊 Pagination for Large Results → If many crates match, allow users to scroll through pages.
⏩ Caching API Responses → Avoid repeated API calls for the same search.

Building this Rust Crate Recommender was a great way to apply Rust programming concepts, including:

Working with APIs (reqwest)
Handling JSON (serde)
Sorting & filtering data
Writing interactive CLI applications
Using Git for version control

Future Innovators Scholarship: How E-Waste Recycling Can Transform Rural Communities

Frank Lawrence — Thu, 06 Feb 2025 23:38:04 +0000

Addressing the Growing Issue of E-Waste

I come from a small rural town where access to technology and awareness of e-waste management are limited. As a result, electronic recycling processes are nearly nonexistent, and outdated technology is often discarded improperly. Without structured disposal methods, harmful waste builds up in landfills, contributing to environmental pollution and wasted resources.

The rise of digital learning and rapidly evolving technology means that communities like mine need a sustainable approach to handling old electronics before it becomes a major issue. A proactive, community-driven initiative could bridge the digital divide, educate people on e-waste disposal, and repurpose technology for those who need it most.
A Community-Based E-Waste Recycling Solution

A structured e-recycling program could be implemented through existing public spaces, such as libraries or schools, to collect, clean, and redistribute functional electronics. Volunteers could assist in sorting and refurbishing devices, ensuring that technology remains useful for those who need it.

For unclaimed devices, we could partner with organizations like TechWaste Recycling to properly dispose of them. This approach would help prevent:

✅Unnecessary landfill waste from discarded electronics
✅Toxic environmental contamination from improper disposal
✅Wasted opportunities to repurpose working technology for students and low-income families

Barriers to E-Waste Recycling & How We Overcome Them

One of the biggest reasons e-waste is improperly discarded is inconvenience. People often don’t know where or how to recycle their electronics, leading them to either store unused technology indefinitely or throw it out improperly.

Additionally, digital security poses another challenge. Many individuals, particularly in rural areas, are unaware of the risks of discarding devices with intact hard drives. A lack of understanding about digital footprints could leave sensitive personal information vulnerable to identity theft or data breaches.

A well-structured program could:

✅ Educate the community on secure e-waste disposal
✅ Provide data-cleansing resources to prevent security risks
✅ Create an accessible drop-off system to make recycling easier

By offering clear disposal guidelines and digital security workshops, we can reduce hesitation in recycling electronics while increasing community engagement.

Impact on Education & Digital Equity

Beyond environmental benefits, this initiative would address a key issue: accessibility to technology.

Students in rural and low-income communities often struggle with digital learning due to a lack of personal computers or tablets. As technology becomes increasingly essential in education, many students fall behind simply because they lack the resources to complete assignments or engage in online learning.

By redistributing refurbished technology, we could:

✅ Give students access to necessary digital tools
✅ Reduce financial barriers for families in need
✅ Normalize tech-sharing and sustainability

The Role of Volunteers & Skill Development

A program like this doesn’t just benefit the environment—it could also empower community members by providing hands-on experience with technology repairs, data security, and logistics management.

Volunteers—especially students—could gain:

🔹 Experience in refurbishing and repairing hardware
🔹 Knowledge of cybersecurity best practices
🔹 Project management and organizational skills

These skills could open doors to career opportunities in IT, cybersecurity, and environmental technology, creating a long-term impact beyond just recycling efforts.
Why I’m Committed to This & How This Scholarship Helps

I believe in leading by example, which is why I have already taken the first step toward implementing this initiative. I have offered to volunteer at my local library, where I hope to establish a pilot version of this program and gather community interest.

My passion for technology and sustainability has driven my academic journey. I have worked full-time while pursuing my education, completing my Associate’s Degree at Bellevue University, an intensive Full-Stack Web Development Bootcamp at Colorado Technical University, and now, working toward my Bachelor’s Degree in Computer Science at Southern New Hampshire University, where I currently hold a 4.0 GPA.

Balancing school, work, and personal responsibilities has been challenging, and financial strain has often determined how many courses I can take per semester. Winning this scholarship would provide the financial support I need to stay on track and graduate by June 2026.

More importantly, this scholarship would allow me to focus on expanding this initiative, turning an idea into real, measurable change. With the proper credentials and financial backing, I hope to grow this project into a fully developed program that can be replicated in other rural communities.
Building a Sustainable Future Together

E-waste isn’t just a local issue—it’s a global problem. However, by creating accessible, community-led programs, we can:

🌱 Reduce environmental impact by properly recycling electronics
💻 Bridge the digital divide by repurposing technology for those in need
🔧 Equip future innovators with tech repair and data security skills

What starts as a small community-driven effort could become a model for other towns facing similar challenges. I am excited about the potential of this program and grateful for the opportunity to apply for this scholarship, which would help me continue my education and push this initiative forward.

This essay is submitted as part of my application for the Future Innovators Scholarship from TechWaste Recycling. If you're interested in learning more or applying yourself, visit TechWaste Recycling’s Scholarship Page.

Battleship.... in the Terminal!

Frank Lawrence — Wed, 15 May 2024 18:53:41 +0000

I have been slowly chipping away at Codecademy's Computer science course over the last few weeks and tackled my first project of the course in the shape of a python script that lets a person battle against the computer component in the classic board-game 'Battleship'.

It was a rewarding challenge to brush up on my Python skills and implement modularization to keep this project manageable during the two weeks of development.

Programming a game in the terminal had its own unique set of challenges, the primary being a visual representation of the state of the game so that the player could easily follow along without losing track of their progress.

I'm particularly proud of the board representation I created using a matrix data structure. It effectively represents the rows and columns of the board, along with alphabetical characters to denote ships and actions that have occurred on each coordinate.

When I initially started the project, I didn't do any coding until I had vision of how the board would be rendered in a read-able manner. Thanks to the library termcolor - termcolor. Making my script render the board with color representations made my vision truly pop.

The second aspect that I am happy with is the function I wrote within the gameFunctions.py, titled boat_spawn() which upon the start of the game randomly places the boats within the matrix following the standard battleship rules of no overlapping boats and no diagonal placements. This functions removed the struggle of the player having to manually enter coordinate by coordinate instructions of where they wanted their boats placed and instead gets the player immediately set into the heat of the game.

Lastly, I needed to design the computer opponent with an aggressive tendency on their turns when they had recently hit a target instead of consistently randomly generating attack coordinates. This aggression would simulate a second real player that would follow up with investigative shots toward successful attacks. This logic can be found in player.py and in the method titled, computer_turn_initiate(self). This method takes the last four attack calls the computer has made and checks it against the array of existing successful hits. The computer then randomly selects from the four possible adjacent indexes within the matrix data structure. While not not perfect in design, this simple solution adds enough depth to the computer opponent and keeps the game interesting.

I'm very happy to be done with this project and continue my Codecademy course but I do plan on re-visiting and flushing out this project some more with a true multiplayer feature one day allowing two people over the internet to battle it out!

If you have any questions feel free to reach out and check out the repository over @ github