Author Archives: skarkonan

Sprint Retrospective – Sprint 2

This sprint pushed us a bit more out of our comfort zones as we moved deeper into authentication, authorization and infrastructure setup. While we had a better sense of our team dynamics and project direction, some unexpected technical challenges tested our adaptability and communication. Especially, With Keycloak setup and JWT integration becoming a major focus, we encountered some unexpected challenges that helped us grow both technically and as a team.

Evidence of activity

  • Configure Realm Export Script/Command(s): Exported realm configuration from binary to JSON to enable version control and team collaboration.
  • Added user group/role to JWT payload: Configured keycloak settings to add users needed information to JWT payload.

What worked well

Clearer Role Distribution:
This sprint had more defined roles, which helped prevent overlap and increased efficiency.

Deeper Technical Understanding:
Working with Keycloak gave us valuable hands-on experience with client scopes, tokens, and user roles.

Proactive Communication:
Team members were quicker to reach out for testing, review, and feedback. That made a noticeable difference in momentum.

why didn’t work well:
One major challenge was managing Keycloak realm configuration collaboratively.

At first, we exported Keycloak changes (clients, roles, users) using the admin console, which generated binary .realm files. These couldn’t be diffed, merged, or version-controlled properly. This became a blocker when multiple teammates made changes at the same time.

The workaround:

  • We each exported changes into JSON format.
  • Then we manually merged the configurations later, ensuring nothing was overwritten.
  • We also began documenting our changes to avoid confusion.

It was tedious and not ideal, but we learned the value of choosing version-control-friendly formats early on when working with tools like Keycloak.

Individual improvement goals:
– Programming Improvement: Over the last sprint, I struggled with translating my thought process into actual code and logic. This made me realize that while computer science courses often emphasize theory, I need to spend more time improving my practical programming skills to bridge that gap.

– Ask Sooner: I struggled with JWT for hours, when help was just a message away.

Apprenticeship Pattern: “Concrete Skills”

Summary:
The “Concrete Skills” pattern emphasizes the importance of acquiring real, tangible skills that make you immediately useful to a team. These are the kinds of abilities that allow you to contribute from day one—whether it’s setting up a development environment, debugging a system, or deploying a service.

Why I Chose It:
This sprint made me realize how much more confident and helpful I feel when I have concrete, hands-on experience with the tools we’re using, especially Keycloak. Initially, I felt lost trying to work with realm exports and JWT validation because I didn’t have real-world practice with them. After digging in and troubleshooting the JSON config issue, I started gaining practical skills that I could apply directly to our project.

How It Could’ve Helped Earlier:
If I had taken time before the sprint to develop specific, concrete skills—like how to export/import Keycloak realms properly, or how JWT verification works at the code level, I could have contributed more efficiently and with less frustration. This pattern reminded me that building a toolbox of real, usable skills is what makes you valuable in a team setting—not just theoretical knowledge.

Final Thought

Sprint 2 challenged me on a deeper level, not just with code, but with collaboration, tooling, and infrastructure. The lessons around version control, documentation, and communication will stick with us as we move forward. We’re not just building an app—we’re learning how to work like a real development team.

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.

What is Integration Testing?

Integration Testing is a key phase in the software testing lifecycle where individual software modules are combined and tested as a group. While unit testing verifies that each module works independently, integration testing checks how these modules interact with each other. In simple terms, Integration Testing is where you check if different modules in your application play nice together. Each module might work fine on its own (thanks to unit testing), but once you connect them, all sorts of bugs can pop up—data not flowing correctly, broken links, miscommunication between components, etc. That’s why this type of testing focuses on the interaction between modules. You’ll hear it called things like “I & T,” “String Testing,” or “Thread Testing.” All fancy names for the same thing—making sure things work together.

Why is Integration Testing Important?

Even if all modules pass unit testing, defects can arise when modules are combined. This can happen due to:

  • Differences in how developers code or interpret requirements
  • Changes in client requirements that weren’t unit tested
  • Faulty interfaces with databases or external systems
  • Inadequate exception handling

Integration testing helps identify these issues early, ensuring seamless data flow and communication between components.

Types of Integration Testing

Types of Integration Testing

There are several strategies to conduct integration testing:

1. Big Bang Testing
All modules are integrated and tested simultaneously.

  • Pros: Simple for small systems.
  • Cons: Difficult to isolate defects, delays testing until all modules are ready.

2. Incremental Testing
Modules are integrated and tested step-by-step.

  • Bottom-Up: Test lower-level modules first, then move up.
  • Top-Down: Start with higher-level modules and use stubs to simulate lower ones.
  • Sandwich: A mix of both, testing top and bottom modules simultaneously.

Stubs and Drivers

These are dummy components used in integration testing:

Driver: Simulates a higher-level module that calls the module under test.

Stub: Simulates a lower-level module that is called by the module under test.

Final Thoughts

Integration Testing bridges the gap between unit testing and system testing. It ensures that individually functional modules work together as a complete system. Whether you’re using Big Bang or an incremental approach, thorough planning and detailed test cases are key to successful integration testing.

Reference:

https://www.guru99.com/integration-testing.html

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

CS@Worcester – The Bits & Bytes Universe 2025-04-01 11:45:13

Best UAT Testing Tools in 2025: Deliver Software People Actually Want to Use

User Acceptance Testing (UAT) is one of those final, crucial steps before launching a product. It’s where real users step in to make sure everything works the way it’s supposed to, and more importantly, the way they actually need it to. To make this process smoother and way less painful, there are tons of UAT tools out there. The real challenge? Picking the right one.

In 2025, UAT tools aren’t just about checking off requirements. They help teams stay aligned, find bugs early, and make sure what’s being built is actually useful. If you’re working on anything from a web app to a full on enterprise system, the right tool can seriously level up your process.

Why UAT Tools Matter

UAT isn’t just testing for the sake of it. It’s about making sure the product works in the real world not just in a controlled dev environment. UAT tools help you organize test cases, manage feedback, track bugs, and bring in users to validate everything. The good ones also make it easier for everyone devs, QA, stakeholders, and end users to stay in sync.

If you care about shipping high-quality, user-friendly software , UAT tools are a must.

Top Tools Worth Checking Out

Here are some standout UAT tools in 2025 that I think are really worth a look:

  • LambdaTest: Solid choice for cross-browser testing and real device testing. Supports both manual and automated workflows, plus integrates with tools like Testim.io and QMetry.
  • TestRail: Great for keeping things organized. Helps you manage test cases, track progress, and integrates nicely with Jira and GitHub.
  • Maze: This one’s perfect if you care about user experience. It gives you heatmaps, click tracking, and real time user feedback.
  • SpiraTest: A full suite that combines test case management, bug tracking, and requirement linking all in one place.
  • UserTesting: Lets you test with actual users from around the world and get feedback via video, audio, and written responses.
  • Testim.io: If you’re leaning into automation, this one’s got AI powered test creation and a visual editor that makes building and updating tests way easier.
  • Hotjar: Not your typical test management tool, but super helpful for visualizing user behavior with session replays, heatmaps, and feedback polls.

Final Thoughts

No single UAT tool is perfect for everyone. The best one for you depends on your team, your workflow, and your budget. Sometimes mixing a couple of tools gives you the coverage you need, from test case management to user feedback and performance insights.

At the end of the day, UAT tools exist to help you build better products—and getting that right can make a huge difference.

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.

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.