From the blog CS@Worcester – dipeshbhattaprofile by Dipesh Bhatta and used with permission of the author. All other rights reserved by the author.
Category Archives: CS-348
Blog Entry: Duck Simulator
Summary of the Resource
The resource I explored is the Duck Simulator project from the article “Design Patterns: The Strategy Pattern in Duck Simulations” by Head First Design Patterns (https://www.oreilly.com/library/view/head-first-design/0596007124/ch06.html). The simulator features different types of ducks like Mallard, Redhead, and Rubber ducks with behaviours such as flying and quacking. What’s particularly interesting is that these behaviours aren’t hard-coded into the duck classes; instead, they can be assigned or changed dynamically at runtime. This design highlights important object-oriented programming concepts, including polymorphism, encapsulation, and code reusability. It also demonstrates how the strategy design pattern allows developers to build flexible, scalable, and maintainable programs. The simulation is not only educational but also fun, giving a visual and interactive way to understand abstract programming concepts.
Why I Chose This Resource
I chose the Duck Simulator because it is a hands-on, practical example that clearly demonstrates OOP principles we are currently learning in class. I was looking for a resource that is engaging, easy to follow, and yet illustrates advanced programming concepts like abstraction, interfaces, and composition. The simulator is particularly appealing because it shows how separating behaviours from the main duck classes makes it easy to add new features or modify existing ones without rewriting the core code. This approach mirrors how professional software projects are structured, and I wanted to see an example that connects what we learn in theory to practical programming.
What I Learned and Reflected On
Working through the Duck Simulator helped me understand how to design flexible and maintainable code. Previously, I often relied on inheritance to share behaviours, but this project demonstrated how composition provides more adaptability and control. For example, I could give a Mallard duck a “fly with rocket” behaviour without touching the original class—something that would have been difficult or messy using only inheritance.
The project also helped me see the value of modular thinking, treating behaviours as separate, reusable components that can be mixed and matched across objects. This makes it much simpler to extend the program, add new duck types, or implement additional actions. Experimenting with the simulation gave me a tangible way to understand polymorphism and modular design, which made abstract class concepts from lectures much easier to grasp. It also reinforced the idea that writing clean, reusable code is as important as writing code that just works.
How I’ll Use This in the Future
In my future projects, I plan to apply the lessons from the Duck Simulator by designing programs in which behaviours can be swapped, updated, or extended independently of the main code. This will be especially useful in games, simulations, or any software where features may change over time. The project reinforced the importance of thinking ahead about software structure and planning for flexibility, rather than just focusing on making the code functional. Overall, the Duck Simulator showed me that good software design is a skill that complements programming ability, and it’s something I will carry forward in both my academic and professional projects.
From the blog CS@Worcester – Site Title by Yousef Hassan and used with permission of the author. All other rights reserved by the author.
Team management in software development
As a software developer there is a significant chance that you will develop software in a team environment. I know as an entry level developer gaining this experience beforehand would be a massive boost for my career but what exactly does team management entail?
The importance of team management
In a perfect world a team of developers all work perfectly together synchronously & complete a task in the best way possible. In reality, each team will have people of different skillsets, creativity, and ideas for development. Therefore, teams need to be managed in order to optimize development as much as possible.
Creating a team
Before assembling a team for a project its important to highlight the scope & needs in order to figure out how many, and the type of, developers. According to itrex, some examples of developers you may need would be:
– Software Developer: Engineers and stabilizes the product & solves any technical problems emerging during the development lifecycle
– Software Architect: Designs a high-level software architecture, selects appropriate tools and platforms to implement the product vision, & sets up code quality standards and performs code reviews
– UI/UX Developer: Transforms a product vision into user-friendly designs & creates user journeys for the best user experience and highest conversion rates
– QA(quality assurance) Engineer: Makes sure an application performs according to requirements & spots functional and non-functional defects
-Test Automation Engineer: Designs a test automation ecosystem & writes and maintains test scripts for automated testing
– DevOps Engineer: Facilitates cooperation between development and operations teams & builds continuous integration and continuous delivery (CI/CD) pipelines for faster delivery
– Business Analyst: Understands customers business processes and translates business needs to requirements.
– Project Manager: Makes sure a product or its part is delivered on time and within budget & manages and motivates the software development team
– Project Owner: Holds responsibility for a product vision and evolution & makes sure the final product meets customer requirements
Post-team assembly
Depending on your project you now have an idea on what team you have, the next step is actually managing them. This entails setting clear objectives/goals, creating a timeline, allocating resources, setting communication strategies, delegating, implementing, tracking progress, monitoring project, managing risks/challenges & maintaining flexibility.
Final thoughts
I now have a better understanding the importance of team management in software development. In order to maximize efficiency towards a project/goal you definitely need to manage a significant amount of aspects related to development. The ability for a team to work together is also valuable & must be taken into account. Overall, I really enjoyed researching this topic, the main sources I used in my research was this section in Atlassians website as well as this section in the itrexgroup website.
From the blog Petraq Mele blog posts by Petraq Mele and used with permission of the author. All other rights reserved by the author.
Git bisect
In our class, in our latest POGIL we’ve started to explore debugging, an essential skill that uses different tests, tools, and commands.. The blog post “Supercharge Your Debugging with Git Bisect” by Phil Haack is a blog that talks about debugging with a tool that we’ve just started to familiarize ourselves with. That being git bisect, a command that helps developers locate the specific commit where a bug first appears. I chose this post because I was curious about how this tool can change debugging for me as a developer, as well as the idea of pinpointing where a bug starts in version control.
The post opens with a relatable story about the author facing a bug that had crept into his project over time. Instead of resorting to endlessly going through each commit and running tests, he turned to git bisect to efficiently find the problem. Haack explains how the command works like a binary search. It starts by marking a known commit where the bug exists and a known commit where the program worked correctly. Git then checks out a commit halfway between those two points. After testing that commit, the developer marks it as good or bad, and Git automatically cuts the range of possible culprits down until it pinpoints the exact commit where the issue began. Haack further elaborates on advanced features such as skipping commits that can’t be tested and automating the process with scripts through git bisect run. He also notes potential complications, like when the first bad commit is a merge rather than a single code change, which can make debugging a bit more complicated.
I chose this article because debugging is one my worst and most frustrating aspects of coding, and git bisect offers an easier approach that turns guessing into a faster, more efficient search. While I’ve used Git regularly for version control, I only recently realized it could actively help in finding bugs. The examples given in the blog made it easy to understand how bisecting commits can save on time, especially in large projects with long histories.
Reading this blog gave me new ideas about debugging. I’ve always viewed Git as a way to manage versions, especially when working with others, but now I see it as a debugging tool as well. The concept of using binary search to isolate problems makes me think about what other commands can be used to enhance my time when coding. It’s also a heads up that effective debugging depends on maintaining small, manageable commits because without manageable commits, even Git Bisect can struggle to pinpoint a specific change. Hopefully I can incorporate this tool into my workflow whenever I encounter bugs that I can’t find.
https://haacked.com/archive/2024/11/11/git-bisect/
From the blog CS@Worcester – Coding with Tai by Tai Nguyen and used with permission of the author. All other rights reserved by the author.
Bridging Structure and Flexibility: Understanding Software Design Methodologies and Agile
Hello everyone, and welcome to my blog entry for this week!For this week’s self-directed professional development, I explored the topic of Software Design Methodologies and Agile Practices. I used several online resources, including tutorials from Atlassian Agile Coach and readings from GeeksforGeeks. Even though the focus was on understanding Agile methodologies, I found that many of the ideas connected directly to our discussions in class about the software development life cycle (SDLC) and software design principles.
Summary of the Resource
Software design methodologies provide structured approaches to building and maintaining software systems. They define how development teams plan, design, implement, test, and deliver software. Traditional methodologies like the Waterfall Model, V-Model, and Spiral Model follow a sequential or plan-driven approach — where each stage must be completed before the next begins. These models emphasize documentation, predictability, and control.
On the other hand, Agile methodologies such as Scrum, Kanban, and Extreme Programming (XP) prioritize adaptability, collaboration, and continuous feedback. Agile breaks development into small iterations or “sprints,” allowing teams to quickly adjust to changes in requirements or user needs. Instead of rigidly following a plan, Agile embraces flexibility — delivering functional software early and improving it continuously.
The Agile Manifesto summarizes this philosophy in four values:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
Why I Selected This Resource
I chose to focus on Agile methodologies because I wanted to understand how modern development teams manage complexity in real-world projects. We often hear about Agile in professional settings, but I wanted to explore why it has become so widely adopted. After learning about structured models like Waterfall, I was curious to see how Agile differs in terms of flexibility, teamwork, and iterative design.
This topic also connects closely to our class discussions on object-oriented design and project management, where adaptability and maintainability are key. Understanding these methodologies helps bridge the gap between theoretical design principles and practical implementation in team environments.
Personal Reflections: What I Learned and Connections to Class
Exploring Agile helped me see how methodology shapes not only the process but also the culture of software development. Here are a few takeaways that stood out to me:
- Iteration mirrors refinement in design. Just like UML diagrams evolve as designs improve, Agile projects evolve through sprint cycles that incorporate feedback.
- Communication is central. In Agile, daily stand-ups and retrospectives ensure the entire team stays aligned, similar to how collaboration in object-oriented design ensures consistent architecture.
- Adaptability is a strength, not a weakness. While traditional models aim for stability, Agile embraces change — which is essential when building modern, user-driven applications.
In class, we often focus on designing systems that can evolve. Agile reinforces that same mindset at the project management level software design should anticipate growth, not resist it.
Application to Future Practice
Moving forward, I plan to apply Agile thinking to my future software projects, especially in group work or larger systems. Instead of trying to perfect a design from the start, I’ll focus on building incrementally, testing continuously, and welcoming feedback early in the process.
For example, in future programming projects, I could organize development into short milestones, use version control branches to represent sprints, and hold mini “retrospectives” after each stage. These habits will not only improve collaboration but also help me develop adaptable, high-quality code.
Citation / Link
Atlassian Agile Coach. “What is Agile?” Atlassian. Accessed October 2025. https://www.atlassian.com/agile
GeeksforGeeks. “Software Development Life Cycle (SDLC) and its Models.” 2025. https://www.geeksforgeeks.org
This exploration helped me connect the structured approaches of traditional methodologies with the flexibility and innovation of Agile. It reinforced that software design isn’t just about code — it’s about creating systems and processes that can evolve as technology and user needs change.
From the blog Rick’s Software Journal by RickDjouwe1 and used with permission of the author. All other rights reserved by the author.
From UML to Design Patterns: Refactoring the Duck Simulator
Hello everyone, welcome back to my blog! In my previous post, I explored object-oriented design basics and the importance of UML diagrams for understanding class relationships. This week, I applied that knowledge to a practical assignment by refactoring the Duck Simulator project using several design patterns, and I want to share what I learned from the process.
Introduction
UML diagrams provide a visual blueprint for software systems, helping developers understand relationships, dependencies, and responsibilities of different classes. While useful on their own, combining UML with design patterns allows us to translate those visual models into flexible, reusable, and maintainable code. In the Duck Simulator project, I used UML to identify repetitive behavior and then applied Strategy, Singleton, and Factory patterns to improve the system’s design.
Using UML to Identify Problems
Originally, the Duck Simulator consisted of an abstract Duck class and subclasses like MallardDuck, RedHeadDuck, RubberDuck, and DecoyDuck. Each duck implemented its own fly and quack methods. My UML class diagram made it clear that this design was repetitive: multiple subclasses had similar or identical behaviors. This repetition violates the DRY (Don’t Repeat Yourself) principle and makes the system harder to maintain or extend. The diagrams highlighted the exact areas where behavior abstraction could be applied, providing a clear roadmap for refactoring.
Applying the Strategy Pattern
The first refactor I implemented was the Strategy Pattern, which separates the fly and quack behaviors into FlyBehavior and QuackBehavior interfaces. Each duck is assigned a behavior object rather than hard-coding methods. Using UML, I could visualize how Duck classes now depend on behavior interfaces, not concrete implementations. For example, RubberDuck now uses the Squeak behavior, and DecoyDuck uses MuteQuack. This change made it easy to swap behaviors dynamically and reduced duplicated code across subclasses.
Using the Singleton Pattern
Next, I noticed that all ducks shared identical behaviors like FlyWithWings and Quack. To avoid creating multiple unnecessary instances, I applied the Singleton Pattern. UML helped illustrate that each behavior class has a static instance and a getInstance() method. This ensured that ducks reused the same behavior object, saving memory and improving consistency.
Implementing the Simple Factory Pattern
Finally, I created a DuckFactory to centralize the creation of ducks with their associated behaviors. UML shows a clear dependency from the simulator to the factory, encapsulating construction logic and removing manual behavior assignments in the simulator. This simplified code maintenance and improved readability, while maintaining all Strategy and Singleton benefits.
Reflection
This assignment reinforced how UML and design patterns complement each other. The diagrams helped me see problems in the design, and patterns provided proven solutions. After completing the refactor, the Duck Simulator is now modular, maintainable, and extensible. I can confidently add new duck types or behaviors without touching existing code. Personally, I learned that UML isn’t just documentation, it’s a tool that guides better design and code structure.
Resources
While exploring this assignment, I also reviewed a great resource that breaks down the concepts from Head First Design Patterns in a clear and structured way. You can find it here on GitHub. It helped me connect UML representations with real-world code implementations, especially when applying the Strategy Pattern in my Duck Simulator project.
From the blog CS@Worcester – Rick’s Software Journal by RickDjouwe1 and used with permission of the author. All other rights reserved by the author.
Blog post 1
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.
From the blog CS@Worcester – Tristan CS by Tristan Coomey and used with permission of the author. All other rights reserved by the author.
Blog Post 1
Since we’ve been going over GitHub and how and why we use it in class, I decided to pick an article right from the source. In the blogpost How we use GitHub to be more productive, collaborative, and secure, Mike Hanley describes how the staff at GitHub use GitHub themselves as well as how they’ve made new additions with developers in mind. A neat thing I thought as developers themselves working on GitHub I’m sure they thought “wouldn’t it be nice if…” then realizing “oh wait we can just add that”. One of those features that the blog mentions is the “new code search and code view”, which allows for a more quick and easy way to sift through multiple lines of code.
Another point in the blog was about productivity and under that Codespaces. As we had used Codespaces during the GitKit Chapters, it felt well integrated, so I was pretty surprised to find out that it was something that they had only recently implemented and started using (they started using Codespaces in 2021 and the article was written in 2022). Based on the article, this allowed what once took 45 minutes on local hardware to 60 seconds on much faster hardware then most would have on hand. This alone struck me as a sort of equalizer, allowing for more inclusivity in the fact that you don’t need to spend a lot of money on hardware to be on the same “playing field” as other developers.
The last main point in the blog goes into GitHub’s stance on security, which I guess isn’t to surprising as Mike Hanley’s current role in GitHub as well as his previous role was being in charge of security. Anyways, too often is cybersecurity put on the backburner until an inevitable data breach occurs, then it’s all “we value our customers security and privacy” and “security is our number one priority”. Mr. Hanley also seems to see things the same way, as he mentions how they were “still pleading with organizations to implement multi-factor authentication…”, something I consider to be pretty bare-minimum in terms of keeping ones accounts safe. Due to this stance on security I was glad to see that GitHub actually enforces multi-factor authentication with security keys. Another method of keeping things secure is their use of CodeQL. According to the article, in the same open-source spirit that GitHub was founded with, CodeQL queries are also open-source where either GitHub or other developers can share vulnerability patterns. This allows for not just “one set of eyes” to pinpoint possible exploits but instead the entire community.
Reading this article has given me a better sense of how the tools and practices we’re learning now actually look in a professional environment. On top of that seeing GitHub’s own team use features like code search, Codespaces, and built-in security tools shows how even though it feels like we’re leagues apart we’re still on even footing.
From the blog CS@Worcester – CS Notes Blog by bluu1 and used with permission of the author. All other rights reserved by the author.
Why My Homework on Forking and Pull Requests is Actually Career Prep
For the past few weeks in my Software Process Management class, we’ve been deep in the Runestone GitKit modules. At first, it felt like we were just going through the motions: fork a repo, create a branch, make a commit, open a pull request. It was a bit mechanical. But once we got to the later modules on syncing with an upstream repository and dealing with merge conflicts, the bigger picture started to click. I realized I was learning a real-world workflow, not just homework exercises. To get a better understanding of why this process is so important, I spent time on the Atlassian “Source Code Management” tutorials. I wanted to see how the steps from our class connected to the way professional developers actually work.
The Atlassian resource was the perfect companion to our GitKit labs. It framed everything we were doing in terms of a “Forking Workflow,” which is massively used in open-source projects and many companies. It explained that forking isn’t just a step; it’s a collaboration model. It gives you your own server-side copy (your “origin”) to experiment freely without threatening the stability of the main project (the “upstream”). This directly clarified the purpose of the two remote repositories we set up in GitKit. The tutorials also gave a crystal-clear explanation of pull requests, describing them not just as a way to merge code, but as a formal mechanism for discussion, code review, and ensuring quality before changes are integrated.
This connection between class and the professional world was a huge lightbulb moment for me. In Module 3, we learned the mechanics of git branch, git push origin feature-branch, and creating a PR. Atlassian explained the why: this process isolates your work, keeps the main branch stable, and makes every change transparent and reviewable. The steps we practiced for syncing with upstream in Module 4—git fetch upstream and merging changes—are exactly how real developers keep their feature branches up-to-date and avoid nasty merge conflicts. Even the .gitignore file, which we learned about, is a professional standard for keeping junk files out of the shared codebase.
Understanding this workflow is no longer just about passing the class; it feels like essential career prep. When I look at internship job descriptions, “experience with Git and GitHub” is a given. Now I know that means more than just making commits. It means understanding how to collaborate using forks, branches, and pull requests. It means knowing how to resolve a merge conflict gracefully instead of panicking. The hands-on practice from GitKit, combined with the conceptual framework from the Atlassian tutorials, has given me the confidence to say I understand a standard professional development workflow. I’m not just memorizing commands for an exam; I’m building a foundational skill I’ll use every day in my future career.
Resource Link: Atlassian Git Tutorials – Source Code Management
From the blog CS@Worcester – DoaaTime by Doaa Mutar and used with permission of the author. All other rights reserved by the author.
Quarter 1 Blog Post for CS-348
My chosen article for this blog post is this article from the National Institutes of Health.
https://pmc.ncbi.nlm.nih.gov/articles/PMC4945047/
While at face value an article from the NIH might seem completely off topic from our class and what we’re learning currently, this article is actually all about Github. The article is centered around the Bioinformatics industry, and how a big problem with it has always been sorting, storing and accessing biological data and information credibly and easily. The introduction of the article gives a solid run down of what Github is and its relation to Git, while the meat of the article surrounds 10 “rules” to follow while using Github.
I chose this article for my first blog post of the semester because it seemed ironically fitting for the current topic of Git in our class for being an article published by the NIH. But I also chose it because it heavily relates to our sort of beginners guided usage of Git and Github that we’ve been doing. The rules given by the article all seem like really helpful guidelines for anyone new to Github like I am. I’ve always wanted to use it for personal projects and such but it’s always seemed like a daunting platform. Granted our class has torn down a large portion of the wall getting in my way from using Github personally but I do also really like these guidelines given by the article. For example, their rule 1, using Github to track your projects progress and changes make to the project, that taking advantage of its own system for doing so is a massive help from tracking progress on ones own, especially when working with a whole team of people on one project.
Out of all these rules though, I really do think rule 5 and 7 are the ones I reflect on most, I’ll admit I’m sometimes lazy and sometimes forgetful. Sometimes I do skip a test on a project. But that’s where I realize I can use that to my advantage with rule 5 of this article. It talks about using Github’s web hooks to test your code, find bugs and detect logic errors every time you push your code. Personally I don’t think it’s advantage I would pass up and don’t want to pass up in the future of using Github for class and myself.
As for rule 7, I know it seems silly but I don’t really like to discuss or bring up problems or issues I have with my projects that I’m working on. It’s always seemed like such a hassle, and whenever I did discuss the issues I’m having, its usually over discord to multiple people at once making responses to each person a mess of trying to keep up and take everything into consideration. So genuinely I do think the issues section of a project will become a very powerful tool for me. It didn’t really hit me in class because actively trying to use it as someone identifying and fixing problems for a project that wasn’t my own felt discouraging, not sure why, but I didn’t really think about from the project lead perspective. I do think a tab dedicated to finding, analyzing and fixing issues will be extremely helpful to me.
From the blog CS@Worcester – Splaine CS Blog by Brady Splaine and used with permission of the author. All other rights reserved by the author.