Category Archives: CS@Worcester

Monoliths and Microservices

Students often focus on code with a singular program as the goal. However, there are many different software architectures to consider based on the scope and specifications of a software. The article linked below gave a detailed comparison of two major architectures types: monolithic and microservices. A monolithic architecture is like the all-in-one software solution. […]

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

UML Diagrams

Unified Modeling Language (UML) is an important tool in software development that helps developers visualize, design, and document the structure of their systems. It allows developers, project managers, and stakeholders to communicate with a medium that is easier to digest and explain. This week, I found a blog that introduces UML diagrams, “What is a UML Diagram?” from Miro. Miro gives an in-depth view of the types, benefits, and when to use UML diagrams.

Early in our course, we discussed and modeled Sequence and Class Diagrams. I chose this resource because of that foundation and because it is a great starting point for beginners. It also explained more diagram types than presented in class.

The blog explains that UML is a standardized modeling language used to visually represent a system’s design in a understandable way. It highlights two main types of diagrams, each with their own subtypes.

  1. Structural Diagrams: These visualize the components in the system and their relationships. Some examples include:
    • Class Diagram: The static structure of a system showing classes, attributes, and relationships.
    • Package Diagram: Shows how packages and their dependencies are organized within the system
    • Deployment Diagram: Shows how software and hardware interact
  2. Behavioral Diagrams: These visualize the system’s behavior over time. It is the dynamic behavior of the system. Some examples include:
    • Activity Diagram: Visualized the flow of activities within a system.
    • Sequence Diagram: Shows how objects interact over time.
    • Use Case Diagram: Shows the functionality of the system from the user’s perspective.

The post then describes the benefits of UML diagrams, such as simplifying complex ideas/code and improving team collaboration. It finishes by explaining the best practices and when to use UML diagrams.

This post helped me shore up my lacking knowledge of UML diagram types. I was unaware of most diagram types discussed, so it was nice to see what they were and how they were properly used. The site also provided a link to a diagram maker with some of the types which could be useful in the future.

The benefits were also insightful. The main takeaway was that the UML diagrams keep everyone on the same page. From the technically inclined to those lacking knowledge, you can communicate the system’s functions effectively. This seems especially true for those working in teams with different specialties. Having a roadmap for the system’s functions with a standard notation that everyone can understand allows the team to work more efficiently. In the future, I will use UML diagrams to keep everyone involved in our projects on the same page so we can collaborate to make our software more effective.

Resource: https://miro.com/diagramming/what-is-a-uml-diagram/#1.-simplifies-complex-ideas-and-systems

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

Love and hate relationship between clean code and Writing documentation

The blog examines the contradiction in which developers emphasize the importance of writing clean code while frequently overlooking the necessity of documentation, even though documentation plays a vital role in software maintenance and in mitigating technical debt. Research demonstrates that high-quality documentation significantly boosts productivity by reducing the time required for tasks and enhancing the quality of code. A comprehensive meta-analysis of more than 60 scholarly articles revealed that effective documentation has a beneficial effect on multiple facets of software development.

Despite these advantages, developers often prioritize other tasks over documentation, particularly when faced with stringent deadlines and an emphasis on delivering functional code, a common scenario in Agile methodologies. This tendency results in informal and outdated documentation, which can contribute to an increase in technical debt.

I selected this blog due to its relevance to my current studies, as it facilitates the application of concepts to my own coding practices. As a student, I find this article on clean code and documentation particularly valuable because it underscores the frequently neglected but crucial importance of documentation in the realm of software development. Although many educational programs prioritize clean code, this article effectively addresses the connection between quality documentation and its benefits, such as fostering collaboration, minimizing technical debt, and enhancing overall productivity. Furthermore, it provides perspectives on real-world challenges, including stringent deadlines and Agile methodologies, thereby equipping students to navigate the intricacies of professional settings.

