Category: Uncategorized

• Improving API Documentation

  OpenAPI and Swagger are huge tools that software developers use every day. It is extremely important to use when it comes to building clear, maintainable, and interactive API documentation. The name of the article I chose was “How to improve API documentation with Swagger and OpenAPI”. According to this article, APIs are central to modern software design, and their documentation plays a critical role in ensuring that developers can consume them and maintain them correctly. “Using the OpenAPI Specification with the Swagger ecosystem offers the much-needed standardization to REST API documentation”. Besides, it explains that the OpenAPI Specification is human- and machine-readable, it clearly states the structure of the API, its endpoints, parameters, responses, and data models. This in turn helps reduce ambiguity, which often results from loosely documented APIs.

  Besides these, there are several tools that come with Swagger, including the editor, UI, codegen, and inspector. It allows developers to design and edit OpenAPI definitions in JSON or YAML with built-in validation so syntax errors can be caught right there and then. The UI presents OpenAPI definitions as documentation that users can try API endpoints from within their web browser. Codegen produces client libraries, server stubs, and SDKs that facilitate rapid development on multiple platforms. Finally, the inspector is a tool for testing APIs directly and generating an OpenAPI definition based on existing APIs.

  There’s also an updated version, allowing for more modularity and an approach to defining the surface area of an API, with the official release of OpenAPI 3.0. This provides even greater flexibility in describing the request and response model of an API. Good schema and component reuse are emphasized in the most recent version, and handling of multipart documents. Advertisements.The reason I chose this topic was because we have been doing a lot of work with swagger and APIs, and I wanted to look closely into how vital it is to be a software developer in the real world. I also wanted to look closer into how swagger can improve my design skills. After reading this article, I started to see why proper documentation isn’t just something nice and handy but a necessity in being a skilled developer. From now on, I plan to strengthen my understanding of swagger and APIs because I think it will also help me in improving my coding skills and future project.

  Resources: https://www.techtarget.com/searchapparchitecture/tip/How-to-improve-API-documentation-with-Swagger-and-OpenAPI

  December 7, 2025

  @Quarter-4, CS-343, CS@Worcester

  ---

• Understanding Software Architecture Through Martin Fowler’s Lens

  Software architecture is one of those concepts that students hear often but rarely get a clear definition of. This week, I chose to read Martin Fowler’s Software Architecture Guide because it went into depth beyond surface-level definitions of architectural thinking that we usually hear. Since our course is so strongly focused on building maintainable and scalable systems, this resource fit perfectly with the themes we have discussed around design decisions and long-term maintainability in software projects.

  Fowler opens the guide by addressing one of the most debated questions in the software community: What, really is architecture? He explains how many definitions focus on “high-level components” or “early design decisions,” but argues these views are incomplete. Referring to an email exchange with Ralph Johnson, Fowler insists that architecture is about “the important stuff.” Architecture is not about big diagrams or an early-stage structural choice; it is about experienced developers having a common understanding of the parts of a system that matter for its long-term health. This makes architecture dynamic and changing rather than merely static documentation.

  Fowler also describes why architecture matters, even when end users never directly see it: A poor architecture leads to “cruft,” or the buildup of confusing, tangled code that slows down development. Instead of enabling fast delivery, weak internal quality ultimately hurts productivity. The argument here by Fowler is that paying attention to internal structure actually increases delivery speed because developers spend less time fighting the codebase and more time building features. What struck a chord for me in this is how architecture is coupled with practical results: maintainability, reliability, and team productivity.

  I chose this article because I really enjoy the topic and wanted to learn more about software architecture in depth. Fowler’s explanation really helped me understand that architectural thinking is something developers grow into by learning to identify what is truly important in a system. This directly connects with the principles we’ve discussed in class around clean code, modularity, and design patterns. Reflecting on the material, I realized that in future software projects, including class assignments, internships, I will have to think about how my design decisions today will affect my ability-and my team’s ability-to maintain or extend the system later. Good architecture supports future evolution, as Fowler put it, and this is something I want to actively apply as I head toward more complex development work.

  Resource: https://martinfowler.com/architecture/

  November 16, 2025

  @Quarter-3, CS-343, CS@Worcester

  ---

