Author Archives: aromeo4f978d012d4

Sprint 3 Retrospective Blog Post

Sprint 3 has been an insightful experience filled with both achievements and challenges. This sprint primarily involved working on backend functionality for Thea’s Pantry IAM system within the LibreFoodPantry initiative. One of my key contributions was addressing Issue #3, which required analyzing authentication workflows, improving data handling, and refining API integrations. Throughout this sprint, I learned valuable lessons about balancing functionality with efficiency, while also adapting my approach to problem-solving.

One of the aspects that worked particularly well was team collaboration. Engaging in technical discussions with peers helped clarify complex issues and streamlined our workflow. GitLab was an essential tool in maintaining transparency about project tasks, allowing everyone to track contributions and progress effectively. Another highlight of this sprint was the feedback loop—code reviews and discussions allowed for refinement in implementation, ultimately leading to higher-quality results. These collaborative efforts reinforced the importance of communication and collective learning in a development environment.

However, there were also several challenges that surfaced throughout the sprint. Unexpected dependency issues caused delays in backend development, requiring troubleshooting and adjustments. Additionally, occasional miscommunications led to minor confusion regarding task ownership. While these issues did not significantly disrupt progress, they highlighted the need for clearer delegation and proactive communication. Another obstacle was testing coverage. We faced last-minute debugging challenges, which could have been avoided with stronger automated testing earlier in the sprint. These setbacks underscored the importance of planning ahead and maintaining consistent testing practices.

Moving forward, there are key improvements that both the team and I can implement to enhance future sprints. On the team level, establishing clearer communication protocols would prevent misunderstandings in task delegation. Additionally, conducting early dependency assessments could help identify potential roadblocks before they impact development. Strengthening our testing strategy will also be crucial to reducing last-minute debugging and ensuring stable releases. On an individual level, I plan to work on better time management, which would help me balance workload efficiently and reduce stress toward the sprint’s end. Furthermore, improving my understanding of authentication systems would allow me to contribute more effectively to similar backend tasks in future sprints. Finally, I aim to be more proactive in seeking clarification when encountering uncertainty rather than hesitating and losing valuable development time.

The apprenticeship pattern that resonated most with my experience during this sprint was “Craft Over Art” from Apprenticeship Patterns. This pattern highlights the importance of focusing on practical craftsmanship over aesthetic perfection when developing software. It suggests that while writing clean, elegant code is valuable, the priority should always be delivering functional and maintainable solutions. I selected this pattern because, during Sprint 3, I found myself spending extra time refining and perfecting small details in the authentication backend instead of prioritizing full functionality first. While striving for quality is important, I realized that over-focusing on perfection can sometimes detract from the broader project goals.

Had I embraced this pattern earlier, I would have directed my attention toward building a reliable and functional authentication system first rather than obsessing over fine-tuning minor details. This approach would have allowed for more efficient contributions to Issue #3, as I would have spent less time on unnecessary refinements and more time ensuring the overall integrity of the backend system. Looking ahead, I aim to apply this mindset by focusing on practical, maintainable solutions while reserving optimization and refinements for when they genuinely add value.

Overall, Sprint 3 has provided meaningful learning experiences that will shape my approach in future development work. The blend of successes and setbacks underscored the importance of adaptability, teamwork, and continuous improvement. Moving forward, I plan to apply these insights to future sprints, strengthening both my technical skills and collaborative contributions.

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

Sprint Retrospective – Sprint [2]

During Sprint-2, my focus was on contributing to the tasks assigned to me through GitLab. These tasks included Issue 4 and Issue 2. Both were critical components in ensuring the functionality and reliability of the fake frontend module in the LibreFoodPantry project. As the sprint progressed, I had the opportunity to reflect on the highs, the challenges, and the lessons learned. Here’s my summary of the experience.

