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.

This week, I am going to discuss some of the benefits of the output-oriented software development methodologies we have been studying in class, like Scrum and Agile. I have built many projects both on my own and for my career from the ground up, which is where the value of these methodologies is most apparent to me. The blog post I will be referencing throughout this discussion can be found here. This post provides an in-depth overview of the Agile methodology, including lower-level analysis of different stages of the process, benefits and purposes of each stage, and various best practices for different stages. I chose this post because it correctly emphasizes the importance the Agile methodology places on continuous delivery, which is something that has been a cornerstone for me in various projects.

A project that comes to mind is actually the same project I discussed in this week’s post for CS-343. A friend came to me and asked for something way above my skill level, and it was daunting to imagine planning out the whole project and implementing/deploying some large framework in any reasonable amount of time. If I hadn’t remembered something an old professional connection had said to me years prior, I don’t think I ever could have known where to start: “your code has to exist before it can be made better.” I think that is what the heart of these continuous delivery methodologies is really about, and it really is a true statement for many reasons. The first, which this blog touches on and which we have discussed briefly in class, is that your perspective will always be better or wider after the work is started. Another reason that statement holds true, and perhaps the most practical reason (at least in my case), is that half the time, I don’t even know what I am doing when I start. It would be impossible for me to design anything, because I don’t know anything. For me, learning my way through a project is almost all the fun, and that is not really an option without methodologies like Scrum and Agile, even if I don’t know I’m using them. This blog post discusses release management a lot, which is not so applicable to personal projects, but I think it connects nicely if you compare a release to a checkpoint or successful implementation of a new feature. In my project, as I built it, I started with: what. Then, I said, I guess I could try that. Then, I implemented a single shoddy feature. I saw my feature and saw a way to make it better. Compound that a hundred times, and I had a full framework that I had approached incrementally, following Agile principles and release management without even knowing it. I think that is a testament to the elegance of these continuous delivery oriented methodologies, and I will more consciously follow these principles moving forward.

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.

In this post, I will be discussing some basic concepts about abstraction in object-oriented programming. The resource I reference can be found here. I chose this topic because in the first few group activities, I was made aware that I had forgotten some of the key differences between kinds of abstraction (at least in Java), such as the difference between an abstract class and an interface. Though we reviewed these differences in class, I wanted to continue to find specific examples that would allow me to better understand the concept. Abu’s blog post briefly explains what abstraction in object-oriented programming is, some of its benefits/purposes, and some elementary examples of how to implement (no pun intended) abstract classes and interfaces.

The largest point of note I want to discuss is the benefit of modularity when abstraction is implemented. I recently finished up a personal coding project, in which modular development was a necessity. The project involved a central framework capable of ingesting a very specific kind of data from different websites, but each of the websites had a different way of providing that data. The most efficient answer I could think of was to make the central framework independent of the websites themselves, and to make it deal only with the data after it was obtained. I then created a module for each website that held the data, and implemented whatever logic I needed to in order to get the data and pass it to the central framework. I used Python for this project, but in hindsight, I may have been better suited to implement an object-oriented programming language like Java. Each module could have been a concrete class that extends some abstract class Parser, as each of my parser modules in my Python project used the same methods anyways. Each module had a get_url_and_interactions() function, a get_parse_function() function, and an stm() function (we can leave that abstract for now). It would have been very simple to use an object-oriented programming language, as I could have abstracted what it means to be a parser.

Now, this worked fine; since I was the only developer on the project, and had full visibility over all of the code, I didn’t need to check if a module implemented, for example, the get_url_and_interactions() function. I knew that it did. Moving forward, if I were coding more collaboratively with anyone else, or even if I just wanted to code according to some better practices moving forward, I could have used abstraction to standardize the parsers to ensure they all implemented certain methods or functions.

Though a little cliche, I do think it is very nice and elegant that the same thing can be accomplished in so many different ways. I think it is a good metaphor for most problems worth solving.

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.

Sunday, September 15, 2024

This week I was introduced to Object-Oriented Design Principles. In this week’s blog, I will be discussing what object-oriented design principles are and how these principles help with creating software so that it is easy to maintain.

