
#### Introduction
Welcome to my blog post! Today, I am excited to share an intriguing project that involves the development of software for a drone delivery service on college campuses. Our aim is to create a scalable and efficient solution for on-campus deliveries using drones, starting with the University of Michigan (UM) and expanding to other campuses.

In this project, we focus on two types of drones: Drone Type I, which is ten times faster but requires drone director beacons for control, and Drone Type II, a regular drone with proportional energy usage. Our goal is to optimize drone delivery routes and cater to the unique requirements of different clients (A, B, and C).

Using MST algorithms, TSP heuristics, and visualization tools, we tackle challenges such as minimizing costs, optimizing beacon placement, and finding efficient delivery routes. Join me as we delve into the technologies utilized, project details, and the remarkable achievements we have accomplished along the way. Let's explore the world of drone deliveries and the power of algorithmic optimization in enhancing on-campus delivery services.

#### Technologies Utilized
To ensure effective drone delivery services, we employed a range of technologies. Here are some of the key technologies used:

MST Algorithms: We implemented Minimum Spanning Tree (MST) algorithms, such as Prim's algorithm and Kruskal's algorithm, to determine the optimal placement of high-speed drone beacons. Our analysis of each algorithm's efficiency in specific scenarios guided us in choosing the most suitable approach.

Branch and Bound Algorithm: In addition to MST algorithms, we implemented a Branch and Bound algorithm. This algorithm played a pivotal role in finding fast and effective bounding approaches, optimizing the drone delivery routes.

TSP Heuristics: To achieve nearly-optimal solutions quickly, we explored various TSP (Traveling Salesperson Problem) heuristics. By leveraging these heuristic approaches, we were able to provide efficient delivery routes for the drones. Extensive web searches enabled us to discover TSP heuristics with better-than-O(n^2) complexity.

#### Project Overview
The core of our project revolves around creating a software solution for on-campus drone deliveries. We developed two types of drones to cater to different needs:

Drone Type I: This high-speed drone moves ten times faster than other drones, enabling rapid delivery. However, to ensure proper control, it requires the installation of drone director beacons along the flight path. The cost of installing these beacons is directly proportional to the desired path's distance, and our clients aim to minimize beacon costs.

Drone Type II: This drone is similar to regular drones available on the market. Its energy usage is directly proportional to the distance it travels.

We categorized our clients into three types: A, B, and C, each with different requirements and tasks. To address these diverse needs, we divided the project into three parts.

Part A: MST Mode
In Part A, our primary goal was to devise an optimal path for placing high-speed drone beacons while minimizing the total distance and cost. To achieve this, we implemented an MST algorithm to connect all the campus locations. We took into account the boundary between the medical campus and other locations, ensuring that the MST did not directly connect a medical campus location to one outside without passing through a location on the border.

The output of Part A included the total weight of the MST, representing the sum of the weights of all edges in the MST. Additionally, we printed all the edges in the MST, showcasing the connections between the campus locations.

Parts B & C: FASTTSP & OPTTSP Modes
In Parts B and C, our focus shifted to solving the Traveling Salesperson Problem (TSP) to determine the optimal delivery route. The route begins at location index 0, visits every other location exactly once, and returns to the starting location.

Part B (FASTTSP mode): We implemented TSP heuristics to provide a solution that is close to optimal. Although not perfectly optimal, our solution aimed to be highly efficient and significantly faster than finding the exact optimal solution.

Part C (OPTTSP mode): We employed algorithms to find the optimal solution to the TSP, ensuring the minimum Euclidean distance necessary for the delivery route.

By incorporating MST algorithms, TSP heuristics, and optimization techniques, we developed efficient delivery routes for both Drone Type I and Drone Type II, addressing the specific requirements of our diverse client base.

#### Highlighted Achievements

Scalable Drone Delivery System: We successfully developed a scalable software solution for on-campus drone deliveries, tailored to the requirements of different client types.

