This is a journal that will track my progress throughout the summer!

This week, I started my DREU program at the University of Illinois Urbana-Champaign. We spent the first two days reading papers on probabilistic roadmaps and how they are used in motion planning. The papers were very dense with information, but it was really interesting reading about how motion planning is applied to various fields and problems. Afterwards, we worked on familiarizing ourselves with the PMPL code base. We used the Parasol Motion Planning Library (PMPL) and vizmo to generate roadmaps and visualize the nodes and edges of the generated roadmaps.

Overall, we've finished part 1 of the motion planning crash course and have started part 2. It's been a vigorous and fast-paced first week, but I've enjoyed learning about motion planning and probabilistic road maps.

Week 2 flew by in a blink of an eye. This week, we cruised through the remainder of the crash course. We finished parts 2, 3, 4, and 5. It's been a productive week of learning about different types of sampling methods and familiarizing ourselves with the PMPL code and made multiple models and roadmaps. On Wednesday and Thursday, we implemented expansive-space trees (ESTs) through the provided crash course instructions. On Friday, we optimized our previous EST code using our own original ideas. I tried to optimize the ESTs so that each individual tree would only choose nodes that were closer than the distance between the goal node and the start node. This allowed the trees to generally grow towards each other and spend less time exploring areas that may not be as useful.

It's been a long week with a lot of dense material, but we're finally done with the crash course and ready to move onto our individual projects. I'm very excited to be assigned a project and to learn what I'll be doing in the following weeks!

This week we were assigned our projects! I will be working with James Motes on Multi-Agent Multi-Task Planner (MAMTP). I spent most of this week familiarizing myself with the Interaction Template (IT) Method and understanding the project. For the remainder of the summer, I will be working on trying to find a solution to motion planning problems where multiple tasks are assigned multiple robots. When there are multiple collaborating robots, it becomes difficult to plan tasks without collisions or delays. I decided to try and take a dynamic programming approach where the results of a Dijkstra's search are stored and manipulated in a table. So far, I have created a dynamic programming table that stores the contents of a Djikstra's search. However, in the following weeks I will need to account for how the table needs to be manipulated when edges and vertices are added and removed from the roadmap.

I'm enjoying the project I've been assigned to. I look forward to working more with the IT method and hopefully finding a solution to the MAMTP problem. This week was a bit slower than the previous weeks, but hopefully it will pick up speed as I become more comfortable with the material and method code.

This week I worked more extensively on the dynamic programming table that implement Dijkstra's algorithm. I spent the first part of the week working on refactoring and accounting for various edge cases with my previously implemented DP table. For the remainder of the week, I worked on trying to move my algorithm into the IT method. This was more difficult than I expected. Due to my unfamiliarity with the code and the organization of the code, it is difficult to find which functions I need to use, where to find examples of them, and how to use them. Most of my time for the last few days was spent familiarizing myself with the code in the branch and testing various snippets of code.

It's been a very slow week. I've spent a lot of time trying and testing various bits of code. The amount of work I have to show seems very disproportionate compared to the time I spent on the work. I'm still not very comfortable with the contents of the method's code.

This week I finished moving DP Dijkstra into the IT method. It was a lot smoother than the previous week because James returned from his fancy vacation. This took up the first two days of the week. For the remainder of the week, James and I planned out our future work on conflict-based searches. We plan to use conflict-based search to replan tasks if their resources overlap with each other. We spent Wednesday and Thursday mapping out the necessary components for implementing conflict-based search. Afterwards, I spent the reminder of my time implementing various classes and methods. I struggled a bit with C++ syntax, but hopefully I'm learning from my mistakes and I can spend less time debugging my code.

This week I worked more on further developing the CBS code. As I've been working through the code, we've been adding more and more to the classes we previously created. I am currently working on debugging the code I've written this week before I finish the CBS code. I've been running into some weird issues as I've been working through the code where the compiler does not recognize changes that have occurred since the previous compilation. This has been making debugging my code very difficult.

This week I mostly worked on finishing up the CBS implementation. After completing the code, I worked on refactoring my work and commenting the chnages. I have written over 2000 lines of codes. It's a lot of code, a lot of classes, and a lot of dependencies. Because everything is so heavily intertwined, we couldn't test any of our code during the process of writing it. Debugging next week will definitely be an adventure.

I also started a literature survey of works related to multi-agent multi-task planning and conflict-based planners. There's a ton of cool work that's been done on multi-agent multi-task planning. When I got a bit tired of reading these articles, i spent some time working on mapping out the different rippling possibilities when edges are added, removed, or modified in the dynamic programming table. We won't be able to finish the dynamic portion of this project as planned, but I am hoping to continue the work for dynamic task allocation during the school year.

This week I worked on debugging the CBS code. Debugging is taking a long time because we wrote about 2000 lines of code without being able to test any of it. Due to this, the bugs are endless and a bit difficult to find within all of the code. We made good progress on debugging the code this week but will need to continue debugging next week.

I am learning a lot about the intricacies of C++ as I debug my code. I am becoming more familiar with the returned error messages as well as where to locate the source of these errors. I am hoping that the things I learned this week will help with next week's debugging.

This week I continued debugging the CBS code. We are getting really close to getting it to work as expected; however, there are a lot of little things that break the code in the smallest ways possible. The last few bugs that we're dealing with are very difficult to find and often times, difficult to fix. One of the most infuriating (and humorous) bugs was an issue where some of our values were not getting copied correctly. Turns out, if you don't delete your pointers after you're done using them, everything will break. Memory leaks are bad, who would've thought? Despite the insistent drilling of "don't forget to deallocate memory," I still forgot to delete every single one of my pointers .

In summary, we are still working on debugging the CBS code. We're pushing close to the last week of the program, but I'm sure we'll be able to finish in time. Alongside debugging, I also worked a bit on writing my final paper and drafting my poster for the DREU program deliverables.

It's the last week! We finally finished debugging the code on Tuesday. We ran some quick experiments to have results for the poster presentation and paper. We cut really close to the deadline. After finishing the code, we spent the rest of the week running more experiments, polishing up the poster, and writing the paper. This project was such a learge endeavour that it was very gratifying when the TCBS method acted as expected.

These last ten weeks have gone by so quickly. It was such a great experience and I am grateful for being able to work with my peers and my mentors in the Parasol Lab. I am looking forward to working more with the Parasol Lab and applying to University of Illinois Urbana-Champaign in the future!