Edward's CS Journey

Larger Tests  This week, we were assigned to read Software Engineering at Google, chapter 14, titled "Larger Testing" or end-to-end system tests. Previously, we learned about the benefits of small-scale testing for unit tests; however, larger tests may be necessary to fully cover the software's overall functionality. Larger testing is the complement of small testing as it is slow, shares resources with other tests, and may interfere with other tests or user states. Creating a large test enables us to assess the software's functionality, whereas small tests allow us to verify that individual parts of the software are functioning properly.  To create a large test, several things need to be put into place. First, a large test needs a system under test, or SUT. There are many different types, so it is essential to select the one that best suits your needs. The test is evaluated based on two factors: Hermeticity and Fidelity. Hermeticity refers to the degree of isolation a...

Importance of Testing The most interesting thing I learned from reading "Software Engineering at Google" was about testing. Testing is a crucial aspect of programming that can significantly improve system designs. A simple test focuses on a single behavior, a method, or an API that is being called. A specific input is given, and an observable output is shown in a controlled environment. When designing a test, a developer needs to take the test size and scope into consideration. It should be a small test (few resources to run the test) and scope (specific to the code that is being verified). The benefits of testing are:  Less debugging increased confidence in changing code improved documentation  simpler reviews thoughtful design fast, high-quality releases While this read highlighted the importance of testing, it was also interesting to learn about how Google implemented testing within its company. Many employers were hesitant to adopt the process, so Google used three initia...

Git for source code management Git is a great distributed version control system as it supports collaborative development. Each developer will have a copy of the repository and can work offline locally before sharing it with the group via the central server. Git's branching system allows developers to manage features without affecting their colleagues' work. Logs and a history of changes are kept of every change that happens and who made the change, which allows for effective communication if there are any questions. Git also keeps track of the versions of a project. Team members have access to all committed versions from the first to the most recent.  In addition to what was mentioned above, Git also allows programmers to merge their work with that of other programmers. Merge will combine programmers' work so that all files have the same code. The issue with using merge is that conflicts can arise if two programmers change the same line of code in a file. It is up to the p...

Mocks in Junit To test components in isolation, we use mocks. Mocks are stand-in objects that allow tests to run without relying on real dependencies. By creating mocks, we can define how external calls are handled, allowing the test to focus solely on the component being tested. If mocks were not used, the software system would be tested with all components, making it difficult to pinpoint an error. Mocks are essential for ensuring that unit tests remain fast, independent, repeatable, self-checking, and timely. When using a mock, we typically do not have to manually implement mock classes; instead, we can use libraries such as Mockito to create the necessary behaviors required for testing. 

 Software Engineering Course Expectations Coming into the Software Engineering course, I expected to learn how to develop software and practice the design process. This was to be accomplished through both individual labs and a group project.  After completing the first week, I realized that there is a lot more to software engineering than just programming. Programming is a more individualized aspect of software engineering that involves the coding component. Software engineering is a collaborative effort that involves programming, as well as other planning and design concepts. There are several factors that a team must consider for software to be sustainable and maintainable.  To create sustainable software, a team must consider time, scale, and trade-offs throughout the development process. Time must be considered in terms of factors such as the software's lifespan and the deadline for delivering specific components of the software.  Scalability involves considering...