Category Archives: CS@Worcester

Scrum

Pushing the Ball Forward Together

Photo by Ollie Craig on Pexels.com

Hello Debug Ducker here and recently I studied a framework used by Software Developers referred to as Scrum. Scrum is a framework that is meant to help teams find adaptive solutions for complex tasks. In layman’s is, it is a way to get hard things done small pieces at a time.

If you are wondering if Scrum is an acronym, well no it is a reference to a scrum in rugby in which teams in rugby work together to move the ball forward, which relates to teams working together to move the product forward.

The idea of Scrum is based on empiricism which is a theory that knowledge comes from experience and lean thinking to which means to focus on the essentials. The Scrum framework consists of the Scrum Team which encompasses the Product Owner, Developer, and Scrum Master who have different accountabilities on a project.

There are also very important pillars to take into account when talking about sprint which are Transparency, Inspection, and Adaptation, which can’t work well without each other. Inspection and adaption work as there is a lot of ongoing feedback during the process.

I was interested in the topic as I have recently learned about it in my software processes class and wanted to share my thoughts on it. As my understanding of it goes, it is based on reducing complexity by having different roles and small teams to handle the task. It also has steps that should be followed that are in specific time boxes, time boxes being the maximum amount of time the step can go on. The Scrum involves a time length for the task, referred to as a Sprint, that goes on specifically for 1 month or less.

I can see myself using this framework in the future, as it helps make those complex tasks easier to handle, especially in group projects. If a task is too great, then perhaps Scrum should be used to make sure the task is not as bad and easier to handle for the groups’ sake. Even though Scrum in this instance refers to Software Development, I can see it being used in other possible fields that involve working together, but that’s just me. There is more to Scrum than just what is referred to here, there is a free guide online that I recommend any viewer interested in software development to check up known as the Scrum Guide that can guide you through it. The link to is down below.

The Scrum Guide

 That will be all from, have a nice day.

The 2020 scrum GUIDETM. Scrum Guide | Scrum Guides. (n.d.). https://scrumguides.org/scrum-guide.html#the-sprint

What is Scrum?. Scrum.org. (n.d.). https://www.scrum.org/resources/what-scrum-module

From the blog CS@Worcester – Debug Duck by debugducker and used with permission of the author. All other rights reserved by the author.

UML Diagrams: Use-Case, Activity, and Deployment

Link to blog: https://developer.ibm.com/articles/an-introduction-to-uml/

To start off the new semester and new course, we’ve been learning, discussing, and practicing with UML diagrams, or Unified Modeling Language diagrams. These diagrams are great ways for software developers and companies to visualize the structure of programs, large or small. There are many different types of diagrams, and we’ve mainly covered Class Diagrams and Sequence diagrams. 

Although I am unsure about the popularity and usage of UML diagrams in professional environments, I believe they can be beneficial to the organization and cleanliness of a team’s code, for it is to be written after it has already been structured and designed. The article I chose today is one by Donald Bell on IBM, and it discusses a few types of UML diagrams with some background information on each.

Bell introduces a new topic to the audience as well as anyone should: with some background information. He states the creation of UML was to model computer applications and ensure that anyone who understands UML diagrams can efficiently, accurately, and productively contribute to the project. 

The first UML diagram covered is the Use-Case diagram. Such diagrams are utilized to help readers understand the interaction between the program and its users. There can be many Use-Case diagrams for one program, but they are more so used to highlight the essentials. Bell describes how to create this type of diagram so that it is easy to understand.

The second UML diagram covered is the Activity Diagram, which shows “the procedural flow of control between two or more class objects while processing an activity” (Bell). Bell believes the best-case scenario for this type of diagram is for more business-oriented visualizations, such as how a company wants to operate at a higher level. These types of diagrams are not as technical as other diagrams which makes it easier to understand for non-programmers (Bell).

The last UML diagram Bell covers is the Deployment Diagram, which shows the physical representation of a software system. This would mean user computers, databases, websites, etc.

I selected this article because it covers a few UML diagrams that we haven’t discussed in class, and it is important for software developers to have some UML proficiency.  This would be a beneficial skill to have at a new job, so you might understand the codebase faster. IBM is also a very credible company in the software industry which is why I chose an article from their website.

The content of the resource was presented in an understandable way for someone with a little bit of software knowledge. I enjoyed learning about the background of UML and its creation, along with the three types of UML diagrams that were listed and described. I hope to use such knowledge at a new job that may use UML diagrams so I could provide more productivity in a shorter time rather than taking too much time trying to understand the codebase.

