CST438 - Week 5

This week we continued work on our group project, focusing on implementing the frontend to communicate with our backend. The frontend development tasks were relatively straightforward, and our project management process has been going well; everyone is following the correct workflow to create, review, and merge pull requests.

Outside of the project, we also had a fairly long chapter to read on large tests in Software Engineering at Google. I admit I wasn't very familiar with testing beyond unit tests, and I'm still not perfect at writing them to achieve full coverage. While unit tests are great for verifying individual pieces of code, such as functions, large tests are important for ensuring that the entire system works correctly across many scenarios.

CST438 - Week 4

This week, we started work on a group project that involves familiarizing ourselves with a partially completed codebase and then implementing the rest.

We also read Chapter 9 of "Software Engineering at Google" on Code Review. Although we have only read a few chapters so far, the most interesting thing I learned was that Google's codebase experiences close to 25 million lines of change every week. I found it interesting how they manage such a massive volume of changes.

Overall, it was a good week. The project was a bit challenging, as it took some time to set everything up and get familiar with parts of the codebase.

CST438 - Week 3

This week, we focused on the basics and importance of Git for managing code, as well as how it functions in a team environment with multiple developers pushing changes to a single repository.

There are a lot of great features of Git, such as simplifying code publishing and updates, enabling the creation of separate working branches, and merging those branches into the main branch.

One issue with Git's merge feature is that it does not flag a conflict if the same line of code was not edited in a different branch. For example, if Developer 1 updates a variable from X to Y, and Developer 2 did not make changes to that line in their branch, there would be no merge conflict. However, the change itself would give an error for Developer 2's code if they tried to use the X variable.

CST438 - Week 2

This week in my Software Engineering class, we were introduced to using React for web development and completed a lab to accompany the lectures. The lab itself wasn't too difficult, but since I had never worked with React before, I ran into some complications at the start.

In terms of the strengths and weaknesses of React, I've only scratched the surface so far, but it seems there's a bit more setup involved and a steeper learning curve. I'll definitely need to read more and watch some videos to gain a better overall understanding.

On the positive side, I really like how React manages UI elements and JS in a single file, making everything easier to maintain and test. The React website also provides plenty of helpful resources and information.

CST438 - Week 1

What did you expect a course in Software Engineering would cover?

It's only week one, but what we have covered so far aligns with my expectations. My initial thought was that the course would go beyond just programming, including working in a team, exploring different software development life cycles, learning about design and testing, and understanding best practices to ensure code maintainability.

After completing week 1, how has your opinion changed?

My opinion has not changed. We have only scratched the surface this week, but the overall content of the class seems to be what I expected.

CST370 - Week 7

Wrapping up our 7th week in Design & Analysis of Algorithms, we covered some new non-comparison sorting algorithms: Counting Sort and Radix Sort. Then we had a lecture on Dynamic Programming, whose basic concept is to break a problem into smaller subproblems and optimize by storing the results of those subproblems so we don't compute the same ones multiple times.

Next, we went over Warshall's Algorithm and Floyd's Algorithm, which look quite similar but have different purposes. Warshall's algorithm finds the transitive closure; in other words, it determines whether there is a path between two vertices. In contrast, Floyd's algorithm is used to find the shortest paths/minimum cost between vertices.

Lastly, we discussed the Greedy Technique, which involves building a solution step-by-step by always making the choice that seems best at the moment, with the hope that these local choices lead to an optimal overall outcome.

Next week we have our final exam, which I'm a bit nervous about. To prepare for it, I plan to review all the material we've covered so far in the previous weeks and work through previous problems in our quizzes and midterm.

CST370 - Week 6

This week, we covered several new topics, including AVL Trees, where we practiced inserting nodes and balancing the tree using rotations. We also learned about 2-3 Trees and how to build them from a set of values. The topic we focused on the most, though, was probably Heaps.

A heap is a special kind of binary tree with two conditions:

• It must be a complete binary tree, meaning every level is completely filled except possibly the last, which is filled from left to right
• 
  
• It must follow the heap property. In a max heap, each parent node is greater than or equal to its children. In a min heap, each parent node is smaller than or equal to its children.

We also learned how to remove a value from a max heap and how to build a heap using a bottom-up method with an array. Additionally, we were briefly introduced to heapsort, a sorting algorithm that works in two steps:

• First, build a max heap from the list of numbers.
• 
  
• Then you repeatedly remove the largest number (which is at the root) and move it to the end of the array. After (n-1) removals, the numbers are sorted.

Lastly, we touched on hashing, which is used to store data efficiently. We also went over important concepts like collisions, load factor, and rehashing.

Overall, this week introduced a few topics I'd plan to revisit to strengthen my understanding. I plan to review the lectures on hashing and heaps, and watch some supplementary videos to better grasp the material.