Category Archives: CS-343

Remote Work

     Ever since the pandemic, the modern workplace has gone through many shifts. The realization that workers can still be effective members of the company from their home has changed a lot of people’s perspective on the corporate work environment. Many workers have pushed for remote work to become a staple of the modern job market. It is easy to see the appeal of remote work: No commute, stuffy office, or even stuffier dress code sounds very appealing to me. I personally enjoy the ease of access to one’s job right in their own home. All of that said, the infrastructure for remote work has been in the works for longer than we realized that there was a need for it. In the modern era, cloud computing has become a necessity for almost any job regardless of whether it is remote or not. Services such as AWS, Azure, and Git hub/lab has supplemented developers with the tools to contribute to their workplace from anywhere on the globe. Now teams can be comprised of any developer within the company and can pull from about any talent pool. This comes with its own set of unique challenges though, as remote work moves developers from a singular office space to their respective homes. Balancing time zones, long-distance communication between team members, increased risk to cybersecurity and more come with the territory of all your developers working from their house. Fortunately, Cloud computing answers some of these problems by providing more security and reliability to development teams. Azure and AWS provide secure repositories for teams and reliable access to their work wherever they are. Then there are Applications such as Zoom, which provides communication between team members and can even facilitate daily scrum meetings if needed. Developers have been using git for a long time, and it has served to supplement collaboration in software development. While the pandemic is over and most companies have tried to push their employees to go back to the office, remote work has become a fixture in the modern work landscape. For some companies, it is an economic option since it is cheaper to subscribe to several cloud services than to rent an entire office space. For other companies, it is simply the efficient option. I believe companies should incorporate these innovative technologies to expand their reach, and to shift society further down the path of better work life balance. The past few years have shown us that the old nine–to–five has become outdated, and possibly unsustainable.  

https://socpub.com/articles/how-can-cloud-computing-enable-remote-teams-work-more-productively-17895

https://aws.amazon.com/application-hosting/benefits/

https://azure.microsoft.com/en-us/resources/cloud-computing-dictionary/what-is-azure

From the blog CS@Worcester Alejandro Professional Blog by amontesdeoca and used with permission of the author. All other rights reserved by the author.

The Effects of AI on the Human Workforce

Automation is an often-overlooked concept when it comes to the study of how human civilization has evolved, which, is a shame, since it has had such a crucial role in making the modern world. The invention of farm equipment meant agriculture required less labor, allowing people to focus their lives on education. These people would go on to create further innovations, creating a cycle in which people create new technologies that give subsequent generations more opportunities to design their own creations.

The automotive industry is a great modern example. Several decades ago, car production plants employed millions, while now, these same factories almost exclusively use robots for the manual labor tasks previously delegated to humans. On the one hand, this has many benefits. Cars are now easily affordable to the regular person and production is now streamlined and faster. On the other hand, however, those jobs working on the factory line are gone, and those previously working on them are left without work.

As artificial intelligence explodes into the modern world, this same process is already beginning to take place. According to Yahoo Finance, as of July 2023, almost a quarter million employees working in the tech sector have been laid off due to being replaced by AI. The idea of replacing expensive employees with comparatively free AI labor is an extremely enticing opportunity for business executives. Just as robots replaced human workers on assembly lines, AI programs have begun to replace human workers sitting in the office.

This is not a phenomenon exclusive to the tech sector either. If you’ve ever had to talk on the phone with customer service for any large company, the voice you first hear after dialing often is no longer a human, but rather a computer. By using voice-to-text software powered by machine learning, calls can be filtered by issue type, and automatically directed to the proper department, where a human can address the caller as required. Sometimes, you won’t even talk to a person at all.

For the sake of clarity; the advancement of machine learning will not lead to artificial intelligence replacing the entire human workforce. Remember back to the previous point about how automation led to the loss of jobs in the automotive industry? This also led to new jobs being created, from designing and programming robots to assemble cars, to technicians maintaining these robots when they inevitably break. The same can be said for artificial intelligence. While self-driving cars may some day replace taxi drivers, this would also lead to job openings in developing and maintaining the software behind them.