Optimal Beacon Placement: By implementing MST algorithms and a Branch and Bound algorithm, we determined the optimal placement of high-speed drone beacons, effectively minimizing the total distance and cost.

Efficient Delivery Routes: Leveraging TSP heuristics, we created fast and near-optimal delivery routes in Part B (FASTTSP mode). In Part C (OPTTSP mode), we employed algorithms to find the optimal routes, ensuring efficient drone deliveries.

Visualization and Debugging: Utilizing visualization tools, we gained valuable insights into the efficiency and accuracy of our algorithms, enabling effective debugging and refinement of the drone delivery routes.

This project provided me with valuable experience in developing scalable software solutions, implementing optimization algorithms, and utilizing heuristic approaches to tackle complex problems. We take pride in presenting this innovative drone delivery system that caters to the needs of different clients, ensuring efficient and accurate deliveries on college campuses.

Drone Delievery Using TSP & MST


#### Introduction

In this project, I built a scalable search engine in Python, utilizing concepts such as PageRank and TF-IDF. The search engine was designed to handle large amounts of data and provide accurate search results. The project focused on information retrieval concepts, parallel data processing using MapReduce, and creating a service-oriented architecture for scalability.The Scalable Search Engine project demonstrated the utilization of Python and Flask to build a powerful search engine. By incorporating information retrieval techniques and parallel data processing, I developed a search engine capable of handling large amounts of data efficiently. This project enhanced my understanding of search engine architecture, data indexing, and user interface design.

#### Technologies Used

- Python: The search engine was built using Python, leveraging its capabilities for efficient data processing and algorithm implementation.
- Flask: Flask, a lightweight web framework, was used to create the REST API backend and the HTML search interface for displaying search results.

#### Project Details

The goal of the project was to create a scalable search engine similar to Google or Bing. The key components of the search engine were:

1. **Segmented Inverted Index**: I implemented a pipeline of MapReduce programs to parse and index over 30 MB of Wikipedia pages. This allowed for efficient storage and retrieval of information.

2. **Index Server**: I built an Index server that served as a REST API app. It handled user search queries and returned search results in JSON format. The server utilized Flask to handle the routing and communication with the search backend.

3. **Search Server**: The Search server provided a user interface similar to Google or Bing. It accepted user search queries and displayed the search results in a user-friendly manner. The server communicated with the Index server to retrieve the relevant search results.

By combining the segmented inverted index, the Index server with a REST API, and the Search server with a user-friendly interface, I created a working search engine capable of handling large amounts of data and returning accurate search results.

#### Highlighted Achievements

- **Scalable Search Engine**: Built a scalable search engine in Python, incorporating concepts like PageRank and TF-IDF for accurate search results.
- **MapReduce**: Utilized MapReduce to efficiently parse and index over 30 MB of Wikipedia pages, enabling faster retrieval of information.
- **Flask Integration**: Designed an HTML search interface and implemented a REST API backend using Flask, allowing for seamless communication between the user interface and the search engine backend.

This project provided hands-on experience in information retrieval concepts, parallel data processing, and building scalable web applications. By combining Python, Flask, and MapReduce, I successfully built a search engine capable of handling large datasets and delivering accurate search results.


Scalable Search Engine - Python, Flask


I have built an impressive Instagram clone using client-side dynamic pages and a REST API. By leveraging JavaScript programming, asynchronous programming (AJAX), and REST APIs, I have developed a client application that runs in the browser and communicates with the server to fetch and update data. Building this Instagram clone with client-side dynamic pages has been an exciting and rewarding personal project. By utilizing technologies such as JavaScript, AJAX, and REST APIs, I have expanded my skill set in modern web development. This project has strengthened my understanding of client-server architecture and equipped me with valuable knowledge for creating interactive web applications.

#### Technologies Utilized:

For this project, I have explored and implemented the following cutting-edge technologies:

