Author Archives: Jaylon Brodie

Sprint 2 Retrospective

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-category-based/frontend/-/blob/WEB-APP-FRONTEND/src/frontend/src/components/BurgerMenu.vue?ref_type=heads

This is the link to the burgermenu component that I recently implemented.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-category-based/frontend/-/blob/WEB-APP-FRONTEND/src/frontend/src/App.vue?ref_type=heads

This is the link to the change i made in APP.vue to make sure the navigations between pages was working.

What Worked Well

What worked well this sprint was my ability to identify the direction I needed to go in early. By proactively researching what types of menus we needed (such as a scanning menu and an inventory display menu), I was able to start building out the feature rather than waiting for instruction. Additionally, I took more ownership of frontend work this sprint, which helped me feel more confident in my contributions. Our team also communicated better this time, which made planning and aligning tasks easier.

What Didn’t Work Well

Time management was one of my weaker areas this sprint. While I began working on the menu features early, I underestimated how long certain aspects, like tying barcode input to inventory display, would take. As a result, some parts are still in development. Another issue was not asking for help as early as I should have when I got stuck on some front-end design decisions, which could’ve saved me time.

Team Improvement Suggestions

Our team has improved in communication and breaking down tasks, but we could still do a better job tracking progress on GitLab. Sometimes, issues remain open even after tasks are completed, which makes it harder to see what’s done at a glance. Adding regular, short update posts during the week, even if work hasn’t been pushed yet would help us stay more aligned. I also think we could benefit from regular 15-minute team syncs mid-sprint.

Personal Improvement Suggestions

Individually, I’d like to work on improving my frontend development speed and getting more comfortable integrating UI features with logic and API calls. I also need to be better about reaching out when I hit roadblocks rather than spending too long stuck. Going forward, I will try to break down my assigned features into smaller sub-tasks and check them off one by one to maintain steady momentum.

Apprenticeship Pattern: “Expose Your Ignorance”

Summary:
The “Expose Your Ignorance” pattern, found in Chapter 2 of Apprenticeship Patters by Dave Hoover and Adewale Oshineye, emphasizes that developers shouldn’t hide what they don’t know. Instead, they should openly acknowledge areas of inexperience and use that as a tool to learn and grow. This transparency not only helps personal development but also builds trust within teams and encourages collaboration.

Why I Chose This Pattern:
I chose this pattern because it perfectly describes one of the issues I struggled with this sprint. There were a few moments where I wasn’t entirely sure how to implement something correctly in Vue.js, especially around the menu layout and dynamic binding of scanned values. Instead of asking for help or noting my uncertainty in discord chat, I tried to figure it out myself and ended up wasting valuable time.

How It Could Have Helped This Sprint:
Had I truly embraced this pattern earlier, I would have flagged those areas where I felt unsure and asked for input from my teammates or professor. This could have saved me hours of trial and error and allowed me to refocus on other key tasks. Going forward, I want to normalize being transparent about what I don’t know so I can get help sooner and grow faster.

From the blog CS@Worcester – Software Dev Capstone by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Sprint 1 Retrospective

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-category-based/frontend/-/blob/WEB-APP-FRONTEND/src/frontend/src/components/UPCScanner.vue?ref_type=heads

This is a link to the UPC scanner component that I recently implemented.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-category-based/frontend/-/blob/WEB-APP-FRONTEND/src/frontend/src/layouts/MainLayout.vue?ref_type=heads

This is a link to the Main Layout for the Web App, this is essentially the homepage.

Reflection on What Worked Well

One of the biggest strengths of our team has been our ability to delegate and handle specific tasks effectively. Each team member has taken ownership of different aspects of the project, whether it’s the frontend, backend, or database. This clear division of work has helped ensure that progress is made across all areas of the application. Since I am working on the frontend, I have been able to focus on designing and implementing the UI while relying on my teammates to manage the backend and database.

Reflection on What Didn’t Work Well

Despite our strong ability to divide tasks, one area that has posed challenges is communication. There have been instances where misunderstandings or lack of updates led to delays in task completion. Additionally, not all tasks have been finished in a timely manner, which has put extra pressure on certain aspects of the project. This lack of synchronization has occasionally resulted in blockers, where one team member is waiting on another’s progress to move forward.

