Author Archives: skarkonan

Sprint 1

GitLab Activity

Install npm JWT Library and handle validation on Mock FE/BE issue – created a file called checkRole.js that as of moment takes a token and decodes it, however since Keycloak is not configured yet with the backend, checkRole.js is still not setup for the verification of tokens.

Reflection on What Worked Well

This sprint, I found that my ability to collaborate effectively with my team improved. We established a structured workflow using GitLab issues and merge requests, ensuring everyone was aligned. Team meetings and project reviews were also particularly helpful in maintaining quality and catching potential issues early. Additionally, I felt more comfortable with our tech stack, which allowed me to contribute more efficiently to the project.

Reflection on What Didn’t Work Well

One of the biggest challenges during this sprint was time management and managing expectations of fellow team members. Balancing multiple tasks while delivering high-quality work proved difficult, especially when unexpected issues arose. There were also moments when communication gaps led to duplicated efforts or confusion regarding task ownership.

Additionally, an unexpected bug related to the jsonwebtoken library took longer to resolve than anticipated, impacting our overall sprint velocity. I underestimated the complexity of debugging the issue, and this resulted in delays. Moving forward, I want to improve my debugging strategies by breaking down issues systematically and identifying potential causes earlier in the process.

Another challenge was that some tasks took longer than expected due to unclear requirements. There were times when I started working on a feature only to realize later that I had misunderstood part of the implementation. This led to rework and inefficiencies that could have been avoided with better clarification upfront.

Reflection on Changes to Improve as a Team

To improve as a team, we need to refine our communication and task allocation strategies. One possible improvement is assigning issues to members with clear deadlines and deliverables. This would help eliminate the need to check in constantly about each other’s progress and give everyone enough space to focus on their designated tasks.

Additionally, we could establish clearer guidelines on documentation and issue tracking. Proper documentation would minimize misunderstandings and ensure that we have a reference point if any team member forgets certain project details. This could be as simple as maintaining a shared document with important technical decisions, dependencies, and any issues we encounter.

Reflection on Changes to Improve as an Individual

On a personal level, I need to deepen my knowledge of the technologies we are using and strengthen my overall web development skills. Additionally, I must improve my time management and prioritization strategies to ensure more efficient task completion. Allocating time for debugging and testing earlier in the sprint would help reduce last-minute stress and improve the stability of our work. I also plan to dedicate time outside of sprint tasks to learn best practices and gain a more comprehensive understanding of our tech stack. Finally, I recognize the importance of seeking help sooner when I encounter challenges, as doing so will allow me to work more efficiently and avoid unnecessary delays.

Apprenticeship Pattern: “Be the Worst”

Summary of the Pattern

The “Be the Worst” pattern suggests deliberately placing yourself in an environment where you are the least experienced or skilled person. By doing so, you expose yourself to opportunities for rapid learning and growth by observing and working with more skilled individuals. While this can be uncomfortable, it forces you to improve and challenge yourself continuously.

Why I Selected This Pattern

I chose this pattern because, during this sprint, I often felt like I was struggling to keep up with some of my teammates who had more experience with certain technologies. Instead of being discouraged, I realized that this was an opportunity to learn from them and elevate my own skills. Their feedback and insights helped me refine my practices and problem-solving approach.

How This Pattern Could Have Changed My Behavior

Had I fully embraced this pattern earlier in the sprint, I would have proactively sought out mentorship and learning opportunities rather than hesitating to ask questions. Additionally, I would have taken more initiative in tackling challenging tasks instead of sticking to what I was comfortable with. Moving forward, I plan to embrace this mindset and view my inexperience as an advantage rather than a limitation.

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

Apprenticeship Patterns

