CST 438 - Week 2

     In lab 3 this week, I developed a simple frontend to communicate customer and order data to the Spring Boot backend. To accomplish this, I used the React library to create reusable interface components. This involved building a user interface for certain tasks such as registering customers and updating customer settings. In React, data can be passed to components as props, which is useful for tasks like providing the EditOrder component data to display a customer's order history prior to editing it. This lab also introduced special functions called hooks  to access the React state and features. The useState function accepts a variable’s initial state and returns an array containing the state variable and function to update the state variable. The useEffect function is used to synchronize with an external system, which in this lab, was used to get orders upon refreshing the page.

    This was not my first time using the React library, but this lab provided a helpful refresher on it. The volunteer CST 462 project I worked on used a frontend built with React components, and I initially found it challenging to quickly contribute to the existing codebase. While I accomplished all tasks assigned to me, the duration of the volunteer work was pretty short, so I did not practice enough using the react library to retain everything that I learned long term. The formal instruction from the lecture videos and the slower pace of the classroom environment has been helpful in reinforcing what I have learned, along with the fundamentals that I missed with my initial work with React.

    From what I have seen so far in this lab, 1 advantage of using the React library that I noticed is the reusability of components. For example, the Message component I created can be used across multiple files and components, eliminating the need to create a separate message dialogue for each one. As an application grows in size, I believe that the value in having reusable components would become more noticeable.

    As someone newer to React, I believe a disadvantage of React is its complexity. For a simple web app, I don’t think it would be necessary to create multiple component files or use React hooks to render page content. However, I am confident that with more experience, it would be less challenging for me to naturally implement the React library..

Comments

Post a Comment

Popular posts from this blog

CST 370 Week 1

This week’s reading material provided an introduction to the design and analysis of algorithms. I have taken classes on data structures and algorithms before, so nothing this week seemed entirely new to me. One example problem covered this week that I believe highlights the importance of this class is finding the greatest common divisor between 2 non negative integers. The reading materials from this week covered several ways to accomplish this. The intuitive way to solve this problem involves starting at the smaller of the 2 numbers and checking each descending integer until a greatest common divisor is found. Another way to do this would be to use Euclid's algorithm, which uses recursion to solve this problem. Comparing each approach and how many operations are required to solve this problem highlights the importance of analyzing the time complexity of algorithms.
Read more

CST 370 Week 4

 This week, I continued to learn about the divide and conquer approach to solving problems. The class lessons used merge sorting as example to demonstrate how divide and conquer algorithms can be implemented. An unsorted array is repeatedly split in half into sub arrays until the sub arrays are one element in size. At this point, the sub arrays are considered to be sorted and can be merged back together in a sorted order. This is repeated until all the sorted sub arrays are merged in order. Using the master theorem, I was shown how this sorting method results in n*log n order of growth. In community college, I had to show how many operations had to occur for sorting an array of n size by counting operations at each step of the algorithm. Learning how to apply the master theorem to merge sorting has made understanding time complexities much simpler.
Read more

CST 370 Week 2

 During this week of class, I spent much of my time learning about the different ways to describe the growth rate of functions. I found the informal definition in the text book was helpful to me in understanding this topic. Recognizing notations such as big oh, big omega and big theta, as the set of all functions with a smaller, larger, or the same order of growth made this material a little easier to digest. Additionally, I began to read about recursion and how to analyze the time complexity of recursive algorithms. I used a recursive merge sort algorithm in hw2-2 to finish the assignment. The merge sort function divides a large array into 2 halves over and over until it reaches its base case. It then merges the sub arrays into sorted sub arrays over and over until it returns 1 sorted array.
Read more