CST 438-40 Software Engineering - Week 3

 Week 3 Learning Journal - 

Before I started using Git, I would make a bunch of backup copies of my files whenever I changed something. I had to keep renaming them with things like “final,” “final2,” or “working version,” and it became confusing to remember which file matched each stage of the project. Git handles that much better by saving organized commits, keeping a history of changes, showing who changed what, and letting developers work on separate branches. It also makes it easier to undo mistakes, compare versions, collaborate, and review code before combining it.

However, Git merge only combines file changes. It cannot determine whether two developers’ code actually works correctly together. A merge may finish without conflicts but still introduce bugs, break business rules, create inconsistent designs, or cause one feature to interfere with another. Git also cannot resolve disagreements about requirements, architecture, naming, or which implementation is better. Developers still need communication, testing, and code review to make sure the merged code is correct.

Comments

Post a Comment

Popular posts from this blog

CST 370-30 - Algorithm Design & Analysis Week 1

 CST 370-30 - Algorithm Design & Analysis Week 1 This week in CST 370, we went over the basics of algorithm design and analysis and what to expect from the course. A big focus was on understanding how to think about problems in terms of best case and worst case scenarios, not just getting an answer. We worked on logic puzzles like the fake coin and ball matching problems, which helped me see how algorithms can be about strategy and guarantees rather than code. These problems showed how careful reasoning can minimize steps while still covering all cases, which I think will be important later in the class.
Read more

CST 370-30 - Algorithm Design & Analysis Week 7

Week 7 Learning Journal -  This week focused on advanced algorithm design techniques including non comparison sorting, dynamic programming, and graph algorithms such as Warshall’s and Floyd’s algorithms. I learned how algorithm efficiency changes depending on the approach used. For example, Counting Sort achieves linear time by avoiding comparisons, and Dynamic Programming reduces repeated computation through optimal substructure. In our group bonus project, we also applied algorithmic efficiency principles. For example, we used an unordered_map for fast keyword searching with average constant time lookup. We also used a priority_queue to efficiently rank bookmarked verses. Even though we did not actually code dynamic programming or graph algorithms in our project, working on it still made me think more about why choosing the right data structure matters. When we picked unordered_map and priority_queue, I could clearly see how much easier and faster certain operations became compar...
Read more

CST 334 - Week 6

Week 6 Overview: This week in CST 334 felt like everything I’ve been learning about threads and synchronization finally came together. We didn’t have actual coding assignments for the lectures on the Bounded Buffer (OSTEP 30a), Semaphores (OSTEP 31), and Synchronization Barriers (OSTEP 31a), but we dove deep into how all these concepts work behind the scenes. It was honestly helpful to slow down a bit and focus more on understanding the patterns and problems before jumping straight into code. The lectures on the Bounded Buffer really helped clarify how semaphores control access between producers and consumers, and how you can use just a few semaphores to avoid race conditions and deadlocks. It made me realize how important the order of operations is when multiple threads are sharing data. The semaphore lecture helped things click a bit more for me. I’ve come across wait() and signal() before, but I always kind of just accepted them without fully grasping why they were used the way they...
Read more