• Understanding Concurrency from a Beginner’s Point of View

  Concurrency is one of those computer science topics that, in theory, makes sense but somehow manages to be a little confusing in practice. In Concurrency 101: From a Beginner’s Point of View, Mrinal gives a straightforward and step-by-step discussion on how languages such as Python, JavaScript, and Go handle more than one thing simultaneously. My favorite was the way the author explained concurrency not as “doing multiple things at the same time,” but rather as making progress on more than one task without getting in each other’s way.

  The article starts by explaining the distinction between concurrency and parallelism, a difference that is essential for authors of responsive programs to understand. Mrinal then discusses the mechanisms that support concurrency: processes, threads, and event loops. Each of these has trade-offs, processes are heavier weight but safer, threads are lighter weight with the risk of race conditions, and event loops (like JavaScript’s) rely on non-blocking operations to stay efficient.

  There’s a large section on synchronization and how programmers prevent “chaos” when threads are reading and writing shared data. I liked the presentation of mutexes and semaphores. The chef example for describing deadlocks made it easy to see how two threads might be waiting for each other forever. Mrinal does discuss practical solutions such as lock ordering, timeouts, and try-locks, all patterns we’ve discussed in CS-343 when we’ve talked about safe concurrent design.

  The post then moves to lock-free programming and message passing and explains how atomic operations and the Actor Model can eliminate many synchronization problems altogether. I liked how Mrinal mapped these concepts to real systems like Go’s concurrency model and Apache Spark’s distributed processes, and how scaling depends on understanding which workloads are benefitted by which model.

  I picked this resource because concurrency has been one of the more daunting topics for me. Having the opportunity to read a post that was written from the perspective of another student made it that much more relatable. The analogies, along with real engineering explanations, bridged the gap between textbook theory and real implementation.

  I took away from this blog to conceptualize concurrency as orderly cooperation between tasks rather than chaos waiting to happen. It opened my eyes to how careful design choices, like tidy lock ordering or message passing, can make programs more correct and speedier. In the coming times, I will apply these lessons when I am working on multithreaded assignments or any program that demands responsiveness, like my Android application that I made this summer which communicates with a Flask backend. Having the fundamentals of concurrency under my belt will allow me to write cleaner, safer, and more scalable code.

  Resources: https://mrinalxdev.github.io/mrinalxblogs/blogs/concurrency.html

  October 26, 2025

  @Quarter-2, CS-343, CS@Worcester

  ---

• Polymorphism in Object-Oriented Programming

  Polymorphism was one of those programming words that used to sound scary the first time I ever heard of it. It literally means “many forms” but in OOP, it’s not as scary-sounding as it is. It’s basically when the same method or function can be something different based on what object it’s being called from. As soon as I started reading over some examples, it made a lot more sense.

  Think of it like this: an individual might be a class student, a home sibling, and maybe a work employee. Same person, various role depending on context. In programming, polymorphism enables us to do one thing with one function that changes its behavior depending on the object.

  There are two main forms of polymorphism. Compile-time polymorphism (or static) is solved before the program ever runs. That generally happens with method overloading, where you have multiple versions on the same method name with different parameters. The compiler figures out which one to invoke. Operator overloading is another example, like using “+” for numbers and strings too.

  Then there is runtime polymorphism (dynamic), resolved as the program is running. That is what happens with method overriding. A case in point is a parent class Shape that has a method draw(). Subclasses such as Circle and Square override draw() to do something else. When you call draw(), the program picks one that matches the actual object.

  First of all, I used to confuse this with inheritance. They definitely go hand in hand, but they are not one and the same. Inheritance is when you are copying another class’s code. Polymorphism is when you have the same method name but have different action.

  A lot of people also think that using polymorphism, especially the runtime kind, makes programs really slow. I used to believe that too, but it turns out that’s not really the case anymore. Modern compilers are built to handle this kind of thing quickly with tricks like virtual tables, so the performance hit is tiny. The trade-off is worth it because you get cleaner code and way more flexibility, so worrying about speed here feels kind of outdated.

  I’ve read about this and it struck me how many times I’ve made my own code overly complicated. In Java, for example, I used to create a whole bunch of methods with unique names when I could have done overloading. I also blocked overriding in subclasses because I believed that it would be slow. Now I know that not just is that fine, it’s the correct thing to do most of the time.

  In the future, I’d like to use polymorphism more intentionally, especially in my Android applications. It’ll be a tremendous assistance if new functionality is introduced in the future because I won’t need to begin anew. That, to me, is the beauty of OOP, it’s not just about making things function, but making them simpler to maintain and extend in the long run.

  Resources:

  https://www.cincom.com/blog/smalltalk/polymorphism-in-object-oriented-programming/

  October 2, 2025

  @Quarter-1, CS-343, CS@Worcester

  ---

