Category Archives: Technology

REST Easy: The API Guide Everyone Needs

In a world where apps constantly exchange information, REST APIs play a major role in making that communication fast, smooth, and reliable. Whether you’re checking your bank balance, ordering Uber Eats, or posting on Instagram, a REST API is working behind the scenes. But what exactly is a REST API, and why does it matter? Let’s break it down in a beginner-friendly way.

What Is a REST API?

A REST (Representational State Transfer) API is a set of rules that allows different software systems to communicate over the internet using simple, predictable URLs. REST is not a programming language, it’s an architectural style that uses standard HTTP methods like GET, POST, PUT, and DELETE to perform operations.

For example:

  • GET retrieves data
  • POST creates new data
  • PUT/PATCH updates data
  • DELETE removes data

Because REST uses these familiar operations, it is easy to understand and widely supported across web technologies.

How REST APIs Work

REST APIs treat everything as a resource, which is represented by a URL. For example, an e-commerce API might represent a product like this:

GET https://api.example.com/users/25

When your app sends that request, the API returns a response often in JSON, a lightweight format that is easy for humans and machines to read.

REST APIs follow a key principle: statelessness. This means the server does not store any information about past requests. Each request must contain everything needed to understand it. This makes REST fast, scalable, and ideal for large applications.

Why REST APIs Are So Popular

Because REST is simple, flexible, and language-independent, it has become the backbone of modern web and mobile development. Companies like Google, Amazon, Meta, Stripe, and Spotify structure their services around REST principles.

  • Simple — They use familiar web protocols like HTTP.
  • Flexible — You can use them with any programming language.
  • Scalable — They handle heavy traffic without breaking.
  • Separation-friendly — Frontend and backend teams can work independently.

Companies like Spotify, Google, and Amazon depend heavily on REST APIs to integrate services and deliver smooth user experiences.

Developers prefer REST APIs because:

  • They are easy to build and maintain
  • They work across many platforms
  • They separate frontend and backend development

In short, REST APIs allow apps to interact smoothly, reliably, and efficiently—powering almost everything we do online.

Conclusion

REST APIs remain one of the most important tools in modern software development. Their simplicity and scalability make them ideal for beginners and professionals alike. Whether you’re building your first backend or integrating external services into an app, understanding REST APIs is essential in today’s tech landscape.

References:

https://www.ibm.com/think/topics/rest-apis

https://www.redhat.com/en/topics/api/what-is-a-rest-api

https://aws.amazon.com/what-is/restful-api

https://www.codecademy.com/article/what-is-rest-api

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

Writing Good Documentation

Sources: Ángel Cereijo and GeeksForGeeks

Writing documentation for your project can be tedious and boring. Say you just finished your project, you published it, and you’re excited to see people use it… but they don’t know how. You need documentation to explain your project. 

Software documentation is the writing that goes along with your project, ranging from what your program does, how you plan to build the program, or any notes you may have for your team. There are four types of documentation: requirement, architectural, technical, and end-user. Requirement documentation explains the requirements for the program and how it should perform. Architectural documentation explains how the program should be structured and how processes should work with each other. Technical documentation explains the technical parts of the program, like the API and algorithms. End-user documentation explains how the software works for the user. 

Good documentation should be created throughout the development process. Saving it all until the end will burn you out and set you back. To prevent this, progress the documentation as you build the project. Split your project into smaller pieces, like how it is done in an Agile setting, and improve the documentation as new features are developed. 

Documentation should explain the purpose of the project as well. It should set up a problem that your program solves and why it is useful to solve the problem. Communicate with your team on how the problem is going to be solved and a plan to get there. Then, split the project up into tasks and assign them to the team members. Explain in detail any information needed for each task. Having the research and plan in writing makes it so anyone can complete the task at any time. As tasks are completed, update the documentation to the project before calling it completed. 

Having explanatory documentation also ensures that tests can be written easily, even without the actual code that is being tested. Then, as you write the code for that task, the tests are already completed and you can move on. 

As your team progresses through the project, your initial plan and process will probably change. With new resources and findings, the initial documentation needs to be updated as well. 

Once your project is published, your documentation is there to help the users easily use your program. It needs to be written in simple language for any reader and avoid ambiguity/unneeded repetition. 