The Medium blog post by Ravi Patel “Understanding Object-Oriented Design Principles” offers an overview of major object-oriented design principles and how they help to the creation of successful and maintainable software. Object-Oriented Design (OOD) is a software design methodology that views the program as a collection of interacting objects, each representing an instance of a class. Ravi goes on to discuss the fundamental principles, encapsulation, abstraction, inheritance, and polymorphism.

Encapsulation is the process of grouping data and methods that operate on it into a single unit or class while restricting access to certain of the object’s components. This aids in concealing the internal state and requires all interactions to be conducted through an object’s methods.

Abstraction is the process of simplifying complicated systems by modeling classes based on key traits and behaviors, while obscuring unneeded information. This focuses on an object’s actions rather than its methods.

Inheritance allows a new class to inherit characteristics and methods from an existing class, enabling code reuse and establishing a hierarchical connection between classes.

Polymorphism allows objects to be viewed as instances of their parent class rather than their own. This enables the use of a single interface for a broad range of activities, increasing code flexibility and extensibility.

I chose this blog post because it helped me understand the principles better. After this week’s reading I now understand that object oriented principles is a theory that helps developers in how to think about and build code that is easier to work with, simpler to understand, and requires less maintenance overall. When working on my POGIL activity with my team this week, there was a question that asked us to define the principles without looking them up. We defined the principles as follows:

Abstraction is simplifying code
Encapsulation is adding code to already existing code
Polymorphism is many forms of code/methods
Inheritance are classes and their super classes and constructors

Our definitions were not entirely wrong. We could gather what each principle meant to an extent. I see myself applying these principles in my future projects. It would help create readable code that can also be modified easily as needed. This week’s material made me understand that not all long code is helpful. The simpler the code is the better it is for the next developer to read it. When I usually code, I add a lot of unnecessary code that does not need to be there. I hope to improve my code writing skills as I learn more.

Blog link: https://medium.com/@ravipatel.it/understanding-object-oriented-design-principles-0c1e48207c89  

From the blog CS@Worcester – computingDiaries by hndaie and used with permission of the author. All other rights reserved by the author.

This week I discovered a blog that caught my attention. The blog discusses the incorporation of psychology into the process of software development. Spending extended periods seated, analyzing codes, searching for logical operations and function calls can exhaust our cognitive abilities. The fatigues could lead us to feel cloudy and have poor resolution. It goes deeper into the mind of a software developer mind on how one’s retain information, problem-solving approach, perceive the behavior and structure of what they’re building. It introduces study concept such as spaced repetition and interleaved practice that have been proven to enhance a person to learn new programming languages or frameworks. I believe that integrating psychological insights into software development can help enhance both individual mental well-being and professional skills.

The blog has eight topics, one of the first paragraph of the first one said,

“A team that communicates openly and respects each member’s input is more likely to solve problems effectively and innovate. On the other hand, a team mired in unresolved conflicts and poor communication can derail even the most promising projects.”

“Linking these psychological insights to Agile practices offers a fascinating avenue for enhancing team-based methodologies. Agile’s iterative approach and emphasis on collaboration are well-suited to leverage the strengths of a psychologically savvy team.”

While managing my team during group activities on Methodology, I believe it is more beneficial for everyone to feel comfortable being their authentic selves rather than feeling anxious and reserved. I think the idea of Agile practices can assists them in expressing their ideas and feeling at ease within the group. Continuing to utilize Agile methods can result in increased efficiency and effective communication within a team to meet project deadlines.

“I recall an instance where a single line of feedback transformed a junior developer’s approach to coding. It wasn’t my code review that pointed out the errors; it was my remark about his unique problem-solving skills that made his eyes light up.” I concur that helping one another to solve a problem or code in an easier way because everyone have different background with coding. Therefore, feedback and mentoring is crucial when it comes to coding. One person code could load faster and less complicated than another. Positive reinforcement can amplify a person’s strengths.

Reading this blog helps me understand how psychology is integrated into software development. All of these aspects, such as team-work, leadership, problem-solving, cognitive biases, feedback, and coaching, can be advantageous when viewed through a psychological lens. It motivates us to improve ourselves and others by helping each other enhance our skills and cognitive abilities. Where we find inspiration daily.