• Maria’s Blog

  Hi everyone my name is Maria and this is my introductiory post for CS343!

  September 8, 2025

  CS-343, CS@Worcester

  ---

• Understanding Smoke Testing in Software Development

  
  In software development, a build has to be stable before further more comprehensive testing in a project so that the project is successful. One of the ways of guaranteeing this is smoke testing, which is otherwise known as Build Verification Testing or Build Acceptance Testing. Smoke testing is an early check-point to verify that the major features of the software are functioning as desired before other more comprehensive testing is done.
  
  What is Smoke Testing?
  Smoke testing is a form of software testing that involves executing a quick and superficial test of the most crucial features of an application to determine whether the build is stable enough for further testing. It is a minimum set of tests created to verify if the core features of the application are functioning. Smoke tests are generally executed once a new build is promoted to a quality assurance environment, and they act as an early warning system of whether the application is ready for further testing or requires correction immediately.
  
  Important Features of Smoke Testing

  
  -Level of Testing: Smoke tests are interested in the most important and basic features of the software, without exploring each and every functionality.
  -Automation: Automated smoke testing is a common routine, especially in the case of time limitations, to perform quick, repeatable tests.
  -Frequency: Smoke testing is normally run after every build or significant change in code in order to allow early identification of major issues.
  -Time Management: The testing itself is quick in nature, so it is a valuable time-saver by catching critical issues early.
  -Environment: Smoke testing is typically performed in an environment that mimics the production environment so that test results are as realistic as possible.

  
  Goal of Smoke Testing

  The primary objectives of smoke testing are:
  
  -Resource Optimization: Don’t waste resources and time on testing if core functionalities are broken.
  -Early Detection of Issues: Identify any significant issues early so that they can be fixed at a quicker pace.
  -Refined Decision-Making: Present an open decision schema on whether or not the build is ready to go to thorough, detailed testing.
  -Continuous Integration: Make every new build meet basic quality standards before it is added to the master codebase.
  -Pragmatic Communication: Give rapid feedback to development teams, allowing them to communicate clearly about build stability.

  
  Types of Smoke Testing
  There are several types of smoke tests based on methodology chosen and setting where it is put to practice:
  -Manual Testing: Test cases are written and executed manually for each build by testers.
  -Automated Testing: Automation tools make the process work by itself best used in situations of tight deadline projects.
  -Hybrid Testing: Combines a mixture of automated as well as manual tests for capitalizing on both the pros of each methodology.
  Daily Smoke Testing: Conducted on a daily basis, especially in projects with frequent builds and continuous integration.
  Acceptance Smoke Testing: Specifically focused on verifying whether the build meets the key acceptance criteria defined by stakeholders.
  UI Smoke Testing: Tests only the user interface features of an application to verify whether basic interactions are working.

  
  Applying Smoke Testing at Various Levels
  Smoke testing can be applied at various levels of software testing:
  Acceptance Testing Level: Ensures that the build meets minimum acceptance criteria established by the stakeholders or client.
  System Testing Level: Ensures that the system as a whole behaves as expected when all modules work together.
  Integration Testing Level: Ensures that modules that have been integrated work and communicate as expected when combined.
  

  Advantages of Smoke Testing
  Smoke testing possesses several advantages, including:
  Quick Execution: It is easy and quick to run, and hence ideal for frequent builds.
  Early Detection: It helps in defect detection in the initial stage, preventing wasting money on faulty builds.
  Improved Quality of Software: By detecting the issues at the initial stage, smoke testing allows for improved software quality.
  Risk of Failure is Minimized: Detecting core faults in earlier phases minimizes failure risk at subsequent testing phases.
  Time and Effort Conservation: Time as well as effort is conserved as it prevents futile testing within unstable builds.
  

  Disadvantages of Smoke Testing
  Although smoke testing is useful in many respects, it has some disadvantages too:
  Limited Coverage: It checks only the most critical functions and doesn’t cover other potential issues.
  Manual Testing Drawbacks: Manually, it could be time-consuming, especially for larger projects.
  Inadequate for Negative Tests: Smoke testing typically doesn’t involve negative testing or invalid input scenarios.
  Minimal Test Cases: Since it only checks the basic functionality, it may fail to identify all possible issues.
  

  Conclusion
  In conclusion, smoke testing is an important practice at the early stages of software development. It decides whether a build is stable enough to go for further testing, saving time and resources. By identifying major issues early in the development stage, it facilitates an efficient and productive software testing process. However, it should be remembered that smoke testing is not exhaustive and has to be supported by other forms of testing in order to ensure complete quality assurance. 

  Personal Reflection

  
  Looking at the concept of smoke testing, I view the importance of catching issues early in the software development process.
  It’s easy to get swept up in the excitement of rolling out new features and fully testing them, but if the foundation is unstable, all the subsequent tests and optimizations can be pointless. Smoke testing, in this sense, serves as a safety net, getting the critical functions running before delving further into more rigorous tests. I think the idea of early defect detection resonates with my own working style.
  
  As I like to fix small issues as they arise rather than letting them escalate into big problems, smoke testing allows development teams to solve “show-stoppers” early on, preventing wasted time, effort, and resources in the future. Though it does not pick up everything, its simplicity and the fact that it executes fast can save developers from wasted time spent on testing a defective product, thus ending up with a smooth and efficient workflow. The process, especially in a scenario where there are frequent new builds being rolled out, seems imperative to maintain a rock-solid and healthy product.
  The benefits of early problem detection not only make software better, but also stimulate a positive feedback loop of constant improvement between the development team. 

  April 17, 2025

  @Week-12, CS-443, CS@Worcester

  ---

