Category Archives: Quarter-2

BLOG 2 – Agile vs Scrum

There are many different methodologies that can be used for project management. The two that I would like the most are Agile methodology and Scrum methodology. So, what are the differences between these two methodologies, and when is choosing the right one? In this article, I want to summarize the key differences between agile and Scrum methodologies based on what I just read from Northeastern University Graduate Programs. Their article is really helpful for me and you to understand what they are and their differences. The article link is posted below. Feel free to check it out for further information: 

Agile vs. Scrum: What’s the Difference?

Agile vs. Scrum: What’s the Difference?

By Shayna Jouber

What is Agile Project Management? 

People say that Agile is a way of thinking about project management that focuses on delivering in small steps, being in touch with customers, and being able to adapt to change. Agile doesn’t tell you what process to use; instead, it gives you ideals and principles (like those in the Agile Manifesto) that you may use with other methods (like Scrum, Kanban, XP, etc.).\

Important traits: constant communication with customers and end users, willingness to change the scope of work, and delivering work in small steps.

What is Scrum Project Management?

One such approach in the Agile family is Scrum. It offers a clear procedure for handling tasks, including who completes them, how they are arranged, and when they are finished.

Typical Scrum responsibilities include a cross-functional team, a product owner who is in charge of optimizing the product’s value, and a scrum master who makes sure the team follows Scrum procedures.

Work is divided into sprints, which typically last two to four weeks. The team decides which subset of the scope to finish at a sprint planning meeting. Every sprint concludes with a review and retrospective to consider what was accomplished and make improvements.

Frequent delivery of “shippable” increments as opposed to waiting until the project is finished to provide everything is one of the clear benefits.

Agile vs Scrum – Key differences 

Agile is the underlying idea or strategy, and Scrum is a way to put Agile into practice.

Scrum is always Agile since it adheres to Agile principles, but utilizing Agile does not imply using Scrum; you may choose to use another Agile methodology instead.

Choosing the Right Methodology 

  • Agile: Agile makes sense if the project requires flexibility, frequent testing, stakeholder feedback, and shifting requirements.
  • Scrum: Scrum usually works well in situations with a lot of uncertainty, rapid changes, and the ability to arrange into sprint cycles.

Selecting the approach is only one aspect of it; another is having strong communication, leadership, critical thinking, project management, and organizational dynamics skills.

Conclusion 

Don’t use “Agile” and “Scrum” interchangeably; Agile is more comprehensive, and Scrum is one way to achieve it.

Before choosing Agile, consider the context of your project; if you decide on Agile, select the appropriate approach.

Methodology is only one aspect of successful project management; other factors include teamwork, stakeholder engagement, effective leadership, and flexibility.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Understanding Team Management

Proper team management is the crux of a well-oiled workflow and a productive team. This blog post by Alicia Schneider highlights not only what good team management is but also how to achieve that and improve your own management skills. Team management covers not only the coordination of oneself and fellow members of the group, but also facilitating and supporting the members through communication and ensuring a healthy and positive work environment that uplifts and motivates all. Clear roles and tasks through delegation are vital in ensuring that everyone knows their job at the overarching goal, as well as giving credit and praise to those who deserve it for a job well done. There are multiple types of management styles, which include:

Autocratic: Managers make decisions without input from team members

Democratic: Team members share ideas and thoughts in decisions that will affect the team before coming to a consensus

Laissez-faire: The Manager allows the team to self-manage with only minor input

Transformational: Managers’ main goal is to inspire and motivate the team to innovate

Transactional: Reward and penalize team members based on their completion of tasks and following outlined instructions

Collaborative: Managers help the team to work together, while the team focuses on working together and making decisions as a group

Coach: Give guidance, support, and advice to team members to improve and develop skills

Servant: Predominantly focused on fostering the growth of the team members

I chose this topic because it aligns with the current lecture material, such as Scrum and Agile workflows. Team management is key for these. No matter one’s role, there is always self-management and teams working in such close collaboration that everyone is managing each other. While the role of leadership may be delegated to a predefined position in these structures, management still relies on communication between people, such as between developers in the Scrum workflow. After reading the blog post, my overall notion of team management has expanded in terms of how to develop my management ideas. I had originally just seen it as delegating tasks and facilitating discussion, but it is actually much deeper after reading. While I myself may not agree with all of the management styles, I find that there are things that can be pulled from them to become a more effective leader and supportive team member, such as fostering the growth of team members from the “Servant” style, which is a great idea to also implement with the “Coach” style of giving guidance and support. By blending the management styles like this, I believe that it will help to produce not only a more productive team but also a more positive environment with great morale. I look forward to implementing these ideas in my future teams I work in and may lead.

