Category Archives: CS-348

Agile vs Waterfall

Week 12 – 11/30/2024

Agile Versus Waterfall: Picking the Right Tool for the Job

As a senior in college, I’m starting to think more seriously about what it will actually be like to work on projects in the real world. I recently read a blog post that compared and contrasted Agile and Waterfall project management methodologies, and it really helped me understand the importance of choosing the right approach for different types of projects. This aligns perfectly with what we’ve been discussing in my class about the need for both strategic planning and adaptability.

The blog post “Agile vs. Waterfall: Understanding the Differences” by Mike Sweeney explained that Waterfall is a very linear, sequential approach, where each phase of the project must be completed before moving on to the next. It’s kind of like building a house – you need to lay the foundation before you can put up the walls. This makes Waterfall a good choice for projects where the requirements are well-defined and unlikely to change, like in construction or manufacturing. In these industries, making changes mid-project can be super costly and impractical, so having a clear plan from the outset is essential.

Agile, on the other hand, is all about flexibility and iteration. The project is broken down into short cycles called sprints, and the team continuously reevaluates priorities and adjusts its approach based on feedback and new information. This makes Agile a great fit for projects where the requirements are likely to evolve over time, such as software development. In software development, client needs and market trends can change rapidly, so being able to adapt is crucial.

One of the biggest takeaways for me was the realization that choosing the right methodology is crucial for project success. I used to think that being flexible was always the best approach, but now I understand that structure and predictability can be equally important in certain situations. The key is to carefully assess the project requirements and choose the methodology that best aligns with those needs.

As I prepare to enter the professional workspace, I feel much more confident in my ability to approach projects strategically. Thanks to this blog post, I now have a better understanding of when to use Agile versus Waterfall. For instance, if I’m working on a software project that involves a lot of client interaction, I’d probably lean towards Agile. But if I’m managing a marketing campaign with well-defined objectives, Waterfall might be a more appropriate choice.

The real-world examples provided in the blog post were super helpful in illustrating how these methodologies are applied in different industries. This practical insight will definitely be valuable as I transition from the academic world to the professional world.

Blog link: https://clearcode.cc/blog/agile-vs-waterfall-method/

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

Code Review

Source: https://about.gitlab.com/topics/version-control/what-is-code-review/

This article is titled “What is a code review?” As clearly stated by the title, the article explains the processes of code reviewing. “A code review is a peer review of code that helps developers ensure or improve the code quality before they merge and ship it.” Code reviews help in the identification of bugs, increase the overall quality of code, and enhance understanding of the source code. Code review, as suggested in the name, happens after a software developer has finished coding. Code needs to be checked before it is merged into an upstream branch for bugs or conflicts. A code reviewer “can be from any team or group as long as they’re a domain expert. If the lines of code cover more than one domain, two experts should review the code.” Adhering to a solid code review process allows for continuous improvement of code and aims to ensure that faulty code isn’t being implemented for customers/users to see and use. This process isn’t just important for the code itself, but also for all of the team members of a software development project. Whilst reviewing the code, meaningful knowledge of the source code is shared between team members to ensure that it is being implemented properly. The main benefits of the code review process are: the sharing of knowledge, discovering bugs earlier, maintaining compliance, enhancing security, increasing collaboration, and improving code quality. Code reviews allow for maintaining compliance because different developers have different backgrounds and thus different personal processes when they are developing. Code reviews allow these people to get together and maintain a standard coding style. Security is enhanced because “security team members can review code for vulnerabilities and alert developers to the threat. Code reviews are a great complement to automated scans and tests that detect security vulnerabilities.” There are many benefits to code review, but there are some disadvantages, including: longer time to ship, focuses being pulled from other tasks, and large reviews mean longer review times. These can be described as necessary evils due to the sheer amount of positives that code reviews offer in software development.

I chose this article because it was published by GitLab, a software that we are heavily using in class for version control, and I thought that it would be interesting to read this specific topic from the syllabus. Version control softwares such as GitLab allow code reviews to happen, so diving deeper into the topic in an article published by this popular software company was tempting. Before reading this article I understood that code reviews were important to pinpoint any bugs or difficulties before merging code into the upstream, but I never really thought about the implications of security or different development styles. I’ll definitely keep this information in mind during future code reviews on the job to remind myself that bugs aren’t the only important thing during a code review.