• Understanding Mocking in Software Testing

  
  Software testing is crucial to ensure that the system acts as expected. However, when dealing with complex systems, it can be challenging to test components in isolation since they rely on external systems like databases, APIs, or services. This is where mocking is used, a technique that employs test doubles. Mocking allows developers to simulate the behavior of real objects within a test environment, isolating the components they want to test. This blog post explains what mocking is, how it is applied in unit testing, the categories of test doubles, best practices, and more.
  
  What is Mocking?
  Mocking is the act of creating test doubles, which are copies of real objects that behave in pre-defined ways. These fake doubles stand in for actual objects or services and allow the developers to isolate chunks of code. Mocking also allows them to simulate edge cases, mistakes, or specific situations that could be hard to replicate in the real world. For instance, instead of conversing with a database, a developer can use a mock object that mimics database returns. This offers greater control of the testing environment, increases testing speed, and allows finding issues early.
  
  Knowing Test Doubles
  It is important to know test doubles to completely comprehend mocking. Test doubles are mock objects that replace actual components of the system for the purpose of testing. Test doubles share the same interface with the actual object but act in a controlled fashion. There are different types of test doubles:
  
  Mocks: Mocks are pre-initialized objects that carry expectations for being called. Mocks are used to force particular interactions, i.e., function calls with specified arguments, to occur while the test runs. When interactions are  not up to expectations, then the test would fail.
  
  Stubs: Stubs do not care about interactions. They simply provide pre-defined responses to method calls so that the test can just go ahead and not worry about the actual component behavior.
  
  Fakes: They are more evolved test doubles with smaller implementations of real components. For example, an in-memory database simulating a live database can be used as a fake to speed up testing without relying on external systems.
  
  Spies: Spies are similar to mocks but are employed to log interactions against an object. You can verify the spy after a test to ensure that the expected methods were invoked with the correct parameters. Unlike mocks, spies will not make the test fail if the interactions are unexpected.
  
  The Role of Mocking in Unit Testing
  Unit testing is testing individual pieces, such as functions or methods, in isolation. But most pieces rely on external services, such as databases or APIs. These dependencies add complexity, unpredictability, and outside factors that can get in the way of testing.
  
  Mocking enables developers to test the unit under test in isolation by substituting external dependencies with controlled, fake objects. This ensures that any problems encountered during the test are a result of the code being tested, not the external systems it depends on.
  
  Mocking also makes it easy to test edge cases and error conditions. For example, you can use a mock object to throw an exception or return a given value, so you can see how your code handles these situations. In addition, mocking makes tests faster because it avoids the overhead of invoking real systems like databases or APIs.
  
  Mocking Frameworks: Mockito and Beyond
  Various mocking libraries are utilized by programmers in order to craft and manipulate the mocks for unit testing. Among the most commonly used libraries used in the Java community is Mockito. Mockito makes it easy for one to write mock objects, specify their behavior, and confirm interactions in an easy-to-read manner.
  
  Highlights of Mockito include:
  
  Behavior Verification: One can assert that certain methods were called with the right arguments.
  Stubbing: Mockito allows you to define return values for mock methods so that various scenarios can be tested.
  Argument Matchers: It provides flexible argument matchers for verifying method calls with a range of values.
  Other than Mockito, other libraries like JMock, EasyMock, and JUnit 5 can also be used. For Python developers, the unittest.mock module is utilized. In the.NET ecosystem, libraries like Moq and NSubstitute are commonly used. For JavaScript, Sinon.js is the go-to library for mocking, stubbing, and spying.
  
  Best Practices in Mocking
  As terrific as mocking is, there is a best-practice way of doing it and having meaningful, sustainable tests. Here are a few rules of thumb to bear in mind:
  
  Mock Only What You Own: Mock only entities you own, such as classes or methods that you have created. Mocking third-party APIs or external dependencies will lead to brittle tests, which will be broken when outer dependencies change.
  
  Keep Mocks Simple: Don’t overcomplicate mocks with too many configurations or behaviors. Simple mocks are more maintainable and understandable.
  
  Avoid Over-Mocking: Over-mocking your tests can make them too implementation-focused. Mock only what’s required for the test, and use real objects when possible.
  
  Assert Behavior, Not Implementation: Tests must assert the system’s behavior is right, not how the system implements the behavior. Focus on asserting the right methods with the right arguments are called, rather than making assertions about how the system works internally.
  
  Use Mocks to Isolate Tests: Use mocks to isolate tests from slow or flaky external dependencies like databases or networks. This results in faster and more deterministic tests.
  
  Clear Teardown and Setup: Ensure that the mocks are created before each test and destroyed thereafter. This results in tests that are repeatable and don’t produce any side effects.
  
  Conclusion
  Mocking is an immensely valuable software testing strategy that provides developers with a way to segregate and test separate components isolated from outside dependencies. Through the use of test doubles like mocks, stubs, fakes, and spies, programmers are able to fake out actual conditions, test on the boundary, and make their tests more reliable and quicker. Good practices must be followed, like mock only what you own, keep mocks as plain as possible, and assert behavior and not implementation. Applied in the right way, mocking is a great friend in creating robust, stable, and quality software.
  
  Personal Reflection

  I find mocking to be an interesting approach that enables specific and effective testing. In this class, Quality Assurance & Testing, I’ve gained insight into how crucial it is to isolate the units being tested in order to check their functionality in real-world settings. Precisely, I’ve understood how beneficial mocking can be in unit testing in order to enable the isolation of certain interactions and edge cases.

  I also believe that, as developers, we tend to over-test or rely too heavily on mocks, especially when working with complex systems. Reflecting back on my own experience, I will keep in mind that getting the balance right, mocking when strictly required and testing behavior, not implementation, is the key to writing meaningful and sustainable tests. This approach helps us ensure that the code is useful and also adjustable when it encounters future changes, which is, after all, what any well-designed testing system is hoping for.

  Reference:
  
  What is Mocking? An Introduction to Test Doubles by GeeksforGeeks, Available at: https://www.geeksforgeeks.org/mocking-an-introduction-to-test-doubles/.

  April 11, 2025

  @Week-11, CS-443, CS@Worcester

  ---