Changes to Improve as a Team

To enhance team efficiency, we need to establish better communication channels. This could include:

  • Holding short daily stand-up meetings to discuss progress and blockers.
  • Setting more reasonable due dates that account for individual workloads and unexpected obstacles. By implementing these changes, we can reduce miscommunication and ensure that tasks are completed within a reasonable timeframe.

Changes to Improve as an Individual

On a personal level, I recognize that I can make improvements by:

  • Checking in with my teammates more frequently to see if they need help with their tasks.
  • Setting personal deadlines to ensure I complete my work on time.
  • Being more open to suggestions and feedback from my team, as collaboration often leads to better solutions. By making these adjustments, I can contribute more effectively to the team and help ensure the overall success of our project.

Apprenticeship Pattern: “Be the Worst”

Summary: This pattern emphasizes surrounding yourself with more skilled individuals so that you can learn and improve at a faster rate. By putting yourself in challenging situations where you are not the most knowledgeable person in the room, you can grow and develop your skills through observation and experience.

Why I Chose This Pattern: During this sprint, I have noticed that I can learn a lot from my teammates, especially in areas I am less experienced in, such as backend development and database management. Rather than just focusing on my own tasks, I want to take the opportunity to learn from their expertise and improve my overall skill set.

How This Pattern Would Have Helped: If I had adopted this mindset earlier in the sprint, I would have been more proactive in asking questions and seeking guidance from my teammates. This could have helped me avoid certain mistakes and speed up my development process. Moving forward, I will embrace this approach to accelerate my learning and become a more well-rounded developer.

From the blog CS@Worcester – Software Dev Capstone by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Reflections on Apprenticeship Patterns: Chapter 1 & Introductions to Chapters 2-6

In reading Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman by Dave Hoover and Adewale Oshineye, I found myself both inspired and challenged by the ideas presented. The book frames software development as a lifelong journey of learning and growth, rather than just a career or a set of skills. Chapter 1, in particular, resonated with me because it introduced the concept of a Software Craftsman someone who continuously hones their craft, learns from others, and embraces the challenges that come with mastery.

One of the most thought provoking aspects of Chapter 1 was the discussion on the three stages of becoming a Software Craftsman Apprentice, Journeyman, and Master. The idea that even experienced developers must remain in a constant state of learning was both humbling and motivating. I found the emphasis on deliberate practice and continuous improvement particularly useful. It reinforced the idea that success in software development is not just about accumulating knowledge but about applying it effectively, seeking mentorship, and refining skills through real-world experience.

The introductions to Chapters 2-6 provided an interesting look at the different aspects of professional growth. Chapter 2 focuses on staying humble and maintaining a beginner’s mindset, which reminded me that overconfidence can block learning. Chapter 3 emphasizes the long journey of mastery, reinforcing the idea that there is no shortcut to expertise. Chapter 4 discusses self-assessment, which I found useful because identifying weaknesses is key to improvement. Chapter 5 highlights lifelong learning, and Chapter 6 encourages taking control of one’s own apprenticeship through mentorship and self-driven education.

While I agree with most of the book’s concepts, one idea I somewhat disagree with is the notion that formal education is only a small part of a developer’s journey. While it is true that hands on experience and mentorship play a critical role, I believe that structured education still provides essential foundational knowledge. Some developers thrive with self learning, but others benefit from the structured approach that degrees and certifications offer.

The chapters that seem most relevant to me right now are Chapter 4 and Chapter 5 because I am currently focused on understanding where I stand as a developer and identifying areas for improvement. The idea that self awareness and continuous learning are key to long-term success resonated deeply with me.

Overall, I found this reading engaging, thought provoking, and practical. The emphasis on self improvement, mentorship, and hands on learning has changed the way I approach my development as a software engineer. While I believe formal education still has its place, I recognize that the real learning happens when knowledge is applied in practice. This book has given me valuable insights into what it truly means to be a Software Craftsman, and I am excited to dive deeper into the patterns in the upcoming chapters.

From the blog CS@Worcester – Software Dev Capstone by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Overview from LibreFoodPantry and Thea’s Pantry