Writing documentation is necessary for every project, helping to communicate with your development team and to serve as a guide to the users. It is important to write good documentation and keep in mind how other people will use it. Having the basics down of writing good documentation will help me in the future and give me a step up as a new software developer. 

From the blog ALIDA NORDQUIST by alidanordquist and used with permission of the author. All other rights reserved by the author.

7 Essential Design Patterns

Design patterns are important for developers to use in their code. They make your programs easy to read and implement and they are able to be adapted to many situations. There are 3 kinds of design patterns: creational, structural, and behavioral. 

Creational patterns are used for creating objects. They give flexibility to change the creation process and allow for many types of objects to be created using the same method. The singleton pattern is used when there should only be one instance of an object. Instead of creating a new object every time you need to call it, you call a method that will call an instance of the object. The builder pattern is used when an object has a lot of optional parameters that make it difficult to know what is being applied when it is created. Using a builder pattern creates an empty or default object and then calls set methods to add each parameter you want to use. The factory pattern is for when there are a lot of objects of a certain type, but with different forms. Instead of creating many new objects, you call a factory to create the objects with the specifications hidden in the factory code. 

Structural patterns are used for how objects relate to each other. These patterns allow for high level code to be readable and simple, while keeping the intricacies hidden below the surface. The facade pattern is used when there are many operations and calculations behind the scenes of a process and those are all hidden with encapsulation. On a high level, one method will, for example, purchase a product, but deeper, there is a payment being processed, shipping calculations, inventory checks, etc. The adapter pattern is for when a program needs to be adapted to fit your code. It can be used for implementing public libraries where their units do not match what your program expects, and each time you use the public library, it calls the adapter to modify the output. 

Behavioral patterns are used for how objects interact with each other. The strategy pattern is used when you have multiple ways of doing a process. Instead of using a lot of if else statements, you can define several strategies and set each object to have a strategy. The observer pattern is used for objects that watch for something. It works by “subscribing” to receive a notification of an event. If a program is watching for errors, it would be automatically notified of any errors so it can add it to a log. 

In class, we went over the strategy, factory, and singleton patterns for the Duck example. These 7 patterns are common practice in the software development field and it’s important to know how to implement them. I watched a video explaining these patterns and now I have a deeper understanding of the three we learned and the four that were new to me. I feel confident I can expand on these in a professional setting.

From the blog ALIDA NORDQUIST by alidanordquist and used with permission of the author. All other rights reserved by the author.

Blog 4 Code Review

