Category Archives: Week 13

Semantic Versioning

One of the earlier topics we went over in this course was Semantic Versioning and how many companies or groups will use it to keep track of their development. Sometimes shortened to “SemVer,” Semantic Versioning describes a versioning structure that will better communicate “implications of new versions, such as breaking changes, new features, or bug fixes” (Victor Pierre). It allows developers to have some comfort in knowing what changes will be made or have been made and whether there is some level of risk in moving to a new version. This risk lies mostly in software that have some sort of dependency, such as libraries or frameworks as updates to those can lead to dependent softwares having to update some part or most of their work, and the software not working otherwise.

Semantic Versioning employs a three-part version number in the format, MAJOR.MINOR.PATCH, with each part signifying a different impact of the release.

MAJOR: Incremented when making incompatible changes or introducing breaking API changes.
MINOR: Incremented when adding new features or functionality in a backward-compatible manner.
PATCH: Incremented for backward-compatible bug fixes or patches.

This is the basic structure for Semantic Versioning but there are many more rules to follow and other cases that will slightly change how the format will look (Victor Pierre). More details can be found on the official Semantic Versioning site (https://semver.org).

When this topic was first introduced, I recognized it and was quite excited because it’s something I’ve seen quite often in the games I play or in other things related to games. The very first thing that came to mind was modding, especially in Bethesda Games. The Elder Scrolls Series and the Fallout Series are some of the most modded games ever, one of the reasons for this is the fact that Bethesda, some time after the release of a game, will implement modding support and tools. I connected Semantic Versioning to how Bethesda will rarely release a major update to Skyrim or Fallout 4, two of the most modded games ever despite how old they are now. These rare updates will cause the modding community to blow up as nearly every modder will have to update their mods in order to be compatible with the new version. After 10 or so years of these rare but destructive updates, many modders have simply stopped updating their mods, moving on to better things or just not caring enough to do so. It’s come to the point in which people have come together to make “downgraders” to play on an older version of the game to have access to a wider variety of working mods.

That was a bit of a long story but overall, I think Semantic Versioning is simple but intriguing and most of all, extremely useful. I look forward to seeing changes, patches, updates for games and other software that I use and having access to an easy-to-follow log of just further cements my liking for Semantic Versioning. I’m not so familiar with other ways to keep track of development but this seems like a staple for developers and companies, and one that won’t be replaced so easily.

https://victorpierre.dev/blog/beginners-guide-semantic-versioning/

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

What is Clean Code?

Once you’ve moved past coding your first “Hello World” and learned some foundational concepts, your programs will naturally grow more complex. Without proper structure, they can quickly become cluttered and hard to follow. To avoid this, it’s crucial to keep your code organized, readable, and understandable—not just for yourself but for others you’ll collaborate with as a professional programmer.

This is where learning about “clean code” becomes essential. Writing clean code focuses on maintaining consistency, clear formatting, appropriate line counts, and effective use of comments, whitespace, and methods. To deepen my understanding, I read an article called “A Deep Dive into Clean Code” on Codacy.com, which explores principles and methodologies that help developers write better code. Here are the key takeaways I learned from the article that could help other studious coders out as well:

1. KISS (Keep It Simple, Stupid)

Simplicity is key. Avoid unnecessary complexity to make your code more readable and maintainable. Simple solutions are easier to debug, modify, and adapt, reducing the risk of introducing errors during updates or when new developers join the project.

2. DRY (Don’t Repeat Yourself)

Eliminate redundancy. Repeated logic scattered throughout the code increases the chances of inconsistencies and bugs. By consolidating repeated logic into functions, methods, or classes, you streamline updates and make the codebase more efficient and maintainable.

3. SRP (Single Responsibility Principle)

Each class or function should serve a single purpose. This modular approach makes code easier to test, debug, and update. With clear responsibilities, changes in one part of the code are less likely to cause unintended effects elsewhere, ensuring stability and flexibility.

4. Meaningful Naming

Descriptive names for variables, functions, and classes make the code self-explanatory, reducing the need for excessive comments. Clear naming improves communication and helps everyone on the team quickly grasp the logic and purpose of each component, especially in collaborative projects.

5. Improved Testing and Maintenance

Clean code principles directly enhance testing and maintenance. With organized and readable code, bugs are easier to identify and fix. Additionally, by minimizing technical debt, you can adapt the code for future features or changes without major overhauls, ensuring long-term project sustainability.

Incorporating these principles into your coding practices leads to better software and a smoother development process for everyone involved. By focusing on simplicity, eliminating redundancy, maintaining clear organization, and using meaningful names, you not only make your work easier but also set the stage for collaborative success.

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

Docker and it basics

Since I use different
computers from home, class, and work, after learning from class about docker
and setting up the same environment for all the devices, I thought it was time
to look into docker more. The article is about what is docker, why it became
popular and comparing it with other tools. That is why I choose this article
because “Docker overview” by Marsdev gives comprehensive introduction about docker,
comparing to virtual machine, use cases and advantage over other tools over the
internet. It clearly explains these things easily and detailed make it ideal
choice to learn how docker works and its benefits.

The article covers essential components of Docker including
Docker Engine, Images, Dockerfiles, Docker Hub, Volumes, Compose, and Desktop
and how they work. For example, Docker Engine serves as the backbone of the
platform, enabling the creation and management of containers, while Docker
Compose allows developers to manage multiple interconnected containers with
ease. Not only that, but it also compares other tools that have similar functions
like Jenkins, Kubernetes. Not only that this article summarizes how container are
“given resources that no other process can access and cannot access any
resources that have not been specifically allotted to them”. In the end, Docker
is a powerful tool that makes development processes faster and build, test and publish
apps faster and efficiently than before.

Reading this article
and idea of ‘container’ showed why docker became a powerful tool for environmental
consistency. Also, I learned that I could have the same development environment
in different devices and applications now after installing docker, I don’t have
to constantly upgrade and downgrade versions of angular, node.js and different
things between different computers, applications. It was a pain going back and
forth and just a single program solves that mess I had. This program gave me a
clear roadmap for implementing containerization in my own work. This article decreased the time I had to use
for development workflow compared to before. Not only that, but I am also
trying to use different dockers extension mentioned in the blog and others in
the marketplace for future use. Extensions like Disk usage help me double check
resource usage during development too. In the end, docker will save me time
during development and expand my base as a programmer as it decrease level of
errors between different versions of my program and the time to find those
errors.

Link to article – https://www.marsdevs.com/blogs/what-is-docker-why-is-it-getting-popular