From the blog CS@Worcester – Shawn In Tech by Shawn Budzinski and used with permission of the author. All other rights reserved by the author.

Why Git

Why is it always git

Photo by RealToughCandy.com on Pexels.com

The version control system that every programmer uses. Even in my computer science class, we had lectures dedicated to Git, the commands in Git, how Git is used, what Git is used for, and just so much Git. The funny thing, is there are other version control systems such as Mercurial, but they aren’t ever brought up they are there but feel overshadowed by git. So the question I am asking now is why Git. So I did some investigating.

The question: what does Git do that is so special compared to other version control systems? Now version control systems can do all sorts of things such as allowing developers to see what has been changed, enable collaborative work, and branch and merge changes to a repo. If multiple can do this, then what does git do differently? An article from Geeks For Geeks lists several. Git can be worked on offline and is resilient because multiple developers can have copies of the repo, and any local repo can be used to restore a project. It also comes with conflict resolution that’s allows one to handle merge conflicts by providing tools to solve those problems. So what about the other systems. Well, GFG got that covered. Here are some comparisons.

Subversion

Compared to Git, the architecture is centralized, one single central repo

Fewer branching and merging options

Better performance

Mercurial

Smaller community compared to Git

Not as much flexibility as Git

Perforce

Can handle very large code base

Not as flexible as Git in terms of merging

Git is Open Source and Free, while Perforce isn’t

That is a decent amount of reasons to use Git over other VCS. I think the community part is important for such a popular system, because if you aren’t too familiar with the commands that come with Git, then you have a lot of people that can help. There are a lot of forums and articles about Git tools out there if you ever need it.

I also feel that the collaborative aspect of Git is, very helpful. A lot of projects have a lot of people working on them, so having something like Git that can handle it and make the task easier is great. Also, the fact that it is accessible helps with that too.

Git being so popular makes a lot of sense now, accessibility, community, and collaboration are what a lot of developers require, and I have to say Git provides that well.

GeeksforGeeks. (2024, September 19). Git vs. other version control systems: Why Git stands out? https://www.geeksforgeeks.org/git-vs-other-version-control-systems-why-git-stands-out/

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

Understanding The Waterfall Methodology

At the start of the semester, we talked about Software Methodologies, and one of the topics we covered was the Waterfall Methodology. The article I chose focuses on the Waterfall Methodology, which emphasizes completing and approving each phase before moving to the next. This approach helps reduce errors, making the process more time-efficient and improving project documentation.

The Software Development Life Cycle (SDLC) is divided into six phases: requirement analysis, software design, planning, software development, deployment, and testing. When the Waterfall Model is applied to the SDLC, it adds structure by defining the time and duration for each phase. This helps developers and teams better understand how long the process will take and what to expect at each step.

The article also explains when the Waterfall Model is the best choice for a project. Since every methodology is different, this model works well for projects with clear concepts, less complexity, a solid and unchanging plan, and minimal room for errors (no repeated phases). It’s commonly used in industries like healthcare and banking. The article also discusses the advantages and disadvantages of the Waterfall Methodology.

One advantage I really like is that each phase is completed one at a time, providing a clear and straightforward plan for programmers to follow. However, a disadvantage I find inefficient is that progress can be slow, which might make it harder to estimate when the project will be completed.

The article outlines the distinct phases of the Waterfall Model:

  • Requirement Analysis: Gathering and documenting what the software needs to achieve.
  • System Design: Translating requirements into system specifications, including hardware and architecture considerations.
  • Implementation: Developing individual units or components based on the design.
  • Testing: Integrating and rigorously testing components to find and fix issues.
  • Deployment: Releasing the completed software to clients or the market.
  • Maintenance: Providing ongoing support, including patches, bug fixes, and updates.

I chose this article because it provides a clear and concise explanation of the Waterfall Model. I also wanted to learn more about this methodology and how it differs from others. Waterfall is one of the more popular choices among engineers and developers, and now I understand why. Its structured approach makes it appealing for certain types of projects, even though it may not always be the fastest.

