Category Archives: CS-343

The Singleton & Desing’s Patterns

12/19/2024

At the start of the semester, we were introduced to Design patterns. These techniques include anything from completely restarting a project to erasing redundancy such as repetition of code. Our biggest focus was to use overrides ONLY where needed and it was our job to figure that out because there were certain methods that did need to be overridden.

We worked on a Duck Simulator that has methods for each duck itself, but some ducks needed functions to be overridden were as some didn’t need them for example a decoy duck does not fly. Whereas a mallard duck does therefore there is no need to override a function for that decoy duck. This design pattern is very easy to overuse specially for people not introduced to these types of problems.

The interesting part of this homework was also using the previously covered topic of UML diagrams. This homework though was more about reading and understanding but the main point was to transfer it to Java code. This was a nice intertwining moment because it makes it easier in the future to understand not just the UML but also the design patterns taught.

We created two different interfaces for the Duck Simulator which one was a Quack() and the other was Fly(). These made it so we as the developer do not have to keep overriding. Hence, we end up with a bit more files, but it saves us the trouble in the future if we needed to edit let’s say the decoy duck to fly. Now we are able to go into one file and edit without having affected any other files. Which in larger systems can become a big issue because now the developer has to go into every single file that uses said method which waste time and can be missed if multiple people are working on it at the same time.

We also learned about the singleton method which just retrieves a single instance of an object and if it is not there then it creates it does not use multiple of the same object. There is one down side I read about in the source and it was about unit testing. The source talks about many unit testing frameworks that rely on inheritance when producing a mock object which is a problem because the singleton class is private, and static methods cannot be overridden. Overall, it is still applicable, and we used it in the intermediate part of the design patterns homework to learn how it worked better to always only have one instance of a method.

Source: Design Patterns in Java

From the blog CS@Worcester – Cinnamon Codes by CinnamonCodes and used with permission of the author. All other rights reserved by the author.

Working as a Front end developer

Now that I have heard about people’s experiences working on the back end, I was curious about people’s experiences working on the front end. Reading personal experiences taught me a lot about working on the back end. You can learn a lot and avoid mistakes by seeing others take similar paths. Also, it can prepare you for problems that you may face in the future. Mistakes are inevitable but being able to adapt or being able to recognize it and fix it goes a long way. Working on projects especially those that have to do with coding errors is always a step away. You can try to get a step ahead on these problems by seeing other people work and implementing it on your stuff. That is why I found an article about working as a front-end developer. These articles are very engaging and always give me a new perspective.

This article is written by Selim Enes who has done freelance work in the past but is currently working as a developer. When he first started he was working on small things like CSS edits until he proved himself. One of his major projects was a blog project where he had to create the display of the UI. He was involved in all operations after 2 months. When he proved to the team that his code wouldn’t crash the project he gained access to the company’s main project. The company’s main project entailed a webinar application that used technologies like WebSocket. One thing that made him know he was going in the right direction was being able to develop features like push-to-talk by himself. There are some negatives to his work with his boss being very hasty on projects. He believes all tasks are urgent and make some work very stressful. Plus with the recent economic regression, he doesn’t believe he will be able to get a raise anytime soon. He has learned to have a full-stack blog project for himself and has an e-commerce project his about to start working on. He is working while also building his portfolio outside of work.

Reading this article was very insightful. It made sense that when you first start working for a company they won’t give you the keys to everything just yet. They ease you up into it until you have gained their trust. Working on his portfolio outside of work motivated me to do the same too. You can sometimes become complacent at your job because you have a living but you shouldn’t. You should always try to improve and hope to find better opportunities elsewhere

View at Medium.com
https://medium.com/@sellimenes/1-year-experience-as-a-junior-front-end-developer-39766fad5c34

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

What is up with Error Codes for HTTP Methods

Photo by Vie Studio on Pexels.com

Hello Debug Ducker here, and I have a question. I am sure you are familiar with a 404 error code, as you may have run into it while surfing the web. 404 Not Found means that the server on the other end couldn’t find what it was looking for, and this is cause the URL is not recognized. This can happen when the webpage is no longer available and you tried connecting to it. 404 is quite the common error, that I believe many have seen at least once but would you be able to tell me what other errors you may have encountered in the web, there is quite a few and some obscures ones you may have never seen.