Reading Apprenticeship Patterns made me take a step back and think about what it really means to grow as a software developer. It’s easy to get caught up in learning new technologies, chasing certifications, and trying to keep up with the latest trends, but this book focuses on something deeper, the mindset and habits that shape a longterm career in software. One of the biggest takeaways for me was the idea that becoming a great developer isn’t about how much you already know, but about how you approach learning. The whole concept of being an apprentice, journeyman, and eventually a master makes sense, but what stood out to me the most is that there’s never really a finish line. No matter how much experience someone has, there’s always more to learn. That’s both motivating and humbling. The book also talks a lot about mentorship, self-awareness, and staying open to new ideas. It made me realize that improving as a developer isn’t just about writing more code, it’s about actively seeking feedback, being willing to unlearn bad habits, and knowing when to ask for help. I’ve always leaned towards figuring things out on my own, but after reading this, I see how valuable it is to learn from others who have been through the process. Another thing that stood out is how easy it is to fall into the trap of either imposter syndrome or overconfidence. The book emphasizes the importance of being honest with yourself, knowing what you’re good at and where you need to improve. It’s easy to feel like you’re behind when you see others moving faster, but at the same time, it’s important to not get too comfortable and stop pushing yourself. Finding that balance is key. Overall, this book challenges the way you think about growth and career development. It emphasizes the idea that learning should be intentional, that mentorship and community matter, and that real progress comes from consistent effort over time. It’s made me reflect on how I approach my own learning journey, and I’m looking forward to applying some of these ideas as I move forward in not only my career, but in life as well.

From the blog The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

CS-443, Sepehr’s Introductory’s blog

Hello everyone,

my name is Sepehr Karkonan, a senior at Worcester State University majoring in Computer Science. I am writing this blog to introduce myself and want to wish everyone a great semester filled with success, valuable lessons and great memories. Looking forward to learning with everyone-happy learning.

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

Mastering Backend Development: A Comprehensive Guide

Backend development is where the real magic happens. While users interact with the front end of an application, the backend is responsible for everything from data storage to user authentication, ensuring smooth communication between services. Mastering backend development goes beyond learning a single language or framework it’s about understanding how to build scalable, secure, and maintainable systems. In this overview, Im going to talk about the article written by DEV COMMUNITY on mastering backend development

Choosing the Right Language

Choosing the right language is the first step in backend development. Your choice depends on the project’s requirements and your long-term goals. JavaScript (Node.js) is popular for event-driven servers, while Python is great for data-centric applications. Java is ideal for enterprise solutions, and Go is well-suited for high-performance services. Each language has its strengths, so pick one that aligns with your project needs.

Understanding HTTP and Networking

Since backend services communicate over the internet, understanding HTTP is crucial. Knowing how HTTP methods like GET, POST, PUT, and DELETE work, along with concepts such as DNS, will help you design efficient and secure APIs. A solid understanding of these concepts allows smooth communication between services and ensures reliable system integration.

Working with Databases

Databases are fundamental to backend development. Whether you’re using relational databases like PostgreSQL or NoSQL databases like MongoDB, it’s essential to know when to use each. A solid understanding of database management enables you to store and retrieve data efficiently, which is crucial for building fast and scalable systems.

API Design and Development

APIs are the backbone of communication between system components. Designing an efficient and secure API is key to building scalable systems. Whether you’re using REST, GraphQL, or gRPC, consider factors like versioning, security, and documentation to make integration easy for other developers.

Security Practices

Security is essential in backend development. Implementing robust authentication methods like OAuth and JWT ensures that only authorized users can access your services. Understanding common security threats and mitigation strategies is key to protecting your system from unauthorized access and data breaches.

Caching and Performance

To optimize performance, caching is a must. Using tools like Redis or Memcached can help reduce database load and speed up response times by temporarily storing frequently accessed data. Proper caching strategies can drastically improve your system’s performance and scalability.

Scalability and Load Balancing

As your application grows, scaling becomes crucial. Load balancing tools like Nginx or HAProxy ensure that traffic is evenly distributed across servers, helping handle increased traffic without sacrificing performance. Understanding scaling strategies, such as horizontal and vertical scaling, is essential for building resilient systems.

Continuous Learning

Backend development is always evolving. Keep up with new tools, frameworks, and best practices by reading blogs, contributing to open-source projects, and experimenting with new technologies. Continuous learning is essential to becoming a skilled backend developer.

By mastering these concepts, you’ll be on your way to building robust, scalable, and secure backend systems.

Reference
https://dev.to/roadmapsh/mastering-backend-development-mpb

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

