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.

Diagram illustrating the roles within a software project development team.

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

Infographic illustrating the challenges of managing software development teams, including communication, role clarity, and meeting deadlines.

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.

Overview of a project manager’s essential roles and responsibilities in software development.

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.

The Value of Clean, Readable Code

Link to resource:
Why Clean Code is Important | The Power of Clean Code

While searching for a resource on software development and craftsmanship, I stumbled onto the article “The Clean Code Debate: Why Readable Code Still Wins.” It explores a long-standing debate among developers about the continued applicability of “clean code” the idea of writing code that is easy to read, understand, and maintain. In contemporary software development. Although frameworks and technology are developing quickly, the author argues that the ability to produce understandable codes that other developers can work with will always be necessary. The article discusses how techniques like consistent naming, few functions, and a clear structure lessen issues and promote collaboration, all while referencing Robert C. Martin’s Clean Code principles.

I choose this resource because I have noticed that a lot of programming projects and classes place more emphasis on getting the code to function than on making it readable or clean. I have come to understand the value of “maintainability” as I get ready to enter the workforce, not only for myself but also for everyone who might use my code in the future. The author made a particularly strong argument when she said that teams eventually get slower due to careless code. It brought back memories of collaborative projects where unclear variable names or a disorganized organization led to misunderstandings and more troubleshooting. I learned from reading this essay that producing “clean code” is about respecting future developers who will have to maintain or enhance the project, not only about style.

The essay taught me that the ideas of software architecture and design that we cover in CS-343 are directly supported by clean code. Writing code that is simple to modify and expand is related to ideas like modularity, separation of concerns, and readability. I too had to consider my own coding practices after reading the post. Although I occasionally shave corners to meet deadlines, this served as a reminder that little routines, such as explicitly naming functions or reworking when something seems too complicated, can add up to a significant impact over time. I intend to put these concepts into practice going forward by going over my assignments and side projects for readability and clarity rather than just functioning.

All things considered, this resource reaffirmed that “clean code” is a professional approach rather than merely an outdated notion. Great developers will always be defined by their ability to communicate through code, even when frameworks, languages, and tools change.

From the blog CS@Worcester – Life of Chris by Christian Oboh 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.

Blog Entry 2

Author: Yousef
Source:
Terra, John. AI for Project Management: Creating More Efficiency, Accuracy, and Better Results. UMass Global Blog, 2025.
https://bootcamp.umass.edu/blog/project-management/ai-for-project-management

Artificial Intelligence and the Future of Project Management

Artificial intelligence (AI) is rapidly transforming how organizations plan, execute, and evaluate projects. In his article, John Terra discusses the growing role of AI in automating processes that once required manual decision-making. He points out that AI technologies can analyze vast amounts of project data to identify trends, risks, and inefficiencies—long before human managers might notice them. This shift marks the beginning of a new era in project management, one where data and prediction take precedence over instinct and routine.

AI tools are now capable of predictive analytics, providing project leaders with accurate forecasts of timelines, costs, and potential risks. Terra also highlights emerging tools such as AI-driven chatbots that handle repetitive communications and machine learning models that track project performance in real time. These systems not only speed up workflow but also strengthen collaboration by giving every stakeholder access to transparent, centralized data. Importantly, Terra reminds readers that AI should complement not replace human judgment. Successful implementation still depends on leadership, empathy, and the ability to interpret data responsibly.

Why This Resource Stood Out

I was drawn to this article because it directly connects to the topics we have explored in Managing Information Systems specifically the use of technology to improve productivity, communication, and decision-making. As someone with a background in IT, I see AI as the next natural step in project management evolution. We already use tools such as GitHub and Trello to coordinate group work efficiently; AI takes this one step further by adding intelligence to those systems. Reading this piece helped me visualize how the principles we study in class can scale up to global business operations that depend on precise, data-driven project control.

Reflection and Application

Terra’s article expanded my understanding of what it means to manage projects effectively in the digital age. I learned that efficiency is not simply about speed it’s about designing systems that anticipate challenges before they occur. The idea of predictive risk management resonated strongly with me because it parallels what we strive for in software engineering: proactive problem-solving instead of reactive troubleshooting.