Blog URL: https://betterprogramming.pub/integrating-psychology-into-software-development-c5f79fc8019e

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

Agile is a set of values and principles that software developers and/or managers use to encourage a positive work environment that is efficient, and promotes a successful workflow.  Agile is becoming the gold standard for software development and programming, because it is inherently based on collaboration.  Not only does it encourage intense collaboration with members of the development team, but also the customers they are making the product for.  A core tenant of Agile is to not only keep the team on the same page, but also stay transparent with the customer and accommodate their every need with the product.  Here are some important values and principles Agile is based on: “Working software over comprehensive documentation”, “Simplicity”, “Responding to change”, “Customer collaboration”, “Human communication”, and last but not least: “Continuous attention to technical excellence”.  These aren’t the only values, but they are some of the most important ones. 

“An Ultimate Guide to Agile Software Development” is an informative video about Agile Software Development, by the YouTube channel Invensis Learning.  In the video, the narrator discusses how Agile is beneficial for teams specifically in the Software Development field.  They describe Agile Software Development as a “set of iterative software development methodologies in which requirements and solutions arise from collaboration among self-organizing cross-functional teams”.  This is very important to understanding Agile, and its uses in the workplace.  Agile allows for teams working on different parts of a project to stay on the same page, and not get ahead of their peers, while still having room for improvement and disagreement.  They also go on to explain how a company following Agile doesn’t necessarily mean there isn’t a manager coordinating these things, but it suggests that each sub-group should be able to handle their problems on their own.  The video also discusses the “Agile Software Development Life Cycle”, which touches on how Software Development teams should roughly plan out their work for a product.  The cycles can differ from company to company based on the amount of employees, type of work, customer expectations, etc.  But, the values and principles should stay the same to maximize Agile efficiency.  The Agile Life Cycle follows six important steps, Concept, Inception, Iteration, Release, Maintenance, and Retirement.

To sum up today’s topic, Agile is a set of values and principles primarily used by software developers to make the workplace much more efficient and stress-free.  Agile promotes customer collaboration, and in-house collaboration with peers to ensure the product is as perfect as possible.  Over time, most software development companies will come to develop these principles, as they have been proven to be one of the best work strategies.

LINK TO VIDEO: https://www.youtube.com/watch?v=Evl5f2CnR08

• Elliot Benoit

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

This blogpost by Martin Fowler was very interesting! It gave a very thorough and comprehensive look into what makes the agile methodology so different from older methodologies, which were very bureaucratic and abrasive when it came to change. It also showed why the principles of the more flexible, adaptive agile methodology helped to give more freedom to the developers and helped to create a better product for the developer’s clients. Reading all this put it into perspective for me how I will most likely be using this methodology in the future when I eventually go out to begin working and how this would really help to tighten up a team’s workflow and give them a better ability to put out a quality product. I really liked how as the post progressed there was a sort of small history about agile and how this blogpost was originally actually a means of pulling together most of the original ideas for the agile methodology in the past. I also understand now that agile really is just a perspective you need to have while working with a team and for a client that will help you to maintain a positive relationship with customers and maintain an efficient team. In the future I can assuredly see myself being apart of or using this methodology to develop software as it seems to be much more effective than older methods. The only thing I need to really look forward to is actually attempting to use the methodology as I don’t really have an understanding for how it would actually work or flow in practice. In essence, I think I picked this most of all because I still had questions about agile that have thoroughly been answered now, but I overall I hope for a chance to give it a try eventually in the future.

Summary: An in-depth discussion examining the difference in principles between the different methodologies of software process and an essentially original look at how agile developed and its methods, while also giving a sort-of mini history about agile and what it meant and means to developers.

Reason: I wanted a better more all-encompassing understanding of agile as I feel like I had heard this term outside of the course before, so I investigated it and came across this blog-post that seemed like it had a very detailed examination of it.

Blog Link: The New Methodology (martinfowler.com)

From the blog CS@Worcester – aRomeoDev by aromeo4f978d012d4 and used with permission of the author. All other rights reserved by the author.