Understanding UML: A Simple Guide to the Unified Modeling Language

In 1997, the Object Management Group (OMG) introduced the Unified Modeling Language (UML). It was created to help IT professionals design and communicate software systems more easily. Think of it like blueprints for a building UML gives developers a standard way to plan and share their ideas about how a system should work.

UML has become a popular tool in the tech world. You’ll often see it listed on resumes, but many people don’t actually know how to use it well. That’s why learning the basics of UML is important if you want to include it in your skillset. In this guide, we’ll cover the article written by Donald Bell who works as a solutions architect for IBM, and some of the most common diagrams and how they’re used.

What Makes UML Special?

UML is not tied to a specific programming language. This makes it flexible and easy to use in many different environments, whether you’re working with Java, .NET, or something else. Also, UML is a language, not a method. This means it can fit into any company’s way of working without requiring big changes.

The main purpose of UML is to help teams understand and share their ideas more clearly. By using UML diagrams, teams can communicate how a system will work, making it easier for new members to join a project and get up to speed quickly.

Key Types of UML Diagrams

Use-Case Diagrams: These show how users (called “actors”) interact with the system. For example, they can illustrate how a customer logs into an app or makes a purchase. Use-case diagrams are simple and focus on the system’s main functions.

Activity Diagrams: These diagrams show the flow of actions in a process. They’re great for mapping out workflows, like how a customer service ticket moves from “open” to “resolved.” Activity diagrams are easy to understand, even for people who don’t have a technical background.

Deployment Diagrams: These focus on where parts of the system will run, like servers or applications. They show how different pieces of the system communicate and help teams plan how everything will work in real life.

Why UML Still Matters

UML has been around for over 25 years, but it’s still widely used because its core ideas are timeless. Much like classic software books that are still relevant today, UML helps solve problems that developers face every day.

Even without fancy tools, you can start using UML with just a whiteboard or pen and paper. By practicing with basic diagrams, you’ll improve how you share your ideas and work with others on software projects. Keep learning, and UML can become one of your most useful tools!

Reference

https://developer.ibm.com/articles/an-introduction-to-uml/

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

Design Patterns

Design patterns are essential tools for software developers, providing standardized, reusable solutions to common coding challenges. Rather than developing unique solutions every time a familiar problem arises, developers use these templates to write organized, efficient, and adaptable code. Design patterns are not complete blocks of code but instead serve as blueprints, guiding the structure of code in object-oriented programming and enhancing overall project organization.

according to the published article on GeeksForGeeks, the article mentions about A key advantage of design patterns which is reusability. Patterns can be applied across different projects, which saves time and effort by eliminating the need to repeatedly solve similar issues. This flexibility also allows developers to apply patterns quickly in various scenarios, accelerating development. Another benefit is standardization; design patterns create a common vocabulary among developers, which simplifies communication and collaboration within a team. By recognizing these patterns, all team members can quickly understand and follow the structure of the codebase.

Design patterns further promote efficiency by offering solutions that have been tested and refined over time. Since developers do not need to invent new solutions for frequently encountered problems, they can progress faster with fewer errors. Additionally, design patterns are designed to be flexible. They are adaptable templates, meaning they can be customized to fit specific project needs, making them a versatile tool for a variety of applications.

Types of Design Patterns

Design patterns fall into three main categories: Creational, Structural, and Behavioral.

  1. Creational Patterns focus on managing object creation to keep systems flexible and independent of object-specific creation logic. Examples include:
    • Factory Method: Allows creation of objects without specifying the exact class.
    • Singleton: Ensures only one instance of a class exists globally.
    • Builder: Breaks down complex object construction into simpler steps.
  2. Structural Patterns emphasize organizing classes and objects to create efficient, larger structures. Examples include:
    • Adapter: Enables incompatible classes to work together by adjusting their interfaces.
    • Facade: Simplifies complex systems by providing a unified interface.
    • Decorator: Adds extra functionality to objects without altering other instances.
  3. Behavioral Patterns focus on defining how classes and objects interact within a system, streamlining communication in complex applications.

