One More Byte CS Devlog

     Writing the SRS this week showed me how the waterfall method works on assumptions. The document is built on the idea that I already know how everything should work before any code exists. Deciding on things like the pickup wait being ten minutes are guesses, but the format doesn't let them look like guesses. They were formatted to be stated as if they were settled choices. Agile goes about this differently because instead of trying to be right at the start, it assumes you'll be wrong and finds out where. Rather than sixteen use cases delivered as one document, an agile team would build two or three, put them in front of test users, and let the feedback influence the rest. Though does SRS supply a document that helps to define all the goals and its scope in once neat place. Neither approach fully removes the guesswork about the ten minute wait, waterfall resolves it by committing early, agile by launching and adjusting.

     This week we focused on unit and system testing. Writing these tests changed how I think about projects. Id previously assumed most effort would be focused into writing the logic for a project followed by testing as a smaller task at the end but working through these unit tests and the Selenium system test showed testing takes just as much effort to perform successfully. A well tested feature often has as much to it as implementation code. At one point I spent some time debugging a multi dialog DOM ambiguity issue in AssignmentViews, a bug that never showed up just from reading and normally running the code, only from testing it properly.          This weeks lecture talk about needing more tests than you'd expect which also clicked once I saw unit and system tests side by side. My mocked unit tests were fast to write and good for edge cases, like an instructor trying to access another instructor's roster. But they couldn't tell me t...

     This week I built out the AssignmentsStudentView and Transcript components so students can view their assignment scores and course transcript. It was good practice tracking down how data is moved from a Springboot dto using a fetch call and putting it into a viewable table.      I had the opportunity to practice my ability to navigation through a multi repo project to find the source of a bug rather than just making a bandaid fix where I first noticed it. When I saw that typing a lowercase semester like "fall" returned no results, I decided to figure out where that value actually originated and traced the input back to SelectTerm, which is a shared component across several student and instructor views. Fixing the case sensitivity there meant the correction applied project wide instead of needing to be duplicated across each view that used it.

     One of the things that I found interesting from 'Software engineering at Google' was the distinction between programming and software engineering. Before taking this class and reading the text, I viewed software engineering as just an advanced form of designing and integrating large systems. While I understood that practices like code reviews, version control, and project planning were important, I thought of them more as supporting tools rather than a defining part of engineering itself.     It makes a lot of sense now that software engineering encompasses much more than writing code or designing architecture. The processes that guide development like code reviews, version control, project organization, documentation, and team collaboration are what allow software to be developed reliably by many people over long periods of time. These noncoding aspects are what separate software engineering from simply programming. I think this shift in perspective i...

     One of the biggest advantages of using git for source code management is that it provides a complete history of a project. If a new feature or bug fix accidentally breaks the program its easy to look back through previous commits and return to a working state. Git also makes collaboration much easier by allowing multiple developers to work on different features at the same time without constantly worrying about keeping every file perfectly synchronized. Branches allow developers to experiment independently before integrating their work into the main project.      Though git doesn't solve every problem that someone might run into when multiple developers are working on the same project. Merge conflicts are an most obvious issue, needing developers to manually decide how conflicting changes should be combined. Additionally, even when Git merges code automatically, its unable to determine whether the merged code makes sense logically. Two developers may m...

     This week we focused on using React alongside Spring Boot to build a full stack web application and learned how the front end communicates with the back end. I really enjoyed this topic because, while previous classes had covered front end or back end development separately, this was one of the first times I got to see how the two actually work together. It was exciting to see how data is passed between the client and server, stored in a database, and then retrieved to update the user interface. Seeing the complete flow made the overall design much easier to understand.      The solo portion of the lab was incredibly valuable because it made me have to think about how to implement the different pieces so they could communicate correctly which really reinforced how each part of the application fits together. Working through the implementation myself helped me understand the mechanics instead of just following along with examples.     ...

     This week was a nice introduction to the course along with some of the services we'll be using, specifically spring boot. I really enjoyed the labs because they gave me a chance to become familiar with spring boot again and refresh my understanding of its components. It was a good balance of reviewing concepts I had seen before while also preparing me for the rest of the course.      Before this week, I thought of software engineering primarily as the process of designing and integrating large systems. In my mind, software development was focused on writing the individual pieces of code, while software engineering was about connecting those pieces through APIs, microservices, and overall system architecture. After this week, I still think those ideas are an important part of software engineering, but I've realized that the development workflow is just as important. The processes, tools, and teams use to build software efficiently are a major part of en...

     This week focused on encoding categorical variables, logistic regression, and overfitting. While the lectures introduced several important machine learning concepts, I think the homework was what helped reinforce them the most. Unlike many previous assignments, this one was much more open ended and required me to make my own decisions about how to approach the problem. We were given a dataset and told to predict a target variable using machine learning practices that we've learned, so how to go about preprocessing the data and tuning the model was left to me.      Initially the open endedness of the assignment made it a bit more challenging with not having a clear step by step process to follow, but it certainly made the assignment feel much more realistic seeing as in an actual career, problems arent going to be presented with exact instructions. Being able to evaluate different approaches is an important skill to train. I felt that I had made good d...

     This week focused on hyperparameter tuning, KNN regression, linear regression, and evaluating regression models. There was a lot to cover in these topics but interestingly enough they gave me an appreciation for what goes into creating machine learning models. From my previous perspective I think I viewed machine learning as mostly selecting an algorithm and allowing it to produce results. But in learning about these concepts like hyperparameter tuning, it showed me that there is still a significant human element involved in the process. The performance of a model can depend heavily on the choices made by the developer, and finding the right settings requires testing and careful evaluation.      Additionally the distinction between classification and regression was interesting because while both are forms of prediction, they are designed to solve different types of problems. Regression is useful in that many real world situations involve predicting nu...

     This week covered machine learning topics like handling missing data, data scaling, z-score calculations, knn classification, test sets, cross validation, and evaluating models. These topics, while diverse, worked well together for preparing data and testing to make sure conclusions drawn from it are accurate.     I found  learning about missing data and how it is represented interesting. I had originally not given much thought to the distinction between values like None and NaN so it was fun learning how these values behave and why they are treated differently. Data is often filled with holes and knowing how to handle missing information is an important part of the analysis process.      Cross validation was another topic that stood out to me. The idea of testing a model against different subsets of data to verify that the results are reliable seems intuitive and clever. It made me think about the people who originally developed these ...

     This week focused heavily on probability and different methods of calculating and interpreting it. We covered topics like boolean, conditional, joint, and marginal probability along with working with data tables to organize the information. Having so many different forms of probability calculations felt a bit overwhelming at first due the concepts being pretty closely related, but after reviewing the lecture and working on the homework I started to become more comfortable with them.     Something I really enjoyed this  week was the data visualization portion of the homework in google Colab. Working with pandas to create graphs and visualizations was very satisfying. The process of building the visualization piece by piece and gradually adjusting the code until it displayed exactly what I wanted felt rewarding due tot he immediate visualization feedback. Manipulating a bunch of raw data into nice visual formats also reinforced how important visualizati...

     This week covered a large amount of topics related to data visualization and statistical analysis using pandas. We learned different plotting systems, how to display information in meaningful ways using , how to customize visualizations, and how to perform calculations using the data. At first it was a little overwhelming because there were many different visualization methods and understanding where each was best used depending on the different types of data. It took me some time and a decent amount of review before I became more comfortable recognizing where certain plotting systems are most useful or how to interpret them effectively.      We also covered concepts like correlation and covariance. One thing I found especially interesting was the idea that even though data may appear objective and straightforward, it still requires critical thinking to interpret correctly. Identifying correlation does not necessarily reveal the full truth behind the ...

     This week the focus was on working with data using the pandas library, and later an introduction to probability density functions. One of the main topics was pandas series and how flexible they are for working with and visualizing data. We covered indexing, vectorized operations, and how Series differ from standard numpy arrays. While both structures are similar, what stood out to me is how pandas series include labeled indices, which makes the data much easier to interpret and work with. Instead of just relying on positional indexing like arrays, being able to have meaningful labels allows for clearer data manipulation. This seems especially useful when working with large real world datasets where context is just as impotent as the values.     P andas dataframes and how they are used to organize data was also covered. This section felt pretty intuitive because it felt like working with tables in a database or spreadsheet. Along with that was an introducti...

     For our the first week, time was spent setting up Anaconda and learning the fundamentals of Python along with an introduction to NumPy. While the basic syntax was straightforward, it was good review to revisit the distinction between expressions and statements and how expressions produce values while statements perform actions.      An interesting topic this week was the difference between standard Python lists and NumPy arrays. took a look at how NumPy is faster for numerical operations largely due to how data is stored in memory. NumPy arrays store elements of the same type in a contiguous block of memory, which makes access much more efficient. This allows NumPy to take advantage of low level optimizations showing that that NumPy’s speed is not just about better algorithms, but also about how data is structured and processed.     P ractice with manipulating arrays using slicing and fancy indexing, as well as creating and working with mult...