A significant insight gained was the impact of documentation on fostering collaboration and minimizing technical debt elements that are closely tied to my group projects and individual coding endeavors. The discussion surrounding AI-enhanced documentation highlighted the transformative potential of automation in optimizing development processes. This revelation has motivated me to investigate tools that can facilitate documentation in both my ongoing and upcoming projects. As I progress, I intend to adopt improved documentation practices within my coding routine, acknowledging that such efforts not only enhance my comprehension but also render my work more approachable for others.

Blog: https://stackoverflow.blog/2024/12/19/developers-hate-documentation-ai-generated-toil-work/

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

SemVer or CalVer: When to Use

Understanding Versioning: SemVer vs. CalVer Most software, libraries, games, etc… will come with a version number attached. Often times, it is easy to just gloss over this and not pay much attention, however that number can reveal important information. The article linked below compares 2 types of versioning you may encounter. Semantic Versioning (SemVer) – […]

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

To Scrum or Not to Scrum

This semester, we spent plenty of time learning about and discussing Agile and Scrum. We learned about the framework and how it can be implemented in teams, as well as the performance advantages of teams that use it. However, just as not every tool is right for every job, it is just as important to […]

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

Backend Development

Backend development is the backbone of any software application. It handles the functionality behind the scenes, supporting interactions between the users and the application or website. The backend manages databases and server-side logic so modern applications remain efficient, scalable, and reliable. Understanding the principles of backend development is essential for developers to create effective software.

For this week’s post, I found a resource discussing key elements of backend development called “Mastering Backend Development” by Dan for Roadmap.sh. Dan introduces a roadmap for becoming an effective backend developer, and in this post, he discusses some of the steps on this roadmap in detail.

Backend development has been a key component of our class. I chose this resource because it is connected to the course, and the roadmap seems accessible to new developers. Having a path for your research and actionable steps to take can help with any knowledge gaps or roadblocks in understanding backend development.

This resource outlines 19 important steps or knowledge necessary for backend development. I have limited the summary to those I found interesting or instructive.

Caching Strategies: Improving the performance by storing copies of frequently requested data, reducing database load, and speeding up responses.

Authentication and Authorization: Ensures only authorized users access the system by implementing security measures.

Architectural Patterns: Picking the correct pattern, like Monolithic or Microservices, helps build scalable and maintainable systems.

Observability and Monitoring: Provide tools to monitor the system’s health, optimize performance, and diagnose issues.

Continuous Learning: Staying up-to-date with technologies, frameworks, and best practices. This ensures developers can adapt to the rapid evolution of backend development.

Some steps seem self-explanatory, but they could provide a good foundation for someone new to backend development. I could see how new developers could choose to prioritize the software’s functionality while forgetting its efficiency, security, and diagnostics. The post also offered plenty of tools to help with each step, like Redis and Memcached for caching strategies and OAuth and JWT for authentication and authorization.

I felt Dan gave an excellent synopsis of the research needed for new developers. Plenty of steps were not readily apparent to me, like cashing or your system’s self-diagnostics. These steps will likely present themselves in development, but for someone with little experience, it gives a good direction for research. This mindset aligns with the last step, continuous learning, and the importance of staying proactive regarding new challenges and technologies. In the future, I will research these backend concepts and stay up to date so I can produce and maintain better backend software.

Resource: https://dev.to/roadmapsh/mastering-backend-development-mpb

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

Refactoring Tech Debt

While studying for my most recent exam in CS-343, I came across a phrase I was familiar with but did not know the meaning of: technical debt. I had a vague understanding and understood refactoring’s purpose to repay technical debt, but I was not positive. I came across an article on increment.com talking about refactoring the definition of technical debt into technical wealth. This article’s title is Reframing Tech Debt by Leemay Nassery