Looking ahead, I want to apply what I’ve learned about the Waterfall Methodology to my future career as a software engineer and projects like my Software Capstone class next semester. Understanding how to plan and organize phases systematically will be important for delivering a successful project. I also want to explore other software methodologies to understand their strengths and weaknesses. Knowing when and what type of project each methodology works best for will help me decide how to approach different challenges in my career.

Source:
What Is The Waterfall Model?

Citation:
Team, Codecademy. “What Is the Waterfall Model for Software Development?” Codecademy Blog, 7 June 2024, http://www.codecademy.com/resources/blog/what-is-the-waterfall-model/. 

From the blog CS@Worcester – CodedBear by donna abayon and used with permission of the author. All other rights reserved by the author.

(Week-12) Copyright and Licensing in Software Development

A lot of developers today mistakenly think that publishing code without a license automatically makes it free for public use. However, under copyright law, code without an explicit license is still technically the property of the original owner. That means that any users cannot legally copy, modify, or distribute it without permission. This can lead to legal disputes, misuse of the code, or anything the original owner did not intend. Posting code on GitHub without a license is defaulted to GitHub’s terms, which allows for limited collaboration but restricts use at larger scale.

When it comes to software projects, making sure you have the right license that fits the needs of the project is extremely important to how others interact with your code.  Typically licenses of this nature fall under two categories, a copyleft license or a permissive license.  A copyleft license, such as the GNU General Public License (GPL), ensures that any derivative works must retain the same license.  These licenses promote transparency and guarantee that the software and its derivatives remain open-source. This is for developers who want to foster a community, make improvements from others testing, and prevent proprietary derivatives.  However, some large companies may avoid this technique, as they could be giving a competitive advantage to other competitors interested in their work.  On the other hand, permissive licenses, such as the MIT or Apache 2.0 licenses, allow derivatives to be licensed under proprietary terms. This approach provides as much “freedom” as possible, while making it easier for businesses to use the code without copyright issues. While this can lead to a large increase in usage, it could get out of hand when companies don’t submit their versions of the code.

“How Copyright Works (Part 5): Copyright Licenses in Simple Terms”, is a short video by the Youtube channel What is Law Even.  It is the last installment of a 5-part series that explains the many rigid aspects of copyright law, and how it is used in the context of today.  This installment focuses on the basics of copyright law, and specifically the license aspect of the law.  The narrator explains what a copyright license is, and the possible royalties that may be attached to that respective license.  It is a great straightforward video that is short, but filled with quick bits of knowledge important in the copyright sphere.

In short terms, copyright licensing is extremely important when it comes to software development.  Licenses are a key part of a project’s workflow, and even when they aren’t explicitly stated, there is a good chance there is still one in the background.  Always be weary of the copyright laws as they are only there to protect owners from unlawful practices against their projects.

Link: https://www.youtube.com/watch?v=XjwOTNBRFpE

  • 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.

What is Scrum?

Understanding Scrum: A Framework for Team Success

Scrum, a popular framework for managing complex projects, has transformed the way teams collaborate to deliver value. I explored this in-depth explanation through an article I found on Scrum.org. This provided a clear overview of the principles, offering how Scrum facilitates productivity and adaptability in many different environments.

A Quick Summary

The article breaks down Scrum as a “framework” designed to help teams address complex problems while delivering high-value results. Originating from Agile principles, Scrum relies on time-boxed iterations called Sprints, typically lasting two to four weeks, where teams focus on completing a specific set of tasks. Key roles in Scrum include the Product Owner, who prioritizes work; the Scrum Master, who ensures the process runs smoothly; and the Development Team, which executes the tasks.

Scrum also emphasizes artifacts like the Product Backlog and Sprint Backlog, which guide work priorities and task distribution. Regular ceremonies such as Sprint Planning, Daily Standups, Sprint Reviews, and Retrospectives foster transparency and continuous improvement.

Why I Chose This Resource

We learned this in class and I think it is a good refresher to read. In the world of of software development, I often think of projects where collaboration and adaptability are required. Scrum is a cornerstone of Agile development, making it a vital topic to understand for both academic projects and industry roles. This article stood out for its clarity, structured explanation, and relevance to course concepts, particularly software design and project management.

Reflections

The article reinforced the value of frameworks in managing stressful development cycles. I was interested by the emphasis on teamwork and iterative progress. While individual accountability is important, Scrum places significant focus on collaboration, encouraging team members to engage in problem-solving and decision-making collectively.