Perhaps you also wondered why 404 is even an error number, why the number is the way it is, why use those specific numbers. Well you see 4xx is specifically for client errors, which means they are errors on your end and not the server. If a server would to have an error than it would use 5xx instead. For example, there is the 500 error code that is an internal server error which just means something messed up in the server and sent you that as a response. Basically each response code are in different categories, with the error categories coming entirely from 4xx and 5xx.

Now here are ones you know and some obscure ones

400: Bad Request, as in the server could not process the request, either because of a syntax error such as misspelling something

402: Payment Required, says what is on the tin you need to pay, not often used

409: Conflict, the request conflicts with something within the server

414: The URI too long, the URI is long and the server is not willing to handle it

418: I’m a teapot…yeah I don’t understand this one, and yes this is real

There are many of these errors code for 4xx and I would recommend you check it out with the link below.

There are also some 500 server errors, that are interesting such as

501: Not Implemented, as in the request has not been implemented, so exactly what it says

503: Service is Unavailable, just means the server are down.

And Many More.

Thre are a fascinating amount of error codes for some interesting stuff and I reccomend you see a bunch in the link below.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status

Anyway have a nice error free day day.

MozDevNet. “HTTP Response Status Codes – HTTP: MDN.” MDN Web Docs, developer.mozilla.org/en-US/docs/Web/HTTP/Status.

“HTTP Status Codes: All 63 Explained – Including FAQ & Video.” Umbraco, umbraco.com/knowledge-base/http-status-codes/#http-status-code-categories.

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

The UML Family Tree

12/18/2024

At the beginning of the semester, we started to work with UML diagrams. We talked about the different types of diagrams and how each is written in plantuml. We started with UML class diagrams which show each files relationship to one another. It also shows the multiplicities which is important to know when, for example making an appointment. For example, only one person can have multiple appointments, but not multiple people can have the same appointment.

We also learned about Sequence UML diagrams which look different but have the same idea behind them. This type of diagram shows the method and its parameters in a sequence, hence the name. It shows how each class will be used whereas the class UML diagram just shows what the method name is and what the parameters for that specified method are as well.

The sequence UML shows the overall order of things whereas the class UML shows the general method and parameters that will be used. Both diagrams could be used on their own but help a lot more to be organized when used together. UML is very important to be able to visualize code without having to read over every single line trying to understand it all. It helps especially if working in larger groups for everyone to understand. There is another type of diagram that we didn’t talk about but is used a lot which is” use case diagram”. This diagram shows functional requirements, for example someone shops and the diagram show the possible actions the user can make. Such as view items or purchase more, but then behind those actions are more possible actions that can be taken like checkout or just cancel purchase. There is also activity diagrams that need to fill in a condition whether the use input the number in the right format or not. If the user did not then it throws an error, but this is all a visual representation of what the code is supposed to look like and be as well.

 UML diagrams have taught me to be organized in my own coding projects with visualizing my functions and the parameters I will be using. It also organizes file management when using the class UML diagram along with showing multiplicities. Even using other UML diagrams that can organize different parts of the same code and show how it will be used for example combining the class and sequence UML diagrams is a great way to use both for not just visualization but also organizing it all for a final product.

Source: Unified Modeling Language (UML) Diagrams – GeeksforGeeks

From the blog CS@Worcester – Cinnamon Codes by CinnamonCodes and used with permission of the author. All other rights reserved by the author.

Week 15

Working inside the backend made me curious about people’s real-life experiences working in their company’s backend. I found articles about the backend but have yet to gain experience working inside it. It would be helpful to get insight into someone’s real-life experiences. By seeing others’ experiences you can learn from them and avoid any mistakes they made starting. Many beginner mistakes are big headaches when they happen, but if someone else can stop you from making them, it will be a huge lifesaver. We learn sometimes the hard way but the biggest help to prevent this is to learn from other paths. Some may think it better to go in blind I think differently. Being prepared for me is always the better option