What went well? My time volunteering as a developer for The Document Foundation was genuinely rewarding. The most valuable aspect was getting first hand exposure to a large, real world codebase, which is something that classroom projects can't replicate at scale. I had the opportunity to learn how to set up a professional development environment from scratch, navigate a complex project, and engage with an industry standard code review workflow through Gerrit. I also got experience with bug tracking tools and learned how to locating the right targets for code changes within a massive project structure. Altogether, the experience gave me a much clearer and more real sense of what day to day work as a software developer actually looks like. What was the most impactful part? The most impactful part of this experience was definitely working directly within a large codebase along with a real code review system. It pushed me out of my comfort zone in a productive way like becoming more...

     This week we first covered counting sort and radix sort. I was especially impressed by the design of radix sort because of how elegant and efficient it is when applied in the right context. It was interesting to see how a noncomparison based sorting algorithms was able to outperform the traditional approaches.      We then moved into dynamic programming. At first, I found the concept somewhat confusing because it did not immediately seem different from simply working through a problem step by step. However, it eventually clicked during the homework that dynamic programming is about intentionally breaking a complex problem into smaller, manageable subproblems, solving each of them once, and then combining their results to build the final solution efficiently. Using this, I was able to pull apart the coin problem logic into smaller pieces and recombine it once each part was solved.      After that, we covered the coin-row problem and work...

     This week started with covering AVL trees and 2-3 trees. At first the order of operations required to properly rebalance and maintain these trees after insertions or deletions was a bit tricky to follow but carefully working through the videos and demonstrations helped clarify the rotation and restructuring processes. Seeing multiple examples made it much easier to understand how these self balancing trees maintain structure.      After that was heaps, how to identify them, how to construct them while maintaining heap properties, and how heap sort works. The progression from understanding heap structure to applying it in heap sort helped connect the conceptual sides of the topic. The final lectures this week focused on hashing and hash tables. I found hashing interesting because the overall concept feels intuitive, which made the material easier to grasp while still demonstrating how powerful hash tables can be for achieving efficient lookups.  ...

       This week, we covered the quicksort algorithm along with the median of three selection technique that helps improve efficiency and reduce the likelihood of worst case scenarios. We also reviewed binary tree concepts such as height and traversals. While binary tree traversals were a review for me, it was still nice to revisit them and reinforce that knowledge.      We then moved on to binary search and the decrease and conquer strategy, focusing on how breaking problems down in smaller pieces can lead to increased efficiency. One of the most interesting topics this week was directed acyclic graphs and their sorting method. The process of removing source nodes and repeatedly identifying new source nodes felt very intuitive and made the idea of topological sorting easy to understand.       Finally, we discussed the usefulness of presorting and how it can greatly improve algorithm complexity by allowing more efficient approaches...

This week was primarily focused on preparing for the midterm exam. This involved reviewing all of the material we have covered so far. Going back through the concepts helped me identify areas where I could improve, particularly reading and writing pseudocode and analyzing the efficiency of algorithms based on that pseudocode. Recognizing this gave me direction in what area I should focus my study. I especially enjoy exams that allow the use of a written study guide. The process of creating it helps cement the material in my memory. I often find that by the time I finish preparing the guide, I don’t need to rely on it as much as I initially expect. While I was nervous, as I usually am before exams, the structured review and preparation made me feel more confident going into the midterm.

 This week we continued with brute force techniques including an example involving string matching. This was a helpful illustration of how brute force algorithms work in practice and also showed that the worst case scenario for an algorithm is not always as obvious as it may initially seem. Lectures then covered several classic example problems like the traveling salesman problem, knapsack problem, and assignment problem which demonstrated how different types of problems often require different algorithmic approaches. We also went into more depth on the graph traversal techniques depth first Search (DFS) and breadth first search (BFS). While these concepts were a review for me, the information was valuable because it introduced new perspectives on analyzing their time efficiency. Later in the lectures we covered the divide and conquer algorithms and the master theorem, including on how to identify the time complexity of recursive problems using this method.  The week’s homewo...