CST438: Week 3 (Week 78)

 One of the best use cases for Git and other version control systems is on projects where multiple developers are working on a shared code base. Most projects solving non-trivial problems require collaboration. Git is a great way to keep code changes in sync with the remote repository as the single source of truth. Developers don't step on each other while working on their respective code changes.

Many years ago, I used a different system called CVS. One of the big improvements that Git has over CVS is that Git allows developers to work on their own local copy of the remote repository. Even if the network is down, an engineer can work on code changes and commit on their local copy then push those changes once network access is restored. This is a big deal for engineers who work while they travel.

One limitation of Git merge is an issue that I came across today. It's a line-for-line, syntax/text based solution. It doesn't understand context. In my case, since my last pull, another developer had changed the API and updated multiple function signatures. The merge worked, but compilation failed. All this to say that developers can't point to a successful merge operation as evidence that the combined code is valid. We still need plan and align our work as a team and make sure to build and test every time we modify the code.

CST438: Week 2 (Week 77)

This week I learned that React is really powerful for building interactive web UIs. It ties state directly to what shows up on screen. Until this class I had only heard about it from web developer content creators on YouTube.

One thing that stood out was how clean hook-based state management is. Using useState to handle name, password, and message meant no canned function calls, imports, and less cut-n-paste code. It's  simple and easy to follow. Then, since state updates are explicit (setName, setPassword, setMessage), the UI always reflects exactly what's going on. So the save/unregister flow wasn't to hard to trace when I was debugging. React Router is does a lot of heavy lifting. useNavigate() made redirecting after unregistering painless. It's a single function call that takes the burden off of the programmer (me).

That said, it has its limitations. I ran some of my code by a co-worker. He pointed out that React by itself doesn't have a built-in way to share state across components. In our case for this this assignment, we're reading and writing straight to sessionStorage inside the component to manage name, customerId, and jwt, which mixes browser storage logic with UI logic. Apparently their are libraries and features to help with this but I don't have the time to study them.

Data fetching could also be better. Every network call (save, unregister) has fetch -> response.ok -> try/catch logic. Looking into it, there's no caching, no request de-duplication, no retries, no built-in loading states (I might be able to implement that part). It's the same in Order.jsx, Login.jsx, and EditOrder.jsx too.

I can see why React is so popular and I why people have found it useful to build on top of it. That explains why there are third party solutions to some of the shortcomings that I pointed out.

CST438: Week 1 (Week 76)

What did I expect that a course in Software Engineering would cover? I figured that it would cover the design, development, validation, and maintenance of software. In other words, it's not just a matter of coding/programming, it builds on what we have learned in other classes and expands on that to cover the entire software life cycle. I also came in with the expectation that we would cover different approaches to software development and why they can make sense in different settings. For example, why might the waterfall model make sense for one organization/project vs the agile model?

I also fully expected that we would do some of our work in teams. It's very rare that you find software that was not developed as part of a collaborative effort. In the workplace, I haven't encountered that scenario. It makes sense that we should try to put that into practice.

Based on the orientation video, the lectures, our first assignments, and the class structure, my expectations were correct.

CST462: Week 8 (Week 75)

 What went well?

The First Robotics Competition organizers have a lot of useful information and instructions on the official website. FRC also has an official YouTube channel with some instructional videos on operating the robot and using Java to program it.

For the students, I think I helped them get a good start on the project by explaining the existing code, how it differs from the Python that some of them have already encountered, and giving them heavily commented code to implement specific functionality, which they could use as a starting point for other features they need to implement.

What was the most impactful part?

On my part, it was impactful in that I spent a lot of time thinking about how best to organize information and present it so that it's easier for people to receive and digest it.

What challenges did you face?

Communication between the students and me was challenging. On one hand, I am busy, so I cannot work with them daily. On the other hand, when we do meet, it would go much more smoothly if I could either see them during our tutoring sessions, so that I could read their faces for understanding, or alternatively if they were more responsive in chat or by voice. It felt like I was talking to an empty room.

On my end, some of the challenges included setting up and learning about their VS Code implementation, the robotics control library, setting up follower mode, and other details.

What would you improve?

The only thing that comes to mind is that the portal for tracking and approving SL hours feels clunky and can probably be improved.

What advice do you have for future SL students?

I would advise future SL students going into tutoring programs to be prepared for unique teaching formats and to be ready to ask questions to get students to talk, while letting them know that there are no dumb questions and encouraging them to ask.

CST370: Week 7 (Week 58)

 This week we covered non-comparison sorting, dynamic programming, Warshall's algorithm, Floyd's algorithm, Greedy Technique, and Prim's algorithm. This week was a heavier week and I'm glad that it's almost done. That said, I found the counting sort algorithm to be very interesting since it uses an approach that is different from standard comparison based sorting which is what we usually, intuitively would try. The dynamic programming problem based on coin collecting was also interesting to me since up until recently, dynamic programming was a popular topic for programming interviews.

Along with our programming assignment I completed the bonus homework assignment. I modified a red-black tree to simulate the one at the core of Linux's Completely Fair Scheduler (CFS). I saw it as an opportunity to catch up on points that I have missed while learning about something interesting that also applies to my career.  My example is VERY bare bones and simple. No preemption, no dynamic time slices (quanta), no priority factors and weights, no multi-CPU support, etc., but I learned a lot in the process.

CST370: Week 6 (Week 57)

This week we covered AVL trees, 2-3 trees, heap trees, and hashing. Hashing is a slight departure from the structures we've covered more recently since it's superficially represented as something other than a tree. That said, it's still a type of mapping construct/process. The rotation operations used in the addition, removal, and ordering/balancing operations of the trees was new. For AVL trees, the professor provided a YouTube video that was an excellent supplement to our recorded lecture. It helped clarify things for me.
https://www.youtube.com/watch?v=msU79oNPRJc

As an interesting footnote, I also liked the example approaches to confirming that a number is a prime number. I don't have a deep knowledge of cryptology and number theory but I have heard that prime numbers play a big role.
https://www.geeksforgeeks.org/cpp/c-program-to-check-prime-number/

As usual, I was curious about real world applications of the concepts introduced this week. I found that the red-black tree at the core of the Linux completely fair scheduler (CFS) is a type of 2-3 tree. I pointed this out in the class discord channel. It's been part of the Linux kernel since v2.6.
https://developer.ibm.com/tutorials/l-completely-fair-scheduler/

CST370: Week 5 (Week 56)

 This week we covered topological sorting, Kahn's algorithm, binary tree traversal, quick sort, and transform and conquer. We covered a broad range of algorithm concepts this week but to me there were two standouts. 1) I like that we coded an algorithm comparison as part of our assignment. Metrics and comparisons are a big part of the class so evaluating run time on the same system side by side is very helpful. I plan to try implementing a multithreaded vs single threaded example when I have time. 2) I enjoyed working on the King's Reach problem in the homework and on the quiz. It's a math focused puzzle and I enjoyed the process of breaking down the problem, recalling some of my algebra, and applying it in this context.