Blessings James starts the article by advising readers that starting it may be difficult but to trust the process because the feeling after you accomplish your task is another feeling entirely. Her favorite project was working on a to-do list application with a backend using Python. It was difficult for her to work while also being data efficient. By doing research she was able to find a scalable model that worked. She also discovered some libraries including Flask-login that would do a lot of the heavy lifting. This was key for security which is often overlooked. Debugging is always a problem that comes up but she was able to gracefully fix them. API design was also a key feature wired on but swagger made it a lot easier. 

Reading this article gave me a lot of insight into someone working in the backend for a real company. There were some similarities to what were doing now including swagger. Swagger seems like the for the API design. We haven’t used all the features of Swagger but using Swagger Preview did help when doing assignments and homework. Our code was automatically able to be seen updated. One thing that interested me was Flask-login. I didn’t know you could use outside libraries but it makes sense if it is open to the public anyone can use it. It can save time by being able to use different libraries and cut your workload by half. Reading that article there was a big emphasis on security and I feel at times is overlooked. You have seen with a lot of companies when it is overlooked the outcomes are drastic. It becoming a bigger issue every day and security should be the first task on everyone’s list.

View at Medium.com
View at Medium.com
View at Medium.com
article
View at Medium.com
View at Medium.com
https://medium.com/@blessingjames1047/an-article-on-backend-ff90312c05b2

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

The Future Of Technical Writing

In this podcast episode from Stack Overflow by Ben Popper with special guest Ryan Donovan, discusses the evolution of documentation and the future of technical writing. The whole episode is about the nature of writing documentation is changing fast. With the advent of generative AI and other tools like linters that can automatically write or run tests make technical writing more automated now more than ever. One of the first talking points is why documentation is being pushed a lot more now. Increasingly because programmers don’t like writing documentation this job is delegated to technical writers. Who will go into code repositories and write documentation.These technical writers end up being some of the most important people when it comes to code structure. Since they write the documentation that defines how the program is specified and built. 

After moving through some background information the next talking point is the future of technical writing. This was of the most interesting parts to me because it discusses not only just the AI aspect, but things like how other tools play a role. The question then becomes will AI replace technical writers? The answer they concluded was no. Although it is able to generate and automate documentation. Often that documentation needs to be looked over. For the moment AI is not able to create fully functioning documentation to that level yet.

I chose this podcast because it directly relates to what we have been doing in class lately. Looking at the Open API yaml and documentation related files. I don’t think there is a specific lesson to be learned from this podcast. More about just thinking about the future of technical writing. As programmers, we will all have to interact with documentation at some point. Whether that be something like java docs or yaml files. I think it’s important to know what goes into making documentation and the people who write. Because it really is a career all in of itself. Like I mentioned before, one of the most interesting aspects of technical writing is how AI is changing the landscape. Like many areas right now, people are worried if their jobs are in danger. I think with a lot of other cases human supervision is still needed. Another point that I didn’t really think about before now is the importance of documentation other than just information. Like in the case of yaml files that define structure. Is how important it is because it literally specifies how software operates. Like the definitions of endpoints that must be fulfilled and other specifications.

Citations

https://the-stack-overflow-podcast.simplecast.com/episodes/your-docs-are-your-infrastructure/transcript

From the blog CS@Worcester – Code Craft by Kyle Tucker and used with permission of the author. All other rights reserved by the author.

Design Patterns – Creational, Structural, and Behavioral

Design patterns are extremely useful within software design. Essentially they are like established solutions to common problems within various contexts. We have learned a lot about design patterns this semester, especially creational, structural, and behavioral. Since we have talked about them and worked with them a lot, I thought it would be a good idea to write a post about what each is. A blog I found while researching more into the topic is called “Intro to Design Patterns” by Saverio Mazza. I think this blog does a great job at giving a brief overview of each of the three different design patterns and how they work. They are extremely helpful for anyone working in software design, and I feel like they will be used in any career I choose. I’m very grateful that I was able to learn more about these design patterns, and I hope my blog post will help you learn more too.

Creational Patterns: As it mentions in the name, creational patterns have to do with the way that objects are created. According to Mazza “They aim to abstract the instantiation process, making a system independent of how its objects are created, composed, and represented. Some examples of creational patterns include the singleton pattern, the factory method pattern, the abstract factory pattern, the builder pattern, and the prototype pattern.