In summary, design patterns help developers produce clear, maintainable, and scalable code. By adopting these patterns, developers can approach recurring problems with reliable solutions, improving collaboration, reducing development time, and creating codebases that are easy to expand and adapt. In the fast-paced world of software development, design patterns serve as a stable foundation for building robust, flexible applications

Reference: https://www.geeksforgeeks.org/software-design-patterns/

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

A Quick Guide to Open Source Licenses

Introduction

The blog, “A Short Guide to Open Source Licenses,”by David Skaife, helps us understand the often confusing world of open source licenses. Let’s break down the key points to make sense of why these licenses matter in the world of computer software.

Understanding Open Source Licenses

Open-source licenses are like rules for sharing computer code. They tell us how we can use, share, and change the source code. These rules help protect the original creators and make it easier for others to use the code without asking for permission each time.

Clearing up Myths: Public Repositories and Licensing

Skaife talks about a common misunderstanding of just putting code on a public platform, like GitHub, doesn’t automatically make it open source. Without a clear set of rules (license) with the code, it’s still protected by copyright, and others can’t freely use or change it. So, it’s crucial to attach a license if you want others to use your code.

Making Sense of Licenses

Skaife acknowledges that there are many licenses, but he suggests focusing on a few popular ones. He also mentions the Open Source Initiative (OSI), which approves licenses, making it easier for us to choose from reliable options.

License Types: Strict vs. Flexible

There are two main types of licenses – strict (copyleft) and flexible. Strict licenses say that if you change the code, your new version must also follow the same rules. Flexible licenses are more relaxed, letting people use, change, and share the code more freely.

Exploring Five Common Licenses

There are five common licenses we might choose from:

  1. MIT License: Simple and flexible, allowing changes with few conditions.
  2. Apache License 2.0: Similar to MIT but a bit more complicated, addressing specific issues like trademark rights.
  3. GNU General Public License (GPL) v2.0 and v3.0: Strict licenses, ensuring all changes follow the same rules, with v3.0 adding more details.
  4. GNU Lesser General Public License (LGPL) v2.1 and v3.0: Less strict than GPL, allowing some exceptions for linking.
  5. Berkeley Software Distribution (BSD) 2-clause and 3-clause variants: Flexible licenses, similar to MIT, with the 3-clause version having extra rules about using contributors’ names.

conclusion

Skaife’s guide helps us navigate open source licenses, making it easier to understand the rules for sharing and using computer code. With this knowledge, anyone working with open source software can feel more confident contributing, using, or creating, fostering a collaborative and innovative community. For those wanting more information, Skaife suggests checking out resources like the Open Source Initiative’s licenses pages and GitHub’s “choosealicence.com.”

reference

View at Medium.com
https://medium.com/nationwide-technology/a-short-guide-to-open-source-licenses-cf5b1c329edd

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

Writing clean code: A developers guide to readable and maintainable code

Clean code refers to computer code that is easy to read, comprehend, and maintain. This type of code is crafted to be straightforward, concise, and expressive, following specific conventions, standards, and practices that enhance readability and clarity. 

The importance of clean code cannot be overstated. When code is readable and comprehensible, it facilitates collaboration among developers and boosts productivity while minimizing errors. Additionally, easy maintainability is crucial for long term projects, ensuring that the codebase can be updated and enhanced over extended periods. The foundation of clean code lies in its readability and maintainability, as beautifully articulated in the blog “How to write clean code?” By FreeCodeCamp. In this article, we’ll dissect the principles and practices behind clean code, and give you a few tips on how to craft clean cod.

Assessing Code Cleanliness

Determining whether code meets the standards of cleanliness involves various aspects. Good documentation, consistent formatting, and a well-organized codebase serve as benchmarks for clean code. Additionally, code reviews and thorough testing contribute to identifying potential issues and ensuring adherence to best practices.

By incorporating tools, practices, and conventions, developers can create a codebase that is efficient.