In my research of the LibreFoodPantry and Thea’s Pantry, I encountered valuable insights that deepened my understanding of open-source projects and community-driven software development. Here are two specific takeaways that stood out to me:

From LibreFoodPantry

One aspect of LibreFoodPantry that I found particularly interesting was its Code of Conduct. The Code of Conduct emphasizes creating a welcoming and inclusive environment for all contributors, regardless of their background or experience level. It outlines expectations for respectful collaboration and provides clear guidelines for reporting and addressing violations.

I chose to write about this because it highlights the importance of fostering a positive and professional atmosphere in open-source communities. The Code of Conduct ensures that contributors feel safe and valued, which ultimately leads to more productive collaboration and better software outcomes. This focus on inclusivity and respect is something I plan to incorporate into any projects I work on in the future.

From Thea’s Pantry

In Thea’s Pantry, I found the User Stories to be particularly insightful and practical. These stories outline the real-world workflows of the intended users, such as staff, administrators, and guests, and guide the software’s design to meet their needs. For example, a staff member logging in to manage inventory or assist a guest is a well-documented process.

What stood out most is how the user stories emphasize accessibility and practicality. For instance, the process of logging donations or generating reports for external organizations like the Worcester County Food Bank showcases a thoughtful integration of functionality and ease of use.

I chose to write about this because it demonstrates the critical role user stories play in designing meaningful software. They provide developers with clear direction and ensure that the end product solves real-world problems. This approach aligns with my goals of creating impactful and user-friendly applications.

From the blog CS@Worcester – Software Dev Capstone by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Behavior Driven Development

Behavior Driven Development ( BDD ) is a test practice that makes sure there is good quality by automating test before or during system behavior specification. BDD test focuses on facing scenarios that describe the behavior of a story, feature, or capability from a user’s perspective. When the tests are automated they make sure that the system constantly meets the required behavior.

The Behavior Driven Development Process

The BDD process has three phases to it. The discovery phase, formulation phase, and the automation phase.

1.) Discover phase: This phase is where the user creates the initial acceptance agenda for the feature. This phase is usually done in a collaborative manor, each team member is contributing.

2.) Formulation phase: This phase is where the acceptance agenda sets into detailed acceptance tests, as the backlog item gets closer to implementation. This phase also incorporates specific examples of the behavior.

3.) Automation phase: This phase is where automation tests are automated to run constantly. This is to make sure that the new system supports the new behavior.

Benefits of Behavior Driven Development

1.) Early detection of errors / defects: When you automate tests in the early stages of development process, you can identify and address the issues. BDD allows for the early detection of defects.

2.) Faster Flow and Time: when using BDD, you can reduce the errors, rework, and replan. BDD accelerates the flow of the development process. Developers can produce features / products faster and more efficiently.

3.) Stronger Test Coverage: BDD allows for a more comprehensive test coverage that focuses on the user behavior and scenarios. Both common and edge cases are tested as well.

4.) Clear understanding: BDD can be plain and clear to understand, because specific scenarios are used to describe the behavior from a user’s point of view. This helps the development to fully understand the requirements and whats going on.

Why I chose this resource

I chose this article ” Behavior Driven Development” because it provided a detail look of a very important test method that goes in conjunction with the technical and business aspect of testing. Understanding BDD is important in today’s society of software development, for giving an efficient and more user friendly user products.

Personal Reflection

This article increased my understanding of BDD and the use of it in software development. I learned a lot about how BDD strengthens collaboration and communication between the business side of things and the technical side of things. This helps to ensure that user’s expectations and requirements are met. The new found knowledge will be extremely valuable in my future endeavors because I will incorporate this method in my future projects. This will help to improve the development process and product efficiency and quality. Also, by using BDD I can make sure that all requirements and specifications are met.

The full article is here: https://scaledagileframework.com/behavior-driven-development/

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Static Testing vs. Dynamic Testing

Testing in software development is important because it helps to deliver efficient and user friendly products to the end user. It also provides the developers with a chance to improve upon the product. Static and Dynamic testing are two important techniques used in software development.

Static Testing