Work Cited:

Schneider, A. (2024, August 21). How to manage a team: 6 powerful tips for team management. Monday. October 22, 2025, https://monday.com/blog/teamwork/team-management/

From the blog CS@Worcester – Dan's Blog by Daniel Fung-A-Fat and used with permission of the author. All other rights reserved by the author.

Keep the Code Simple.

In software development, simplicity is further required in coding. It is the foundation of how software genuinely works. Every line of code we write in system, from short programs to large systems, teaches us one major lesson: keeping code simple leads to stronger, cleaner, and further reliable software. When code is simple, it becomes easier to understand how each part of a program interacts, how data flows through the system, and how changes can be made without breaking additional components.

Throughout our computer science class, we learn that writing code is not just about making something run, it’s about designing how it runs. Concepts like encapsulation, abstraction, and modularity form the heart of this process. Encapsulation keeps data protected and managed within defined boundaries. Abstraction allows us to hide unnecessary details so that only the important parts are visible to the developer. Modularity divides complex programs into smaller, independent sections that can be developed, tested, and improved separately. These principles not only make programs easier to understand but also reflect how big software plans are built in real-world projects.

Simplicity also plays pivotal role in collaboration. When multiple developers work on the same clear and consistent code, it allows everyone to read, modify, and contribute without confusion. In our group projects, clear code helps everyone understand and contribute easily. Even when we continue working from home, the project feels simple and organized, not stressful. This clarity saves time, reduces errors, and keeps teamwork smooth.

Another reason simplicity matters are maintenance. As we study different programming software models, we see that maintaining complex code can become easy to modify and frustrating. Clean, readable code allows group members to trace logic quickly and identify issues before they cause system failures. This is why experienced programmers often say, “Code is read more often than it is written.” The goal is not to write the most advanced or impressive code, but to write the most understandable and dependable one.

Keeping code simple also encourages better thinking. It forces us to focus on problem-solving rather than decoration. By keeping things simple, we learn to study the requirements carefully, organize the program’s structure wisely, and create efficient code that works effectively without unnecessary lines. Simplicity shows real understanding of how software functions at its core.

As I continue learning software design, I realize that simplicity is not the opposite of intelligence, it is the best outcome of experience and clarity. The coders don’t make code complex; they make it clear. True creativity in programming lies not in how much we write, but in how well it makes as simple—and that always begins with keeping the code simple.

From the blog CS@Worcester – Pre-Learner —> A Blog Introduction by Aksh Patel and used with permission of the author. All other rights reserved by the author.

Week 2-CS 343 blog: SOAP API

During class, I went over the topic of REST API and how amazing it was to understand and analyze how it works. However, there are many types of API, including REST API, GraphQL APIS, RPC APIS, and SOAP APIs. Today, I would like to go through what catches my attention the most is SOAP APIS. I read an article about explaining how SOAP API work, when to use them, and how they compare with modern REST APIS, and I would love to share it with you. The article is posted below, and feel free to check it out for further information (all the information is according to the article) 

https://blog.postman.com/soap-api-definition/

WHAT is SOAP? 

In the late 1900s, SOAP, a messaging protocol that was developed to enable different systems running on multiple operating systems, languages, and networks, with the purpose is to exchanging structured information reliably 

Unlike REST, SOAP focuses on messages rather than resources. 

SOAP messages are formatted in XML and usually contain: 

  • Envelope – defines the start and end of the message 
  • Header – contains optional information like authentication or transaction details 
  • Body – holds the actual request or response data 
  • Fault – handles errors 

How SOAP works?  

A SOAP client sends an XML request to a server, which also responds with another XML message. These communications often occur over HTTP (but sometimes also SMTP, TCP, or UDP) 

  • SOAP messages are defined by the Web Services Description Language (WSDL) to describe the operations, parameters, and return types

Advantages of SOAP

  • Platform independent – works across languages and OS. 
  • Protocol flexible – not limited to HTTPS 
  • Strong security – supports encryption and authentication 
  • Error handling – display clear fault messages 
  • The ideal workplace, where rigid relationships and dependability are essential 

Disadvantages of SOAP 

  • More complex and verbose than REST 
  • Harder to evolve or version 
  • Slower performance due to XML analysis 
  • It is less appropriate for web applications because of its limited catching support. 

Common Use Cases 

SOAP API is commonly used in banking, telecommunications, transportation, and enterprise systems – these cases require reliability, structured data, and strict security. 

  • Examples: 

In banking, SOAP API is used for bank transfers.

In transportation, flight booking systems 