From the blog CS@Worcester – Josh's Coding Journey by joshuafife and used with permission of the author. All other rights reserved by the author.

version control

For this week’s blog post, I will be focusing on Version control. Version control is a software tool  that helps software teams and programmers keep track  of updates when working on a project. In a software team, there are multiple people in a group and there are multiple changes made  in a project. Multiple users in a team are working on different files under the same project folder, and  through version control  each team mate’s work progress is saved. For software teams and programmers, through version control, updates and changes in a project folder can be traced, and a user can view what lines in a file have been modified, deleted, added. During times when dealing with errors, with  version control  users can track back to where exactly in their code an error is occurring.

When I was choosing a topic for this week, this topic was important to me because I wanted to build upon what I know about git. I am glad that in this course we are going to spend time on git. Over the summer, I worked on a few different software projects. When I was first starting off, I didn’t know much about version control. As time went on, I became familiar with how  version control works. I had used a version control called Git. With git, I was able to use version control in visual studio code. When I was doing these projects, I wished that I had used version control to fix or prevent errors. In  Introduction to programming and in unix programming, we are taught   to test or run code in small bits,  and not build a whole program and run it at once. When I was doing these projects, I was building a whole program and running it, but as time went on, I realized that I should work with simple parts of code at a time. 

Moving forward, I want to double check my code, and I can do that through version control, and make that when working with code to apply the techniques taught to me in previous classes. For software teams, there  is a branch where software teams work independently on parts of a project,  and can merge their parts together. 

Branch can be effective as teammates can work on their parts  of code, make sure there are no errors, and bring together their error free parts of a  program. 

Blog url:  What is version control | Atlassian Git Tutorial

From the blog CS@Worcester – jonathan's computer journey by Jonathan Mujjumbi and used with permission of the author. All other rights reserved by the author.

Fecophiles and their stinky code

The blog post I chose comes from a widely known programming blog, The Clean Code Blog. The Clean Code Blog is written by Robert C. Martin (Uncle Bob). The post we will be discussing today was posted on January 20, 2012, and is called “Fecophiles”. The post focuses on two subjects: refactoring and code smell. It talks about a section of code that was refactored by someone and, oddly enough, received negative feedback from some of his coworkers. To clarify the rest of the post, Uncle Bob refers to “Fecophiles” as people who like to “smell” code. Amidst many harsh, and perhaps aggressive, comments about the coworkers’ reactions, Uncle Bob goes through 13 points proving that the original code under analysis “smells.” Screenshots of the initial code and Uncle Bob’s refactored solution can be found on The Clean Code Blog.

This post caught my attention for a couple of reasons, including how refactoring is helpful and how it addresses code smells. Refactoring is a technique that demonstrates how coding in teams or practicing peer coding is a good practice. Often, the way I see a problem and the solutions I come up with could be completely different from someone else’s. Not only that, but refactoring may also improve runtime, thereby increasing the code’s efficiency. There is always the possibility of a better way to solve a certain problem. A new solution might involve using different or more efficient techniques. A statement I always remind myself of is: “Two heads are better than one.”

On the topic of code smells, I will point out a couple of issues the code in question had. The code exhibited needless complexity and unnecessary repetition. The original code, before refactoring, checked the same condition two or three extra times. Because it repeated the same thing too many times, it became more complex than necessary.

But is such code really that problematic? I don’t think so. I could call it a different way of reaching the same point. Sometimes, the original code was simply an expression of the solution as the developer initially conceived it. The biggest issue is that it should not have been left that way. After writing down the solution to a problem, it may become easier to visualize a different, better approach. This is something I will apply to myself in the future—writing down the solution or coding it, but always reviewing it with the intent of making it cleaner and more functional.

From the blog CS@Worcester – CS Today by Guilherme Salazar Almeida Nazareth and used with permission of the author. All other rights reserved by the author.

On the subject of Inheritance…

In this post, I will be exploring the concept of inheritance in object-oriented programming. Inheritance is one of the core principles of OOP that allows a new class to inherit properties and behaviors from an existing class. The largest benefit of inheritance, in my opinion, is the ability to eliminate unnecessary (or otherwise necessary) repetition in the code. This week, we discussed design smells, and excessive repetition is one that can make code incredibly tedious to read and maintain, and it is one that can be eliminated or minimized by proper use of inheritance. The blog post I will be referencing this week can be found here, and it provides a very detailed example of inheritance as well as some further explanation of vocabulary and more advanced concepts that we have not yet covered in class, like upcasting and downcasting. I chose it because of these extra details it provides; most resources I found about inheritance provide the definition and a basic example, without going much further.