The article discusses the concept of tech debt, which is the accumulation of negative choices made during product development that can hinder long-term system efficiency. The article proposes reframing it as tech wealth. The article begins by explaining that tech debt arises from quick fixes and shortcuts taken to meet product goals. This debt leads to system inefficiencies that accumulate over time. Tech wealth reframes this idea as an investment in building scalable systems that improve developer productivity, system stability, and overall team happiness. A key example comes in the form of an automated deployment system, which makes all development afterwards faster. Tech debt is often seen as a nuisance or a negative aspect of engineering, but through tech wealth you allocate time to improve the code’s architecture. The article argues that addressing tech debt (or building tech wealth) should be prioritized, as it ultimately saves time and resources in the long term. The article gives some example strategies to build tech wealth:
1. Allocate Time in Planning Cycles: Teams should allocate a portion of their engineering capacity to work on tech wealth alongside feature development. For example, 20% of the time can be dedicated to tech wealth activities such as automating processes or improving system architecture.
2. Quarterly Focus: Teams can also dedicate a few cycles per quarter to focus entirely on tech wealth, using this time to clean up past code and improve the system’s foundation.

The article closes with a conclusion that suggests rethinking tech debt as tech wealth and incorporating this mindset into planning cycles. This shift not only benefits engineers but also leads to improved product outcomes for users, even if the benefits aren’t always immediately visible.

This article was essential in my complete understanding of the importance of technical debt. Through this article I was able to conclude strategies to tackle technical debt, and the power to be found in conquering it. I found the automated deployment example most tangible as I have had struggles developing in environments without that feature. Tackling these issues is an interest of mine and I am excited to read more.

https://increment.com/planning/reframing-tech-debt/

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.

Git Learning

Git is a strong version control system that allows collaboration, monitors changes, and ensures project integrity. The Atlassian Git course explains key techniques like branching, merging, and maintaining a clean commit history, which are critical for effective development workflows. It describes how teams can work independently on feature development using branches without interfering with the main codebase, and how merging techniques guarantee that changes are seamlessly integrated. In order to show how Git can manage intricate projects with several contributors, advanced techniques like rebasing and resolving merge conflicts are also discussed. These ideas are supported by the official Git documentation, which offers comprehensive instructions on topics including marking releases, stashing changes, and fixing errors. I selected these resources because they offer a comprehensive grasp of Git’s features, which are essential for contemporary software development. They provide useful insights into how Git might improve team operations and avoid common development problems, building on the version control system lessons we covered in class. The focus on crafting relevant commit messages, for instance, relates to our lessons on preserving traceability and clarity in software projects. Their emphasis on bridging the gap between complex workflows like conflict resolution and cherry-picking modifications and beginner-friendly techniques like basic commits and branching is another factor in the selection of these resources. These guidelines have demonstrated to me that Git is about more than just code storage; it’s also about fostering teamwork, accountability, and transparency. 

One idea that struck a deep chord was that of “atomic commits.” Atomic commits highlight how crucial it is to organize changes into logical chunks so that each commit embodies a single, coherent concept. Debugging, tracking project history, and undoing particular changes without causing unexpected consequences are all made simpler by this procedure. Changing my perspective has had a big impact on how I handle version control. For instance, I now make extra effort to commit often and make sure that the context and goal of the modifications are explained in detail in my commit messages. In order to eliminate extraneous noise in the project history, I have also begun utilizing Git’s interactive staging functionality to include only pertinent changes in each commit. I want to apply these Git best practices into every project I work on going forward. For example, I’ll employ branching more methodically, making sure that experiments, bug fixes, and features are separated for simpler testing and evaluation. In order to find areas for improvement and keep the repository clear and understandable, I also plan to make it a practice to routinely review the commit history. In order to maintain uniformity and cooperation, I will also urge team members to adhere to the same procedures. By doing this, I hope to enhance both individual productivity and productive teamwork by producing high-quality code and establishing a clear, stable, and future-proof project history.

From the blog CS@Worcester – A Bostonians Blogs by Abdulhafeedh Sotunbo and used with permission of the author. All other rights reserved by the author.

Agileeeee

