This repository is a consolidation of all monthly sprint project assignments I completed over nine months as a student at BloomTech.
A high level description of each project is outlined below with links to the project's GitHub repository.
The specific assignments for each project can be found in the sub-repository's README or DESIGN_DOC
There is also one sprint project left off this list because it focused more on the frontend. The project repository can be found here
Description:
Designed backend architecture that can select an ad for a given user profile based off which targeting group the user belongs to. Generating the advertisement is accomplished by evaluating a list of user targeting predicates against a group of targetable users and then sorting the results by click-through rate. The service has the ability to process the predicates in parallel. If necessary, the service can wait for response data to finish processing before returning a generated ad.
- Gained experience handling big data concurrently
- Implemented asynchronous request and response objects
- Composed future object chaining
- Worked with dependency injection at a large scale with Google Dagger
- Ensured proper communications between multiple data access objects
- Handled optional values in a relational database
- Optimized network I/O performance with concurrent processing
- Designed a nifty console logger to keep track of various future objects stages and execution times
Description:
Implemented logic for a service that can publish a book to a Kindle account. The service accounts for both an Author account, and a User account. Integrated with DyanmoDB, the service is designed to be scalable, with ability to process a queue of publishing requests
- Assembled DynamoDB queries from incoming request objects
- Distributed HTTP requests with an Application Load Balancer using AWS EC2
- Integrated and configured Docker with AWS EC2
- Setup the service to run the Docker container for each instance needed by the Load Balancer
- Routed HTTP requests using RESTful best practices
- Implemented Spring RESTful controllers to convert the payload of incomming requests into an internal data structure
- Integrated I/O performance monitoring with Micrometer and Prometheus
- Preserved order of incomming HTTP request processing by implementing a Queue combind with Java CompletableFuture objects
Description:
Created an API with GET, POST, DELETE, and UPDATE functionality. The Application also integrates with AWS DynamoDB for storage of user's data.
- Gained experience programming a RESTful API from scratch
- Provided DynamoDB utilities for CRUD operations with AWS lambda functions and dependecy injection
- Setup table structure and data model for DynamoDB
- Worked with unordered hash indexes in DynamoDB with range and hash primary key attributes
- Implemented dependecy injection on a project from scratch
- Designed a song order Enum capable of defining Comparator sorting functionality from arguments passed in
- Configured AWS APIGateway endpoints for playlist retrieval and creation
- Wrote unit tests which required mocking the database
Description:
Implemented a service that can calculate the cost of a shipment based on the weight of the item and the material used for packaging the shipment. The finished project provides modular shipment recommendations to a shipment fulfillment center.
- Gained experience implementing essential data structures
- Worked with hash table buckets and object hashing to efficiently store and retrieve data
- Implemented hash functions and hash table collision resolution
- Created an Interface for shipment cost calculations that provides calculations of the cost of different materials
- Structured Java class Inheritance and hierarchy
- Learned how to preserve an object's internal state while exposing only what's necessary
- Created custom Exception classes for specific error conditions
- Used interface and abstract class design patterns to properly structure java classes
Description:
Implemented a service that can fulfill orders for a customer and communicate it through a "promise" back to the client (in this case the client was a call center command line interface). This was one of the first projects in the course and was a great opportunity to learn about how a backend can maintain a high level of abstraction between servers and clients.
- Worked extensively with java Collections and iterating over them
- Handled communications between data access objects and business logic classes
- Followed best practice Builder design patterns
- Implemented Comparator Interface to sort order objects by comparable traits
- Learned conceptual use of mutability/immutability of collections and objects
Description:
Implemented a text adventure game that allows the user to explore a world in text format. The game is designed to be played in a terminal window. The user can move around the world and interact with items, places, and creatures. This was the first project of the course, and was a lot of fun.
- Learned Java fundamentals and object-oriented design principles