ETC, ….

Shipping and logistics services 

Conclusion 

SOAP API is a great protocol, robust and standardized, but compared to REST, it’s less flexible. REST is better for modern web applications and faster iteration. SOAP API is always needed and valuable for many applications that prioritize security, reliability, and formal structure.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Quarter-2 Blog Post

The blog post I decided to talk about is on “Design Smells” in software development. I chose this topic because we’ve touched on it in class during assignments where we matched the correct design smell to its definition. It’s an important concept to understand since we’ll be working with API designs and need to know how to avoid these issues. In the post written by Keith Casey, he compares design smells to your car sounding weird or your “Spidey Senses” going off, subtle signs that something is off with your code or design. He focuses on four main design smells: Inconsistent naming, CRUD-only APIs, Customer-specific features, and Per-resource versioning.

He gives a realistic example of inconsistent naming with variables like interest_rate, intRate, and iRate. It might seem like a small problem, but those tiny differences can cause major confusion (Opacity). While it may look like just a style issue, it often shows that team members have different understandings of the same concept. I’ve seen this happen in class, where one student uses userName and another uses username. It makes the code harder to read and maintain. In the future, I think it’s important for teams or individuals to agree on consistent variable names early, so the code stays clean and easy to follow.

The next design smell discussed is “CRUD over HTTP”. I wasn’t too familiar with this one, so it was interesting to read about. This happens when an API just wraps a database without adding any real logic (Needless Complexity), which the author calls a “glorified database.” Using methods like GET, POST, PUT, and DELETE might seem correct, but if your API only moves data around, it’s not doing much. A good API should validate input, include logic, and make the system useful beyond basic storage. We’ve talked about these HTTP methods in class, learning how each one interacts with data, so this gave me new ideas. Before, I only thought about what each method did; now I’ll think more about what the API is modeling and how it supports the system’s purpose.

For the last two design smells, customer-specific functionality and per-resource versioning, both show how small design changes can turn into big headaches. Customer specific functionality happens when a team adds a feature to please one customer. It sounds harmless, but every tweak adds complexity, more testing, and a higher chance for things to break. The author makes a good point to inspect each request carefully and compare it with the API’s design. The last design smell gives each resource its own version number. It may sound flexible, but it quickly becomes messy and confusing for users. These two examples show that good design means knowing when to say no and keeping things simple within the API.

Overall, this blog post helped me understand how small details can affect the bigger picture in software design. “Design smells” can be avoided with a little attention and ensuring not adding things than can be needlessly complex.

Source: https://caseysoftware.com/blog/api-design-smells

From the blog CS@Worcester – Mike's Byte-sized by mclark141cbd9e67b5 and used with permission of the author. All other rights reserved by the author.

More Information on Agile and Scrum

I decided to write this self-directed blog entry on an article I found regarding information and differences between Agile and Scrum, two topics we have recently been covering in class. I sought to learn more about these two topics, as I was not entirely confident in my understanding of them. I unfortunately was absent due to an illness on the day we covered the Agile methodology in class, so in order to get a better understanding on the topic, I went through the activity and learned more about it on my own time. This article summarizes what Agile and Scrum are, their differences, the core Agile values and principles, the basics of Scrum, and when and how they should be utilized. This was quite a thorough read and was very informative to reinforce what I had learned from the class. One thing that I did not immediately connect from class was that Scrum was based on the Agile philosophies. As best said in the article, Agile is the guiding principles to shape how you work, Scrum gives a structured playbook to follow.

Though I do not plan to go into software development as a career path, I think this is still a beneficial way to learn quality teamwork and collaboration. Regardless of concentration or field of study, computer science and information systems related disciplines require efficient teamwork and collaboration. Working professionally in the field for four years now, there has never been a project or major task that involved no one besides myself. I always had to work with different teams to accomplish the final goal that was needed. Learning this framework could be very beneficial for me moving forward so I can apply it to my future professional projects. Having better tools almost always leads to a better job done, and I always strive to improve and better myself as a technology professional.

One discovery made from this article is that there are other common implementations of Agile outside of Scrum. One of these, I recognized from my professional experience, as my current organization requires all full-time staff to participate in Lean training. I was not aware that Lean training, which according to the article, “aims to eliminate waste and maximize customer value by focusing on efficiency and continuous improvement,” was an extension of the Agile methodology. This is critical, especially in the healthcare environment that I work in. It is an everchanging field and an environment that can change drastically within a matter of seconds. Though I am not a full-time employee and have yet to participate in that training, I will participate in it once I resume full-time work permanently at the end of December 2025.

ZG