Tips for writing clean code:

  1. Effectiveness, Efficiency, and Simplicity
    • Prioritize effectiveness to ensure the code solves the intended problem.
    • Strive for efficiency by optimizing resource usage.
    • Embrace simplicity for code clarity and easy comprehension.
  2. Format and Syntax
    • Enforce consistent indentation and spacing.
    • Maintain a uniform syntax throughout the codebase.
    • Adhere to consistent case conventions (camelCase, PascalCase, snake_case).
  3. Naming
    • Choose clear and descriptive names for variables and functions.
    • Avoid vague or generic names that obscure the purpose of the entity.
  4. Conciseness vs. Clarity
    • Strike a balance between concise and clear code.
    • Prioritize clarity to enhance readability, even if it means sacrificing conciseness.
  5. Reusability
    • Design code with reusability in mind, promoting efficiency in development.
    • Embrace modular and scalable software architectures.
  6. Clear Flow of Execution
    • Ensure a logical and clear flow of execution in the code.
    • Steer clear of spaghetti code through thoughtful organization and structure.
  7. Single Responsibility Principle (SRP)
    • Assign a single responsibility to each class or module.
    • Enhance code readability and maintainability by adhering to SRP.
  8. Single Source of Truth
    • Centralize data or configurations to avoid duplication and ensure consistency.
    • Simplify updates by having a single source for critical information.
  9. Only Expose and Consume Needed Data
    • Minimize exposure or consumption of unnecessary information.
    • Utilize object destructuring for selective access to required data.
  10. Modularization
    • Break down code into smaller, manageable modules for ease of understanding.
    • Foster reusability and maintainability through thoughtful modularization.
  11. Folder Structures
    • Organize the project based on features rather than file types.
    • Cultivate a clear and logical folder structure for seamless navigation.
  12. Documentation
    • Employ comments to provide context and explain the functionality of the code.

Reference: https://www.freecodecamp.org/news/how-to-write-clean-code/

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

Git for Web Designers: A Guide to Smoother Collaboration

In the dynamic world of web design, managing projects efficiently is a constant challenge, and collaboration between team members is key to a successful management of projects. Without a strong version control system, things can quickly get out of control, leading to lost files, overwrites, and the dreaded conflicts between front-end templates and back-end functionality. In this blog post, we analyze the insights presented in the article “Introduction to Git for Web Designers” explore the benefits of version control and take a deep dive into the world of Git, an open-source version control system that has become a staple for web developers and designers alike.

The Power of Version Control

Version control, also known as Revision Control or Source Control Management, is a game-changer for web designers working in collaborative environments. The basic concept involves a central repository for project files, allowing team members to check out, make changes, and commit them back to the repository. This systematic approach tracks changes, timestamps them, and provides a clear history of revisions. The advantages include preventing file overwrites, maintaining a common repository, facilitating simultaneous collaboration, and offering the ability to revert to previous versions if needed.

The Developers’ Current Struggle

Before diving into Git, many developers manage their files using a crude version control system. Picture a folder filled with various versions of PSDs and other large binary files, an approach that works for static designs but falls short when managing the source code for a dynamic website.

Git: Your Ultimate Version Control Companion

Among the various version control systems available, Git stands out as a powerful, distributed version control system originally created by Linus Torvalds for Linux kernel development. Unlike its predecessors, Git ensures that every user has a complete copy of the repository data stored locally. This distributed nature brings several advantages, including offline work capabilities, resilience against a single point of failure, and faster processes.

The Learning Curve

While Git has a slightly steeper learning curve compared to some alternatives, the benefits far outweigh the initial challenges. Installing Git may seem daunting at first, but there are many online resources and guides to assist users on different operating systems.

Getting Started with Git

Once Git is installed, transitioning an existing folder into a Git repository is a straightforward process. Through simple commands in the terminal or command prompt, users can initialize a directory, add files, and commit changes. Visual tools like Git GUI, GitX, and TextMate with a Git bundle provide user-friendly interfaces for those less inclined towards the command line.

A Peek into a Sample Git Workflow

A web designer’s daily interaction with Git involves checking for the latest changes, making edits, committing changes locally, and pushing them to the master repository. Tools like GitX and TextMate’s Git bundle offer efficient ways to organize commits and visualize changes.

Learn More and Level Up