The idea that AI will replace humans completely is a scary pitfall to get into, however, this isn’t a situation that humans haven’t experienced before. As technology grows and develops, so does society. Usually for the better.

Works Cited

Bizouati-Kennedy, Yael. “How AI Is Already Causing Layoffs in the Tech Industry.” Yahoo Finance, Yahoo, 7 July 2023, finance.yahoo.com/news/ai-already-causing-layoffs-tech-181221028.html?guccounter=1&guce_referrer=aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8&guce_referrer_sig=AQAAAJAmzoKggZHQoJa3SOThKQQJGXifMZImGxyqNzN0QuSfct2VP3Hogm4jAVSBaWYVCO3qG2EFiZ3w9vvVmynD1s7Z-Azpd6vHXVAQGqJzbb8F49e13O-O_d13SdyEm5vAzsdi3hQ3Pni6tJrWmh3Y64m4Fzd_igLHjv54uf8kMykf.

Kothari, Jash. “Artificial Intelligence: Cause of Unemployment.” GeeksforGeeks, 16 Aug. 2019, http://www.geeksforgeeks.org/artificial-intelligence-cause-of-unemployment/.

“Will AI Replace Humans in Customer Service?” Www.ultimate.ai, http://www.ultimate.ai/blog/customer-experience/will-ai-replace-humans-in-customer-service#:~:text=It.

From the blog Butler Software Construction, Design, and Architecture by Griffin Butler and used with permission of the author. All other rights reserved by the author.

Understanding the Nuances of Smells: Code, Design, and Beyond (Week-11)

In the realm of software development, the term ‘smells’ is often bandied about, yet its nuanced connotations can be elusive. This blog post delves into three distinct types of ‘smells’: everyday smells, code smells, and design smells, exploring their significance and how they metaphorically interrelate with the course material.

My exploration was sparked by an intriguing resource: Martin Fowler’s seminal work, “Refactoring: Improving the Design of Existing Code”. This text, rich in insights, lays the foundation for understanding code and design smells in software engineering. The reason for selecting this resource stems from its practical relevance and the profound impact it has had on my perspective on software quality.

Fowler’s book is a treasure trove of knowledge on how to spot and rectify issues in code (code smells) and software design (design smells). It emphasizes that like an unpleasant odor, these ‘smells’ in software signal deeper problems. The book meticulously categorizes various smells and provides strategies for refactoring, essentially cleaning up the code.

Reflecting on this material, I was struck by the parallels between the tangible world of everyday smells and the abstract domain of software development. Just as an unpleasant smell in a room can indicate something amiss, a code smell suggests underlying problems in the software’s structure. This analogy profoundly altered my understanding of software quality and maintenance.

Code smells, such as duplicate code or excessively long methods, often point to a need for refactoring. Design smells, on the other hand, are more insidious. They indicate deeper issues in the software architecture, like rigidity or needless complexity. Understanding these concepts has armed me with the knowledge to write cleaner, more maintainable code.

Moreover, this resource has reshaped how I approach software development. Recognizing smells early on can prevent costly reworks in the future. It’s akin to addressing a small leak before it becomes a flood. This proactive approach is something I intend to apply rigorously in my future projects.

Application in Future Practice

Armed with this knowledge, I envision a more refined approach to coding and design in my future endeavors. The ability to identify and rectify these smells promptly will not only enhance the quality of my work but also reduce the time and effort required for maintenance.

Conclusion

In sum, the exploration of smells in software, inspired by Fowler’s enlightening work, has been a journey of discovery. It underscores the importance of vigilance and continuous improvement in software development. This learning experience has been transformative, reshaping my approach to coding and design, and it’s a perspective I’m eager to apply in my professional journey.

Sources

Martin Fowler. (2018). “Refactoring: Improving the Design of Existing Code.” Addison-Wesley Professional.

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

anti-patterns

During our Software Construction, Design and Architecture class, we’ve gone over a multitude of different design techniques, patterns and tools to ensure that we write quality code. We’ve also touched on some design / code smells and the concept of technical debt. While design smells can give you an indication of something that might be wrong with your code, whether in a small section or in the overall design, anti-patterns represent a much more obvious, prevalent problem in your code.