Another key takeaway was the emphasis on communication and ethics in using AI. Even the most advanced algorithms require human insight to ensure fairness, clarity, and accountability. As I advance in my career, I plan to explore AI-based project management tools and incorporate them into my workflow. This aligns perfectly with our program’s learning outcomes lifelong professional development and effective communication in both technical and managerial settings.

From the blog CS@Worcester – Site Title by Yousef Hassan 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.

An Introduction into REST API

The topic for this blog post was REST API. I chose this topic because later on in the semester we will be going over REST API design and I wanted to get a firm understanding of what REST APIs are first. I watched the video linked below, which is titled “REST API Crash Course”, in which the first half of the video was defining and explaining what a REST API is and then the second half was how to implement REST APIs in your code. https://www.youtube.com/watch?v=qbLc5a9jdXo

To begin, what exactly is a “REST API.” It stands for Representational State Transfer Application Programming Interface. The REST part is a set of rules and guidelines about how you should build a web API. The API part is another set of rules and guidelines about how applications communicate with one another. 

In essence REST APIs are a way for two softwares to communicate with one another.  No two softwares are built the same and have their own factors and variables. For instance, if you have one application coded in Python and another application coded in JavaScript and wanted them to communicate to one another… they would not be able to due to the fact they are in different languages. This is where REST APIs come in which enables a pathway for communication between the two different applications. 

We can further expand on this by using client-server communication example. The server exposes an endpoint API → client makes a request to the endpoint API of the server→ the server processes the request → once processed, the server sends it back to the client in a JSON format. 

It should be noted the client should NOT go directly to a database. If a client to database connection did occur, it would not be good due to the fact the database info would be exposed; which could lead to corruption and information getting exposed inside of the database. With an API, the client does not receive database credentials, limited with permissions to the extent of the API, and the server always retains the real database credentials. Long story short, with an API the information stays hidden. 

There are four main methods of requesting data from the server:

-GET is used to retrieve information from the server.

-POST is used to write information to the server; add a resource.

-PUT is used to update/replace a resource on the server.

-DELETE is used to remove a resource from the server. 

Learning about REST APIs and APIs in general makes me feel a lot more comfortable when we do get to the point of our semester of REST API design. Furthermore, it’s all starting to come together in terms of software construction. Starting with design then going to a better structured scalable design, addressing the relationships of servers and clients in class and soon REST API design, very cool, looking forward to it!

From the blog CS@Worcester – Programming with Santiago by Santiago Donadio and used with permission of the author. All other rights reserved by the author.

Improving Design Communication with PlantUML (Reposted)

Why I chose this?