• Basis Path Testing in Software Testing

  
  
  Software testing is a significant part of confirming the functionality, reliability, and performance of software products. Out of all the diverse types of tests, Basis Path Testing is one essential technique for confirming the control flow of a program. In this blog, we share the concept of Basis Path Testing, its importance, and how it is applied in software testing.
  
  What is Basis Path Testing?
  Basis Path Testing is a white-box testing method that focuses on software control flow. It was formulated by Thomas J. McCabe as a part of the Cyclomatic Complexity metric, which calculates the amount of linearly independent paths in a program’s control flow. The approach is designed to test the software by executing all the independent paths through the program at least once to provide complete coverage of the code.
  
  The goal of Basis Path Testing is to locate all the potential paths within a program and ensure that each of them is tested for possible issues. It helps in determining logical defects that are not obvious through other testing techniques, such as functional or integration testing.
  
  Key Elements of Basis Path Testing
  Control Flow Graph: The first step in Basis Path Testing is to design a control flow graph (CFG) for the program. This graph represents the control structure of the program, including decision points, loops, and function calls.
  
  Cyclomatic Complexity: The second step is to compute the cyclomatic complexity of the program, which is the number of independent paths. The metric is calculated as:
  V(G) = e – n + 2*P

  Where, e is number of edges, n is number of vertices, P is number of connected components.
  The cyclomatic complexity provides the minimum number of test cases required to exercise all the independent paths.
  
  Independent Paths: After calculating the cyclomatic complexity, the independent paths in the control flow graph must be determined. These are paths that don’t reuse any other path’s sequence of execution.
  
  Test Case Design: Once independent paths are identified, test cases are created to execute each path such that all aspects of the program’s logic are exercised.
  
  Importance of Basis Path Testing
  Basis Path Testing is particularly useful in revealing intricate logical errors that can result due to intricate control flow. By carrying out all independent paths, it ensures that nothing in the program is left untreated, and this reduces the chances of undiscovered defects.
  
  The approach is used widely in unit testing and integration testing, especially for programs with intricate decision structures and loops. It is also a good approach to use in regression testing, where changing the codebase can probably introduce flaws into previously tested paths.

  Conclusion
  Basis Path Testing is a highly valuable method for thorough testing of software using independent paths through the control flow of a program. By understanding and applying this method, software developers are able to improve the quality of applications, reduce errors, and deliver improved software to end-users.
  
  Personal Reflection
  Having studied Basis Path Testing, I can see how this approach is essential to checking the strength of software systems. As a computer science major, what I have learned from my studies is that testing is not just about checking if the code runs but, more importantly, that the logic and correctness of running are checked. Basis Path Testing’s focus on cyclomatic complexity provides a clear, mathematical way to ensure that all possible execution paths are considered.
  
  My experience is that application of this technique detects logical flaws in programs which would otherwise not be easily seen through normal debugging or functional testing. 

  
  Citation:
  “Basis Path Testing in Software Testing.” GeeksforGeeks, https://www.geeksforgeeks.org/basis-path-testing-in-software-testing/.

  April 2, 2025

  @Week-10, CS-443, CS@Worcester

  ---

