As the title of this section suggests, it is solely focused on creating a reading list. On the surface, this section has to be the most straightforward in the book, and yet the one I practice/experience the least. With the ever-growing importance of broadening my learning through reading, I wanted to focus on this section as it feels like the obvious place to start.

Section Summary:

The idea of creating a reading list seems simple, yet so open-ended that it may also feel impossible. The section focuses on ways you can expand your reading list without feeling so overwhelmed with the endless knowledge that is available. When it comes to learning what books are important and useful enough to add to your list, it makes sense to ask mentors. Other online sources can offer reading lists from other people which may give a good insight of which books should be added to your list. The third way of finding useful sources was to pay attention to which sources are commonly referenced and cited in other readings. Seeing the same book cited multiple times can be a great indicator that it is an important book to add to your list. 

Reflection:

Having a list of which books to read next is a great way to stay organized however, having a reading list will also keep track of what books you have read. One of the points the reading made was that this list is also a reflection of your past reading habits. My list right now would reflect awful reading habits, and I must change that. When I first started to read through the patterns at the start of the semester I saw the entire chapter dedicated to reading and how important it was to broaden my education and craft with the use of reading. Starting a reading list from scratch felt like it was going to be an impossible task, with zero clue where to start or what books would be worth my time. With simple solutions provided by the reading, such as looking for likeminded lists from other people, asking mentors, and paying attention to the cited sources, I now feel way more comfortable with being able to develop my reading list.

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

