The first quarter of the semester has come to a close. In CM-348 we have gone through a number of Git and GitHub features. Learning about pushing and pulling data, as well as doing some data cleaning was a great learning opportunity. As I finish my last year of school, I am trying to look at these processes in an analytical sense because that’s what I want to do moving forward.
In my free time over the past few weeks I have watched a lot of Alex The Analyst videos on YouTube. He has provided free knowledge on what it takes to become a data analyst. From interviews, to Git, to data visualization he provides a lot on his channel for people who want to learn. This week I watched his “2 Hour Data Analyst Masterclass” video. In this video, Alex breaks down what a data analyst interview process looks like from start to finish. He discusses what kinds of technical questions to expect, the importance of storytelling with data, and how to demonstrate value through projects or case studies. He also covers common interview mistakes, like not being able to explain one’s own projects clearly or failing to connect technical skills to business outcomes. This video was very insightful, he showed his viewers what skills you really need to get into the field, and it personally showed me some things I might need to work on.
I chose this resource because it’s directly relevant to where I am in my career path, as well as in my learning. I’m starting to build my portfolio and think seriously about interviews and job readiness. Alex’s advice helped me see how important communication is in data roles, it is more than being technically skilled, also being able to explain how your work impacts decisions. This connects to CM-348 because version control, documentation, and communication are key parts of the Git workflow. I am doing a bit of projecting here, but I look forward to watching more of his videos.
The GeeksforGeeks article “Coding Standards and Guidelines” highlights the importance of writing code that is clean and consistent. It also underlines the need for code that is easy to understand. It explains that coding standards are a set of rules and conventions that help developers maintain clarity and quality across a project. These standards cover areas such as naming conventions, indentation, code structure, comments, and documentation. The article emphasizes that following standards is not about limiting creativity. It is about making sure that everyone working on a project can easily read and maintain the code. It also points out that coding guidelines help prevent errors. They make debugging easier. They ensure that software projects remain manageable as they grow.
I chose this resource because I’ve noticed how quickly group projects can become messy. Each person having a different coding style contributes to this messiness. I’ve always cared about writing code that works. I’ve started realizing that how the code looks and reads is just as important. This is especially true in team environments. This article stood out to me because it clearly explained the purpose behind coding standards.
One key lesson I learned from this article is that consistency builds trust among developers. When everyone follows the same structure, it becomes easier to understand, review, and modify code written by others. The article also reinforced the idea that good code should be self-explanatory. For example, meaningful variable names like totalPrice or userCount communicate intent better than short, unclear ones like x or val. I also learned how proper indentation and spacing make code more readable and reduce the risk of logic errors that come from misaligned statements or missing braces.
Reading this resource made me reflect on my own coding habits. Sometimes, when I’m rushing to finish an assignment, I skip comments or mix naming styles without thinking about how confusing it might be later. Now, I see that writing clean code is an investment as it saves time when debugging and helps others understand what I meant. I also want to use tools like linters and formatters to automatically enforce standards in my projects.
Overall, this article helped me understand that coding standards are not about perfection but they are about communication. Clean, organized code reflects professionalism and respect for the next person who will read it. It reminded me that in software process management, technical skills and teamwork go hand in hand. Writing code that others can easily follow is one of the best ways to contribute to a project’s long-term success.
One of the primary obstacles in software design is ensuring that code remains easy to maintain and extend. Initially, inheritance seems like the clear answerplacing shared code in a superclass and allowing subclasses to override as necessary. However, as demonstrated in the classic Duck Simulator example, relying solely on inheritance can result in fragile designs.
From Inheritance to Strategy
In the first version of the Duck Simulator, all ducks derived from a base Duck class. This approach worked until we introduced unique ducks like RubberDuck (which squeaks instead of quacking and cannot fly) and DecoyDuck (which does neither). Suddenly, we found ourselves needing to override or disable inherited methods, leading to duplication and design issues such as viscosity and fragility. Transitioning to interfaces helped to declutter the design, but it also required us to replicate code across similar ducks. The true breakthrough arrived with the Strategy Pattern,
We extracted behaviors like flying and quacking into separate classes (FlyWithWings, FlyNoWay, Quack, Squeak, MuteQuack). Now, ducks possess behaviors rather than inheriting them. These behaviors can be altered at runtime, and new ones can be introduced without changing existing code. This transition underscored the principle of favoring composition over inheritance and illustrated the Open-Closed Principle: code is open for extension but closed for modification.
Design Principles in Action
The exercise reinforced several essential principles: High Cohesion: Each behavior class excels at a single task. Low Coupling: Ducks are indifferent to how they fly or quack, only that they can delegate to a behavior. Encapsulate What Varies: Changes in behavior are contained, not dispersed across subclasses. Collectively, these factors enhance the design’s flexibility and maintainability.
UML: Clearly Communicating Design
We also engaged in the practice of illustrating designs through UML diagrams. In contrast to code, UML offers a higher-level representation that clarifies relationships: Associations (for instance, a Student possessing a schedule of Course objects). Multiplicity (for example, a student may enroll in 0–6 courses). Inheritance and interfaces (such as Faculty extending Employee and implementing HasCourseSchedule). Tools like PlantUML enable us to create these diagrams in Markdown, facilitating easy adjustments and sharing.
Key Takeaways
Relying solely on inheritance frequently results in fragile designs. The Strategy Pattern addresses this issue by encapsulating behavior and employing composition. Guiding principles such as High Cohesion, Low Coupling, and Open-Closed promote cleaner designs. UML diagrams provide us with a common language to convey and analyze code. What began as a straightforward duck simulator evolved into an insightful lesson on the significance of design patterns. By embracing the Strategy Pattern and utilizing UML for design modeling, we discovered how to construct systems that are not only functional but also resilient, adaptable, and easy to maintain.
I am Dipesh Bhatta, and I am writing this blog entry for CS-348 Software Process Management for Blog Quarter 1. I chose to write about version control and how it is applied in software process management. My chosen resource is an article entitled “What is Version Control?” by Atlassian’s Git tutorials ( https://www.atlassian.com/git/tutorials/what-is-version-control ). This passage explains what version control is, why software projects require it, and how developers use it in practice.
The passage defines version control as a process that records file changes over time. It allows several people to work on the same project simultaneously without losing work or overwriting each other’s work. Another important advantage is that version control has a complete history of the project, and developers can go back to an earlier version or reverse mistakes when necessary. The article also explains how the older systems, like the centralized ones such as Subversion (SVN), differ from newer distributed systems such as Git. Git has risen to be the most widely used version control system because it offers each developer a full copy of the project; thus, it is reliable and flexible. Apart from this, the article captures the workflows like branching, merging, and pull requests, which make collaboration safer and more structured.
I used this resource because version control is associated with managing the software process, the subject of CS-348. The course is all about managing software development in an organized fashion, and version control is one of the most important tools used to facilitate this process. I also wanted to understand the reason why version control is crucial and not just how to use it, since understanding its purpose makes me aware of its application in professional software development.
This article made me realize version control is not just saving code—it is a process of keeping collaboration and advancement. Without it, projects quickly become unmanageable, and you can’t even know who did what to the code. The explanation of Git branches was most helpful because it mirrors what we do in CS-348. Branches allow developers to experiment with new functionality without affecting the original codebase, and this is a clear demonstration of process management in action.
The article also got me to think about my own working habits. Writing good commitment messages, responsible use of branches, and adherence to a process-based workflow are all habits that enhance collaboration and project quality. These habits will benefit me in group projects from now on and later in professional work.
In short, version control is an essential part of software process management. It facilitates collaboration, organization, and accountability—all major themes in CS-348. By performing these routines throughout Blog Quarter 1, I am creating technical skills as well as professional routines that will benefit me throughout my career.
Hello everyone, my name is Rick Djouwe, and this semester I am beginning CS 343: Software Construction, Design & Architecture. I am truly excited for this class because it represents the next step in strengthening my ability to think beyond coding and focus on building well-structured, scalable, and maintainable software systems.
What This Course is About
CS 343 covers a wide range of essential topics in modern software development, including:
Design principles such as abstraction, encapsulation, inheritance, and polymorphism.
Best practices like SOLID, DRY (“Don’t Repeat Yourself”), and YAGNI (“You Ain’t Gonna Need It”).
Design patterns that provide reusable solutions to common problems.
Software architectures and frameworks, including REST API design.
Refactoring, code smells, and concurrency, which improve software quality and longevity.
Modeling and documentation tools like UML, which ensure clear communication of design decisions.
In short, this course is not just about writing code, it’s about learning to think like a software engineer who can approach problems critically, design solutions thoughtfully, and work effectively with others.
Skills and Outcomes
Through CS 343, I will gain valuable experience in:
Collaborating with stakeholders to design, test, and deliver software systems.
Applying professional judgment and staying current with evolving tools and practices.
Organizing projects using proven methodologies and team processes.
Communicating complex technical concepts clearly, both in writing and orally.
These outcomes connect directly to the broader goals of my Computer Science major: analyzing problems, building solutions, and developing the professional skills needed to succeed in the field.
Why This Matters to Me
As someone pursuing a career as a software engineer specializing in artificial intelligence, this course will help me strengthen the foundations of software design and architecture that are critical in building intelligent, scalable systems. Beyond my academic goals, I also see a strong connection to my current role as an Automation Developer at The Hanover Insurance Group, where I contribute to projects that rely on thoughtful design, testing, and collaboration. The principles and practices I learn here will make me more effective in my work today while preparing me for even greater responsibilities in the future.
I am eager to reflect on my progress throughout the semester, connect this material with experiences across my other courses, and apply these lessons directly to both my professional role and long-term career.
For me, CS 343 is more than a class, it’s a bridge between where I am now and the kind of innovative, responsible, and skilled software engineer I strive to become. I am also excited to meet everyone in this course and learn from each other as we move forward together. Feel free to reach out if you’d like to connect, collaborate, or study together this semester!
Debug Ducker here, now with my final Sprint retrospective for the semester. I want to not only reflect on the progress made on this sprint, but also the past sprints as well.
Initially, when starting the project, we had a different scope in mind than what was needed. Expiration dates aren’t what many think they mean. They are made by a company, there are no governing bodies that oversee expiration dates, and meant for markets to throw stuff out that isn’t fresh. So we decided to instead try to make it so that when a product is scanned, it will then display the USDA food guidelines on what to do to ensure the food is within the spoilage range. We then introduced what we had for our customer during Sprint 1, which at the time, we had the scanner system and the inventory backend. What we learn here is that the customer has an idea of what they want, while the programmers may have a different idea. The customer said that in the pantry, they remove food after 6 months, and realizing this decided to shift our development to just displaying if a product goes bad after six months, so the group worked on displaying how long a product in the inventory can go on for instead. I feel this is a great example of customer input that I learn, as they may have an idea that we can not change completely, but improve on through software, so instead of manually checking the food, they can just check in the database what products are past the six months. As a result, our final product reflects that
This last sprint was our tidying-up sprint. We just needed to tidy some code to make it cleaner and also fill out some documentation for the next group, which I was in charge of. The tidying code is where the issue lies. You see, we use a certain code as a base to work off from for smoother development. The problem is that a lot of the words and variables used are based on the previous code base, which was guest. Since this backend is meant for product, we wanted to replace every instance of guest with product so future developers won’t be confused like we were. Unfortunately, just finding and replacing all instances of guest was not going to be easy, as the problem was deeper than a few JavaScript files. It seems the issue lies deeper within the code, and it was an issue that would have taken too long to fix. I feel perhaps we could have avoided this issue at the start if we had gone out of our way to change the variable names in the beginning of the project. Though I am still not sure if that had fixed everything.
Before we end, I want to thank my team for being the best one I’ve had. I don’t think I’ll find an understanding and kind group like this even in my upcoming professional career. I’m going to graduate from college soon, a big change in my life with new responsibilities. Furthermore, I remember a pattern from the book “Apprenticeship Patterns”, by Dave Hoover and Adewale Oshineye. This book has been mentioned a lot in my retrospective, but a lot of what is said is thought-provoking. The most thought-provoking pattern to me is the Long Road. This pattern speaks about learning and growing your skills over a long period to be what is called a master software craftsman. You need to think in the long term, not short-term gains. I feel this will be important when it comes to my future in the software development field. It is going to be a long journey where I will gain new skills and abilities that will leave me unrecognizable from my previous self. Though this one will take time and an unknown amount of time that I am prepared to face. It will be a journey full of unexpected twists and turns, but it will be worth it in the end. I learned a lot from this group project and I hope to apply it in the future
Thank you for your time, Debug Ducker out.
Final results of the Backend in collaboration with me and 2 other devs
During sprint 3, I kept working on the frontend, like the last sprint, I had been stuck trying to get the backend up, while trying to work on the frontend. I had a teammate work with me for this sprint to complete it. We worked on two different branches, mine and Jason’s. Inside my branch, I was having a problem starting up the frontend through development mode, so I decided to see the original branch and work back into the updates I had made. Jason was able to start the frontend without the backend using dev. This gave me the advantage of designing the frontend and seeing what would work. Working with someone this sprint improved the sprint overall for me because last sprint, everyone else was in the backend while I was working in the frontend. My teammates were helpful, but without working with someone directly in the frontend, it was difficult to get help on exactly what I needed.
First starting on the design, I had noticed that I had to make the banners and everything the perfect size, or it wouldn’t be eye-appealing. Small things like having the top and bottom borders being same size were important. One of my biggest problems was attempting to make sure the page could fit on one page without having to scroll, because, first, designing the front end, there would be empty white space that wasn’t needed, or having the logos be too small. But I was able to persevere and have a design that I was proud of. I also have to give credit to Byron, who posted his design, which I translated into my design. It helped in choosing what logos should be prioritized and gives the frontend a coherent design.
For this sprint, I would choose Kindred Spirits as the pattern that most resonated with me. This pattern highlights the importance of working together and working with someone who is like-minded and is determined to learn and accomplish their goals. This is great to have in a team because it allows teammate to grow together while also accomplishing their tasks. Working with a teammate this sprint greatly affected the amount of work I was able to accomplish. I was able to complete more in a shorter amount of time given. Directly working with Jason during this sprint gave me more insight into the issues we faced and helped me grow faster and feel more supported. Before this sprint, as I mentioned, I was isolated, working on the frontend by myself. It was difficult to troubleshoot my work with others because they were working on different aspects of the project, mostly in the backend. My teammates were helpful in what they could help me with, but there was always a disconnect because I didn’t want to slow them down on their work, and they were working on the backend. Working in collaboration with Jason allowed me to exchange ideas and confirm each other’s work. It gave me more confidence to ask questions because we were working in unison on the same problem. If I had been aware of this pattern earlier, I would have gotten a partner sooner because working in isolation isn’t a deterrent to just you but to the whole team.
I never thought software testing would teach me many new things. I had experience with it in a previous college I attend. So when transferring, I assume I would relearn a lot about what was taught. Now after experiencing the class I realize my previous lessons were a mere microcosm compared to the vast methods of testing. Which makes sense as my testing back then was done out of necessity and as a way to auto grade my assignments. I won’t go too deep in the past, as today I will discuss the present and my future instead.
Hi, this is Debug Ducker, and I want to tell you what I have to learn about software testing. I would also like to share my thoughts and feelings on my upcoming graduating and my future in computer science. I hope you enjoy.
Now software testing is more than just testing, there are methods to it, different ways to approach it. One approach I didn’t really understand until later was black box testing. Basically, you don’t see the code, but you still run it. My first thought was, “Wow, that doesn’t make sense to me”. Why would I test something that I can’t see. Then after a while I understood perfectly. You don’t have bias when you don’t see the code. The developer has an idea how the software works base on what they write, so there is a possibility that they didn’t account for something. A person who wouldn’t know what the code looks like could test best on assumptions, and could find flaws without bias. QA testing does this regularly, and I understand why it helps developers save time.
Why I feel this is important because it opens my eyes to a lot of things about software testing and how useful they can be. Node path to see how the code progresses and to spot potential issues based on the structures of the code. The many range testing methods that can help detect potential functionality issues and see what needs to be tested or not. There is so much to share but so little time.
I have learned a lot and hope to use this knowledge for the future. Speaking of which, what about my future. Well, I think that is hard to say. Once I graduated, I plan to apply to some software development positions and see what happens. This is a very strange moment in my life. Like I am reaching a major conclusion. I can only see a small part of what life has for me, and I hope they are good and without issue. I just have to apply all my skills that I have learn throughout my four years in college and hope I succeed.
Hello, Debug Ducker here. Last post I made was discussing the developer prioritization of quality for an enterprise product compared to a consumer product. The topic got me thinking what other things does a developer need to be concern with when it comes to Enterprise software and consumer software. What ideas or planning needed when it comes to the two.
First the differences are clear when it comes to developing and testing these types of software. For Consumer products you are developing for a large majority and prioritize the experience for an individual user. Enterprises are for mostly organization use, like a company. When making either one needs to think what is the needs for the software. Take consumer products such as photo editing, video editing, spreadsheets, etc. Enterprises product are specific to the organization that may need it to fill a specific purpose. That doesn’t mean that software that can help a business is always an enterprise software, some software is not just useful for the individual but for business like spreadsheets programs.
When it comes to developing the two products different mindsets and thoughts are needed. For consumer, you need to get into the consumers head and think what they may look for in the product. Probably not anything to specific to say but they may look for other things such as price and needs. Enterprises are different in the fact that they wouldn’t mind paying more and would want a degree of quality. I found that enterprise products tend to have more care put into them compare to consumer products but that is probably because a business wouldn’t want to upset a partner. Enterprise may want specifics that they hope the developers may be able to fill and it because of that is why software developers would work closely with business. Think of it as a bonus when it comes to working with Enterprise as it may demand more out of the developer but the advantage is if work closely, you may be able to get stuff done meeting their demands.
Testing for Enterprise software is a lot more complex to. I found some details online that list specific types to look out for.
Functionality Testing
Testing to see if it passes functionality requirements
Usability Testing
Test for optimal user experience
Security Testing
Testing for vulnerabilities
Performance Testing
Test to see how well it performance
Integration Testing
test to see if different modules and applications and external system work with it
Compliance and Regulatory Testing
Test to see if it passes legal and specific industry requirements
These are all the types of testing to look out for, when it comes to enterprises. Not to say the same can’t be done for consumers, though it is a lot more important when it comes to enterprise.
Thank you for your time, have a nice day.
The Ultimate Guide to Enterprise Software Testing – Testlio, 3 Jan. 2025, testlio.com/blog/enterprise-software-testing/.
Shields, Keith. “Enterprise Software Development vs. Regular Software Development.” Custom Software Development and Mobile App Design, Designli LLC, 1 Mar. 2025, designli.co/blog/enterprise-software-development-process.
During this sprint, I switched up the work I did compared to the last sprint instead of working on the backend I was given the task to oversee the front end. First going into the front end blindly I didn’t know exactly how far the front end was already and had to accommodate myself to the code. First opening the frontend I noticed it was missing several files that would hold great importance in starting the frontend. One of my first fixes was the docker-compose file left by the other group was the backend file the same so I created a new file that would hold both servers of the front end and the backend. I updated some of the documentation that had been outdated compared to what we were working on currently. I created a new way to start the frontend server because it was missing that and added an up.sh, down.sh, and rebuild.sh for the front end. I also updated the outdated docker file. After I had a basis for what was needed I decided to go in and organize it better to read the new files in an organized manner to see what files were missing. Had to add new assets and components including new pictures of Libre food pantry and any other ones that were needed.
During this sprint, I worked well working alone but I should have checked more often with my teammates because of the issue that would later fall upon me. I was making progress every week but I hadn’t yet seen the biggest fault was the backend would crash on me. Next time I should check in with my teammates sooner instead of making progress on my own. I just didn’t want to slow down my teammates with my work. That is a fault in itself I shouldn’t be scared for help because the team will fail if I do this.
This time around the apprenticeship pattern that resonated with me the most was breakable toys because it is the basis of each sprint. You must create a small project where you can make mistakes in order to learn and be better. During this spring I was learning the ins and outs of the front end on something someone else created that I had to update and fix. This pattern could have made me more confident in messing up because it’s now wrong to mess up. Failing would help with issues that would come up that would show me what to do in other scenarios. Another pattern I would choose is to learn how you fail. I had many times during this sprint where I was head scratching to find an answer or come to an understanding of something but picking up on the patterns of how I failed I could change for the next issue that would come up. This issue opens my mind to being more intentional with my work and picking up on my common mistakes even if sometimes simple mistakes are the biggest headaches. Errors can be preventable by understanding why you do something and adapting to catch them next time. During this sprint, I learned a great deal about my project and I hope in the next sprint I will be able to learn more.