Some of the most common examples of anti-patterns I’ve heard in conversations I’ve had with my friends, classmates and even teachers in a joking matter, like spaghetti code, and copying and pasting code snippets from random repos (which isn’t just bad practice for coding, it’d also be possible to infringe upon licenses or the lack thereof placed on that code). I think the reason why these are fairly common among the circles I’ve been in is just because everyone has done it before for a school assignment or something, and it’s just funny to joke about.

Some anti-patterns are a bit more involved with designing software in a meaningful sense, though. In a blog post from Lucidchart, some other anti-patterns found in software development and design are golden hammers, god objects, boat anchors and dead code. What’s interesting about these is that they actually are actual manifestations of design smells, in the most obvious ways.

For example, a boat anchor is a piece of code that isn’t being used yet but might be used in a future version, maybe. This results in needless complexity, an addition that isn’t necessary and makes it harder to read your code. Dead code is similar, code that gets executed but isn’t even used in the output of a program, causing immobility. Using a golden hammer means you are using the same tool for a bunch of different jobs, thinking that it is the best tool for all cases. This contributes to fragility, needless repetition and opacity depending on the implementation one goes about with a golden hammer. God objects are similar in a sense, as they’re objects that do too much and are responsible for too many functions. This violates encapsulation principles that are good practice in software design, while also resulting in immobility, viscosity and possibly even more. Dead code

This reinforces the idea of checking for code smells and refactoring code as needed, because otherwise you will build upon a foundation that was fundamentally problematic, and the rest of your code will reflect it no matter how much better it is. This all ties into technical debt, and brings all of the software design principles, concepts and ideas together into a picture that says: please maintain your code cleanly!

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

The Art of Future-Ready REST API Design

Best practices for REST API design: https://stackoverflow.blog/2020/03/02/best-practices-for-rest-api-design/

In today’s digital landscape, REST APIs play a pivotal role in facilitating seamless communication between various clients and services. However, designing these APIs requires careful consideration of factors such as security, performance, and ease of use for consumers. In this blog post, we will delve into the key best practices for designing REST APIs that are not only easy to understand but also future-proof and secure.

Summary: The selected resource outlines essential guidelines for designing REST APIs. It covers crucial aspects like choosing the right data format (JSON), using nouns instead of verbs in endpoint paths, logical nesting for hierarchical objects, handling errors gracefully with standard error codes, and implementing features such as filtering, sorting, and pagination. The article also emphasizes the importance of maintaining good security practices, caching data for improved performance, and versioning APIs to manage changes effectively.

Reason for Selection: This resource was chosen because it directly aligns with the course material, providing a comprehensive guide to REST API design principles. The clarity of the content and its relevance to common challenges in API development makes it a valuable reference for anyone involved in creating robust APIs.

Comments on Content: The guidelines presented in the resource offer practical insights into building effective REST APIs. The emphasis on using JSON for data exchange aligns with industry standards, ensuring compatibility across various technologies. The recommendation to avoid verbs in endpoint paths simplifies API readability and adheres to the RESTful principles of using HTTP methods for actions. The article’s discussion on error handling and status codes enhances the overall robustness of API implementations.

Personal Reflection: As a developer, this resource reinforced the importance of consistency and adherence to best practices in API design. The concept of logical nesting for related resources provides a structured approach that can enhance both API usability and maintainability. Learning about caching strategies and the significance of versioning in API development has broadened my understanding of how to address performance and compatibility concerns in real-world scenarios.

Application in Future Practice: The insights gained from this resource will significantly influence my future API development projects. I plan to implement the recommended practices, especially in areas like error handling, security, and versioning. Additionally, the emphasis on caching strategies will be integrated to optimize data retrieval and enhance the overall performance of the APIs I develop.

In conclusion, the resource serves as a valuable guide for both beginners and experienced developers, offering practical tips for designing REST APIs that stand the test of time. By incorporating these best practices, developers can create APIs that not only meet current requirements but also adapt seamlessly to future changes in technology and user needs.