Agile methods emphasize flexibility, collaboration, and iterative development to deliver high-quality software efficiently. The Scrum Guide explores core practices like sprint planning, daily stand-ups, and retrospective meetings, which help teams adapt to changing requirements and ensure continuous improvement. It highlights the importance of clear roles, such as the Product Owner, Scrum Master, and Development Team, to maintain focus and accountability. Similarly, the Agile Manifesto underscores values like prioritizing individuals and interactions, working software, and customer collaboration over rigid processes. Together, these resources demonstrate how Agile methodologies foster an environment of transparency and adaptability while driving innovation and customer satisfaction. 

I selected these resources because they offer a thorough comprehension of Agile principles, which are critical to contemporary software development. They enhance our classroom instruction on iterative processes and team dynamics, which has made it easier for me to understand how Agile promotes productivity in practical settings. These tools were chosen in part because they emphasize useful strategies like prioritizing client input and dividing work into digestible chunks. These guidelines are particularly helpful for keeping projects moving forward and avoiding the problems associated with strict, long-term planning. For instance, I had trouble with scope creep and late deliverables in earlier projects. Following my study of these materials, I came to understand how Agile frameworks, such as Scrum and Kanban, might lessen these problems by encouraging gradual development and frequent review cycles.

One concept that resonated deeply was the principle of “embracing change.” Rather than viewing changing requirements as a hindrance, Agile promotes adapting to them as a competitive advantage. This mindset has changed how I approach project management. I now see flexibility as an integral part of the development process rather than a disruption. Moving forward, I plan to integrate Agile practices like iterative development and regular retrospectives into my work. By doing so, I aim to create workflows that are not only efficient and adaptive but also aligned with customer needs and evolving goals.

Moving forward, I plan to integrate Agile practices like iterative development, regular retrospectives, and active stakeholder involvement into my work. To guarantee that all stakeholders are included and that input is consistently implemented, for example, I try to include user stories and sprint reviews. In order to increase focus and productivity, I also plan to implement the timeboxing concept. By doing this, I hope to develop processes that are not only effective and flexible but also in line with changing objectives and client needs. In addition, I want to create a cooperative atmosphere where candid communication and mutual responsibility propel the project ahead. By using these techniques, I will be able to provide not only functional software but also long-lasting solutions that genuinely satisfy user needs.

From the blog CS@Worcester – A Bostonians Blogs by Abdulhafeedh Sotunbo and used with permission of the author. All other rights reserved by the author.

The new partnership between GitLab and Amazon Q

A brand new partnership was just created between GitLab and Amazon Q. It has revolutionized the traditional flow of software development with its new AI capabilities. Now with the help of Amazon Q’s ai driven assistant developers now can get help in complex tasks including feature development, code reviews, and even codebase upgrades. Developers can use Amazon Q with simple commands in GitLab, which can streamline their workflow and boost productivity. The partnership offers capabilities like automated code generation, assisted code reviews, and legacy code upgrades, all inside of GitLab. This helps developers be able to focus their time on other tasks required for development rather than coding in order to enhance their productivity. 

The reason I chose this specific resource was because throughout the entire semester we mainly used GitLab and I believed that it had a lot to do with the majority of what we learned in class. Not only this, but because ai is one of the biggest topics and technologies in the world right now and I believed that this new partnership with GitLab was going to make every aspect of it much easier and make it much more efficient and efficiency in coding is another topic we went over in class a lot as well, with Scrum and Agile principles. I also believed that this would be not only important for me to learn, but others as well since this new program helps with many of the slowest parts of coding. I believed that it was a tool that would serve not only me, but everyone else who is majoring in computer science very well. This new information has also changed the way I think about software development as it shows that ai is not just some popular, interesting and controversial media topic, but now it is a useful tool that is being included into the daily process of developers. It is clear that anyone who wants to one day be a software developer must be able to not only code well, but also know how to use ai in the most efficient way possible. 

I plan on using this in the future by using AI more to be able to assist me in generating code, but also to stay mindful on a good balance between ai and my own ideas in order to make sure my coding is the most efficient it can possibly be and to keep the quality of my code as high as I can.

Link: https://aws.amazon.com/blogs/aws/introducing-gitlab-duo-with-amazon-q/

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