Structural Patterns: These types of patterns deal with how classes and objects are composed in order to form larger structures. They make sure that when one part of a system changes, the rest of it doesn’t need to. Similarly, they make sure that parts of the system are decoupled and can improve the system’s flexibility and reusability. Some examples of structural patterns include the adapter pattern, the composite pattern, the proxy pattern, the flyweight pattern, the bridge pattern, and the decorator pattern.

Behavioral Patterns: Behavioral patterns deal with algorithms and the assignment of responsibilities between objects. They describe the patterns of communication between objects and classes as well as the patterns between them. They let you concentrate just on the way that the objects are interconnected. Some examples of behavioral patterns are the observer pattern, the strategy pattern, the command pattern, the state pattern, the visitor pattern, the mediator pattern, the memento pattern, and the template method pattern.

If you want to learn more about the specific patterns mentioned, I highly recommend checking out the linked blog for more information!

Link: https://medium.com/@saverio3107/intro-to-design-patterns-66f1aebe5be5

From the blog CS@Worcester – One pixel at a time by gizmo10203 and used with permission of the author. All other rights reserved by the author.

Week 15 Post

This week’s post will focus on the powerful backend tool, MongoDB and its data modeling features. MongoDB is a NoSQL database management system that’s mainly used to handle large datasets through a method called sharding. Sharding is a process that involves utilizing multiple servers to distribute data which improves scalability. This tool is especially flexible in various languages like C, C++, C#, Go, Java, Python, Ruby and Swift, making it applicable in numerous types of projects. Additionally, MongoDB is well-suited for use with Node.js, Express.js, and other modern web frameworks, making it an integral part of the MEAN and MERN stacks.

MongoDB is different from other backend data management tools because it uses NoSQL, instead of tables and rows of data it uses collections and documents of key-value pairs. These documents utilize Binary JSON or BSON because it accommodates more data types, making it versatile in any format. Gillis adds, “Documents will also incorporate a primary key as a unique identifier. A document’s structure is changed by adding or deleting new or existing fields”, which allows for fast indexing and queries.
Unlike traditional relational databases with fixed schemas, “MongoDB doesn’t require predefined schemas. It stores any type of data. This gives users the flexibility to create any number of fields in a document, making it easier to scale MongoDB databases compared to relational databases”. This one feature allows developers to not have to worry about changing schemas in the future due to changing product expectations.

According to Alexander Gillis from TechTarget, “Organizations also use MongoDB for its ad-hoc queries, indexing, load balancing, aggregation, server-side JavaScript execution and other features”. Uber uses MongoDB to optimize ride-hailing logistics, ensuring low latency even during peak traffic. Adobe uses it for handling billions of document transactions efficiently, ensuring user productivity on platforms like Adobe Creative Clouds.

When deciding to use MongoDB, it’s important to account for its shortcomings, for example, its non-relational nature can lead to duplicated data, which may require careful management. Additionally, it puts a lot of stress on memory resources. Another problem is its security, because user authentication is setup on default, hackers have learned to target un-secure MongoDB databases. Despite this, MongoDB is an example of how modern backend tools cater to the evolving needs of developers. Its flexibility and scalability make it a dependable tool when dealing with the unpredictable demands in software.

I specifically chose this topic to research because it will be crucial tool to have in my arsenal when working in full-stack projects. Additionally, this tool is the main backend tool for Thea’s Pantry, making this information vital for my capstone project. I hope to utilize this information next semester.

Blog: https://www.techtarget.com/searchdatamanagement/definition/MongoDB

From the blog CS@Worcester – Computer Science Through a Senior by Winston Luu and used with permission of the author. All other rights reserved by the author.

Understanding Technical Debt

In software development, technical debt refers to the extra work required in the future when quick, easy solutions are chosen instead of more thorough, time-consuming approaches. This concept is explored in the article “What is Technical Debt & How Can Companies Manage It?” by Coder Academy.

The article defines technical debt as the accumulation of suboptimal code or design choices made to deliver projects faster. While these shortcuts may lead to quicker releases, they often result in higher maintenance costs and reduced code quality over time.