Evidence of Activity on GitLab

  • Issue 4: Task to implement functionality improvement in the fake frontend. This required debugging and making updates to enhance module performance.
  • Issue 2: Debugging and addressing existing issues with edge case scenarios in the fake frontend module.

These activities provided me with valuable experience in problem-solving and adapting to unexpected challenges, which were prevalent throughout the sprint.

What Worked Well

One of the key successes during Sprint-2 was the level of collaboration within the team. Regular communication ensured that tasks were clearly defined, and support was readily available when needed. I found that breaking down complex problems into smaller, manageable components made debugging much more efficient. Issue 2, in particular, benefited from this approach, saving considerable time and allowing me to focus on improving code reliability. Additionally, Issue 4 was completed with minimal revisions thanks to the clarity of the requirements and prior preparation.

What Didn’t Work Well

However, Sprint-2 also presented its fair share of challenges. Initially, unfamiliarity with certain aspects of the codebase slowed my progress. The intricate structure of the fake frontend module required extra time to understand before making meaningful contributions. Furthermore, testing processes revealed several edge cases that were not anticipated during planning, leading to some delays in resolving issues. These experiences underscored the importance of early preparation and thorough testing.

Changes to Improve as a Team

Reflecting on the sprint, there are several improvements the team could make to enhance our efficiency:

  1. Knowledge Sharing: Organizing sessions to familiarize team members with the codebase would help reduce delays caused by a lack of understanding.
  2. Proactive Testing: Incorporating more comprehensive testing during the earlier phases of the sprint could catch edge cases sooner.
  3. Clearer Documentation: Providing detailed documentation of tasks and processes can ensure everyone is aligned and reduce ambiguity.

Changes to Improve as an Individual

At a personal level, I identified several areas for growth:

  1. Skill Development: Spending dedicated time learning tools and frameworks used in the project would enhance my ability to tackle tasks with confidence.
  2. Proactive Engagement: Being more proactive in seeking clarification when tasks feel ambiguous would help minimize initial slowdowns.
  3. Time Management: Allocating focused work periods for specific tasks could improve overall productivity.

Apprenticeship Pattern Selection: “Expand Your Bandwidth”

  • Summary: “Expand Your Bandwidth” is a pattern that emphasizes the importance of stepping outside one’s comfort zone to learn new tools, techniques, and frameworks. By actively seeking opportunities to grow, developers can broaden their capabilities and handle more complex challenges.
  • Relevance: This pattern directly relates to my experience during Sprint-2, where unfamiliarity with parts of the codebase initially caused delays. By expanding my bandwidth through dedicated learning, I could address similar tasks more efficiently in the future.
  • Impact on Behavior: If I had read this pattern before Sprint-2, I would have approached the unfamiliar codebase with a proactive mindset, dedicating time to research and practice before diving into the tasks. This preparation could have prevented the slowdowns experienced during the sprint and improved my overall contribution.

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

Test Doubles: Enhancing Testing Efficiency

When developing robust software systems, ensuring reliable and efficient testing is paramount. Yet, testing can become challenging when the System Under Test (SUT) depends on components that are unavailable, slow, or impractical to use in the testing environment. Enter Test Doubles—a practical solution to streamline testing and simulate dependent components.

What are Test Doubles? In essence, Test Doubles are placeholders or “stand-ins” that replace real components (known as Depended-On Components, or DOCs) during tests. Much like a stunt double in a movie scene, Test Doubles emulate the behavior of the real components, enabling the SUT to function seamlessly while providing better control and visibility during testing.

The implementation of Test Doubles is tailored to the specific needs of a test. Rather than perfectly mimicking the DOC, they replicate its interface and critical functionalities required by the test. By doing so, Test Doubles make “impossible” tests feasible and expedite testing cycles.