Let’s consider a practical example related to the one used in the blog post. Imagine you’re developing a software application for a zoo. You might have a base class called Animal that includes properties like name, age, and methods such as makeSound(). From this Animal class, you could create specific subclasses like Lion and Elephant. Each of these subclasses would inherit the properties and methods from Animal, allowing you to easily manage common functionality while still being able to define unique behaviors for each animal.

To expand on some of the details provided in the blog post, we could also create an instance mufasa of the Lion class and assign it to some Animal a1 = mufasa;. This would be allowed as upcasting, since Lion extends Animal. We could also then downcast a1 back into an instance of the Lion class, because at runtime, a1 will actually be a Lion instance.

Again, the main advantage of inheritance is its ability to promote code reuse. Instead of duplicating code across multiple classes, you can simply extend an existing class. For instance, if you needed each animal to have a method eat() that does the same thing for any animal, you could just implement it to the Animal class instead, saving time and space and keeping your code cleaner. The elegance of inheritance lies in its ability to create a hierarchy of classes. In our zoo example, you could further extend the Elephant class to create subclasses for different species of elephant, each with its own unique features, all while retaining the common behaviors defined in Elephant. The real world is full of hierarchies, and understanding how we can mirror those relationships programmatically when we want to represent or implement them in our code is a critical skill to have for an object oriented programmer.

From the blog CS@Worcester – Mr. Lancer 987's Blog by Mr. Lancer 987 and used with permission of the author. All other rights reserved by the author.

Scrum: Is it really that bad?

I was reading an article called “Why Scrum Fails” by Jason Godesky. The link is here: Why Scrum Fails | Better Programming. It is pretty a list of much all the pitfalls Scrum contains. The author lists many points for why Scrum is not a good wat to achieve Agility. He criticized the increments saying that they do not focus on customers and giving working software. He then criticizes self-managing teams by saying that managers can interfere. They could see their positions threatened, since there are no managers in scrum teams, and try to squeeze themselves into teams. Managers may try to take management task from the developer’s shoulders as a good gesture but in actuality they take away the team’s autonomy. No one is willing to just give up their role in the company. The author also mentions a “monkey’s paw” situation where companies that want to have a quick and painless way to improve output get it and later stunt the company growth. This is mainly because companies refuse to use Scrum to transform the company but instead delegate it to a developer only thing.

This made me think of what I learned previously about Scrum. I thought it was a structured and reasonable process. First there is the Sprint where ideas turn to value. Then Sprint Planning to plan for the work that will be done. Then the Daily Scrum which acts as a progress report. After that the Scrum Review which inspects outcomes and determines future adaptations. Finally, Review Retrospective which plans for the future. All of this seems reasonable. Although, after reading the article I can start to understand the criticisms. There is no role for the managers. But to counteract this I want to add that the managers could just become Scrum Masters. Maybe the role could be divided into two and have middle managers be involved. Also, there is no focus on working software but that could be added to the Definition of Done. Easy fix. To be honest it is strange to be introduced to something as a positive and helpful and then to immediate learn that it has so many faults.

To conclude, Scrum is not perfect which makes sense since it is man made. Also, a lot of the problems in Scrum is just how the companies enact it. For example, one critism was that Scum is mostly limited to developers and not companywide. Still there are still flaws. Nevertheless, I still think it is relevant to companies and would like to use it in the future. Overall, Scrum is not scum.

From the blog CS@Worcester – My Journey through Comp Sci by Joanna Presume and used with permission of the author. All other rights reserved by the author.

Performance Testing – should never be overlooked

URL: https://blog.scottlogic.com/2024/09/17/performance-testing-the-often-overlooked-ingredient-in-web-application-success.html

Performance testing—the often overlooked ingredient in the success of web applications—was written by Andrew Whitmell. In his post, Andrew explores a certain type of software testing method that he claims is sometimes overlooked. He also discusses various topics to show that performance testing is vital. One of his main points is that, over the years, users and companies have been seeking more and more performance. As Andrew demonstrates with various external data, better software performance leads to better business performance. The different topics presented by Andrew relate to the various benefits that performance testing brings.

