Posts

CST 489/499 Week 11 Learning Journal

  Milestones Accomplished This week, my main contribution to our capstone project was to convert our data-fetching logic to use server-side rendering (SSR) instead of client-side fetching. Previously, I was using `useEffect`  on the client to load data, which could expose sensitive information in our API calls. I refactored the logic by creating a server-side function that securely retrieves the data on the server and then passes it to the client component as props for rendering. This helps protect sensitive data and improves initial load performance. In addition, I helped a team member implement authentication with Supabase. We successfully created a new account using Supabase Authentication and simulated logging in and out.  Next Steps My plans for next week are to update the database so that the Supabase Authentication table is properly linked to our User table. I also plan to revise the User table structure to focus on user-specific profile information rather than aut...

CST 489/499 Week 10 Learning Journal

Milestones Accomplished This week, my main contribution to our capstone project was creating app routes in our repository. I created a route that displayed the data pulled in JSON format. Then I tested that the data could be integrated from our database into our frontend application and shared my results with the team. I also wrote documentation to help my team members set up their own database instances using Docker. Next Steps My plans for next week are to integrate database data into the appropriate pages on the front end. I will also be updating the database schema based on our scheduling algorithm and user information. Once completed, I will share my updates with the team via GitHub.  Challenges The challenges we are currently facing primarily concern updating the database schema to support the scheduling algorithm. We are taking the changes step by step, but will eventually have them connected. No instructor assistance is needed yet. 

CST 489/499 Week 9 Learning Journal

Milestones Accomplished This week, our team accomplished many milestones. My main contribution was the draft database schema. I created SQL statements based on the schema sketch we developed as a team. In addition, I imported the problem sets we are using into the database, added fake data to the other tables, and provided a test SQL statement to verify that the tables were being joined correctly.  Next Steps My plans for next week are to connect the database to the frontend by creating app routes in our repository. I will test running our database in a Docker container. Once successful, I will write out instructions for the group to implement to connect their databases locally.  Challenges The challenges we are facing right now are the amount of work on each person’s plate. We are doing our best to take on specific tasks while supporting our other team members. No instructor assistance is needed at this point. Our instructor, Dr. Feng, gave us the push we needed at our last m...

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...

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...

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 ...

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...