Posts

CST 438 Week 8 Learning Journal

-
Image
Five Important Takeaways from CST 438 CST 438 was a very interactive class in terms of the components of software engineering. From all of the readings, assignments, and group activities, there were five important takeaways.  1. REST APIs The first important takeaway was working with REST APIs. REST APIs were introduced in previous courses, but in this course, we were able to see their implementation in a project using Spring server before the frontend was completed. We were able to test our backend system (registrar and gradebook) using HTTP requests and become more familiar with using Postman to test them. This was valuable as it improved our ability to start REST APIs, troubleshoot errors, and interpret console responses during debugging.  2. Behavior-Driven Development Behavior-Driven Development was introduced during the first iteration process in Assignment 1 and helped us write detailed stories that described how a user can interact with the software. This process not o...
Post a Comment
Read more

CST 438 Week 7 Learning Journal

-
Image
Agile & PD Comparison When engineering software for a customer, a team can use a variety of different methods to bring the software to life. Two of these methods are the Agile method and the Plan and Document (PD) method. While they both can help develop software to meet the needs of a customer, their processes differ in various ways.  The Agile method uses iteration to develop the software in short cycles and involves continuous customer interaction, which allows for flexibility in change. The design of the software evolves as iterations are completed. Its documentation is in the form of stories written using Behavior Driven Development (BDD), meaning that the stories describe how the user will interact with the software.  In contrast, PD is more of a sequential process and flows more like a waterfall rather than in iterations. While the PD method also uses BDD for its use cases, it focuses on heavy documentation and involves less frequent customer interaction than the Ag...
Post a Comment
Read more

CST 438 Week 6 Learning Journal

-
Image
Compute as a Service An example of CaaS This week, we were assigned to read the chapter Compute As A Service from Software Engineering at Google . When the code is production-ready, it is important to find a compute service that will meet the organization's needs and follow best practices. Some best practices of a compute service include automation, workload types, data handling, and implementing distributed system concepts.  The first best practice for a service is to leverage automation. In this case, we are referring to handling failures such as container crashing or dealing with an unhealthy job or machine. Containers and machines should be used as "cattle" for services to be healthy, which means that when one crashes, another can pick up the job and continue forward.  The next best practice is handling different types of workloads. A service should be designed to handle batch jobs and serving jobs. Batch jobs are short-lived jobs that are split into small chunks by ...
Post a Comment
Read more

CST 438 Week 5 Learning Journal

-
Image
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...
Post a Comment
Read more

CST 438 Week 4 Learning Journal

-
Image
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...
Post a Comment
Read more

CST 438 Week 3 Learning Journal

-
Image
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...
Post a Comment
Read more

CST 438 Week 2 Learning Journal

-
Image
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. 
Post a Comment
Read more