Static Testing has various names like Verification Testing, Non-execution Testing, etc. This testing technique is used to identify defects in software without actually executing the code. This method usually includes manual and automated evaluation of the software and the code. Developers use this method usually in the beginning stages of the development process to catch issues early on, which will also lead to be easier and cheap to fix. This method focuses on reviewing the test cases, test scripts, test plans, and source code.

Static Testing Techniques

1.) Informal Reviews: Developers review each of the documents and give feedback

2.) Walkthroughs: Someone presents the product to the team and someone else takes notes.

3.) Technical Reviews / Code Reviews: review the technical specifications and the source code to make sure everything meets the requirements and standards.

4.) Inspection: Check for defects. Developers usually review the process with a checklist to help identify and record for defects.

Dynamic Testing

Dynamic Testing is a technique that analyzes the dynamic behavior of the code by actually executing it. This method makes sure to check that the software functions correctly and that there are no underlying issues / conditions. Sometimes developers use this method in conjunction with black box or white box testing to provide more realistic results.

Dynamic Testing Techniques

1.) White Box Testing: Examines the internal code structure. You need to actually have the internal code (source code)

2.) Black Box Testing: Checks the functionality without the actual internal code (source code) .

Benefits of both Static Testing and Dynamic Testing

1.) Early detection of defects

2.) Cost efficient

3.) Showcases runtime errors

4.) Reliability

Why I picked this Resource

I chose the article “Static Testing vs. Dynamic Testing” because this article gave me a more detailed and in depth look between two very important testing methods that are currently being used in todays society. It is very important to understand these two testing methods in the software development process because they can deliver efficient and user friendly products to the end user. This article also aligns with what we have learned in the course, making it relevant to talk about and to understand.

Personal Reflection

This article deepened my understanding of static and dynamic testing. I was able to learn a lot about these two testing methods that I did not know, even the many benefits that each method has. Knowing how crucial these two methods are in the software development process and what I know now, this knowledge will help me on my future endeavors when approaching new projects in regards to testing .

The full article is here: https://www.geeksforgeeks.org/difference-between-static-and-dynamic-testing/

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Test Doubles

Test doubles are a very important tool in software testing. Test doubles allow for users to break off a portion of their code to test specific parts and functions. This helps because users can do this without depending on the other factors within their code. Test doubles are substitutes, they copy the behavior of real objects. This helps to make sure that the tests remain structured and efficient.

Overview of Test Doubles

For this blog post, I chose the Article “Test Doubles: Mocks, Stubs, and Fakes Explained” by Martin Fowler. The article talks a lot about the overview of the different types of test doubles, their roles, and how they can be used in testing.

Types of Test Doubles

1.) Dummy: A dummy object is required for the creation of another object required in the code. Dummy objects will never be used in the test, they are simply like place holders to satisfy the code and its requirements.

2.) Fake: A fake is an object that will always have the same return value. This object is useful for testing certain scenarios, like a user that is logged in or in a consistent database response. They are simple implementations that are not that suitable for production but are good for testing.

3.) Stub: A stub will provided predetermined responses to method calls. Stubs usually imitate the behavior of external components like databases or web services.

4.) Spy: A spy will record information about the interactions with the object being under tests. This helps verify interactions and make sure there is the correct behavior in method calls.

5.) Mock: A mock can be a more advanced test double that will allow for dynamic behavior based on the test scenario. They verify interactions and can change behavior based on conditions. They are useful for ensuring that certain methods are called with specific parameters during the test.

Benefits of Using a Test Double

1.) Early detection of errors/issues: Using Test Doubles will help the users to find any issues within the code. This helps with reducing the risk of defects in production

2.) Cost Efficiency: Using Test Doubles will significantly help to reduce the costs that will come with fixing the issues later in the development process.

Why I Picked this Resource

I chose this resource for the blog post because it provided an in depth overview of the various types of test doubles and their specific role within testing. This article’s contents had some similarities of what we discussed in the class, making it relevant and valuable.

Personal Reflection

This article not only increased my understanding on the topic of Test Doubles, but it also showed my how unique and important each one can be in regards to testing. I also learned the various benefits of these test doubles, so when I choose one in my future endeavors I will know which one will benefit me the most.