Key Variations of Test Doubles Test Doubles come in several forms, each designed to address distinct testing challenges:

  1. Test Stub: Facilitates control of the SUT’s indirect inputs, enabling tests to explore paths that might not otherwise occur.
  2. Test Spy: Combines Stub functionality with the ability to record and verify outputs from the SUT for later evaluation.
  3. Mock Object: Focuses on output verification by setting expectations for the SUT’s interactions and validating them during the test.
  4. Fake Object: Offers simplified functionality compared to the real DOC, often used when the DOC is unavailable or unsuitable for the test environment.
  5. Dummy Object: Provides placeholder objects when the test or SUT does not require the DOC’s functionality.

When to Use Test Doubles Test Doubles are particularly valuable when:

  • Testing requirements exceed the capabilities of the real DOC.
  • Test execution is hindered by slow or inaccessible components.
  • Greater control over the test environment is necessary to assess specific scenarios.

That said, it’s crucial to balance the use of Test Doubles. Excessive reliance on them may lead to “Fragile Tests” that lack robustness and diverge from production environments. Therefore, teams should complement Test Doubles with at least one test using real DOCs to ensure alignment with production configurations.

Conclusion Test Doubles are indispensable tools for efficient and effective software testing. By offering flexibility and enhancing control, they empower developers to navigate complex testing scenarios with ease. However, judicious use is key, striking the right balance ensures tests remain meaningful and closely aligned with real-world conditions.

This information comes from this article:
Test Double at XUnitPatterns.com

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

Sprint Retrospective – Sprint-[1]

GitLab Activity

During this sprint, I contributed to multiple aspects of the project, focusing on both collaborative research and frontend development. Below are the key tasks I worked on, with links to the related issues:

  1. Issue #26: Created a fake frontend – Designed and developed a simulated frontend to represent the user interface for testing and demonstration purposes.
  2. Issue #20: Researched Docker architecture – Collaboratively explored and documented Docker architecture with the team to establish a strong foundation for the project’s infrastructure.
  3. Issue #31: Created dummy pages for frontend login redirect – Built placeholder pages to simulate the login redirection process, enabling smoother navigation during development.

Reflection on Performance

What Worked Well

This sprint highlighted some clear wins for both myself and the team. Collaborating on Docker architecture research proved to be an invaluable learning experience. By pooling our knowledge and resources, we quickly gained a better understanding of Docker’s potential for our project. On the frontend, creating the fake frontend and dummy login redirect pages allowed me to apply and refine my skills in UI development. These tasks were particularly fulfilling because they provided tangible progress toward a functional interface.

What Didn’t Work Well

While the sprint had its successes, there were also challenges. Managing time effectively across multiple tasks was one of my personal struggles. For instance, balancing the research on Docker architecture with the development of the frontend required careful prioritization, and I occasionally found myself spending too much time on one task at the expense of another. Additionally, the lack of established workflows for testing the fake frontend made it harder to identify and fix issues early on.

Changes to Improve as a Team

As a team, we could benefit from setting aside dedicated time for pair programming or collaborative problem-solving sessions. This could enhance our understanding of challenging topics, like Docker architecture, and ensure that everyone feels confident in applying what we’ve learned. Regular check-ins or daily stand-ups could also help us address blockers more quickly and align our efforts more effectively.

Changes to Improve as an Individual

Individually, I want to work on improving my time management and task prioritization. Establishing a clear plan at the start of each sprint, with time allocated to specific tasks, could help me maintain better focus. I also aim to proactively seek feedback on my work, particularly when tackling new challenges like Docker architecture, so I can learn more efficiently and avoid unnecessary delays.

Apprenticeship Pattern Reflection

Selected Pattern: “Expose Your Ignorance”

For this sprint, I chose the Apprenticeship Pattern “Expose Your Ignorance” from Chapter 2. This pattern emphasizes the importance of acknowledging knowledge gaps and actively working to address them by seeking help, asking questions, and being open about what you don’t know.

Summary

The pattern advocates for embracing ignorance as a normal part of the learning process. It challenges the notion that developers should appear to have all the answers, encouraging honesty and curiosity instead. By exposing ignorance, individuals can learn more effectively and foster a collaborative environment where everyone feels empowered to grow.