For those eager to delve deeper into Git, a variety of resources are available. Git cheat sheets, tutorials, and online guides can help developers become proficient in this essential tool. Embracing version control is not just about file management, it represents a fundamental change leading to effective teamwork and project triumph.

Conclusion

In the fast-paced world of web design, mastering version control is an essential skill. Mastering version control with Git isn’t just about files – it’s about smooth teamwork and awesome projects. Git gives you the tools to collaborate without the chaos. So, dive in, make friends with Git, and enjoy a design journey with fewer headaches.

Reflecting on the blog:

In summary, the article “Introduction to Git for Web Designers” stands as a guide for design professionals maneuvering the detailed world of version control. With clear explanations, it unravels the seemingly complex realm of version control, emphasizing Git as a crucial tool for bringing organization and collaboration to the field of web design.

References

https://www.webdesignerdepot.com/2009/03/intro-to-git-for-web-designers/#more-7224

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.

choosing the right software development mythology: Agile, or Waterfall?

Whether you’re embarking on a new project or contemplating a shift in your development approach, deciding between Agile and Waterfall methodologies can be challenging. Selecting the right approach is crucial for the successful development of your project. In this blog, we will analyze the specifics of Agile and Waterfall methodologies to help you make an informed decision tailored to your project’s needs.

Understanding Agile

Ever wondered about the magic behind Agile Software Development? I have recently come across a blog on Agile development by Martin Fowler, a British software developer, author, and international public speaker on software development, who specializes in object-oriented analysis and design, UML, patterns, and agile software development methodologies, including extreme programming. The blog “Agile Software Guide” by Mr. Fowler takes you on a journey through its beginnings and the core ideas that makes Agile work. Written by someone who was there from the start, this blog unravels the secrets of Agile development. The author shares early memories of Extreme Programming and co-authoring the Manifesto for Agile Software Development that sets the stage for an insightful tour through the world of Agile, coming from a credible source who has seen it from its beginnings. The blog dives into the key concepts of Agile thinking, emphasizing how it differs from traditional software engineering. It breaks it down into two main points: being adaptable instead of sticking to plans, and focusing on people rather than processes. A simple breakdown that makes the essence of Agile clear. Mr. Fowler also talks about Agile plans being like a flexible baseline, changing as the project progresses. Unlike traditional plans that demand sticking to a set path, Agile plans are adjusted based on what’s happening. Success in Agile is all about the value the software brings, not just following a rigid plan. However, with all its advantages, the blog doesn’t pretend Agile is perfect. It talks about the challenges, like some practices being called “Agile” when they really aren’t. This honesty adds a dose of reality, reminding everyone to keep an eye on how Agile is actually being used. Agile methodology is often praised for its customer-centric, and flexible approach to software development. In Agile, projects are divided into small increments with minimal planning, and teams work in short cycles, known as iterations or sprints. The methodology emphasizes collaboration, customer feedback, and the flexibility to adapt to changing requirements in which results in continuous delivery of functional software, close collaboration between cross-functional teams, stakeholders, and the customers.

understanding Waterfall

Unlike Agile, the Waterfall methodology follows a linear and step-by-step approach. the project is divided into distinct stages where each stage build’s upon the previous one. The development process flows steadily downwards similar to an actual waterfall, through stages like requirements, design, implementation, testing, deployment, and maintenance. Each stage must be completed before the next one begins, and changes are discouraged once a phase is underway.

How to choose the right methodology? 

The choice depends on several factors, such as project requirements, team expertise, and customer involvement in your development process. If project requirements are clearly defined from the beginning, and changes won’t be necessary during the development process, then the Waterfall methodology could be the right choice for you. However, I personally believe that Agile methodology is usually the right choice for most projects.

In today’s world of constant change, adaptability is crucial in any developmental process. Additionally, based on my experience in various customer service jobs, I’ve realized that customers often don’t know exactly what they want. Therefore, having the ability to adapt if the customers’ needs changes’ slightly is incredibly important.

Agile Software Development: A Concise Overview. (2023). Retrieved from https://martinfowler.com/agile.html

From the blog CS@Worcester – The Bits & Bytes Universe by skarkonan and used with permission of the author. All other rights reserved by the author.