CST438 - Week 3

The most obvious benefit to using git as version control is being able to revert back to previous working version of your code. Before I learned to use git, there were times that I started re-writing code for a new feature, just to break everything that worked fine before. With git, I'm able to restore the file to a previous version in order to more easily figure out where I went wrong. Another thing I find useful about git is the ability to coordinate with team members on projects in parallel. I can work on one branch while my partner works on another and we are able to push and pull our code remotely without having to worry about copy and pasting or downloading files from each other.

One thing git merge does not solve is when two developers make changes to a file, but not to conflicting lines of code. What I mean by this is if two developers both modify line 15 of a program in different ways, git merge will find that problem and flag it as a conflict. However, if one developer writes line 15 to print a variable and line 14 defines it. But developer 2 changes the variable name or deletes line 14, we're going to run into problems that wouldn't necessarily be caught by git merge. Even though there is no merge conflict, the code will still not compile or work as expected.

CST 438 - Week 2

 This week we were introduced to React.js. React is a front-end framework that manages a virtual DOM to allow for increased performance. We used this to connect a visible webpage with our previous module's Java code. This allows users to interact with our database and related functions in an intuitive user-friendly way. I found the way the codebases connected to be really satisfying and I'm really looking forward to utilizing this in more depth as we move forward.

I think one strength of React is the way it promotes modular code by utilizing components. Similarly to the way we use partials in Node.js, I can see how the individual components allow for less re-writing and better efficiency.

On the other hand, I found learning the pattern of the React concepts a little intimidating and can imagine how much more intimidating it would be without a solid background in code. Alternatively, vanilla JS, HTML and CSS are more approachable and the structure is more easily understood.

CST 438 - Week 1

 I expected a course in software engineering to cover what goes into building a software from scratch, including the design, the technologies and the life cycle. After the first intro course to software engineering that we took last year, I expected it to include aspects of multiple courses from back-end to front-end, databases, and security. After the first week in this course, my expectations were met, but I also learned more about things like scalability and maintainability along with the importance of communication amongst not only developers but with the clients as well. In my coding experience so far, it has been easy to make changes or refactor code, because I've been primarily working alone or in small groups. Emphasizing the impact of project management and tradeoffs will be vital to working on larger scale projects 

CST 325 - Week 1

 Journal Week 1: Link to Doc

CST 462s - Service Site Reflections

 For this class, I spent my time serving at The Document Foundation doing bug testing. I signed up for this opportunity because I knew it would be a challenge for me and I wanted to expose myself to fields outside of what I normally lean toward. Even with this in mind, getting started with the service hours was difficult for me. I had to learn how to use the software first in order to test bugs along with how to go about the actual testing process. Sometimes I would get stuck trying to figure out if I was actually not able to replicate a bug, or if I was just misunderstanding the problem in question. Luckily, the site supervisor was very accessible for questions and troubleshooting problems and The Document Foundation had good resources via website for some of the problem-solving that needed to happen. Overall, I think the most impactful part for me was seeing how much goes into building "complete" software. Seeing the way that new problems arise or the way that old problems can come back during updates made me really have a lot more patience when dealing with small issues in the software I use regularly. I also gained a lot of respect for the development of software with regards to different operating systems.

My advice for future students would be to get started on the service hours early, as it can take some time getting used to the process and you don't want to be stressed about hours at the end of the semester. Also, communicate with your site supervisor and the other students (if any) who are at the same site as you. They can give you help and advice and save you a lot of wasted time. Lastly, don't get discouraged if you feel like you don't understand something or it's not "clicking" for you. Try to understand that this isn't an achievement-based service, but more an opportunity to learn something new and see if it's something you would want to participate in post-graduation.

CST370 - Week 7

 Studying for the final this week went smoother than expected. My biggest concern was getting a grasp on AVL and 2-3 trees. For whatever reason, constructing these trees just wasn't clicking for me, but after working through some practice problems, I'm feeling more comfortable with the material. The last module introduced Djikstra's algorithm, which determines the shortest path from a single source vertex to each of the other vertices. This algorithm is widely known and used for GPS, internet routing, etc. My favorite algorithm from the last two modules is probably Prim's algorithm. Something about finding the minimum spanning tree was just really fun for me to work through.

CST370 - Week 6

 For this week, we went over what makes an AVL tree, 2-3 trees, and heaps. Luckily most of this was familiar to me from my data structures class, as my biggest challenge this week was finding time to work on homework due to a busy holiday weekend at my job. Part 1 of the coding assignment had to do with "heapifying" a data set to maintain a max heap, or a heap where every parent is larger than both its children. The second part of this week's module had to do with hashing and how to handle collisions. We went over two strategies for handling collisions - "separate chaining" and "linear probing". For the coding assignment, we wrote a program that would take in user commands (for example, "insert 20") and hash/rehash the map as necessary. In the instance of a collision, it will simulate the steps of linear probing. I had a lot of fun with this assignment actually, even though I had to finish it in quite a rush. It was a good review of unordered_maps in C++ and I got a much more thorough understanding of how a rehashing works.