In my future endeavors, I plan on using what I have learned about these Test Doubles objects by implementing them on future projects. This new found knowledge will help me to make better decisions in the future and will also improve the quality of my work.

The full Article is here: https://ahmadgsufi.medium.com/test-doubles-understanding-the-different-types-and-their-role-in-testing-67cbf71ea252

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Security Testing

In software development security testing is very important to making sure applications are strong enough against cyber attacks. Security testing encompasses a variety of practices like, application security testing, and penetration testing.

Overview of Security testing

For this blog post, I chose the article ” Security Testing from Bright Security. The article provides a lot of insight on security testing, it’s goal, benefits of security testing, key principles, and the different types of security testing.

1.) Goals: The article showcases the main goals of security testing, which are realizing what assess needs protection, identifying the potential threats and vulnerabilities, evaluate the risks that come with the vulnerabilities.

2.) Key Principles: The article covers the main key principles of security testing, which are availability, integrity, authentication, and authorization. These principles make sure that important/sensitive information is accessed only by authorized users, and that it remains accurate and trustworthy.

3.) Different types of Security Testing:

. Penetration Testing: This security testing method replicates real world cyber attacks to test the effectiveness of already existing security measures.

. Application Security Testing: This security testing method finds and eliminates the vulnerabilities within software applications.

. Web Application Security Testing: This security testing methods test different techniques that gauges the vulnerability of web applications.

. Security Audits and risks Assessment: This is a test method that checks to make sure that everything is structured properly and in compliance with the rules/standards.

4.) Benefits of Security Testing:

. Early Detection of Vulnerabilities: Security testing allows for the early recognition of potential security issues, reducing the risk of exposure.

. Risk Management: When the vulnerabilities are identified, then we can create solutions to solve the risks of a cyber attack or data leak.

. Trust and Cost Efficient: Early detection of risks and vulnerabilities will not only enhance the rust of customers but it will significantly reduce the cost of a data breach and various fines.

Why I picked this Resource

I picked this resource because it provided a comprehensive and detailed overview of Security Testing. This Article had a lot of similarities with the topics that we covered in our course. Also, the article makes it easier to understand the nature of security testing and various practices and principles associated with it.

Personal Reflection

Reading this article expanded my understanding of security testing beyond what we learned in class. I learned how important it is to just about everything related to technology. Identifying threats, risks, and vulnerabilities and how each of these things come together to reduce cyber attacks. One thing that I can takeaway from this is learning about the various types of Security Testing and each one does something different, but all have a similar goal.

In my future endeavors, I plan on using what I have learned about these Security Testing principles by implementing them on future projects. This new found knowledge will help me to make better decisions in the future.

The full Article is here:
https://brightsec.com/blog/security-testing/

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Pairwise and Combinatorial Testing

The article “Combinatorial Testing” focuses on the insights of software testing methods. This article explores the evolution of combinatorial testing, talking about advancements in algorithm performance and constraint representation. The article also talks about the importance in detecting interaction failures within software systems. The article also demonstrates the effectiveness of t-way combinations fault detection across various domains. The article “Pairwise Testing” talks about pair testing as a permutation and combination technique aimed at testing each pair of input parameters to ensure that the system if functioning properly across all possible combinations. The article also addresses the many benefits of pairwise testing and it’s role in reducing test execution time and cost while maintaining test coverage. Also, it talks about the challenges associated with pairwise testing, including the limitations in detecting interactions beyond pairwise combinations.

Pairwise Testing

pairwise testing is a software testing method that aims to comprehensively validate the behavior of a system by testing all possible pairs of input parameters. This method is mainly used when many of the defects in software systems are triggered by interactions between pairs of input parameters, rather than by individual parameters in isolation.

Benefits & Challenges

some benefits that pairwise offers is, efficiency: by testing the combinations of two input parameters at a time. This reduce’s the number of test cases required compared to exhaustive testing. pairwise testing also offers effective defect detection: by effectively finding defects that are triggered by interactions between pairs of input parameters, pairwise testing also helps to identify certain scenarios by systematically exploring pairs of parameters. Some challenges that pairwise testing may face is when it comes to parameter selection. Selecting the right parameters is crucial and requires a lot of knowledge of the software and it’s potential interaction scenarios. If the wrong parameter is selected this can lead to incomplete test coverage and missed defects.

