Category Archives: CS-343

Understanding UML

I had seen UML diagrams in previous classes, but honestly had no idea it was a language. And I also had no idea I could create my own. Working with UML diagrams in class as well as for homework has been an interesting challenge since it is a language I’ve never seen before. I searched for blogs related to UML and stumbled upon a blog by Suneel Kumar from Medium called, “Understanding UML: The Unified Modeling Language”. It provided me with a much better understanding of UML and how it can be applied to ease the process of designing code.

Unified Modeling Language

Unified Modeling Language, UML for short, is a standardized visual language used to design, document, and communicate complex systems. The creation of the language is credited to Grady Booch, Ivar Jacobson, and James Rumbaugh, who are collectively known as “the Three Amigos”. The three already had their own separate methods: Booch method, Object-Oriented Software Engineering, and Object Modeling Technique. They were combined to create the unified approach. The first version of UML was made in 1997, and the current version, 2.5.1, was made in 2021.

Diagram types

UML has many diagrams designed for different purposes. The different types of diagrams are categorized into two groups, Structural and Behavioral diagrams. Structural diagrams represent the static aspects of the system, while behavioral diagrams represent the dynamic aspects of the system. An example of a structural diagram would be a class diagram. Class diagrams are the UML diagrams that I’ve been most familiar with. It shows the classes in a system, as well as attributes, operations, and relationships between objects. Here is an example of what one would look like:

An example of a behavioral diagram would be a use case diagram. Use case diagrams capture the functional requirements of a system and show the interactions between the user and the system. It would look a little something like this:

Relationships

We touched on the relationships that UML uses a little bit in class, but the blog gave me a clearer explanation of what each one meant.

Association represents a relationship between classes and is generally shown as a simple line. As seen in the diagram below, Person and Car have a relationship since Person must drive the Car. This is shown with a simple line.

Aggregation is a specialized form of association that represents a “whole-part/has-a” relationship. In the diagram below, there is a line with an open “diamond” between Department and Employee. The open “diamond” is on the Department side and indicates that the Department is made up of Employees, but Employees can exist independently of a Department.

Composition is a stronger form of aggregation where the parts cannot exist without the whole. In the following example, house and room are related and there is a filled in diamond on the House side. This represents the relationship as a Room cannot exist without a House.

Inheritance represents an “is-a” relationship. Child classes point to the parent class with a hollow triangle at the end of the line. In the following example, Car and Truck are both types of Vehicle, and is shown with a hollow triangle pointing to vehicle

And realization is often used to show that a class implements an interface. In this example Shape points to Drawable, which is labeled as an interface.

From the blog Blog del William by William Cordor and used with permission of the author. All other rights reserved by the author.

Object Oriented Programming

Hello everyone,

This week’s blog topic will be about Object Oriented Programming. I chose this topic as it is a fundamental knowledge that every programmer should know and this blog does an amazing job at explaining to new programmers while also giving good advice for experienced developers. I would say I am in the middle ground of that spectrum so this was the perfect resource for me to strengthen my understanding of Object Oriented Programming and its concepts.

The author starts the blog by first explaining and introducing Object Oriented Programming to readers who are not familiar with it and he also lists the topics that this blog will cover giving you a great idea of the structure of the blog and also what is he going over. He explains how Object Oriented Programming revolves around two key building blocks which are classes and objects. He then shows how they work together when writing code. This is another thing that I like about this blog is that he often explains something and provides images and examples to simply it even more, thus making it easier to understand. What was a nice addition to this blog was the section where he started talking about the origin of Object Oriented Programming. This shows us how it was not created overnight, but it took years of hard work and dedication to create sucha great innaviation. Knowing the context of how it started it also makes me appreciate the significance that OOP has. Another good point that I have to give to the author is how he compared it to procedural programming. It is kinda hard to understand why certain approaches are picked and by giving us this comparison between the two it makes it a lot easier when to use OOP. My favorite section was definitely where he talked about the four pillars of Object Oriented Programming which were inheritance, encapsulation, polymorphism, and abstraction. The explanation for each one of them were concise, and meaningful examples were provide clarifying any questions that readers may have had. The author also gives great analogies and I appreciate this a lot as it makes understanding the concepts a lot easier. My favorite example of this is when he was going over Abstraction, “Abstraction is like a laptop’s user interface. When you use a laptop, you interact with the interface (e.g., the keyboard, trackpad, and screen) without needing to know about the underlying hardware (e.g., the Processor, RAM, and Hard Disk).”

