Author Archives: Jamaal Gedeon

Backends for Frontends and Modern Web Architecture

For this week’s blog post I wanted to go with the “Backends for Frontends” (BFF) architecture pattern through Microsoft Azure’s documentation(https://learn.microsoft.com/en-us/azure/architecture/patterns/backends-for-frontends), having read the article in-depth since it gave me some food for thought.

The article explains how BFF works as an API design approach where each type of client; such as a web application, mobile app, or IoT device kind of communicates with its own tailored backend service. Instead of one universal backend trying to serve every kind of client, BFF splits the responsibilities across dedicated backend components. This lets each frontend receive data in exactly the structure and format it needs, without unnecessary complexity or over-fetching. The article also describes when BFF is useful, the problems it solves (like avoiding “one-size-fits-all” backend design), and its trade-offs, such as increased cost and operational overhead.

I guess I chose this resource considering how BFF connects directly to what we’ve been doing in CS-343 with REST APIs, Express endpoints, data validation using OpenAPI, and separating layers of an application. During the recent advanced assignment(referring to the REST API Back End Implementation homework of course), I had to build new endpoints, interact with multiple collections, and send changes to a message broker. That required some time of me thinking carefully about how different parts of the system communicate with each other.

The biggest takeaway for me was how the BFF pattern embraces specialization. Instead of making one giant backend do everything, you just got to let each client have a backend that fits them. This avoids exposing unnecessary fields, reduces client-side processing, and improves performance. It also aligns well with microservices, because each BFF can orchestrate multiple services behind the scenes. I realized that the structure of our assignments- frontend consuming API endpoints, backend handling logic, and MongoDB representing the persistence layer; is essentially a simplified version of this architectural thinking.

This article also made me reflect on situations where BFF might solve real problems i could probably encounter in the near future. For example, in our backend assignment, if we had a separate mobile client, its data needs would be very different from the web interface that interacts with full guest objects. A BFF layer could format responses appropriately, avoid over-fetching, and simplify the logic on the client side. The idea of tailoring backends to frontends also helps me make sense of why large systems separate responsibilities; it keeps things maintainable and avoids tightly coupled components.

So in short, i’d say that this resource strengthened my understanding of how backend architecture is shaped by client needs. It also helped me see the bigger picture behind concepts we’ve been using: validation, routing, endpoint design, and database access. Going forward, I expect this perspective to help me structure backend code more intentionally, especially when designing APIs that may evolve to support multiple types of clients.

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Express.js and it’s association with REST API

For this third quarter’s professional development, i read the Treblle post, “How to Structure an Express.js REST API with Best Practices” (https://treblle.com/blog/egergr). The article mostly just talks about on how to properly organize and build RESTful APIs using Express.js while maintaining clean, scalable, and modular code. It covers some key principles like separating app and server logic, implementing a layered architecture, structuring routes and controllers clearly, and designing the API in a way that’s easy to maintain and expand. It also makes mention on the importance of using Docker for containerization and environment consistency, which is essential for deploying APIs reliably across different systems.

I picked this specific resource because i think it ties closely with what we’ve learned in class earlier, taking into account the things like modularity, separation of concerns, and maintainable software design. It helps that we were doing class exercises when it comes to building small web services and understanding how system components interact(at least tangentially when it comes to the guestinfobackend stuff), so reading about how Express.js projects are structured in real-world settings gave a lot of context for people such as myself interested in backend or full-stack development, it’s the kind of practical foundation that helps turn classroom principles into actual coding habits.

From the article, I learned that Express.js isn’t just about setting up endpoints quickly; it’s about creating a clear, layered structure where each part of the API has its own responsibility. In one instance, it recommended dividing the project into three layers: a web layer (for routes and middleware), a service layer (for handling logic and validation), for the other a data layer (for managing database access). I’d say this structure kind of keeps your code modular and easier to debug. Another thing I think is useful was the reminder to containerize the API using docker, which helps standardize development and production environments so you can avoid those “it does/doesn’t work on my machine” problems.

I’d say the article reinforces many of the software architecture concepts we’ve referenced in class, such as modularity, abstraction, and loose coupling. A modular API design definitely makes it easier to scale, test, and maintain which at the end of the day is really the heart of software construction. It also reminded me that tools like Docker play a key role in supporting architecture by making deployment consistent and repeatable, which is just as important as how the code itself is structured.

As a whole, i’d say this article helped me better understand what good backend architecture looks like in practice. It gave me a clearer sense of how to build modular, scalable APIs using Express.js and Docker and i can somewhat see how those principles might carry over into any kind of future coursework and professional projects that i might be part of.

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Learning RESTful Designs Principles

So for this second quarter’s professional development activity, i read the Stack Overflow post, “Best practices for REST API design”(https://stackoverflow.blog/2020/03/02/best-practices-for-rest-api-design/), in basics it covers the fundamental guidelines for designing Restful APIs that are both efficient and developer-friendly, covering some key principles like properly structuring URLs, making sure to use nouns instead of verbs when it comes to endpoint naming, implementing HTTP methods accordingly to standards as well as ensuring consistency in API design. The post also talks a little bit about versioning, error handling and security as vital aspects of any production-level API.

I selected this specific resource considering it does relate to what we were doing in class and some of our homework as well, since we’re getting involved on building maintainable, modular systems and REST APIs are just one of the common interfaces used in modern software architecture, for anyone trying to work in backend development you can deepen your understanding of how to design APIs that other developers can easily understand, use and extend to some degree.

From the rest of the article(no pun intended), I learned that REST isn’t just about making the things in question work but having a consistent and predictable interface that makes client-server communication easier. I like how the article broke down best practices for naming conventions, like how using resource-based URIs like /users or /orders/1234 instead of action-based ones like /getUser makes the API more intuitive. I also remembered about the significance of using HTTP status codes, like 201 Created for successful POST requests or 404 Not Found for missing resources. These small details can contribute somewhat to API usability and maintainability.

So i’d say pretty much that the article reinforces the more architectural concepts that we’ve discussed before in class, like abstraction, modularity and encapsulation. An API that is well-designed abstracts away complex backend logic and presents a clean, understandable interface much like how we design modules in general when it comes to software construction. I also like to think that it connects to our work when it comes to some other software design principles like separation of concerns and loose coupling. RESTful Design makes it so that different parts of a system can evolve independently, which is essential for large-scale software projects.

If i had to reflect on this after my reading of the article, i would say that i realize on some occasions i find myself taking shortcuts when designing endpoints for personal projects, mostly just trying to focus on making sure it’s functionality is in suitable position as opposed to focusing on structure, but after my reading i think i’ll try to be more deliberate when it comes to naming conventions, HTTP method uses and documentation.

Overall, this resource gave me a clearer framework for thinking about web service design, and I can already see how it will help me create more scalable and maintainable software in future projects.

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Improving Design Communication with PlantUML (Reposted)

Why I chose this?

So for this week’s professional development blog, i decided to go with this resource regarding UML diagrams(https://miro.com/diagramming/what-is-plantuml/#what-is-plantuml) considering we’ve been working on this in class for the better part of a few class days now. While syntax is important, I wanted a resource that went beyond the basics and emphasized best practices — specifically, how to make diagrams more readable and effective as communication tools. Which ties back to what we were doing for the classwork activity, the learning objectives of the activity we did in-class together includes identifying parts of UML diagrams, being able to connect them to Java implementation or even being able to draw the diagrams using Markdown with PlantUML.

What did I learn?
The article did help me with solidifying my understanding of the lifelines, the messages and the activation bars within the UML sequence diagrams, but in general from the article, i learned how PlantUML treats diagrams as code: by writing simple text scripts, you can generate UML diagrams consistently and efficiently. This can help out in collaborative environments, where diagrams kind of have to evolve along with the codebase. The section on best practices i find the most interesting since the article highlights that diagrams should focus on clarity over completeness.

For example, a UML sequence diagram should emphasize the key messages between objects rather than every small detail. The guide also pointed out how to use colors, notes, and layout to improve readability — so them giving pointers on how to use those things is good in case we want to make things look more pretty or neat-looking. I do appreciate the explanation of how PlantUML integrates with version control systems although it’s not something i found particularly too significant. Since diagrams are stored as text, they can be tracked and managed in Git just like source code. This makes them much easier to update collaboratively, compared to traditional tools where diagrams are static images.

Reflection and Application?

I thought it might be something i’d forget about in a month or two, i do think it helped with reinforcing the core concept that the UML designs aren’t just academic exercises that we were doing in class, it can be a practical tool for teams collaborating with each other compared to the traditional tools where it’s like the diagrams are just static images alongside the fact that it isn’t just checking a box but being able to make sure everyone understands, I guess i’d say for any future projects that come to mind, i’ll apply what i’ve learned by keeping my diagrams somewhat simple and try to make it with an audience in mind since there will be people i’ll interact with and get feedback when it comes to my PlantUML code. I also wouldn’t mind experimenting with Markdown and Git so that the diagrams can evolve with the codebase, becoming almost like living documents as opposed to a static artifact.

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Improving Design Communication with PlantUML

Improving Design Communication with PlantUML
I guess when it comes to software engineering, code is usually the arbiter of truth, although it isn’t always the best avenue for communicating a design for your average person/laymen considering developers and computers can parse through lines of code like it’s nothing- but trying to understand the higher-level structure or interactions within a system can be somewhat challenging without some kind of abstraction to it, which is why UML diagrams have a great deal of utility to them as they strip-away the low-level implementation details that the layperson in question doesn’t have to deal with- allowing us to focus on the essential interactions.

Why I chose this?

So for this week’s professional development blog, i decided to go with this resource regarding UML diagrams(https://miro.com/diagramming/what-is-plantuml/#what-is-plantuml) considering we’ve been working on this in class for the better part of a few class days now. While syntax is important, I wanted a resource that went beyond the basics and emphasized best practices — specifically, how to make diagrams more readable and effective as communication tools. Which ties back to what we were doing for the classwork activity, the learning objectives of the activity we did in-class together includes identifying parts of UML diagrams, being able to connect them to Java implementation or even being able to draw the diagrams using Markdown with PlantUML.

What did I learn?
The article did help me with solidifying my understanding of the lifelines, the messages and the activation bars within the UML sequence diagrams, but in general from the article, i learned how PlantUML treats diagrams as code: by writing simple text scripts, you can generate UML diagrams consistently and efficiently. This can help out somewhat in collaborative environments, where diagrams kind of have to evolve along with the codebase. The section on best practices i think i find the most interesting since the article highlights that diagrams should focus on clarity over completeness.

For example, a UML sequence diagram should emphasize the key messages between objects rather than every small detail. The guide also pointed out how to use colors, notes, and layout to improve readability — some things that you don’t really pay too much attention to(at least for myself) so them giving pointers on how to use those things is good in case we want to make things look more pretty or neat-looking. I do appreciate the explanation of how PlantUML integrates with version control systems although it’s not something i found particularly too significant. Since diagrams are stored as text, they can be tracked and managed in Git just like source code. This makes them much easier to update collaboratively if need be, compared to traditional tools where diagrams are static images.

Reflection and Application?

At first i thought it might be something i’d forget about in a month or two(if i’m being just honest with the article), i do think it helped with reinforcing the core concept that the UML designs aren’t just academic exercises that we were doing in class, but it can be a practical tool for teams collaborating with each other compared to the traditional tools where it’s like the diagrams are just static images alongside the fact that it isn’t just checking a box but being able to make sure everyone understands, between the code and the people. I guess i’d say for any future projects that come to mind, i’ll apply what i’ve learned by keeping my diagrams somewhat simple and try to make it with an audience in mind since there will be people i’ll interact with and get feedback when it comes to my PlantUML code. I also wouldn’t mind experimenting with Markdown and Git so that the diagrams can evolve with the codebase, becoming almost like living documents as opposed to a static artifact.

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Introduction(CS-343)

Hi, my name is Jamaal, been a while since i made a blog but coming back to it and getting in the grove of things especially for CS-343, hopefully this will be an enjoyable semester when it comes to learning about software construction/design and architecture .

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

The Principles of Writing Clean Code

In the realm of software development, the challenge of deciphering convoluted and tangled code, often referred to as “spaghetti code,” has persisted. This final blog explores the significance of writing clean code—a practice that not only caters to machines but, crucially, facilitates human collaboration, ensuring project success.

I selected this resource since it delves into the importance of clean code in software development. i feel as though it emphasizes readability, consistency, and meaningful naming conventions, addressing the challenges posed by complex and unclear code structures. The text advocates for clean coding practices that enhance collaboration and ease of understanding among developers.

i picked this since it stood out due to its comprehensive coverage of clean coding principles, ranging from intuitive code structure to the strategic use of comments and robust error handling. Its relevance lies in providing practical insights into writing code that is not just functional but also maintainable and adaptable, aligning with the collaborative nature of software development.

The content underscores the pivotal role of developers in the software industry and how clean code is indispensable for creating software with easy usability. Consistency, meaningful names, simplicity, strategic comments, and robust error handling are identified as key components of clean programming. The emphasis on collaborative practices, such as code reviews and refactoring, highlights the continuous learning and improvement inherent in writing clean code.

The use of AI in code reviews and automated testing aligns with current technological trends, enhancing the efficiency of maintaining clean codebases. The resource effectively communicates that writing clean code is not just a good practice but a fundamental aspect of sustainable software development.

This material reinforces the profound impact of clean coding on the collaborative and productive aspects of software development. It has heightened my awareness of the long-term benefits of investing time and effort in writing clean code. I understand that clean code is not just about pleasing aesthetics; it’s a strategic approach that ensures maintainability, efficiency, and scalability throughout the software development lifecycle.

https://reflectoring.io/clean-code/

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

The Evolution of Kanban: A dive into another methodology

having taken a look at Kanban (which was part of our homework task), a powerful framework for software development teams, has become a cornerstone for teams aiming to enhance efficiency and transparency in their workflow. Originating over 50 years ago from Toyota’s manufacturing processes, the methodology has seamlessly transitioned into the realm of software development. In this blog post, we’ll delve into the key principles of Kanban, its historical roots, and its application in modern agile practices.

from what information i was able to gather, Kanban is grounded in the just-in-time (JIT) manufacturing process that Toyota pioneered in the late 1940s. it draws inspiration from supermarkets stocking products based on consumer demand, to which Toyota aimed to align their factory inventory levels with actual material consumption. The implementation involved passing a visual signal, known as a “kanban,” between teams to communicate real-time capacity on the factory floor and with suppliers.

Fast forward to today, and agile software development teams have embraced these JIT principles to optimize work in progress (WIP) and match it with the team’s capacity. The heart of Kanban lies in visualizing work, limiting WIP, and ensuring real-time communication of capacity.

Central to the Kanban methodology is the Kanban board, a visual project management tool available in physical or digital form. This tool aids in visualizing work, limiting work-in-progress, and maximizing efficiency or flow. Whether physical or virtual, the Kanban board serves as the single source of truth for the team’s work, ensuring transparency and real-time communication of capacity.

Kanban offers a plethora of advantages for software developing teams, making it one of the most popular software development methodologies today. The flexibility in planning, shortened time cycles, fewer bottlenecks, and the use of visual metrics contribute to its widespread adoption. The ability to adjust priorities without disrupting the team, optimize cycle time, and limit WIP ensures that Kanban is not only effective but also adaptable to different team structures and objectives.

in terms of what stuck with me the most after reading the article, i’d say the historical connection to Toyota’s manufacturing processes highlighted the enduring nature of concepts like just-in-time manufacturing and efficient inventory management. Understanding how these principles seamlessly translated into the realm of software development underscored the universal applicability of Kanban aswell as the emphasis on visualization through Kanban boards and the use of cards for each work item struck me as a simple yet powerful way to enhance collaboration and transparency within a team. The flexibility in planning, especially the ability to reprioritize work without disrupting the ongoing tasks, stood out as a valuable feature. This aligns well with the dynamic nature of software development, where changes in priorities are not uncommon.

https://www.atlassian.com/agile/kanban

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Navigating Success with Scrum: A Journey Through Agile Evolution

when it comes to the ever-evolving landscape of software development, i’d say it’s imperative to keep pace with methodologies that not In the ever-evolving landscape of software development, it’s imperative to keep pace with methodologies that not only foster innovation but also ensure efficiency and quality. Scrum, a natural evolution of Agile Management, emerges as a powerful ally in this quest. I wanted to try explore in this blog post some of the intricacies of Scrum, the roles it defines, its numerous benefits, and the heartbeat of the framework – Scrum ceremonies.only foster innovation but also ensure efficiency and quality. Scrum, a natural evolution of Agile Management, emerges as a powerful ally in this quest.

Our journey through Scrum begins with the understanding that it’s a flexible methodology firmly grounded in the 12 agile principles. It operates in time-bound blocks known as Sprints, where the emphasis is on delivering tangible results efficiently. A critical element is the Product Owner, who ensures alignment with the project’s goals and client priorities.

I wanted to choose this due to its holistic approach to Scrum, covering both its foundational concepts and its profound impact on software development and beyond. It’s particularly relevant to our course as it provides insights into harnessing technology for project management.

The article underscores Scrum’s suitability for modern demands – the need for quality, fast delivery at lower costs. Its ability to adapt to changing requirements is an invaluable asset. Scrum’s emphasis on the most important functionalities first ensures swift client access and timely risk management. The definition of roles, especially the Product Owner and Scrum Master, is pivotal to maintaining a balance between business priorities and agile development.

This resource served as a reminder of Scrum’s pivotal role in the software development ecosystem. It reinforced my belief in the importance of flexibility, adaptability, and efficiency in project management. The incorporation of Scrum’s ceremonies ensures that every aspect of the project is aligned with the overarching goal, promoting collaboration, transparency, and improvement. I see myself applying this knowledge in future projects, advocating for scrum methodologies to achieve better results.

As we conclude our exploration of Scrum, it’s evident that its application extends beyond software development, seeping into various organizational models. The benefits of scalability, expectation compliance, flexibility, and risk reduction make Scrum a cornerstone in project management methodologies. The Scrum ceremonies, with their structured yet flexible approach, not only foster collaboration and transparency but also ensure timely progress and continuous improvement.

https://www.nimblework.com/agile/scrum-methodology/

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Exploring the Classical Waterfall Model in Software Development

In most respects the classical waterfall model serves as the foundational software development life cycle (SDLC) model, almost embodying a structured and sequential approach to project management and software development which can prove effective when doing a variety of coding projects. While it may not be as commonly employed today, its significance lies in being the basis upon which other SDLC models have evolved, the process often involving steps and details with which have been planned beforehand. This model finds its relevance in the realm of more large, complex projects, being a model characterized by its rigorous, phase-driven progression, making it suitable for scenarios where project requirements are well-defined, and project stakeholders seek a high level of confidence in the outcome.

The waterfall model, although now less prevalent in contemporary software development considering it’s lesser effectiveness compared to more agile methodologies , it remains a foundational framework for understanding software development life cycles. This model’s structured, sequential approach entails phases like requirements gathering and analysis, design, implementation, testing, deployment, and maintenance, each building upon the preceding one. It is a document-driven model, placing high importance on quality control and rigorous planning, thus ensuring that the project is well-defined and the team operates with clarity and precision.

it becomes pretty clear that the simplicity and linear progression that come with the waterfall technique offer advantages for specific project scenarios. This approach favors discipline, with a focus on defining requirements before design likewise with the design before coding. For smaller, well-understood projects, it can be effective in maintaining clarity and ensuring milestones are met.

At the same time though, the rigidity and limitations of the waterfall model become apparent in more complex, dynamic projects. Its lack of flexibility to accommodate changing requirements and late defect detection pose significant challenges. The sequential nature of the model restricts stakeholder involvement in later phases, potentially leading to misunderstandings and costly revisions.

in practice, project managers and development teams should carefully assess project requirements, size, complexity, and the degree of uncertainty to select the most appropriate SDLC model since the waterfall method might not always be effective, sometimes proving to be an unwieldy method for projects better suited to adaptability. Moreover, hybrid approaches, combining elements from multiple models, can offer the best of both worlds, allowing for structure and adaptability.

In conclusion, the classical waterfall model, while valuable for certain projects, is not a one-size-fits-all solution. Its use should be considered in situations where requirements are well-defined and change is unlikely, such as large-scale, safety-critical, or government projects considering these have a tendency to have big budgets and therefore need to be mapped out when taking into account the money spent on particular projects. In today’s rapidly evolving software landscape, more adaptive SDLC models have gained prominence, offering flexibility and responsiveness to changing needs.

https://www.geeksforgeeks.org/software-engineering-classical-waterfall-model/

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.