1. Client-side Dynamic Pages: I have utilized client-side dynamic pages to create a seamless and interactive user experience. By manipulating the Document Object Model (DOM) using JavaScript, I have achieved dynamic content updates without the need for page reloads.

2. JavaScript Programming: To power the client application, I have extensively employed JavaScript, a powerful scripting language widely used in modern web development. This has allowed me to bring interactivity and responsiveness to the Instagram clone.

3. Asynchronous Programming (AJAX): With the help of AJAX, I have implemented asynchronous requests to the server, enabling smooth and efficient communication between the client and the REST API. Asynchronous programming ensures that user interactions are not blocked while waiting for server responses.

4. REST APIs: By building a RESTful API, I have established a standardized way for the client application to interact with the server. This has facilitated seamless data retrieval and manipulation, ensuring a cohesive user experience.

5. Command-Line Proficiency: Throughout the development process, I have honed my command-line skills, efficiently managing the project and executing various commands required for development, testing, and deployment.

#### Project Overview:

In this personal project, I embarked on building an Instagram clone with a focus on client-side dynamic pages. To kickstart the development, I reused server-side code from a previous project, refactoring it into a REST API. This allowed me to separate concerns between the client and server, enabling smoother data retrieval and manipulation.

The client application, developed in JavaScript, communicates with the REST API using AJAX calls. This ensures efficient and real-time updates, delivering an engaging user experience. By implementing client-side dynamic pages, I have achieved dynamic content rendering without reloading the entire page.

Through this project, I aimed to enhance my skills in client-side web development, JavaScript programming, asynchronous programming, and REST API integration. The result is a fully functional Instagram clone that mirrors the main functionalities of the original application, providing a rich and interactive experience for users.


Building an Instagram Clone with Client-Side Dynamic Pages


#### Introduction
In this project, I developed a MapReduce server in Python, inspired by Google's original MapReduce paper. The server executes user-submitted MapReduce jobs with multi-server capability, enabling distributed processing on a cluster of computers. The project aimed to provide hands-on experience with MapReduce program execution, basic distributed systems, fault tolerance, OS-provided concurrency facilities, and networking using sockets. The MapReduce server project showcased the utilization of Python to build a distributed data processing framework. The implementation of multi-server capability and fault tolerance demonstrated my ability to tackle challenges in distributed systems. Through this project, I gained hands-on experience in MapReduce program execution and acquired a deeper understanding of the concepts behind distributed computing.

#### Technologies Used
- Python: The MapReduce server was implemented using Python, leveraging its powerful features for efficient data processing and networking.

#### Project Details
The MapReduce framework consists of two major components: a Manager and multiple Workers. The Manager listens for user-submitted MapReduce jobs and distributes the workload among the Workers. Each Worker receives instructions from the Manager and executes map and reduce tasks, collectively forming a MapReduce program.

To interact with the MapReduce server, a command-line interface was implemented. Users can submit their MapReduce jobs by providing the necessary input files and configuration parameters through the command line. The Manager then distributes the tasks to the Workers, which execute the program in a distributed manner.

#### Highlighted Achievements
- **MapReduce Server**: Developed a MapReduce server in Python to execute user-submitted MapReduce jobs with distributed processing.
- **Multi-Server Capability**: Implemented multi-server functionality using multi-threaded TCP and UDP sockets for effective master-worker communication.
- **Fault Tolerance**: Added fault tolerance functionality to enhance program resiliency in case a worker unexpectedly terminates.

This project provided valuable insights into MapReduce program execution, distributed systems, fault tolerance, concurrency facilities, and networking using sockets. By leveraging Python's versatility, I successfully implemented a MapReduce server capable of executing complex data processing tasks on a cluster of computers.


software-engineering

Drone Delievery Using TSP & MST

Scalable Search Engine - Python, Flask

Building an Instagram Clone with Client-Side Dynamic Pages

MapReduce Server - Python