In conclusion this blog turned out to be very beneficial for me, and I hope the same for whoever is reading this. His blog was very informative without being overwhelming and this allowed me to strengthen my foundation of Object Oriented Programming

Source:
https://www.designgurus.io/blog/object-oriented-programming-oop

From the blog Elio's Blog by Elio Ngjelo and used with permission of the author. All other rights reserved by the author.

Pros and Cons of Java

I found an article that discusses the pros and cons of Java in 2025. This caught my attention because Java is the language I have used in most of my classes. Object-oriented programming is also what we are discussing in CS-343. Java seems to be pretty versatile, and is fairly straight forward. I was interested to see in more depth what it has to offer and what it might not be so good with.

The article begins with an overview of Java as a whole. It discusses Java’s wide usage for a variety of different projects and its user friendly features that make it so widely liked. It quickly goes into the benefits of using Java. The author lists four main pros for the language: a straightforward learning process, object-oriented programming, heightened security, and platform independence. It is also mentioned how its simplicity makes it perfect for both beginners and more experienced programmers. For each main pro, the article goes into deeper detail to explain further what these benefits really mean for Java. Some interesting points in these explanations were the security features and the use of JVM (Java Virtual Machine). However, there are also the cons that come with it. The main cons listed here were performance constraints, licensing expenses, and GUI development complications. Similarly to the pros, these cons are then explained in more depth. The article’s last main section gives examples of ideal use cases for Java and some that are not so ideal. Web applications, mobile app, cloud computing and big data projects were listed as ideal use cases, where complex desktop GUI’s and alternative languages being more fitting for certain tasks were listed as times you may not want to use Java.

I found this article to be fairly interesting. Java is a language that I already knew a decent amount about, but it was interesting to learn more about it. As we learn more about Java and object-oriented programming, it is nice to know the benefits and what its strengths are. I also found it interesting that big data projects were listed as something Java works well with. Typically, R and Python are the languages most associated with data, but tools like Hadoop make it fitting for processing large amounts of data which may not be obvious to someone new to the language. Overall, it seems like Java has many benefits, and the cons seem to be minimal. I look forward to learning more about Java as I continue to use it!

https://www.netguru.com/blog/java-pros-and-cons

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

REST APIs and Data

I decided to dive further into what REST APIs really are, and how they are used, as they now appear both in my course syllabus, and as a possible solution for progressing my own internship work.