So for this week’s professional development blog, i decided to go with this resource regarding UML diagrams(https://miro.com/diagramming/what-is-plantuml/#what-is-plantuml) considering we’ve been working on this in class for the better part of a few class days now. While syntax is important, I wanted a resource that went beyond the basics and emphasized best practices — specifically, how to make diagrams more readable and effective as communication tools. Which ties back to what we were doing for the classwork activity, the learning objectives of the activity we did in-class together includes identifying parts of UML diagrams, being able to connect them to Java implementation or even being able to draw the diagrams using Markdown with PlantUML.

What did I learn?
The article did help me with solidifying my understanding of the lifelines, the messages and the activation bars within the UML sequence diagrams, but in general from the article, i learned how PlantUML treats diagrams as code: by writing simple text scripts, you can generate UML diagrams consistently and efficiently. This can help out in collaborative environments, where diagrams kind of have to evolve along with the codebase. The section on best practices i find the most interesting since the article highlights that diagrams should focus on clarity over completeness.

For example, a UML sequence diagram should emphasize the key messages between objects rather than every small detail. The guide also pointed out how to use colors, notes, and layout to improve readability — so them giving pointers on how to use those things is good in case we want to make things look more pretty or neat-looking. I do appreciate the explanation of how PlantUML integrates with version control systems although it’s not something i found particularly too significant. Since diagrams are stored as text, they can be tracked and managed in Git just like source code. This makes them much easier to update collaboratively, compared to traditional tools where diagrams are static images.

Reflection and Application?

I thought it might be something i’d forget about in a month or two, i do think it helped with reinforcing the core concept that the UML designs aren’t just academic exercises that we were doing in class, it can be a practical tool for teams collaborating with each other compared to the traditional tools where it’s like the diagrams are just static images alongside the fact that it isn’t just checking a box but being able to make sure everyone understands, I guess i’d say for any future projects that come to mind, i’ll apply what i’ve learned by keeping my diagrams somewhat simple and try to make it with an audience in mind since there will be people i’ll interact with and get feedback when it comes to my PlantUML code. I also wouldn’t mind experimenting with Markdown and Git so that the diagrams can evolve with the codebase, becoming almost like living documents as opposed to a static artifact.

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

A brief look at UML

 Hello! For my first real blog, I like to talk about an entirely different blog I read written by Fredrik Klingenberg, titled “UML Sequence Diagrams“. For one of my classes where we talk about software design processes, UML diagrams were something that was taught to us very early on, and I got the impression that they would be something I would see a lot of for the rest of my career. As such, I wanted to find a blog that could give me an idea of how they would be realistically applied, and after some digging I found this. 

In the blog, he talks about not only what the diagrams are and how to construct them, but more importantly how to actually use them in a day-to-day basis. Firstly, if you are unfamiliar, a UML Diagram is a graphical tool used to visualize the structure and behavior of a software system. Think of it sort of as the visual equivalent of pseudocode, if you shifted the focus to more of an overview of the entire project. Visualizing the codebase in this manner isn’t an exact science, for instance you decide how much detail you want to include; something that changes depending on your reason for making one. As such, you may end up having to put more effort into making one than you originally wanted to which could offset the benefits you get from doing so. Fredrik provides insight for how he balances things out by explaining how these diagrams should be developed in tandem with the code, and how this can be done more easily.

To do this, he talks about using a tool called Mermaid, which is effectively a way to create a diagram from pseudocode. It’s very similar to a tool we were taught to use in class, called PlantUML, the key difference is that Mermaid is simpler, but faster. These “diagram as code” tools can also be version controlled which helps with keeping them updated as the code changes. 

I chose this blog specifically because it shows an anecdotal perspective of how UML is used in the real world; my main takeaways are that completeness isn’t necessarily the main priority of them, rather they need to be able to communicate (effectively but also quickly) the code, how it works, and it’s reason for existing. Shifting your priorities like this allows you to make them more quickly, which in my opinion makes them more realistic to not only create, but actively update as the project develops. Moving forward I definitely think that adopting this approach is a good idea, and probably something I will start doing.

From the blog Joshua's Blog by Joshua D. and used with permission of the author. All other rights reserved by the author.

A brief look at UML

 Hello! For my first real blog, I like to talk about an entirely different blog I read written by Fredrik Klingenberg, titled “UML Sequence Diagrams“. For one of my classes where we talk about software design processes, UML diagrams were something that was taught to us very early on, and I got the impression that they would be something I would see a lot of for the rest of my career. As such, I wanted to find a blog that could give me an idea of how they would be realistically applied, and after some digging I found this. 

In the blog, he talks about not only what the diagrams are and how to construct them, but more importantly how to actually use them in a day-to-day basis. Firstly, if you are unfamiliar, a UML Diagram is a graphical tool used to visualize the structure and behavior of a software system. Think of it sort of as the visual equivalent of pseudocode, if you shifted the focus to more of an overview of the entire project. Visualizing the codebase in this manner isn’t an exact science, for instance you decide how much detail you want to include; something that changes depending on your reason for making one. As such, you may end up having to put more effort into making one than you originally wanted to which could offset the benefits you get from doing so. Fredrik provides insight for how he balances things out by explaining how these diagrams should be developed in tandem with the code, and how this can be done more easily.

To do this, he talks about using a tool called Mermaid, which is effectively a way to create a diagram from pseudocode. It’s very similar to a tool we were taught to use in class, called PlantUML, the key difference is that Mermaid is simpler, but faster. These “diagram as code” tools can also be version controlled which helps with keeping them updated as the code changes. 

I chose this blog specifically because it shows an anecdotal perspective of how UML is used in the real world; my main takeaways are that completeness isn’t necessarily the main priority of them, rather they need to be able to communicate (effectively but also quickly) the code, how it works, and it’s reason for existing. Shifting your priorities like this allows you to make them more quickly, which in my opinion makes them more realistic to not only create, but actively update as the project develops. Moving forward I definitely think that adopting this approach is a good idea, and probably something I will start doing.

From the blog Joshua's Blog by Joshua D. and used with permission of the author. All other rights reserved by the author.