Key Factors Contributing to Technical Debt

  • Time Constraints: Meeting tight deadlines can lead to hasty decisions that prioritize speed over quality.
  • Evolving Requirements: As project requirements change, older code may no longer align with the current needs.
  • Lack of Documentation: Poor documentation can create misunderstandings and increase errors, contributing to technical debt.

Strategies for Managing Technical Debt

The article suggests several ways to manage technical debt effectively:

  • Regular Code Reviews: Consistently reviewing code helps identify and address suboptimal practices early.
  • Refactoring: Improving existing code without changing its functionality can enhance readability and maintainability.
  • Comprehensive Documentation: Thorough documentation supports better understanding and future modifications.
  • Prioritization: Address technical debt based on its impact on the overall project’s progress and quality.

I chose this article because technical debt is a common issue in software development and is closely related to our course material. For Computer Science students, learning how to avoid technical debt is critical. If technical debt becomes a habit, it can lead to poor time management, less active learning, and weak decision-making skills. Understanding its causes and management strategies is essential for maintaining code quality and ensuring project success.

The article provided valuable insights into technical debt and its consequences. I learned that while quick fixes may save time initially, they often lead to higher maintenance efforts and system issues later. The importance of regular code reviews and refactoring stood out, as these practices can help reduce technical debt and improve code quality.

I also appreciated the visual diagrams and tables in the article, which made it easier to understand what technical debt is and how to manage it. I particularly liked the advice on avoiding technical debt and understanding its long-term impacts as a programmer.

By adopting the strategies outlined in the article, I aim to contribute to developing sustainable, high-quality software solutions. This knowledge will help me avoid accumulating technical debt in my future work. I am motivated to build new habits, such as maintaining good documentation, participating in regular code reviews, and prioritizing refactoring. These practices will help me become a more effective and skilled programmer.

Sources:
What is Technical Debt, and how can you manage it?

Citation:
Academy, Coder. “What Is Technical Debt, and How Can You Manage It?” Medium, Medium, 18 May 2016, medium.com/@coderacademy/what-is-technical-debt-how-can-companies-manage-it-1af08992f6d0. 

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

REST API History and Fundamentals

We have discussed REST APIs in class and are learning to use them with a practical, hands-on approach. This approach is faster for the course and is better for my understanding of the material, but I thought it would be a good idea to learn the history of REST APIs and expand my general knowledge of the subject. I found The Postman Team’s blog post, “What Is a REST API? Examples, Uses, and Challenges,” which discusses the fundamentals of REST APIs, including their history, standards, functionality, uses, benefits, and challenges.

The blog starts by explaining how REST APIs evolved from a simpler alternative to SOAP APIs, becoming the backbone of the modern web. With the advances in the internet during the early 2000s, developers and companies needed to be adaptable, which SOAP API was not the tool for. The post expands on the disadvantages of SOAP APIs and explains why they were less valuable at the time. SOAP APIs were not scalable and too restrictive, making it difficult for developers to innovate. REST APIs, on the other hand, gave companies and developers the flexibility and scalability needed to keep up with the internet as it evolved. Another key feature it had was independence. REST APIs are not tied to a platform or language and have client-server separation. The adaptability and simplicity made REST APIs an obvious choice for companies like eBay and Amazon.

The post also discusses some of the challenges involved with REST APIs. Some include maintaining consistent endpoints, managing multiple versions, and dealing with differing authentication methods. All these issues complicate the development and maintenance of REST APIs which is why there are standards used to mitigate problems in the future.

The blog’s final section showed REST API examples, including Amazon S3, Twitter, Instagram, and Plaid. It explained how each API has its own specialization, like Twitter’s registration process or Amazon’s ability for developers to incorporate AI.

What I found most interesting about the blog post was the timeline for REST APIs’ evolution, the big names that pushed REST APIs forward, and the reasons behind their actions. Major companies we know today, like eBay and Amazon, got ahead of the curve, leading the way for companies like Twitter and Facebook. Learning the reason behind its success and its practical uses was interesting. I will use what I’ve learned to approach future projects with a stronger understanding of REST APIs, ensuring I design scalable, adaptable, and efficient code.

Blog: https://blog.postman.com/rest-api-examples/

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