Table of Contents
Course Description
The course description from the CSE 374 Course Website:
Covers key software development concepts and tools not in introductory courses. Concepts of lower-level programming (C/C++) and explicit memory management; techniques and tools for individual and group software development; design, implementation, and testing strategies.
Introduction
Taking CSE 374 during Spring 2020 at the University of Washington, I gained a good understanding of shell scripting, C programming, and other development tools. The class was taught by Megan Hazen and I was able to learn about a variety of topics related to software development. Although we covered many other topics, the class focused primarily on bash scripting and C programming. The other topics were more introductory and not as in-depth when compared to these two topics.
This post will outline what I learned from CSE 374 and will be structured and organized very similar to my previous course posts. My CSE 142 and CSE 143 posts may be useful to read since both are prerequisites to this course.
In Spring 2020, the University of Washington had to offer their courses in a completely remote format. As such, my experience may have been somewhat different to what the class usually would be like. Online classes were a new experience for me and I was able to learn a lot about managing my time. I outlined what I learned in an online quarter in another blog post here.
The code I have written for this class will not be publicly available. This is to prevent others from plagiarizing. Instead, I will try and offer the important lessons that I learned from each assignment. Prior to posting this publicly, on June 12, 2020, I emailed my instructor to read this article for anything that might be deemed as academic misconduct. On the same day, I got approval from my instructor.
Homework
Here is the link for information on the homework assignments for my quarter: CSE 374 Assignments.
Homework 0 & 1
The first assignments were very simple and had us learn about the Linux environment and shell. It detailed different commands that were available and what we could do. It was not very difficult and only required reading documentation and searching for commands.
Homework 2
In this assignment, we were introduced to more shell commands and writing Bash scripts. Shell scripting is a program designed to be run by a command-line interpreter.
Getting experience with command-line interfaces was really interesting to me because everything that I could do with a graphical user interface was still possible using the command line. Combining this with scripting, it was a great experience in how an interaction with a computer could be automated.
Homework 3
Homework 3 introduced commands like Grep and sed. We processed files and strings using these commands in order to filter our input. Regular expressions and tools like these are useful in finding patterns.
In this assignment, I learned that it is important to find specific markings that can help isolate the pattern that we want. What helped for me during this assignment was to work in steps. First, I got the input lines that matched and then slowly added expressions that could help isolate the actual data I wanted.
Homework 4
This assignment had us write and create a Unix utility program implemented in C. Being my first introduction into C programming, Homework 4 was somewhat difficult because pointers were still confusing to me. As I continued to learn, I made the connection of how pointers are similar to reference semantics in Java. Similar to how an array's variable points to a reference in Java, pointers are just a variable that point to an address. With a pointer in C, we can then also access the address that the pointer references and the value stored at the address.
In addition to being introduced to C programming, I was also introduced to the unix debugger, GDB. Using a debugger tool was very useful and allowed me to stop my code during runtime and inspect what my program was doing. Although I had used debuggers before, this was my first time using a command-line debugger. It was different from what I was used to, but it still allowed me to inspect my code effectively.
Homework 5
Homework 5 continued with C programming and introduced dynamic data structures. In this assignment, we implemented T9 predictive text using a trie. It was really interesting to see how a trie could make a more complex program easier to develop. Using the right data structures can often lead to great development and this assignment showed me how to use them properly in C.
However, with these more complex data structures, it was a lot harder to debug. In Homework 4, I did not use GDB very much. However, with these dynamic data structures, it was harder to see where the issues were. To debug, it helped me to understand how my program's data and variables were actually structured. Knowing how it was structured allowed me to access the values of my trie and understand how the references and values were incorrectly set.
We were also introduced to Makefiles which allowed us to specify how to compile our programs. Make is a build automation tool that helps to improve workflow and consistency within a project. In a bigger project with multiple people, programs like Make can be combined with other tools like automated testing to create a more seamless developer workflow.
Homework 6
In Homework 6, we were grouped together by pairs and tasked to develop and benchmark a memory management package. This included the benchmarking program and the library to allocate, free, and manage memory.
This was also a chance to practice using Git collaboratively on a project. After splitting parts of the project evenly, we also decided to get practice with pair programming. This allowed us to take turns between writing and reviewing our code. Working together is always an important skill and it was great to practice different collaborative techniques.
The main difficulty for my group was managing the pointers and memory. It was important to allocate memory for the portion that stored data about the block and the portion for actual use. Using pointer arithmetic, the address for the useable memory could be calculated. Given the address of that useable memory, it was also possible to calculate the address for the portion that stored information about the block.
Homework 7
The last assignment was to implement a C++ type for Rational numbers. This was good practice for writing a class in C++, but it was not a very difficult homework assignment. During this week we also went over concurrency. It was a topic that seemed very interesting and would have been great to expand on in a homework assignment. However, I understand that this class is more of an introduction to many different topics and cannot fit everything into a single quarter.
Exams
This quarter, there was no midterm for this class. Instead, we were given weekly check-in quizzes that were not very stressful. These would be given at the end of the week and go over the material we covered in lecture.
The final exam for this class was optional and consisted of three different sections. There was a quiz that covered the entire quarter's material and two assignments. The two assignments covered shell scripting and C programming.
Since my quarter was offered remotely, there were many changes to the course and this may be different to how the course is usually offered.
Overall Thoughts and Conclusion
This class revealed to me a lot about software development and the tools used to support it. Focused primarily on bash scripting and C programming, the class still introduced command-line tools throughout each week. With so many different topics, it can be difficult to cover them all in-depth. However, this class was a great introduction to many of the tools used in programming and software development.