Posts

CST438 Learning Journal 8

The five most important things I learned in this course were the Software Development Life Cycle (SDLC), Agile development, testing practices, Git/GitHub, and REST service development with Spring . Software Development Life Cycle (SDLC) I chose SDLC because it provides the foundation for understanding how software is developed from beginning to end. Learning the different phases helped me understand that software development involves much more than just writing code. Planning, designing, developing, testing, deploying, and maintaining software are all important parts of producing a successful system. Agile Development Agile was important because it introduced concepts such as user stories, epics, backlog grooming, acceptance tests, story points, and team velocity. I chose this topic because Agile is widely used for managing software projects and allows teams to respond to changing requirements. Comparing Agile with the Plan and Document approach also helped me understand that different...
Post a Comment
Read more

CST438 Learning Journal 7

This week working on these assignments, quizzes, and labs, I learned more about how software development processes affect the way a project is planned, documented, developed, tested, and deployed. One major topic was the difference between Agile and Plan and Document, also known as Waterfall. Plan and Document focuses on completing detailed requirements and design documentation before implementation begins. For example, we learned how a System Requirements Specification (SRS) documents functional and non-functional requirements so that developers, testers, managers, and other stakeholders have a common understanding of the system. Agile is more iterative. Instead of trying to completely define the system at the beginning, developers create working versions, receive feedback, and improve the system during short iterations. The SRS assignment helped me understand requirements more clearly. I learned how to create use cases with actors such as the Customer and Driver in our taxi service....
Post a Comment
Read more

CST438 Learning Journal 6

This week I learned more about end-to-end system testing and how it differs from the unit testing we had been doing throughout the semester. While unit tests focus on verifying the behavior of individual components in isolation, system tests verify that the frontend, backend services, database, and messaging components all work together correctly. I implemented a Selenium system test that automated an instructor logging in, navigating to a course, creating an assignment, entering grades for students, and verifying that those grades were successfully saved. Building this test helped me understand how Selenium interacts with a real browser and how important it is to use reliable element identifiers and explicit waits to synchronize with the application's state. I also learned that preparing reliable test data is just as important as writing the test itself. Before creating the Selenium test, I updated the seed data in both the Registrar and Gradebook applications so that the require...
Post a Comment
Read more

CST438 Learning Journal 5

This week I learned how to build and test React components that interact with a backend REST API while following an existing project structure. I implemented the instructor features for managing assignments, including viewing, adding, editing, and deleting assignments, and learned how to use React hooks such as useState , useEffect , useCallback , and useRef to manage component state, fetch data, and control dialog windows. I also worked with asynchronous API requests using fetch , handled server responses and error messages, and refreshed the UI after successful operations. I also implemented the instructor grading interface, which involved retrieving grade data from the backend, displaying it in an editable table, validating user input, and sending updates back to the server. Although I could not fully test the grading workflow because the student enrollment frontend was still being developed by a teammate, I verified that the frontend communicated correctly with the backend and ha...
Post a Comment
Read more

CST438 Learning Journal 4

I think the most interesting thing I learned from Chapter 9 of Software Engineering at Google is that code reviews are not just about finding bugs—they are an essential way of sharing knowledge and maintaining long-term code quality. Before reading this chapter, I thought code reviews were mainly a final step before merging changes. However, I now understand that they are also a learning opportunity for both the author and the reviewer. One point that stood out to me was Google's emphasis on making code reviews small and manageable. Smaller changes are easier to understand, receive feedback on more quickly, and reduce the chance of introducing errors. This approach encourages continuous improvement rather than waiting until a large feature is completed. I also found it interesting that reviewers are expected to focus on the overall quality, readability, and maintainability of the code instead of only checking whether it works. Another valuable lesson was the importance of creating ...
Post a Comment
Read more

CST438 Learning Journal 3

  Describe what are the good points about using Git for source code management.  What are possible problems that Git merge does not solve when merging code from different developers?    Git is a useful source code management tool because it helps developers keep track of changes made to a project over time. Each commit creates a record of changes, which makes it easier to understand how the code has developed and to return to an earlier version if a new change causes problems. Git also supports branching, allowing developers to work on new features, bug fixes, or experiments without immediately changing the main version of the project. This is especially helpful when several developers are working on the same project because each person can work independently and later merge their changes together. Git also makes collaboration easier through shared repositories, and the commit history can help with code reviews by showing exactly what was changed and why. Since Git i...
Post a Comment
Read more

CST438 Learning Journal 2

During this React lab, I gained a much better understanding of how React applications are structured and how the different pieces work together. One of the biggest concepts I learned was that React is built around components , which are reusable pieces of the user interface. Breaking an application into components like Login, Register, Order, and Settings made the project much easier to organize and understand. I also learned how state works using the { useState }  hook. Instead of manually updating the page, React automatically re-renders components whenever the state changes. The { useEffect } hook was another important concept because it allowed me to load data from the backend when a component first renders, such as displaying a customer's order history. Another valuable lesson was learning how React communicates with a Spring Boot backend using the fetch() API. I used GET, POST, PUT, and DELETE requests to retrieve, create, update, and delete customer and order information...
Post a Comment
Read more