Combinatorial Testing

Combinatorial testing is a software testing technique that focuses on efficiently testing the interactions between different input parameters of a system. This test method involves generating a set of test cases that include various combinations of input values / specific parameter values.

Benefits & Challenges

Some benefits of combinational testing include improved software quality: by being able to identify and address the interaction failures early in the development process. This test method tests various combinations of input parameters, which can help find defects that could impact the systems performance. A challenge that combinational testing may face is the scalability. Combinatorial testing is effective for small to medium sized systems and when scaling it to large and complex systems with a high number of input parameters and values, you may run into some problems.

Why did I pick this Article?

I pick these two article that talk about pairwise and combinatorial testing because both these test methods stand at the forefront of software test methods. The article’s goes into details about how both of these test methods offer an efficient way to ensure comprehensive test coverage while minimizing redundancy. Both of these articles have taught me a lot about pairwise and combinational testing.

Reflection

After reading both of these articles, I have gained a greater understanding of both these test cases. With the new found knowledge, I aspire to apply pairwise and combinatorial testing techniques in my future projects. Both these test methods offer practical solutions to common testing challenges, and by incorporating them into my future endeavors I aim to contribute to the development of reliable software systems.

Article link is here: https://www.sciencedirect.com/science/article/abs/pii/S0065245815000352

https://testsigma.com/blog/pairwise-testing/

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Understanding Test Driven Development in Software Engineering

Test Driven Development is a method in software development in which tests are created before the actual code. By writing test before hand, developers have a clear understanding of what will need to implemented, which can help avoid unnecessary errors. This approach will help to have the software behave as expected. This method is a structured and systematic approach. This test method is doesn’t just focus on testing, however it also focuses on quality and behavior. The main goal of this test method is to ensure that the code meets the specified requirements and behaves as expected. Test Driven Development helps with clarifying requirements, reducing defects, and improving the code maintainability.

How does it work?

Test Driven Development operates on a cycle like, first write a test, second make it run, third change the code to make it pass, and then repeat. Developers should first write a test that will analyze the behavior that they want implement. After running the test and writing and rewriting the code to make the test pass, developers will then need to continue reframing the code to improve it’s design and maintainability without changing it’s behavior. This process will make sure that that each piece of code is throughly tested and validate before moving on to the next.

Test Driven Development vs Traditional Testing

The difference between Test Drive Development and Traditional testing is that test driven development method has a different approach and objective. Traditional testing methods usually aim to find bugs or even defects in code, test driven development mainly focuses on making sure that the code meets the specific requirements. A failed test in test driven development method tells the developers to write new code to fulfill the requirement’s, and it also tends to make sure that the code will be lead to higher quality, with fewer defects.

There are also two levels of test driven development that focuses on different aspects of software development. Those two levels being Acceptance TDD and Developer TDD. Acceptance involves writing acceptance test that verify the overall behavior of the systems based on the users requirements. Development TDD, focuses on writing unit tests for individual components or modules of the system.

Why Did I pick this Article?

I chose this article because Test Driven Development is a very important concept in software engineering. This article has taught me a lot about test driven development , which include numerous benefits like improved quality of code, reduced bugs and fewer defects, and faster development cycle. These many advantages are valuable for any software development project.

Reflection

After reading this article, i have learned a lot about Test Driven Development and it’s many advantages. One key take away for me was how in this method developers are to write test before actually writing the code, which can help in clarifying and ensuring that the code is correct and meets the required specifications. I also found how the article talks about the difference between test driven development and traditional testing methods. Learning about the Acceptance TDD framework helped me with my understanding of how test drive development can be scaled for larger projects and integrated into Acceptance methods.

Now that my understanding has been enlighten with this new found valuable knowledge and insights into test driven development methods, I can apply this in my future software development projects. I will also be able to writer better, cleaner, and more maintainable code when using this method.

Article link is Here: https://www.guru99.com/test-driven-development.html

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.