A key takeaway for me was the importance of transparency, which Scrum achieves through its artifacts and ceremonies. For example, the Daily Standup ensures that every team member is aligned, minimizing the risk of miscommunication, something I can apply to my group projects in the future.

What I plan to use

In future group projects, I aim to incorporate elements of Scrum, such as structured meetings and task prioritization using a backlog. For example, if I do have a software development project, I plan to propose implementing a Sprint-like system where my team can review progress and adjust objectives weekly. Long term, understanding Scrum positions me better for internships and career roles where Agile methodologies are prevalent.

This article not only described what Scrum is but for me also underscored its practical applications, affirming its relevance to professional sides.

From the blog CS@Worcester – function & form by Nathan Bui and used with permission of the author. All other rights reserved by the author.

Docker: Diving In

After understanding the team aspects of software development, I wanted to shift focus to the tools at a team’s disposal. In conjunction with version control software, development environments become among the most important tools at a tem’s disposal. In projects outside of class I am working closely with docker, and we briefly utilized it to prepare for CS-448 capstone. I wanted to spend more time learning about these development environments. To do so I found an article on the basics of understanding Docker. The article’s title is In-depth Docker by Walter Code

This blog post begins by outlining what it contains. The article expands on configuration management, Docker’s technical components, and Dockerfile commands. Walter explains that configuration management builds on Docker’s layered image management, which addresses issues with traditional “golden image” models that often lead to unmanageable images. Docker’s approach allows for faster iteration and better flexibility. The article continues to highlight some key technical components such as isolation of filesystems, processes, and networks, and resource management via cgroups. Docker is extremely flexible and can run on any x64 host with a modern Linux kernel, and is compatible with OS X and Windows via virtual machines. The post also introduces Docker’s user interfaces, such as Shipyard, Portainer, and Kitematic, which help with container management. Walter also touches on essential Dockerfile commands, like ADD, CMD, and RUN, which are covered to help users configure containers. The article wraps up by discussing Docker’s filesystem layers that allow changes to be applied to a writable layer while keeping underlying read-only layers intact. Additionally, Docker Compose enables users to manage multi-container application stacks, while Docker Swarm helps scale workloads across container clusters. The post finishes by highlighting Docker’s simplicity, security, and rapid deployment, making it a compelling tool for developers, with more practical examples to follow in future posts.

This article helped me better understand how Docker can be essential for teams. It also provided me with more knowledge to aid me in my personal projects that utilize docker. This is a key step for me in understanding how best to work with a team with these tools. What I found most helpful was an explanation of how Docker’s configuration management could be used, and why docker compose is so useful. Next in my blog I will cover more strategies or tools to help me better function in a team for software development. 

Source:https://waltercode.medium.com/in-depth-docker-faa0c4dd9a63

From the blog CS@Worcester – WSU CS Blog: Ben Gelineau by Ben Gelineau and used with permission of the author. All other rights reserved by the author.

Clean code and reality.

 

The
article examines the question, “is clean code by Robert Martin still matters?” From
author’s 16-year coding experience, he writes about reality in writing clean
code and its criticism. He acknowledges that t in the end meeting the deadline
with functional and bug free code is more important then elegant code following
the principle of clean code. However, he argues in the end as a developer,
trying to integrate small aspects of clean code into your code base is going to
make your skill improve as an engineer in the long run even if many people will
not care about it.

I selected this
article as it addresses some uncertainty that I had with clean code. All the
code I have written feels like I got pressure to deliver functional code as
quickly as possible and now I’m supposed to write elegant, maintainable code so
I wanted to see the real live example from experience if clean code was that necessary.
The author’s real-world experience and practical approach toward the subject made
it an interesting topic to delve into deeper.

This article showed
that clean code is not something you have to write all the thing following to
it, it is about finding the right balance between quality code following the
clean code and functional code. I feel like clean code still matters in a bit
as we want to write a code in time but needs to make it modular to be abled to be
easily refactored for later uses. Not only that, this article advice to start
small feels realistic and something I can do to grow as a programmer.  The hierarchy of what matters in the software
part will be my checklist in the future as it is the basic outline of how the
code needs to be structured. When writing code, the working code always comes first,
then make it without bug and if there is bug, you should be able to be fixed
easily then I will try to add instance of small parts of clean code in. I want
to make the code a bit modular because I spent hours trying to refactor code sometimes
and finding which part of the code went wrong took a long time because my code
was always a mess. Therefore, I feel like idea of clean code by Robert martin
is not dead but only small part of it is still alive to become better
programmer. As the most important thing for programming is to make software
that is easy to maintain, adapt and scale.

 