Relevance to My Experience

This pattern resonated deeply with my experience during the sprint, particularly in the context of Docker architecture research. Initially, I felt hesitant to admit my lack of familiarity with some Docker concepts, but collaborating with the team and sharing our findings made the learning process much smoother. Similarly, while working on the fake frontend, I encountered unfamiliar scenarios where seeking guidance earlier would have saved time.

How It Would Have Changed My Behavior

If I had fully embraced this pattern from the beginning of the sprint, I would have been more proactive in asking questions and seeking clarification during our Docker research sessions. I might also have reached out to teammates or mentors for advice on frontend best practices when creating the fake frontend and dummy pages. In future sprints, I plan to actively apply this principle by fostering a culture of openness and curiosity, both for myself and within the team.

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

Path Testing in Software Engineering

Path Testing is a structural testing method used in software engineering to design test cases by analyzing the control flow graph of a program. This method helps ensure thorough testing by focusing on linearly independent paths of execution within the program. Let’s dive into the key aspects of path testing and how it can benefit your software development process.

The Path Testing Process

  1. Control Flow Graph: Begin by drawing the control flow graph of the program. This graph represents the program’s code as nodes (each representing a specific instruction or operation) and edges (depicting the flow of control from one instruction to the next). It’s the foundational step for path testing.
  2. Cyclomatic Complexity: Calculate the cyclomatic complexity of the program using McCabe’s formula: E−N+2PE – N + 2P, where EE is the number of edges, NN is the number of nodes, and PP is the number of connected components. This complexity measure indicates the number of independent paths in the program.
  3. Identify All Possible Paths: Create a set of all possible paths within the control flow graph. The cardinality of this set should equal the cyclomatic complexity, ensuring that all unique execution paths are accounted for.
  4. Develop Test Cases: For each path identified, develop a corresponding test case that covers that particular path. This ensures comprehensive testing by covering all possible execution scenarios.

Path Testing Techniques

  • Control Flow Graph: The initial step is to create a control flow graph, where nodes represent instructions and edges represent the control flow between instructions. This visual representation helps in identifying the structure and flow of the program.
  • Decision to Decision Path: Break down the control flow graph into smaller paths between decision points. By isolating these paths, it’s easier to analyze and test the decision-making logic within the program.
  • Independent Paths: Identify paths that are independent of each other, meaning they cannot be replicated or derived from other paths in the graph. This ensures that each path tested is unique, providing more thorough coverage.

Advantages of Path Testing

Path Testing offers several benefits that make it an essential technique in software engineering:

  • Reduces Redundant Tests: By focusing on unique execution paths, path testing minimizes redundant test cases, leading to more efficient testing.
  • Improves Test Case Design: Emphasizing the program’s logic and control flow helps in designing more effective and relevant test cases.
  • Enhances Software Quality: Comprehensive branch coverage ensures that different parts of the code are tested thoroughly, leading to higher software quality and reliability.

Challenges of Path Testing

While path testing is advantageous, it does come with its own set of challenges:

  • Requires Understanding of Code Structure: To effectively perform path testing, a solid understanding of the program’s code and structure is essential.
  • Increases with Code Complexity: As the complexity of the code increases, the number of possible paths also increases, making it challenging to manage and test all paths.
  • May Miss Some Conditions: There is a possibility that certain conditions or scenarios might not be covered if there are errors or omissions in identifying the paths.

Conclusion

Path Testing is a valuable technique in software engineering that ensures thorough coverage of a program’s execution paths. By focusing on unique and independent paths, this method helps reduce redundant tests and improve overall software quality. However, it requires a deep understanding of the code and may become complex with larger programs. Embracing path testing can lead to more robust and reliable software, ultimately benefiting both developers and end-users.

All of this comes from:

Path Testing in Software Engineering – GeeksforGeeks

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

Equivalence Class Testing