From the blog CS@Worcester – Site Title by rkaranja1002 and used with permission of the author. All other rights reserved by the author.

REST API | Week 10

Rest API Designs

In this article the general theme of it helps new or even current programmers understand the fundamentals of REST API’s and help make it more comprehensible as well as to remember important key points in this theme. From how to properly use HTTPS to getting to know how to construct it and remembering what errors you might have, what they mean, this article covers it all. 

I selected this article because sometimes I like to look at things from a different perspective and search around to help me understand something in a different way to clarify a problem or to just maybe help me to connect the dots. Personally this article is a very good introduction into grasping the fundamentals of REST API’s. The material that was observed and taught in class as well as this article really made this click and helped me to move forward with this knowledge in the lessons ahead.  

The article is set up perfectly to go in order of how to design a REST API and why per say the said details are important and it truly helped me to push forward in certain homeworks and as well as the assignments in class. The first operation is to make a simple URL that is simple and just easy. Following up is something that was surprisingly helpful and it was the importance of nouns that you needed to be aware of. This is sometimes being the most common mistake with developers. Tying into that is understanding when to use the right HTTPS methods and why said method should be used as well as why some are more useful than others. Diving to understand and help what parameters are and why we need them. HTTPS methods are just as important as the HTTP codes. Narrowing it down that the most important range of numbers that are used are from 200s all the way to the 500s. Moving to understanding versioning and why it’s very important because it helps keep a check on the amount of updates, small or big that lead to those said versions and helps tracking them when they come out. The last three titles are the use of pagination which helps understand the developer how downloading is going and if its causing any disruptions lowering the services that are in store. API responses must respond or  return in JSON though that may vary if you are using a legacy app. The cherry on top is the using proper error messages. Practice and observe what error messages pull through. 

Link:

https://betterprogramming.pub/restful-api-design-step-by-step-guide-2f2c9f9fcdbf

From the blog CS@Worcester – Site Title by Jon Skende and used with permission of the author. All other rights reserved by the author.

Week 11: CS-343

Software Frameworks

What is a framework?

A framework is a platform providing a foundation for creating software development projects. Frameworks can be thought of as a template of a working program where developers can modify the program by adding code. Because frameworks are essentially templates, there are shared resources that are bundled into one package. Some of these resources include libraries, image files, and reference documents. The package can be customized to match the needs of the project.

Different types of frameworks

Backend Web Frameworks

Backend Web, or also known as simply Web Frameworks, are the most commonly used. These frameworks help developers create web applications and dynamic websites. The use of web frameworks has streamlined the process of web development by automating common tasks of web developers such as database access and session management. Rather than using HTML, JavaScript and CSS, backend frameworks use programming languages to access a database, hosted on a server. A common backend framework is Django.

Frontend

Unlike backend where frameworks are loaded server-side, frontend frameworks are executed in the user’s browser. Frontend frameworks allow developers to customize and design the way the web application looks to the user. Popular frontend frameworks are Angular JS and React.

Mobile Development

Nowadays mobile applications are extremely common resulting in mobile development frameworks. Similarly to desktop frameworks, these give developers a foundation to build their mobile applications while allowing full customizability. There are two types of mobile frameworks, native and cross-platform. Native frameworks are for applications that are built specifically for a particular operating system (iOS or Android). Alternatively cross-platform frameworks are for apps that are built to be compatible with any phone. A commonly used mobile framework is Flutter.

What makes a good framework?

A good framework should be simple to understand and easy to implement. It should also follow design principles such as:

  • Being extendable, adding new functionality by adding code rather than modifying
    • Framework cannot be modified at all, but only extended
  • Allows developers to create components that can be reused
  • Should have a default behavior and be useful. No redundant code that is unnecessary

Why use a framework?

Frameworks greatly reduces the time spent on developing. When starting a new project, there are steps that need to be done regardless the project. Using frameworks helps streamline that process by already providing those details. This allows developers to focus their time on extending the functionality specific to their application’s needs.