Article
link :
https://tommcfarlin.com/who-cares-about-clean-code/

 

From the blog Sung Jin's CS Devlopemnt Blog by Unknown and used with permission of the author. All other rights reserved by the author.

Mastering Github

This post dives deep into the problem of developers not having an in-depth understanding of the code that they or their peers write. It’s a common occurence that code is covered in errors and holes that prevent it from getting done what it was initially made to do. This is a common problem among teams of developers who work together on projects. However, Github has resources to target these issues such as the Copilot function which helps to fill in code where they might see fit. Another issue is the lack of teamwork and communication in these projects between the developers. Github also promotes collaboration and frequent code reviews heavily to increase that engagement factor that helps to bring developers together more often to create a more successful code.

This post does a great job at touching upon this problem in the coding world that not a lot of people realize can be solved with just the simple solutions of better teamwork and the resources that Github offers. These simple solutions are very commonly overlooked as developers can just want to rush their projects or believe they don’t need extra reviewing. This important especially since Github is a very widely used platform for coding. It’s part of a blog that continously does posts about updates globally in the world of technology. They talk about topics ranging from new use of A.I. in farming to the U.K. involvement in trying to improve connectivity and broadband issues. It’s a great website overall to keep expanding your knowledge in today’s world of technology.

I will definitely use this post to my advantage. I also believe that good code comes out of well-coordinated team work and Github definitively has resources to foster a good work environment. The more that people are able to bounce ideas as well as concerns with each other in a project, the more the project is to come out as thorough as possible. The code reviews I think are especially great as they allow the developers to take a pause on their work for a bit and reflect on what’s already there. With more frequent edits and reviews, the possibility of a bigger problem with more undoable mistakes happening later on is decreased.

Blog link: https://www.computerweekly.com/news/366567312/GitHub-Top-tips-to-make-software-developers-more-productive

From the blog CS@Worcester – coding.upcoming by Simran Kaur and used with permission of the author. All other rights reserved by the author.

Clean code and reality.

 

The
article examines the question, “is clean code by Robert Martin still matters?” From
author’s 16-year coding experience, he writes about reality in writing clean
code and its criticism. He acknowledges that t in the end meeting the deadline
with functional and bug free code is more important then elegant code following
the principle of clean code. However, he argues in the end as a developer,
trying to integrate small aspects of clean code into your code base is going to
make your skill improve as an engineer in the long run even if many people will
not care about it.

I selected this
article as it addresses some uncertainty that I had with clean code. All the
code I have written feels like I got pressure to deliver functional code as
quickly as possible and now I’m supposed to write elegant, maintainable code so
I wanted to see the real live example from experience if clean code was that necessary.
The author’s real-world experience and practical approach toward the subject made
it an interesting topic to delve into deeper.

This article showed
that clean code is not something you have to write all the thing following to
it, it is about finding the right balance between quality code following the
clean code and functional code. I feel like clean code still matters in a bit
as we want to write a code in time but needs to make it modular to be abled to be
easily refactored for later uses. Not only that, this article advice to start
small feels realistic and something I can do to grow as a programmer.  The hierarchy of what matters in the software
part will be my checklist in the future as it is the basic outline of how the
code needs to be structured. When writing code, the working code always comes first,
then make it without bug and if there is bug, you should be able to be fixed
easily then I will try to add instance of small parts of clean code in. I want
to make the code a bit modular because I spent hours trying to refactor code sometimes
and finding which part of the code went wrong took a long time because my code
was always a mess. Therefore, I feel like idea of clean code by Robert martin
is not dead but only small part of it is still alive to become better
programmer. As the most important thing for programming is to make software
that is easy to maintain, adapt and scale.

 

Article
link :
https://tommcfarlin.com/who-cares-about-clean-code/

 

From the blog Sung Jin's CS Devlopemnt Blog by Unknown and used with permission of the author. All other rights reserved by the author.