In the realm of software testing, equivalence class testing stands out as an efficient black-box testing technique. Unlike its counterparts—boundary value analysis, worst-case testing, and robust case testing—equivalence class testing excels in both time efficiency and precision. This methodology logically divides input and output into distinct classes, enabling comprehensive risk identification.

To illustrate its effectiveness, consider the next-date problem. Given a day in the format of day-month-year, the task is to determine the next date while performing boundary value analysis and equivalence class testing. The conditions for this problem are:

  • Day (D): 1 < Day < 31
  • Month (M): 1 < Month < 12
  • Year (Y): 1800 < Year < 2048

Boundary Value Analysis

Boundary value analysis generates 13 test cases by applying the formula:

No. of test cases(n = no. of variables)=4n+1\text{No. of test cases} (n \text{ = no. of variables}) = 4n + 1

For instance, the test cases might include:

  1. Date: 1-6-2000, Expected Output: 2-6-2000
  2. Date: 31-6-2000, Expected Output: Invalid Date
  3. Date: 15-6-2048, Expected Output: 16-6-2048

While this technique effectively captures boundary conditions, it often overlooks special cases like leap years and the varying days in February.

Equivalence Class Testing

Equivalence class testing addresses this gap by creating distinct input classes:

  • Day (D): 1-28, 29, 30, 31
  • Month (M): 30-day months, 31-day months, February
  • Year (Y): Leap year, Normal year

With these classes, the technique identifies robust test cases for each partition. For example:

  • Date: 29-2-2004 (Leap Year), Expected Output: 1-3-2004
  • Date: 29-2-2003 (Non-Leap Year), Expected Output: Invalid Date
  • Date: 30-4-2004, Expected Output: 1-5-2004

This approach ensures comprehensive test coverage, capturing edge cases missed by boundary value analysis.

Conclusion

Equivalence class testing offers a systematic approach to software testing, ensuring efficient and thorough risk assessment. By logically partitioning inputs and outputs, it creates robust test cases that address a wide array of scenarios. Whether dealing with complex date calculations or other software functions, equivalence class testing is a valuable tool in any tester’s arsenal.

In essence, this method not only saves time but also enhances the precision of test cases, making it an indispensable step in the software development lifecycle.

All of this can be found from this link:

Equivalence Class Testing- Next date problem – GeeksforGeeks

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

Unit Testing and Testable Code

Unit testing is a fundamental practice in software development, ensuring that individual units of code work as expected. However, the real challenge often lies in writing code that is easy to test. Poorly designed, untestable code can complicate unit testing and introduce expensive complexity. In this blog post, we’ll explore the importance of writing testable code, the common pitfalls that make code hard to test, and the benefits of adopting testable coding practices.

The Significance of Unit Testing

Unit testing involves verifying the behavior of a small portion of an application independently from other parts. A typical unit test follows the Arrange-Act-Assert (AAA) pattern: initializing the system under test, applying a stimulus, and observing the resulting behavior. The goal is to ensure that the code behaves as expected and meets the specified requirements.

However, the ease of writing unit tests is significantly influenced by the design of the code. Code that is tightly coupled, non-deterministic, or dependent on mutable global state is inherently difficult to test. Writing testable code is not only about making testing less troublesome but also about creating robust and maintainable software.

Common Pitfalls in Writing Testable Code

Several factors can make code challenging to test, including:

  1. Tight Coupling: Code that is tightly coupled to specific implementations or data sources is difficult to isolate for testing. Decoupling concerns and introducing clear seams between components can enhance testability.
  2. Non-Deterministic Behavior: Code that depends on mutable global state or external factors (e.g., current system time) can produce different results in different environments, complicating testing. Making code deterministic by injecting dependencies can address this issue.
  3. Side Effects: Methods that produce side effects (e.g., interacting with hardware or external systems) are hard to test in isolation. Employing techniques like Dependency Injection or using higher-order functions can help in decoupling and testing such code.