I always try to break down my process of selecting something to read or listen to into steps. I do not like to base my decision solely on an article’s title, as it can be misleading. However, I tend to read the article’s title, open it, and also read the subheading. First, Andrew’s title caught my attention because he considers performance testing something that is often overlooked. In my opinion, performance testing should be a priority among testing methods. I chose to write about this post because it presents a different point of view from mine. An application, or the idea of an app, always arises from a need to resolve some kind of issue. Taking this into consideration, we can say that performance should always be a goal of any application.

I would like to highlight a couple of topics covered by Andrew, namely the identification of bottlenecks, the optimization of resource utilization, and SEO boosting. I had not heard of bottleneck identification as a method for improving application performance. Interestingly enough, I was talking to a friend of mine a few days ago about software runtime complexities. We discussed a well-known programming problem called Two-Sum, and he mentioned that utilizing hash maps for this problem improves the runtime complexity from O(n²) to O(n). Just as Andrew points out, the identification of existing bottlenecks in an application can enhance its performance.

The optimization of resource utilization involves testing the program under extreme conditions that are not expected to occur daily. The results from such testing will allow us to identify whether we can better utilize what we have or if we are overspending on certain services. I would also like to mention that SEO boosting is vital for large companies, but not as much for small or local ones. I have seen many local or small companies that do not necessarily provide a web application but have a website for their product. Most of those companies overlook SEO boosting. The amount of time users spend on a certain page depends on its performance, and SEO rankings are highly affected by performance.

From the blog CS@Worcester – CS Today by Guilherme Salazar Almeida Nazareth and used with permission of the author. All other rights reserved by the author.

The downfall of “Scrum”

This week, I will discuss the subject that was recently discussed in class. The topic is “Scrum”, understanding its purpose, application, and limitations compared to Agile. Understanding the specifics of Scrum can enhance teamwork within projects, particularly in software development, where it is a widely utilized project management approach.

The information I researched offered a detailed explanation of the factors that could lead to the failure of Scrum. An essential realization was that following Scrum rules without adapting them to a team’s specific needs could result in too much inflexibility. This really affected me because I have seen situations where teams got stuck in processes and forgot the main objective: delivering value to customers. It caused me to think about past projects in which team members prioritized adhering to protocols over achieving the end goal of creating a useful, practical product. The resource I examined offered a detailed explanation of the factors contributing to the possible downfall of Scrum. One crucial finding was that adhering strictly to Scrum guidelines without adapting them to suit a team’s specific needs could result in too much rigidity. This had a significant effect on me as I have seen situations where teams got stuck in processes, ignoring the main objective of delivering value to customers. It led me to think about past projects where team members prioritized following procedures over delivering a successful, useful end product.

I found out that Scrum offers a structured way of working, but its success depends on teams embracing Agile principles, not just following a set of tasks. The article pointed out that even the best-designed Scrum plans may fail if team members lack commitment or the necessary skills. This has emphasized the significance of establishing a solid team environment in which every member is valued and motivated to take part. The article also delved into how focusing too much on Scrum practices could result in unnecessary bureaucracy, hindering efficiency and restricting innovation.

I chose this blog because I plan to incorporate these lessons by promoting a culture of flexibility in my team. I intend to prioritize the Agile principles of collaboration, customer focus, and adaptability over strictly adhering to Scrum methodologies in our process. Regularly meeting with the team to evaluate our advancement and adaptability will be of utmost importance. Effective communication will allow us to adapt our strategies according to the project’s objectives and the team’s abilities.

Reflecting on the Scrum blog, I discovered its thoughts on the restrictions of the framework to be very informative. It highlighted how sticking strictly to Scrum may impede success, underscoring the need for flexibility. This mirrored my own experiences, as a lack of flexibility frequently resulted in difficulties. I discovered that emphasizing teamwork and transparent communication is essential for providing value. In the future, I intend to foster a flexible culture among my team, consistently communicating to ensure our practices are in line with our goals. This research has enhanced my comprehension of Agile methods and emphasized the importance of flexibility and dedication in project management.

Blog URL: https://medium.com/better-programming/why-scrum-fails-ac92cab05c6a

From the blog CS@Worcester – Matchaman10 by tam nguyen and used with permission of the author. All other rights reserved by the author.

LeadingAgile SoundNotes: an Agile Podcast

Blog Title: Aligning Product-Driven Organizations with Customer Experience: Key Insights