The blog written by Krishna Teja Dinavahi, “Unit Testing – Is it Really Helpful?” (https://engineering.zoominfo.com/unit-testing-is-it-really-helpful) does a great job explaining the importance of writing unit testable code. What is also mentioned is how unit testing and integration testing are two different forms of testing that are both equally important. I specifically enjoyed this blog because of the great examples of code that was not unit testable along with the steps taken to refactor the code. 

What is Unit Testing and How is it Helpful?

As it’s mentioned in the blog, looking up unit testing online will give you the textbook definition, “Unit tests help you test individual parts of your application in isolation.” This is the same thing that was described to me in class, but I had the same general reaction to unit testing as Dinavahi describes. Unit testing can sometimes feel tedious and redundant. However, the real importance of unit testing is clear when you explore code that is not unit testable. Unit testing can not be done on code that is written poorly. This was the biggest eye opener for me as I read this blog, especially with the great examples provided. Notably, the one where having the external dependencies in its own function allows for easy bug fixing if anything was to change in the eternal API.

What Makes Code Unit Testable?

As I recently began refactoring old code with some of the new techniques and agile methods, I noticed the largest hurdle for me is being able to create “pure functions.” These are functions that are limited to doing one task and are very clear what that task is. From my experiences, having pure functions and good naming conventions are the two most important aspects to readable and scalable code. Approaching the code with unit testing in mind, the should automatically be written in a way that you will create pure functions. 

Conclusion

As someone who strives to write clean, readable code, I feel like I share the motivation Dinavahi expresses in the blog when it comes to learning unit testing. Each time I have refactored my code, I have always felt like it was just not finished. However, using unit testing I will be able to identify which parts of my code are not written properly and need to be refactored again. This time, with the knowledge of the steps I can take to get to unit testable code. 

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

A while ago, we used the Mockito framework in Java during an in-class activity. If I’m being honest, I wasn’t paying full attention to the material, and so I wanted to review some of the material in addition to looking into mocking more.

The idea with mocking is that unit testing without the actual classes being written is problematic solely because we can’t actually test stuff that isn’t written. This mostly applies to a specification-based testing environment, a subset of black-box testing. Mocking solves this by simulating the construction of objects and allowing set values to pass through for tests, which can then be refactored once the classes are actually created. As such, we can have tests created for the behaviors we want in our project, without having written the project yet, which is great if we’re applying specifications to tests.

This contrasts with stubs, pieces of code that are written as minimally as possible to get the test suite to function. Stubs are useful in that they can quickly provide the correct result for a test without the need of an outside resource, but what seems to happen is that as you write more tests, you end up writing the actual program in the process to make the tests match. This is good for test-driven development, where we actively write tests while we code the actual program, but if our interest is solely on writing the tests based on specifications, this isn’t a great approach.

According to a blog post by Rohit Khankhoje, mocks are great in that they are more cost-effective, acccessible and efficient than writing stubs or creating fakes. By setting up mocks, you have less set-up time for tests because you don’t need to have the system accessible in order to have a fully functioning test suite. While this is great, there are some obvious drawbacks. For example, tests that utilize mocking will still frequently have to adapt to new code changes when functionality is added to the project. This is more pressing with the idea in mind that tests will continue to pass with mocks despite code in the actual project changing, and so mocked tests need to be developed side-by-side with the actual code, otherwise the testing suite isn’t actually portraying accurate information regarding the accuracy and performance of the system.

As such, while mocking is a very strong tool, it seems to only be very useful in an environment where we don’t have access to code, and when we do have access to code (or we are also the coders ourselves, not just testers) it seems much more efficient to implement test-driven development.

From the blog CS@Worcester – V's CompSCi Blog by V and used with permission of the author. All other rights reserved by the author.

In the fast paced Software Development field, staying ahead is not just advantageous but essential. Yet, many of us tend to find ourselves stuck in a rut, focused solely on the task at hand and neglecting the broader landscape of knowledge and innovation. The Expand Your Bandwidth pattern emphasizes the importance of continually expanding our knowledge and skills beyond just the day to day tasks we complete. Additionally, the importance of actively seeking out new information and participating in various learning opportunities to help accelerate our professional growth.

What I found particularly interesting regarding the pattern is the notion that we all want to achieve mastery following the long road, but achieving that mastery level is more than just mastering a specific technique or technology, but rather about cultivating a broad and adaptable skill set. The pattern also presents an analogy for learning through a straw and a fire hose. By immersing ourselves in a fire hose of information, while it may be overwhelming, is incredibly empowering. Therefore challenging the notion of compliance and encouraging us to continually learn, explore, and experiment.

After reading more about this pattern, it has changed the way I think about my approach to learning and professional growth. Previously, I tended to focus solely on completing immediate tasks, projects, and work, ignoring the broader landscape of knowledge and innovation. However, this pattern has inspired me to adopt a more expansive mindset and go out of the box to seek different opportunities for learning and growth. 

While I embrace the message from this pattern, I do think it is important to limit how much information we try taking in all at once. If we don’t manage all the information properly or carefully, it could lead to an information overload and overwhelm or stress us out.

With this being said, the Expand Your Bandwidth pattern helps serve as a powerful reminder of the always changing and evolving field and the importance of continually trying to learn more and more to increase our skillset. By embracing this pattern, I am confident that I will not only enhance my skills as a developer but also create a mindset of lifelong learning and adaptation, which is essential for success in our dynamic field.

From the blog CS@Worcester – Conner Moniz Blog by connermoniz1 and used with permission of the author. All other rights reserved by the author.

The article “Evaluating Test Cases, Checks, and Tools” explores into the process of evaluating the efficiency of test cases, checks, and tools in software testing. This blog post was written by Michael Bolton, a renowned software tester and consultant, the article provides insightful perspectives on how to critically evaluate these elements to improve the quality of testing practices. Bolton begins by separating between test cases and checks. Test cases are comprehensive procedures designed to explore the behavior and functionality of a software system. On the other hand, checks are automated scripts that verify specific phases of the system’s behavior, typically based on a criteria. While both are important to testing, Bolton emphasizes the importance of recognizing their distinct purposes and limitations. The author highlights the significance of evaluating the value and effectiveness of test cases and checks. Rather than blindly holding to predefined test cases or relying only on automated checks, testers should continually assess their importance and effectiveness in uncovering defects and providing meaningful feedback. Bolton encourages for a dynamic and adaptable approach to testing, where testers actively engage in critical thinking and exploration to uncover issues. Also, Bolton discusses the role of testing tools in the evaluation process. While tools can speed up certain testing activities and enhance efficiency, they are not a answer for all testing challenges. Testers must carefully evaluate tools based on their suitability for the given context, considering factors such as work use, compatibility with the testing environment. Throughout the article, Bolton emphasizes the importance of context-driven testing, where testing strategies are tailored to the unique characteristics and requirements of each project. He encourages testers to adopt a mindset of examination and experimentation, continuously seeking opportunities to improve their testing approaches and improve overall effectiveness. “Evaluating Test Cases, Checks, and Tools” offers valuable insights into the nuanced process of evaluating test cases, checks, and tools in software testing. By organizing a critical and context-driven approach, This was an interesting read considering it was very much so what we have been learning this semester. It helped me understand the value and importance of organizing test and to learn more of adaptable approach of testing

From the blog CS@Worcester – CS- Raquel Penha by raqpenha and used with permission of the author. All other rights reserved by the author.

Performance testing is a big part of software development, it helps make sure that the final product can run smoothly without any errors and gives the user an easy experience. The main aspect of product testing is performance testing, which evaluates the speed and stability of the system. The point is to identify and address any performance bottlenecks that could give the user a bad experience. When dealing with performance testing it should always be used after functional testing, as soon as the basic function of the system is tested and verified. Performance testing involves testing a bunch of different parameters like processing speed and workload efficiency. By measuring the response time under different conditions developers should be able to find areas that need improvement and target system performance. So many companies should make sure to sort performance testing by doing diagnostics aid and software problem identification.  Diagnostics aid is when performance testing helps identify computing bottlenecks in the system and allows developers to use recourses to improve its performance. Software problem identification shows the areas where the application is failing and shows developers how to address the software performance issues. Performance testing plays a big role in evaluating the system’s performance, it helps provide ideas about what areas to work on to improve the performance.

I picked this topic because we have been working on testing in class a lot more recently and thought that this topic is a great choice to get a better understanding of performance testing as well as product testing. Performance testing helps developers address common problems and provide solutions to tackle these problems.  I learned that there are different ways to approach performance testing when doing it for example by analyzing the data I would want to share or use those results and retest it after making some small changes. This information has helped me look at system testing a little differently since we’re working on system testing in class but this new information will help me in the future to make sure that I focus on the system behavior and include the test in the development process to make sure that the system runs smoothly.

https://www.techtarget.com/searchsoftwarequality/definition/performance-testing

From the blog CS@Worcester – Kaylene Noel's Blog by Kaylene Noel and used with permission of the author. All other rights reserved by the author.

In the intricate world of software engineering, the creation and implementation of a test plan stand as a cornerstone of project success. Test plans, detailed documents outlining the strategy, objectives, schedule, and necessary resources for software testing, play a pivotal role in ensuring that a software product not only meets its intended specifications but also delivers a reliable and functional experience to users.

What is a Test Plan?

At its core, a test plan is a blueprint for the testing process. It begins with a skeletal structure at the project’s inception, fleshing out with details as the project progresses. This dynamic document covers everything from the scope of testing and available resources to the specific methodologies that will be employed to assess each feature of the software product.

Types of Test Plans

Understanding the different types of test plans is crucial:

1. Master Test Plan: This document offers a comprehensive overview of the testing approach across different test levels, providing insights into the testing efforts and strategies to be employed throughout the project.
2. Test Phase Plan: Focused on specific test levels or types, these plans delve into the details not covered in the master test plan, outlining schedules, benchmarks, and necessary activities for each phase.
3. Specific Test Plans: These are dedicated to specific types of testing, such as performance or security, focusing on the unique requirements and methodologies applicable to these areas.

Objectives and Importance of a Test Plan

A well-crafted test plan serves several key objectives:

• It outlines the start and end points of the testing process, detailing the resources needed.
• It acts as a roadmap, specifying detailed tasks and guiding the project through its phases.
• It anticipates challenges, offering solutions and organizing stakeholder interactions effectively.

Moreover, a test plan is crucial for facilitating communication within the team and with stakeholders, helping manage changes and ensuring that testing remains aligned with project requirements.

Key Components of a Test Plan

A robust test plan includes several essential components:

• Resource Allocation: Who will test what?
• Training Needs: Identifying skill gaps and training requirements.
• Scheduling: Planning milestones and task durations.
• Tools: Listing software and tools for testing and reporting.
• Risk Management: Identifying potential risks and mitigation strategies.
• Approach: Detailing the testing strategy and scope.

Crafting an Effective Test Plan

Creating an effective test plan involves several steps, from defining the document’s identifier and introduction to outlining the test items, features to be tested, and the testing approach. It also includes planning for staffing, scheduling, risk management, and detailing the deliverables that stakeholders can expect.

In the evolving landscape of software development, the importance of a comprehensive test plan cannot be overstated. It not only ensures the functionality and reliability of the software but also streamlines the development process, making it more efficient and effective. By adhering to a well-thought-out test plan, software engineering teams can navigate the complexities of project development, mitigate risks, and achieve their goals with precision.

All the data are related to this initial blog which helped me understand more about Software Testing: https://www.knowledgehut.com/blog/software-testing/test-plan-in-software-testing#frequently-asked-questions

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

Test Driven Development (TDD)

Test driven development is a form of testing done in software development that focuses on creating unit tests before the actual code. Developers create small test cases for every feature with the intention of modifying the code only when the tests fail. Test driven development is also a practice that focuses on the structure of the code that allows for the creation of optimized code that remains reliable over time.

TDD vs Traditional Testing

As stated above, one of the main differences between TDD and traditional testing is that tests are created before the actual code unlike traditional. However some other differences include the testing scope and the processes that each form of testing follows. The testing scope in TDD focuses on testing small, individual pieces of the codebase whereas traditional testing tests the entire system including integration testing. The process of each type of testing also differs in that TDD is an iterative process. As tests are created, this process also includes cycles of developing small chunks of code, testing that code, then refining until all tests pass. An important part of the TDD process is refactoring. Once tests pass, it’s important to check the code if there are any optimizations that can be made, or if there is any redundancy that should be removed.

Benefits to TDD

Test driven development allows for the creation of optimized code by nature because of the process that TDD follows. Once code is written, if the tests fails then the developer is forced to go back and fix the code until the tests pass. The test coverage that TDD covers is greater than traditional testing methods. This is because before any code is written for a specific functionality, the test is created beforehand which ensures every function passes testing. Using test driven development also helps in reducing the number of larger, more complex issues that arise. This is because testing is done on a consistent basis, where development does not progress until each set of tests are complete.

Conclusion

I chose this article because it clearly explained what test driven development is, differences between traditional and test driven development, and the benefits. I also appreciated the use of examples the article used to further explain what the TDD approach would look like in real scenarios. Learning about different approaches to developing software is helpful because I am exposed to approaches that could be more useful than what I already know. I plan to try test driven development in the future.

Resources:

https://www.browserstack.com/guide/what-is-test-driven-development

From the blog CS@Worcester – Zack's CS Blog by ztram1 and used with permission of the author. All other rights reserved by the author.