• Learning Boundary Value Analysis in Software Testing

  One of the most significant ways of ensuring that an application is reliable and efficient before deployment is through software testing. One of the most powerful functional testing techniques that focuses on testing the boundary cases of a system is Boundary Value Analysis (BVA). Boundary Value Analysis finds potential defects that are apt to show themselves on input partition boundaries.

  What is Boundary Value Analysis?

  Boundary Value Analysis is a black-box testing method which tests the boundary values of valid and invalid partitions. Instead of testing all the possible values, the testers focus on minimum, maximum, and edge-case values, as these are the most error-prone. This is because defects often occur at the extremities of the input ranges rather than at any point within the range.

  For example, if a system accepts values between 18 and 56, instead of testing all the values, testers would test the below-mentioned values:

  Valid boundary values: 18, 19, 37, 55, 56

  Invalid boundary values: 17 (below minimum) and 57 (above maximum)

  By running these primary test cases, the testers can easily determine boundary-related faults without unnecessary repetition of in-between value testing.

  Implementing BVA: A Real-World Example

  To represent BVA through an example, let us take a system processing dates under the following constraints:

  Day: 1 to 31

  Month: 1 to 12

  Year: 1900 to 2000

  Under Single Fault Assumption, where one of the variables is tested while others are at nominal values, test cases like below can be written:

  Boundary value checking for years (e.g., 1900, 1960, 2000)

  Boundary value checking for days (e.g., 1, 31, invalid cases like 32)

  Checking boundary values for months (i.e., 1, 12)

  By limiting test cases to boundary values, we are able to have maximum test coverage with minimum test effort.

  Equivalence Partitioning and BVA together

  Another helpful technique is combining BVA and Equivalence Partitioning (EP) together. EP divides input data into equivalent partitions where every equivalence class is expected to behave in the same way. By using these techniques together, testers can reduce the number of test cases but still maintain complete coverage.

  For instance, if a system would only accept passwords of 6 to 10 characters long, test cases can be:

  0-5 characters: Not accepted

  6-10 characters: Accepted

  11-14 characters: Not accepted

  This mix makes the testing more efficient, especially when using more than one variable.

  Limitations of BVA

  Although BVA is strong, it does face some limitations:

  It works well when the system contains properly defined numeric input ranges.

  It has no regard for functional dependencies of variables.

  It may not be equally effective on free-form languages like COBOL, which has more flexible input processing.

  Conclusion

  Boundary Value Analysis is one very important test method that can help testers define most probable fault sites of a system. Merged with Equivalence Partitioning, it has highest test effectiveness at the maximum elimination of test case replication and minimum complete loss of test coverage. In as much as BVA isn’t a “catch-all”, yet it represents an essential technique of software provision quality and dependability.

  Personal Reflection

  Learning Boundary Value Analysis has helped me understand more about software testing and how it makes the software reliable. It has shown me that by focusing on boundary values, defects can be detected with higher efficiency without generating surplus test cases. It is a very practical approach to apply in real-world scenarios, such as form validation and number input testing, where boundary-related errors are likely to be found. In the future, I will include BVA in my testing approach to offer more test coverage in software projects that I undertake.

  Citation

  Geeks for Geeks. (n.d.). Software Testing – Boundary Value Analysis. Retrieved from https://www.geeksforgeeks.org/software-testing-boundary-value-analysis/

  March 24, 2025

  @Week-9, CS-443, CS@Worcester

  ---

• Maria Delia’s Blog

  First Blog for CS-443

  Hello I am Maria Delia and this is my first blog post for Software Quality Assurance & Testing.

  January 27, 2025

  CS-443, CS@Worcester

  ---