While searching for information, I came across a blog post titled, What Is a REST API? Examples, Uses, and Challenges (https://blog.postman.com/rest-api-examples/). This post goes over what REST APIs are, how they are used, and what you can do with them.

The post also included a YouTube video, demonstrating setting up a REST API, and this part I found particularly interesting. I saw the person in the video utilize GET, and a command to filter for a specific Id associated with the data they wish to retrieve. This rings a bell for me, as I index database instances with an Id very often at my workplace. As I now need to export some of the data produced by my workplace software, in particular by fetching and filtering various attributes such as by Id, for other platforms, utilizing a REST API to aid me in transferring data could provide the data bridge I need to produce analytics from the software I’ve created.

The post delves into the history of the APIs as well, and talks about how REST can be more efficient than SOAP, and how big names like Facebook and Instagram utilized, and still do utilize, REST APIs to transfer data for their users. I was also intrigued to find out that the Amazon S3 storage buckets also utilize REST APIs, and I’ve worked with them in data courses already.

Some of the benefits of using REST APIs include scalability, flexibility, portability, light-weight, and language/platform independence.

The challenges that need to be accounted for when using REST APIs include ensuring endpoint consistency, keeping the URL structures uniform across teams, versioning, maintaining old APIs while introducing new ones, authentication complexity, including basic or bearer tokens, API keys, or OAuth tokens and passwords, as well as accounting for and preventing security risks, such as through encryption, or protecting keys.

Some best practices recommended by the poster include using correct HTTP status codes, 200, 400, 404, etc, returning informative error messages, making sure to secure your APIs via encryption, input validation, and role-based access. Documentation is also naturally very helpful for reminding yourself what you’ve done or made, and share that information with your team or other coders.

I hope to successfully implement a REST API in the near future!

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

Behavioral Design Patterns

Design patterns provide many benefits when it comes to coding and software development. They are essentially blueprints to help guide and solve problems through the process of designing software. While there are three types of design patterns, the one I will be focusing on here is behavioral patterns. Behavioral design patterns mostly focus on the assignment of responsibilities between objects and help with communications between those objects.

There are many different types of behavioral design patterns. Some of these patterns include:

Chain pf Responsibility
Command
Interpreter
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor

All of these of different uses along with different pros and cons. For example, command patterns turns request into stand-alone objects called a command. This pattern allows you to capture each component of a request allowing the undo and redo of operations. However, this may cause overcomplications of code because of the layer between senders and receivers. Design patterns are easily customizable to help you approach any problem and provide solutions to many problems you may be having within development.

We’ve begun to touch on design patterns within class using UML diagrams and showing different ways to solve problems. We used the example of a duck class and different types of ducks. More duck types were added that were unusual types of ducks that had different behavior types. We used a couple different methods to help make the program work including overriding, interfaces, and behavior types. Each of these solutions had different pros and cons depending on what the user wanted out of the program.

All-in-all, each different type of design pattern has their own uses and downfalls. When working with design patterns, understand what a client or users want out of a program is key to really determining what design pattern to actually use.

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 Uml digram

The blog
post, UML Diagrams – Everything You Need to Know to Improve Team Collaboration,
provides a clear explanation of Unified Modeling Language(UML) Diagram, its
usage and types ending with how it helps to visualize the project. Starting
off, the blog covers the usage of UML diagrams, continuing with its key uses,
forward design, modeling before coding to plan a system, and backward design, modeling
after coding to document a finished system. Also, it covers the thirteen UML diagram
types and what each type shows and describes what each type represents and how
it contributes to visualizing processes effectively.

I chose this
article as it summarizes clearly what the UML diagram, its usage, how the UML
diagram can be used to collaborate with other teammates. First was that since
the class, I felt that I needed to understand UML diagrams better as I still
did not get what use does it has. The fact that it emphasizes UML diagram as
white board for building and analyzing the system the team gave me some reason
for understanding more about UML diagram. Not only that, but the article also
clearly goes in-depth about the UML diagram that goes way in depth compared to
the course of behavioral and structural diagrams and how they can fit together
in real-world workflows. Overall, this blog clarified how UML diagrams support
collaboration as a visual tools to help team members to see and discuss system
structures and behaviors. It made me view UML not just as an academic
requirement but as a practical communication tool that can strengthen teamwork
in future software projects.

After
looking at the article and learning more about UML diagram, I felt like even
though it might not be perfect, that I might have to use it for future use. When
coding I have something on my mind to create, but when trying to explain it or comment
on the structure of the code. Sometimes others don’t understand or sometimes I cannot
remember why I did that later. Not only that, but the rough draft of the
structure can also be used when talking with other teammates because I cannot
do everything by myself and we need to see the same picture, and I think UML diagram
will be the virtual whiteboard for it.

https://www.bluescape.com/resource-library/uml-diagrams-everything-you-need-to-know-to-improve-team-collaboration