Reflection

This article was chosen because it broke down the different parts of a framework such as what it is, the different types, and why one might use a framework. Prior to reading this blog, I had a somewhat unclear understanding of what frameworks are. Now I understand that they are useful tools that speeds up the development process by providing essentially a template of a working program. What was learned will be applied to future, larger projects that could benefit from a framework.

Resources:

https://codeinstitute.net/global/blog/what-is-a-framework/

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

Git and Game Development

     A subject that has always been near and dear to my heart is video games. Throughout my life I have always been deeply enamored with games and the process of their creation, from the intricacies of 3d modeling to the various game engines in use. Despite that, I would not say I am an expert in modern game development by any means. As my classes have progressed however, I have begun to understand more about the inner workings of software development and how teams are managed. This led me to investigate how game developers use these tools to manage projects and keep everything orderly. After doing some research, I found that many game engines are compatible with git and have no issue being stored on GitHub. Not only that but prominent game engines like Unreal Engine even have their source code up on GitHub, available for anyone to fork and clone. This was done to allow developers to modify the game engine itself, for whatever purposes they need. Godot is a free open-source engine that uses the MIT license and is also entirely up on GitHub. Of course, even if an engine does not have their code on GitHub or Gitlab that does not mean you cannot just host your code in an online repository. Thanks to what I have learned this semester, I can now make use of GitHub in the creation of repositories for any game projects I have. 

  It is not enough to learn about how game developers make use of git, project management is also a vital tool for game development. In terms of project frameworks, agile methodologies have seen widespread use within various industries, including the video game industry. Scrum is the most prominent of these methodologies and has been adopted by various companies. Due to the nature of video game development, there is a greater need for cross-disciplined teams comprised of developers versed in various skills. Game development can be effectively chopped up into tasks that fit nicely into each increment, for the medium itself necessitates a functioning step by step pipeline. Level designers cannot do anything without the assets created by artists and so on and so forth. The first couple sprints would work on creating functional assets like 3D models, textures, and game mechanics. The goal of each subsequent sprint would be to create a functional game section by section. I hope to one day make use of scrum and help create a game of my own.

https://www.unrealengine.com/en-US/ue-on-github

https://www.gamedeveloper.com/production/agile-game-development-with-scrum-teams

https://starloopstudios.com/best-agile-practices-in-game-development/

From the blog CS@Worcester Alejandro Professional Blog by amontesdeoca and used with permission of the author. All other rights reserved by the author.

Kubernetes Clusters: What they are, and why it may become the most in-demand skill in the 2020’s

To say that the use of containers has revolutionized how applications are designed and deployed would be an understatement. Gone are the days of applications being run on physical servers, as due to the issues with resource management, the alternative of using virtual machines to run multiple applications on a single CPU provides vastly more flexibility to developers. One downside of virtualization, however, is that these virtual machines are considered rather “heavy.” Each VM is a fully-functional machine, running a full OS in addition to whatever virtualized hardware is added on. In environments where each server’s CPU may have multiple virtual machines running, the same issue occurs; high resource usage.

To solve this problem, the use of containerized software has become common. Containers share the same OS instance as the host machine, as opposed to a VM, which has an entirely separate OS. This leads to a multitude of benefits, such as reducing image storage size. While a VM uses images multiple gigabytes large, container images are much smaller; often measured in megabytes. Additionally, containers are entirely independent, meaning they are much more easily portable, which leads to faster and easier deployment.

One major drawback to containers is the upkeep. Containers must have a specific amount of resources added to them, such as memory usage, while also, like anything else, can fail and need repair.

Enter Kubernetes; an open source platform designed to automatically conduct these maintenance tasks. Kubernetes uses clusters as the basis for their infrastructure, each containing nodes which run and manage the application. Control plane nodes manage scheduling, the API server, and other services. Worker nodes are where applications are actually run, with larger applications using more worker nodes than smaller ones.

If such a platform is so valuable, why are so many positions left unfilled? Because jobs working with Kubernetes are hard.