I am Dipesh Bhatta, and I am writing this blog entry for CS-348 Software Process Management for Blog Quarter 4. I chose to write about code review and how it connects to software process management. My chosen resource is an article titled “What is a Code Review?” from Atlassian (https://www.atlassian.com/agile/software-development/code-reviews). This passage explains what code review is, why it matters in software development, and how teams use it to maintain quality, consistency, and shared understanding across a project.

The passage defines code review as the practice of examining another developer’s work before it becomes part of the main codebase. It emphasizes that code review is more than a bug-finding activity. It helps improve readability, structure, naming, and overall maintainability. One important idea from the article is that code review serves as a communication channel. When developers submit changes for review, they are also sharing their reasoning and thought process with the team. This allows everyone to stay aligned and ensures that the project follows a predictable and well-managed workflow. These ideas directly connect to the concepts of structured processes and shared ownership that we learn in CS-348.

I chose this resource because code review is a key part of modern software process management. Throughout the semester, we used Git, branches, merge requests, and clean code practices. Code review brings all of these together into a single process that supports collaboration and project organization. Understanding how professional teams use code review helped me see the purpose behind good habits such as writing meaningful commit messages, keeping changes small, and separating different tasks into separate branches. These practices make reviews easier and prevent confusion later.

Another valuable point from the article is how code review helps reduce technical debt early. Small issues, such as unclear variable names or overly complex functions, may not break the program right away, but they make the code harder to maintain. Code review allows teams to fix these problems before they grow. This is especially important in long-term projects, where small mistakes can become costly if left unchecked.

The article also highlights the importance of giving feedback respectfully. Suggestions like “Could we simplify this part?” or “What do you think about renaming this variable?” create a more positive and productive review environment. I experienced this in class as well. The way feedback is written affects how teammates respond and how smoothly the discussion goes. Good communication makes the whole team stronger.

In short, code review is an essential part of software process management. It supports collaboration, improves quality, and keeps the codebase organized. Through Blog Quarter 4, I strengthened my understanding of reviews, communication, and clean coding practices that will benefit me in future projects and my career.

From the blog CS@Worcester – dipeshbhattaprofile by Dipesh Bhatta and used with permission of the author. All other rights reserved by the author.

Licensing Your Projects

Sources: Codecademy, TLDR Legal, and Choose A License

Choosing a License

All projects should have a license, but choosing a license for your project can seem daunting. By breaking it down into simple goals you want to achieve, the process can be much easier! 

First, choose how you want your users to interact with your project. Do you want to preserve your original code in future versions or do you want users to be free in how they modify it? There are two main kinds of licenses to choose from, permissive and copyleft. 

Permissive licenses do not restrict the user from modifying the code or using it how they like. Some popular examples are the MIT license and Apache license. Both of these licenses state the user can modify, distribute, and sublicense the code how they want, and do not require future versions to use the same license. 

Copyleft licenses preserve the original code and protect the creators and users. Some examples of a copyleft license are General Public license (GPL) and Lesser General Public license (LGPL). Both of these licenses allow the users to modify and distribute the code how they like, but require the same license to be used on all future versions and require user protections like install instructions and a change log. 

One license is not better than another, all that matters is that your project has a license and it’s what is best for you. If you are still unsure of which one to choose, try looking at the licenses of similar projects or projects from people like you. 

Why Do You Need a License

Licenses state the rights of you as a creator and of all the people that interact with your code. Without a license, users do not know where you stand on using, modifying, and sharing your work. Attaching a license allows you to have peace of mind your code is being used how you want it to and allows people using your code to have it clearly laid out what they can and cannot do with your work. 

Choosing a License For Your Code’s Documentation

Now that you have a project with a license, you need to apply a license to your documentation as well. Most of the time, it will use the same license you chose for the code by default, but in the case you do not want it to, you can choose any license that you feel applies.

From the blog ALIDA NORDQUIST by alidanordquist and used with permission of the author. All other rights reserved by the author.

Choosing the Right Open Source License

Choose an open source license

For this week’s self-directed professional development, I explored the topic of choosing open source licenses, which is a fundamental but often overlooked part of releasing software. I based my reading on ChooseALicense.com and supporting resources that explain how permissive licenses, copyleft licenses, and public domain-style licenses differ. What I found most interesting is how a license doesn’t just define legal rules — it reflects the values, intentions, and goals of a developer or a team. Software licensing shapes how a project evolves, how a community forms, and how contributions are handled over time.

Open source licenses fall into a few broad categories. Permissive licenses like MIT or Apache 2.0 give users almost complete freedom to reuse the code, even in closed-source commercial products. Copyleft licenses like GPL ensure that any derivative work must remain open source under the same license. And options like the Unlicense or CC0 place code essentially in the public domain, allowing anyone to use it with zero restrictions. Before this week, I assumed licensing was just a legal formality, but now I understand how strongly each license type influences collaboration and long-term project direction.

I chose this topic because licensing is directly connected to the work we do in Software Process, especially when we talk about transparency, collaboration, and project ownership. As future developers, we will eventually publish our own tools, libraries, or contributions. Knowing how to license our work is part of being a responsible member of the open source community. Many people assume that posting code publicly means anyone can use it, but without a license, nobody can legally copy, modify, or reuse it. That detail alone made this topic worth exploring, and it helped me rethink how important explicit permissions are.

One thing I learned is that choosing a license is really about choosing a philosophy. If a developer wants to share knowledge broadly, enable commercial use, and reduce friction for adoption, a permissive license makes sense. If the goal is to ensure the code stays free for everyone and cannot be closed off by others, a copyleft license protects that intention. The reading made me think carefully about what I would want if I released a personal project. Personally, I lean toward permissive licenses because I want people to build on my work without worrying about legal constraints. But I also understand why larger community-focused projects might choose GPL to preserve openness.

Going forward, I expect licensing to be something I pay more attention to in both school projects and professional work. As software engineers, we’re not just writing code; we’re shaping how others can interact with it. Licensing is part of that responsibility. This topic helped me better appreciate the intersection between technology, ethics, creativity, and law — and it reminded me that releasing software is more than just pushing code to GitHub; it’s about defining how that code fits into the larger ecosystem of open source development.

From the blog CS@Worcester – Life of Chris by Christian Oboh and used with permission of the author. All other rights reserved by the author.

Refactoring Code

When looking for some ideas with what to write about for this blog post, I settled in on refactoring code. For starters I know what it is and why we do it, but I wanted to go more in depth by looking at other resources and what they have to say about it. One of the first sources I came across was a blog post called “How to create a culture of continuously refactoring code?” by Stas Wishnevetsky. This post from Medium revealed something that for some reasons wasn’t so obvious to me and this was that refactoring isn’t a one and done kind of thing. Instead, it is more of a routine and should be done as one to keep code maintained properly and to make sure it remains easy to use.

The first thing that really struck me when reading this article was talking about code like it is something physical and biological. This comparison was made to show how code can “decay” and “rot”. While the code itself doesn’t break down and fall apart with time, there are multiple reasons that make it seem like it does. These reasons include: coding abilities improving over time, business needs and scale fluctuating, and deliberate tech debt. The article then goes on to explain why we should refactor and the end goal of maintaining stability and creating improvement.

I guess I have never had the need to deal with refactoring my code since most the time I program one time assignments and never had the need to upkeep some kind of program. I have, however experience my abilities improving while creating a project and have had some parts be sloppy while later improvements are better done. I suppose I should have gone back and refactored those early parts but the bottom line is that I’ve never had the need to. I would also run into problems trying to make small changes which would be risky in my program. This is one of the many pains explained in the article I read and makes lots of sense.

I know going forward in my career refactoring will become very prominent in my work and understanding it more now makes me feel better about it. This also really shows the amount of effort that is put into big programs we use on a day to day basis. Starting the practice of constantly and consistently refactoring my code, even simple projects, will be super beneficial for me going forward.

From the blog CS@Worcester – Works for Me by Seth Boudreau and used with permission of the author. All other rights reserved by the author.

The Importance of Keeping Code Clean.

After reviewing its meaning and apply the practice in my class, I wanted to search for a good source on clean code principles and some more reasons why it is important. i came across and read an article from the Codacy blog called “What is Clean Code? A Guide to Principles and Best Practices.” This article really went into depth on what it means to have your code be clean and have it makes to not only you, but other people as well. The link to the original post is right here: https://blog.codacy.com/what-is-clean-code

One of the first things this blog states is “writing code is like giving a speech. If you use too many big words, you confuse your audience. Define every word, and you end up putting your audience to sleep.” This very starting statement is what drew me to this post. Thinking about it like this makes so much sense. I believe I am pretty decent at public speaking myself so relating code it really helps define clean code to me. This post contains nine different methods on how to do this such as following code-writing standards and refactoring continuously. The article also explains how clean code helps development teams: teamwork is way easier, debugging becomes more straightforward, and overall it helps prevent many mistakes.

In class we’ve gone over many concepts this post explains, such as DRY(don’ repeat yourself), using comments sparingly, and writing short, straight forward functions. The most backwards concept for me is the comments. In past classes many professors have told me to write lots of comments explaining what certain things do. Now I’m being told to try not to use any? It does make sense, focus on making your code readable so you don’t need any comments.

Going forward for myself, making code simply and understandable will be a main focus for me. Keeping things simple and understandable makes way more sense than making code I need comments in. Another big thing for me is eliminating repetition. Using functions and calls instead of writing the same code over and over again will one hundred percent make my computer science life way easier and save me tons of time as well. I’ve only just started writing code in teams so I’ve only ever written code for my professors or just for myself. I know that keeping this readable will prevent meetings with teammates and hours explaining what the code I’ve created does.

From the blog CS@Worcester – Works for Me by Seth Boudreau and used with permission of the author. All other rights reserved by the author.

Version Control: Why It Matters in Software Development

Version control is something I’ve used before in classes, but I never fully understood its importance until I read the Atlassian article, “What is Version Control?” (https://www.atlassian.com/git/tutorials/what-is-version-control). I selected this resource because Atlassian explains technical concepts in a way that feels practical and industry-focused, which fits perfectly with what we are learning in CS-348. Since this course emphasizes collaboration, documentation, project organization, and professional tools, I wanted to learn more about how version control actually supports real-world software development.

The article defines version control as the practice of tracking and managing changes to code. What stood out to me is that version control isn’t just for “saving work”, it’s a full system that captures every change, who made it, when it was made, and why. Atlassian highlights how this creates a long-term project history that developers can search through, compare, or revert. This directly connects to our CS-348 topics like software maintenance, project management, documentation standards, and team collaboration, because version control supports all of these practices behind the scenes.

The resource also explains how version control allows teams to work on separate branches, make experimental changes, fix bugs, or build features without interfering with one another. This connected with my experience in this course because when we work on group projects or assignments, version control prevents us from overwriting each other’s work. The article also discusses merge conflicts, and reading about it made me feel better about the moments when I’ve run into conflicts myself. Instead of seeing them as mistakes, the article made me realize they are a normal part of teamwork and software development.

One major takeaway for me was the idea of traceability. Every commit tells a story, not just about the code, but about decisions, goals, and teamwork. This encouraged me to treat commit messages more seriously so that my future teammates (or even future me) can understand the purpose behind changes. The article made me realize that version control isn’t just a technical tool; it is a communication tool. This is something I didn’t appreciate before reading it.

This resource affected how I view my future practice because version control is required in almost every professional software environment. Reading about how teams rely on it to avoid lost work, manage parallel development, and maintain high-quality software helped me understand why CS-348 emphasizes collaboration tools, project organization, and documentation. Going forward, I plan to use branching more intentionally, commit more frequently, and write clearer commit messages. I also want to apply what I learned outside of class by using version control for my personal and club-related tech projects.

Overall, this article helped me connect the technical skills we practice in CS-348 to how real development teams work. It showed me that version control supports not just code, but communication, teamwork, and professionalism — all skills I want to continue developing.

Source

Atlassian. What is version control. Retrieved from https://www.atlassian.com/git/tutorials/what-is-version-control

From the blog CS@Worcester – Circuit Star | Tech & Business Insights by Queenstar Kyere Gyamfi and used with permission of the author. All other rights reserved by the author.

Code Can be Dirty?

Unfortunately, yes

The above code is positively awful to look at, read, try to understand, and generally poor practice. Recently, in this semesters Software Development class, we have moved away from project structures, and into clean code. What makes it clean, why is it important, and related topics.

Why clean?

Clean code provides an easy reading experience for anyone looking at it. This include people later working on something released years ago, as well as the person writing completely new code for the first time. Every example of code can benefit from being clean. Coding cleanly enables readers to understand what the code is doing, and makes it easy to follow mentally. As well as this, clean code can make better code, as spotting mistakes is made easier when you know where everything should be.

What makes code clean?

Clean code is code that is easy to read, understand, and modify because it expresses its intent clearly and avoids unnecessary complexity. It uses meaningful names, small and focused functions, and consistent structure so that another developer can quickly grasp what it does without confusion. Clean code avoids duplication, hides internal details, and keeps responsibilities separated so each block does one thing well. It favors simplicity over cleverness, documents why decisions were made, and is organized in a way that makes future changes safe, predictable, and maintainable.

In the wild

This video is a perfect example of how clean code, and specifically refraining from nesting your code too much, is a good habit to form. The video explains that multiple layers of if statements, loops, and conditional branches make code harder to read, maintain, test, and debug. The creator argues that nesting increases cognitive load because developers must track several scopes at once, and it often signals that a function is trying to do too many things. The video recommends techniques such as using early returns, inverting conditions, and extracting complex inner blocks into smaller, well-named functions so the main “happy path” remains flat and easy to follow. Overall, reducing nesting leads to cleaner, more understandable, and more maintainable code.

I chose this resource as it was a fun video that I found ‘in the wild’ while simply scrolling, and felt that it closely aligned with principles we have been learning in class.

In conjunction with in class learning, I have been swayed to become a ‘never-nester’. I would like to put into practice this behavior, and am excited to maintain clean, readable code in future projects.

This concludes my mandatory blog post of Quarter 3 for the semester.

— Will Crosby

From the blog CS@Worcester – ELITE Computer Science by William Crosby and used with permission of the author. All other rights reserved by the author.