CST 438 - Module 3

 Week 3,

This week's module is more centered around the importance of incorporating testing with our code. In our case, we automated the input of the lab we worked on last week using a google chrome driver. This helps speed up the process of checking our code returns the correct result by having the inputs be done automatically, rather than typing out the inputs manually. With proper testing, we can be more confident in our changes, and more inclined to embrace change in programs, especially when it is necessary.

Additionally, we are re-introduced to using the version control system known as git. It was nice to get a clear refresher on git, and it was interesting seeing the different ways people can manage their different versions of code. Personally, I see the strong points being the use of commits and branches. Being able to fall back on previous commits in a scenario where the head commit is not worth the investment and using branches to work on different versions of releases. Such as having a branch for the main release, but the code still being developed would be on a beta branch. In combination with GitHub, this becomes even stronger and makes it easy to develop with other developers. However, there is a bit of a trickiness with working with other developers. If two developers manage to work on the same piece of code, and both try to push their code, if any lines of code are changed on both ends, there will be a merge conflict that requires manual intervention. And while some cases may result in no merge conflicts, it doesn't guarantee the code will still be logically sound. For instance, maybe a variable is changed by one developer but not the other. However, the majority of the code is not conflicting with each other so there are no merge conflicts. So, some functions may be expecting a different variable and result in an incorrect output or an error.

Comments

Post a Comment

Popular posts from this blog

CST 311 - Module 3

 Week 3 This week's material was very more focused on the transport layer. One topic was multiplexing and demultiplexing. To sum the topic up, this is how data is handled from multiple sockets using a transport header. The multiplexing occurs at the sender, using the transport header containing the source and destination port number, then demultiplexing occurs at the receiver, which allows the receiver to deliver the received segments to the correct socket. There are also two variants of these, connectionless demux and connection-oriented demux.  More on the topic of connection and connectionless transport, connectionless refers to the UDP protocol and is considered bare bones, there is no handshaking and each UDP segment is handled independently. What makes it bare bones is the fact that there is no effort in flow control, delivering data in order, reliable data transfer. However, it can be implemented at the application layer. On the other hand, with connection transport (us...
Read more

CST 338 - Module 4

 This week in CST 338, there were few assignments to complete. This time we got to get our hands on Android Studio, where we created very simple app where android users can convert temperature °c to temperature °f, or vice versa. We also got to complete our first project, where we practiced inheritance using an abstract class, and concrete classes. However, besides that, we were also allowed to go back to our previous assignment, Markov, and have our teammates review each other's code. I worked with my teammate Ryan Matsuo  and after reviewing his code, I learned a few things that could help me in the future, like splitting a string using str.split() with a regex of "\\s+" instead of what I did which was more complicated. My strategy with solving the Markov assignment was that I started writing the code right away. I didn't put anything to practice into paper because I feel I can do the same thing in the code. I would read the prompt, create stubs for the methods to b...
Read more

CST 370 - Module 3

 Week 3, This week's module started off with the continuation of Brute Force. This time using Brute Force with string matching problems. In short, when given a string of text and a pattern, find the pattern within the text. Using brute force, you would compare the strings character by character, and if there is a mismatch, shift a character and re-compare. This could have a fast best case scenario, however, worst case is longer than you would initially think. The next topic involved Exhaustive Search, an algorithm which determines all possible scenarios of a solution to the problem, compares each of them, and selects the fastest/lowest cost result. For example, the Traveling Salesman Problem requires you to find the shortest path to visit all nodes once, and return to the starting nodes. Using the Exhaustive Search approach, you would first find out all the different combinations of paths to take when starting from the first node, find out how much it costs for each path, then choo...
Read more