On the one hand, developing and maintaining applications with Kubernetes requires experienced engineers, and time. The nature of the environment simply demands developers have the knowledge and experience to implement it.

On the other hand, because Kubernetes is such a new technology, the field is rapidly evolving, requiring developers to evolve along with it. Each change requires testing and optimization, as well as programmers needing to continue to broaden their expertise.

Why is this problematic? In addition to creating a work environment prone to causing burnout among employees, engineers working in this field can outgrow their positions quickly. As they gain more experience and widen their skillset, many move on to positions that offer higher pay. According to Forbes, Kubernetes engineers spend an average of just 18 months in their positions before moving on.

This creates a cycle; engineers are hired to work on Kubernetes platforms, hold their positions for a short while, and either due to the intense workload, higher paying positions, or a mix of both, move on. This leaves an opening in their previous position, which must be filled by a new hire. Rinse and repeat.

Works Cited:

Budhani, Haseeb. “Council Post: Addressing the Kubernetes Skills Gap.” Forbes, http://www.forbes.com/sites/forbestechcouncil/2023/05/10/addressing-the-kubernetes-skills-gap/?sh=2a1430223f42. Accessed 20 Nov. 2023.

“Overview.” Kubernetes, kubernetes.io/docs/concepts/overview/. Accessed 19 Nov. 2023.

Poulton, Nigel. “What Is Kubernetes, and Why Should I Learn It?” Www.pluralsight.com, 2 Jan. 2023, http://www.pluralsight.com/blog/cloud/what-is-kubernetes#:~:text=Kubernetes%20is%20notorious%20for%20having. Accessed 20 Nov. 2023.

From the blog Butler Software Construction, Design, and Architecture by Griffin Butler and used with permission of the author. All other rights reserved by the author.

Understanding SOLID Principles: A Reflection on Best Practices in Software Engineering (Week-10)

Overview

In the dynamic field of software engineering, the SOLID principles stand as critical guidelines for designing maintainable, scalable, and robust systems. Introduced by Robert C. Martin, these principles encompass Single Responsibility Principle (SRP), Open-Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). This post explores the essence and practical application of each principle in modern software development.

Single Responsibility Principle (SRP)

SRP champions the concept that a class should have a single responsibility, thereby promoting modularity. This approach simplifies software, making it easier to comprehend, debug, and update. Personally, adhering to SRP has streamlined my coding, enhancing readability and maintainability.

Open-Closed Principle (OCP)

OCP dictates that software components should be open for extension but closed for modification. This principle underlines the importance of designing flexible systems that can adapt over time without needing modifications to the existing code. In my practice, OCP has been crucial for developing systems that are both flexible and robust.

Liskov Substitution Principle (LSP)

LSP asserts that objects of a superclass should be seamlessly replaceable with objects of its subclasses without affecting program correctness. This principle emphasizes the significance of robust class hierarchies. Adhering to LSP has helped me maintain consistent and reliable class structures in my software.

Interface Segregation Principle (ISP)

ISP advocates for the creation of specific interfaces over general-purpose ones, ensuring that clients are not forced to depend on unused methods. This principle aids in organizing code more efficiently and mitigating the impact of changes. Implementing ISP has allowed me to develop more focused and efficient interfaces in my projects.

Dependency Inversion Principle (DIP)

DIP emphasizes that high-level modules should not depend on low-level modules, but rather on abstractions. This principle fosters a loosely coupled architecture that is easier to test and maintain. Applying DIP has been instrumental in my development work, enhancing system flexibility and testability.

Personal Reflection and Application

My experience with the SOLID principles has been transformative, sharpening my coding skills and altering my approach to software design. These principles have enabled me to develop software that is not only theoretically sound but also practically effective, impacting the quality of my work significantly.

Conclusion

The SOLID principles are not merely best practices; they represent a mindset shift towards better software development. Understanding and implementing these principles can dramatically improve the quality, maintainability, and scalability of software. As I progress in my career, these principles will continue to shape my approach to software engineering.

Resources

  • “Principles Of OOD” at butunclebob.com
  • “SOLID: The First Five Principles of Object Oriented Design” at butunclebob.com

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