Benefits of Testable Code

Adopting testable coding practices offers several benefits:

  1. Improved Code Quality: Testable code is typically well-structured, modular, and easier to understand. This leads to higher code quality and reduces the likelihood of bugs.
  2. Easier Maintenance: Code that is easy to test is also easier to maintain. Changes can be made with confidence, knowing that unit tests will catch any regressions.
  3. Faster Development: With a robust suite of unit tests, developers can iterate quickly and confidently, reducing the time spent on manual testing and debugging.
  4. Enhanced Collaboration: Clear and testable code promotes better collaboration among team members, as the intent and behavior of the code are easier to comprehend.

Conclusion

Writing testable code is a crucial aspect of software development that extends beyond the realm of testing. It encompasses good design principles, decoupling, and the elimination of non-deterministic behavior and side effects. By focusing on writing testable code, developers can create software that is not only easier to test but also more robust, maintainable, and reliable. Embracing these practices ultimately leads to higher quality software and more efficient development processes.

All of this comes from the link below:

https://www.toptal.com/qa/how-to-write-testable-code-and-why-it-matters

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

Intro Blog Post for CS-443

Hello, I’m Antonio and this will be the blog that I’ll be using for Quality Assurance Testing where all my blogs will be posted and hopefully read by someone. Thank you for reading.

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

LibreFoodPantry

Reading through the LibreFoodPantry website, it actually surprised me that when I looked through the Coordinating Committee section I saw that there were actually several other colleges that seem to be working on this project and possibly contributing to it. This to me gave a bit of a reality to the wider scope of the project, obviously the goal of this project is to reach as many people as possible with the help they need through FOSS projects and to help students see the positives of contributing projects such as these. For me this was just interesting to see the project already have a somewhat far-reaching impact.

From Thea’s Pantry I thought how openly transparent all the documentation would be and how thorough it is with every aspect of the software. Though the most interesting part for me was the ID-Scanner documentation. Seeing the UML charts outlining how it works was pretty interesting, as my part of the project with my group is working on Login and Authentication so this will potentially be valuable for getting it to work properly with other systems. But otherwise seeing the user stories was also very interesting as it seems like it will help immensely to write the code in the right direction.

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

The Observer Pattern

Back again with another design pattern, and this time with one I have absolutely no idea about. I chose this particular video because I like this guy’s videos and I think he does an excellent job with explaining things in a way I can understand and I wanted to know some more design patterns. From another video by Christopher Okhravi I am learning about the Observer Pattern. Mr.Okhravi goes over this pattern with a lot of visuals which I very much appreciate and also goes into great depth with this pattern, but what does this pattern do? This pattern which involves utilizing one object that acts as the “Observable” and then this Observable object has a relationship with many “Observer” objects where if there is a change inside the Observable the Observable pushes out a change to all the Observer objects it’s connected to.

Looking at this pattern it’s kind of hard for me to wrap my head around an example of what it could be used for, but I did understand how the system itself would work, it just feels somewhat more complicated than I can really handle at this moment. Otherwise, though I did feel like I learned quite a bit about this pattern like how different languages have different variations and limits on what an observer pattern can do. Though the somewhat odd nature of the pattern does confuse me, even though it looks so simple. Like how it’s kind of cyclical where we are passing observer objects to the observable and then back again. This just really confused me but I think I’ll need to watch the video again to really grasp it fully. The example Okhravi uses of a “weather station” helped to really elucidate what I was confused about, where we have the physical components displaying the data and then the actual data that is being monitored by the weather station and watched by those observer components.

I think for the future I’m not really sure how often I’ll be using this pattern but I can foresee some use cases for it as it might be very useful when I need constant monitoring of something. But I think evidently even if I can’t come up with any ideas now I definitely think in the future I’ll be making use of this pattern and that I need to learn about even more patterns so that I can apply them where I need them, and to maybe go back and relearn those initial patterns I learned about.

Here’s the video:

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