The link to the blog post: https://monday.com/blog/rnd/agile-vs-scrum/

, ,

From the blog CS@Worcester – zach goddard by Zach Goddard and used with permission of the author. All other rights reserved by the author.

Learning RESTful Designs Principles

So for this second quarter’s professional development activity, i read the Stack Overflow post, “Best practices for REST API design”(https://stackoverflow.blog/2020/03/02/best-practices-for-rest-api-design/), in basics it covers the fundamental guidelines for designing Restful APIs that are both efficient and developer-friendly, covering some key principles like properly structuring URLs, making sure to use nouns instead of verbs when it comes to endpoint naming, implementing HTTP methods accordingly to standards as well as ensuring consistency in API design. The post also talks a little bit about versioning, error handling and security as vital aspects of any production-level API.

I selected this specific resource considering it does relate to what we were doing in class and some of our homework as well, since we’re getting involved on building maintainable, modular systems and REST APIs are just one of the common interfaces used in modern software architecture, for anyone trying to work in backend development you can deepen your understanding of how to design APIs that other developers can easily understand, use and extend to some degree.

From the rest of the article(no pun intended), I learned that REST isn’t just about making the things in question work but having a consistent and predictable interface that makes client-server communication easier. I like how the article broke down best practices for naming conventions, like how using resource-based URIs like /users or /orders/1234 instead of action-based ones like /getUser makes the API more intuitive. I also remembered about the significance of using HTTP status codes, like 201 Created for successful POST requests or 404 Not Found for missing resources. These small details can contribute somewhat to API usability and maintainability.

So i’d say pretty much that the article reinforces the more architectural concepts that we’ve discussed before in class, like abstraction, modularity and encapsulation. An API that is well-designed abstracts away complex backend logic and presents a clean, understandable interface much like how we design modules in general when it comes to software construction. I also like to think that it connects to our work when it comes to some other software design principles like separation of concerns and loose coupling. RESTful Design makes it so that different parts of a system can evolve independently, which is essential for large-scale software projects.

If i had to reflect on this after my reading of the article, i would say that i realize on some occasions i find myself taking shortcuts when designing endpoints for personal projects, mostly just trying to focus on making sure it’s functionality is in suitable position as opposed to focusing on structure, but after my reading i think i’ll try to be more deliberate when it comes to naming conventions, HTTP method uses and documentation.

Overall, this resource gave me a clearer framework for thinking about web service design, and I can already see how it will help me create more scalable and maintainable software in future projects.

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

Principle of Least Knowledge (AKA Law of Demeter)

Hello everyone, today I will be talking about the Principle of Least Knowledge (AKA Law of Demeter). When first looking into this topic I was unsure of exactly what this was and how it would be applied to programming. When doing my research I found the Khouri College of Computer Sciences at North Eastern University had a page dedicated to this topic, where this law was first introduced.

General Formulation

Illustration of the Law of Demeter, highlighting the principle of limiting interactions between objects.

The LoD is essentially a simple style rule for designing object oriented systems.

“Only talk to your immediate friends” is the motto. 

Professor Leiberherr, the author, states a formulation of “Each unit should have only limited knowledge about other units: only units “closely” related to the current unit.” Its main motivation is to control information overload thus helping memory management as each item is closely related.

You can informally summarize the Law with these three formulations:

  • Each method can only send messages to a limited set of objects, namely to the argument objects and to the immediate subparts of the class to which the method is attached.
  • Each method is “dependent” on a limited set of objects (organize dependencies)
  • Each method “collaborates” with a limited set of objects (organize collaborations)

To formulate the Law we can choose from the following independent possibilities:

  • Object/Class
    • Class formulation is intended to be compile-time
    • Object formulation is intended to be followed conceptually
  • Messages/Generic functions/Methods
  • Weak/Strong
    • If we interpret it as all instance variables, including the inherited ones, we get the weak form of the Law. If we exclude the inherited instance variables, we get the strong form of the Law.

Benefits

In a paper written by Leiberherr, there are a couple facts stated for the benefits:

  • If the weak or strong LoD is followed and if class A’s protocol is renamed, then at most the preferred client methods of A and A’s subclasses require modification.
  • If the weak or strong LoD is followed and if the protocol of class A changes, then only preferred client methods of A and its subclasses need to be modified and only methods in the set of potential preferred clients of A and its subclasses need to be added
  • There’s even more benefits highlighted in the paper pertaining to limiting information overload.

Final Thoughts:

Prior to this webpage I knew nothing about this law/principle, however I now understand that it is a fairly useful rule or its respective use case. The law teaches you a way to program Classes, Inheritance, Abstraction, and a few other techniques. Infact There is so much more depth to this that I cant even fully fit it into this blog post. I would highly recommend you check out this page as It contains all the information you need along with sources to learn this.

, ,

From the blog Petraq Mele blog posts by Petraq Mele and used with permission of the author. All other rights reserved by the author.

Blog Post for Quarter 2

October 21st, 2025

Recently, my class has been going over stuff regarding teamwork and ways to approach building a software or product. For example, the waterfall method, agile methodology, and scrum have come up in discussion. This has reminded me of POGIL since POGIL was a group used in the classroom semi-frequently.

Because of this correlation, I decide to look at blogs about POGIL. However, I noticed something interesting about the blog I chose. So I chose two just because I found some things interesting. The first was made with WordPress.com, much like the one I’m making here. It was about POGIL. The blog appeared to just be called “The POGIL Project.” Or, that’s what I have surmised after looking at the web address. Additionally, there was some interesting notes regarding how it appears to be designed for faculty teaching or implementing POGIL based team activities. However, the last post appears to be in 2015, which is not as recent as I’d like. (However, there appears to be someone who has the same name as the author of this blog who is cited to be impactful to the development of POGIL. Which is pretty cool, though I couldn’t concretely find evidence that they were the same person.)

So, I looked for an alternative. The author was not listed which isn’t great but it is recent. It appears to also be about POGIL. But the most interesting part was how it was applied to science as opposed to actual computer science. Actually, both blogs do that as well.

This new blog I picked was basically an overview of how POGIL works and why it is good to use. It overviewed the reasons why POGIL is used and what it is intended to do. It basically overlaps with what I know about POGIL already.

In a way, this is interesting in how this mean POGIL is both universal and useful. It isn’t just a weird Computer Science class thing we do, it’s an actual science thing. Which is definitely more interesting to know about considering I rarely encountered POGIL before college. It probably won’t really affect my opinion on POGIL but it is mildly interesting how it is something that I’ll see around. I guess I can keep that in mind.

FIRST INITIAL BLOG: https://thepogilproject.wordpress.com/

SECOND, REVIEWED BLOG POST: https://www.transtutor.blog/pogil-guide-high-school-biology

From the blog CS@Worcester – Ryan's Blog Maybe. by Ryan N and used with permission of the author. All other rights reserved by the author.

BPM On the Up & Up

With the technological advances and innovations in business continue to exponentially grow within their practices. The biggest challenge is all the pressure they face to stay afloat. From high climbing costs to having the fiercest competition with other companies. Long term, this causes danger to viability and businesses cannot afford to screw up continuously. To address these issues, a software has been implemented that eventually became the foundation of “digital transformation”, according to Digital Journal.

This is called Business Process Management (BPM), a software providing tools to quote “streamline processes, manage compliance, and adapt to shifting market conditions”. BPM is used to touch various different areas like different departments, locations, and IT systems. A revolutionary tactic has been made here, due to this process helping managers efficiently track and pinpoint errors & inefficiencies. Also for the team members, they can have a clear understanding of their goals and mission(s). 

Speaking of efficiency, this is essentially the first and most important benefit (arguably) that users hopefully will recognize. A lot more tasks can be completed in a higher-level manner. Let’s use a couple of examples: finance and healthcare. To treat and prevent illnesses, increased automation creates higher capacity. For financing, provider automation keeps secureness over companies against fraud and error. This translates to transparency, where these companies get to view their status and performance, in turn increasing accountability.

Despite the pros, all ideas come with its cons. BPM is not a straightforward process that is easily implemented whatsoever. Some businesses and organizations are limited in terms of skill gaps, fear of change and redesign complexities. In order to resolve this, companies need to broaden their vision by being open to the idea of BPM. Seeing the benefit will lead to greater outcomes in the performance as a whole.

Why is this important to discuss? The business industry is constantly changing, from the amount of businesses being formed, their structure outlines, idea creations, improving outcomes, etc. Depending on the size of the business (whether it’s yours or you work for one), there needs to be some sort of structure and process to have smooth outputs and less friction. For me personally, I knew that all businesses had their own processes in terms of how they’re run, but BPM is a new term I had never really learned or tapped into.

Moving forward, with the knowledge of programming and software development that I’m currently learning through a curriculum, I can hopefully bring a new/different perspective into a business when I am ready to delve deeper into the work field. Maintaining business process management will improve productivity, so it is not something to ignore at all. 

Source: BPM software and the move toward smarter business practices – Digital Journal

From the blog CS@Worcester – theJCBlog by Jancarlos Ferreira and used with permission of the author. All other rights reserved by the author.