This week, I listened to a podcast titled “How to Align Your Product-Driven Organization to the Customer Experience.”  The episode goes into and explores the challenges that product-driven companies face in ensuring their offerings truly meet customer needs. It explains in detail how organizations can align internal processes and product development strategies in concert with the overall customer experience and emphasizes the importance of both understanding and responding to customer feedback throughout the product life cycle.

The host starts off by discussing the gap that often exists between a company’s internal product focus and what customers actually want. They explain how organizations can get caught up in their own innovations, losing sight of customer pain points. The podcast stresses the need for continuous customer engagement, using both qualitative feedback and quantitative data to drive product decisions. They also highlight the role of cross-functional collaboration, urging teams across departments to work together to create products that not only function well but also deliver real value to users.

I chose this podcast because it directly relates to our course discussions on systems thinking and customer-centric design, both of which are crucial in software development. This points to a greater and broad development process: aligning internal systems with customer’s needs externally. More particularly, I felt that the guest speaker has done a very good job in bridging the gap between product innovations and customer satisfaction, a very crucial gap in most of the tech-driven industries today, including software development.

The one important thing I took from the episode has to do with how significant it is to assess products from a customer’s perspective. This is something that up until this point I had considered in terms of features against functionality. In this podcast, it helped me understand how important it would be to always reassess if those features actually impact the user experience. I also liked the talk about cross functional teams because it helped me confirm that successful collaboration among different departments brings much better results for any product. 

With my understanding now, using what I’ve learned can be used to integrate  into my approach to project work. Whether it’s in software development or product management, understanding the customer’s journey will be key to delivering value. I now see the importance of continuous feedback loops and how integrating customer experience into every phase of development can lead to better, more successful products. This episode has given me a fresh perspective on how to bridge the gap between product design and customer satisfaction, and I’m excited to apply what I’ve learned in future team projects.

Link to Podcast: How to Align Your Product-Driven Organization to the Customer Experience

From the blog CS@Worcester – Harley Philippe's Tech Journal by Harley Philippe and used with permission of the author. All other rights reserved by the author.

WEEK 1 | Employing Agile Methodology In Scrum Master Role.

Article URL: https://clickup.com/blog/scrum-master/

The article chosen, written by the PMO Team, group responsible for moving the needle across various projects at ClickUp, discusses the vital job of a Scrum Master lies in promoting teamwork, eliminating roadblocks, and making sure execution of Agile principles to achieve successful project management !! The article is called “How to Become a Scrum Master: Skills, Tools, and Tips”; in essence, examines the duties and significance of a Scrum Master. The Scrum Master promotes dialogue among stakeholders, the product owner, and the development team while emphasizing the aim of constant enhancement. I personally was interested in this article as it applies to the agile methodology. Agile has been a topic of discussion in our lectures in the past couple of weeks and has been greatly employed in our POGIL activities. To add on to the Scrum Master lesson we had this past week, it was pivotal to come to an understanding of how all this applies together.

I chose this resource because it offers a thorough and understandable summary of the Scrum Master’s responsibilities, which is in line with my studies on Agile techniques and project management in CS-348. I found the article to be very helpful in helping me better grasp Scrum and other Agile methods because it breaks out details of the role in a straightforward way. 

I could relate to the blog post’s topic on a number of levels. I had some misconceptions regarding the function of the Scrum Master, which it cleared up first. I had kind of thought of the Scrum Master as the team’s “administrative” position before reading this. But the article made clear how much more dynamic this position is, needing the person to be a servant + leader who continually strikes a balance between the team’s requirements and productivity while preserving Agile principles. The focus on the Scrum Master as a facilitator rather than ‘traditional’ manager was what really caught my attention. The differentiation matters because it shows how the Scrum Master, instead of assigning tasks, enables the team to self-organize. With this discovery, my perspective on leadership in Agile settings has completely changed. I now see that good leadership is about empowering people to perform at their highest level, not about having control over them.

This resource has taught me that becoming a Scrum Master is more than just knowing the fundamentals of Scrum. It also involves combining soft skills like empathy and communication. This understanding will change the way I handle Agile project management from now on. For example, I now see how crucial it is to maintain a collaborative atmosphere where team members feel motivated and ready to take responsibility for their work. In order to create a positive team environment, I will continue to work on cultivating my assistance techniques and look for roadblocks that might prevent development.

From the blog CS@Worcester – Just A Girl in STEM by Joy Kimani and used with permission of the author. All other rights reserved by the author.