Author Archives: Serah Matovu

HOW DECISION TABLES CHANGED MY SOFTWARE TESTING MINDSET.

If you’ve ever written test cases based on your gut feeling, you’re not alone. I used to write JUnit tests by simply thinking, “What might go wrong?” While that’s a decent start, I quickly realized that relying on intuition alone isn’t enough especially for complex systems where logical conditions stack up fast.

That’s when I understood the magic of Decision Table-Based Testing.

What Is Decision Table Testing?

A decision table is like a truth table, but for real-world logic in your code. It lays out different conditions and maps them to the actions or outcomes your program should take. By organizing conditions and results in a table format, it becomes much easier to identify what combinations of inputs need to be tested and which ones don’t. It’s especially helpful when you want to reduce redundant or impossible test cases., when you have multiple input variables (like GPA, credits, user roles, etc.) and also when your program behaves differently depending on combinations of those inputs

Applying Decision Tables in Real Time

For a project that I happened to work on, we analyzed a simple method; boolean readyToGraduate(int credits, double gpa). This method is meant to return true if Credits ≥ 120 and also when GPA ≥ 2.0. We had to figure out what inputs would cause a student to graduate, not graduate, or throw an error—such as when the GPA or credit values were outside of valid ranges.

Instead of testing random values like 2.5 GPA or 130 credits, we created a decision table with all the possible combinations of valid, borderline, and invalid values.

We even simplified the process using equivalence classes, like:

  • GPA < 0.0 → invalid
  • 0.0 ≤ GPA < 2.0 → not graduating
  • 2.0 ≤ GPA ≤ 4.0 → eligible to graduate
  • GPA > 4.0 → invalid

By grouping these ranges, we reduced a potential 256 test cases to a manageable 68 and even further after combining rules with similar outcomes.

Well you must be wondering why this even matters in real projects. It matters because in real-world applications, time and efficiency are everything. Decision tables help you cover all meaningful test scenarios. They also help to cut down on unnecessary or duplicate test cases. Decision tables as well help to reduce human error and missed edge cases and provide a clear audit trail of your testing logic.

If you’re working in QA, development, or just trying to pass that software testing class, mastering decision tables is a must-have skill.Switching from intuition-based testing to structured strategies like decision tables has completely shifted how I write and evaluate test cases. It’s no longer a guessing game—it’s a methodical process with justifiable coverage. And the best part? It saves a ton of time.Next time you’re designing tests, don’t just hope you’ve covered the edge cases. Prove it—with a decision table

Have you used decision tables in your projects? Drop a comment below and share your experience!

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

Mastering Software Testing: The Magic of Equivalence Class Testing.

If you’re like me, getting into software testing might feel overwhelming at first. There are countless methods and techniques, each with its own purpose, and it’s easy to feel lost. But when I first learned about Equivalence Class Testing, something clicked for me. It’s a simple and efficient way to group similar test cases, and once you get the hang of it, you’ll see how much time and effort it can save.

So, what exactly is Equivalence Class Testing? Essentially, it’s a method that helps us divide the input data for a program into different categories, or equivalence classes, that are expected to behave the same way when tested. Instead of testing every single possible input value, you select one or two values from each class that represent the rest. It’s like saying, “if this value works, the others in this group will probably work too.” This approach helps you avoid redundancy and keeps your testing efficient and focused.

Now, why should you care about Equivalence Class Testing? Well, let me give you an example. Imagine you’re writing a program that processes numbers between 1 and 1000. It would be impossible (and impractical!) to test all 1000 values, right? With Equivalence Class Testing, you can group the numbers into a few categories, like numbers in the lower range (1-200), the middle range (201-800), and the upper range (801-1000). You then pick one or two values from each group to test, confident that those values will tell you how the whole range behaves. It’s a major time-saver.

When I started using this method, I realized that testing every possible input isn’t just unnecessary—it’s counterproductive. Instead, I learned to focus on representative values, which allowed me to be much more efficient. For instance, let’s say you’re testing whether a student is eligible to graduate based on their GPA and number of credits. You could create equivalence classes for the GPA values: below 2.0, which would likely indicate the student isn’t ready to graduate; between 2.0 and 4.0, which might be acceptable; and anything outside the 0.0 to 4.0 range, which is invalid. Testing just one GPA value from each class will give you a pretty good sense of whether your function is working properly without overloading you with unnecessary cases.

Another thing I love about Equivalence Class Testing is that it naturally leads into both Normal and Robust Testing. Normal testing focuses on valid inputs—values that your program should accept and process correctly. Robust testing, on the other hand, checks how your program handles invalid inputs. For example, in our GPA scenario, testing GPAs like 2.5 or 3.8 would be normal testing, but testing values like -1 or 5 would fall under robust testing. Both are essential for making sure your program is strong and can handle anything users throw at it.

Lastly, when I first heard about Weak and Strong Equivalence Class Testing, I was a bit confused. But the difference is straightforward. Weak testing means you’re testing just one value from each equivalence class at a time for a single variable. On the other hand, Strong testing means you’re testing combinations of values from multiple equivalence classes for different variables. The more variables you have, the more comprehensive your tests will be, but it can also get more complex. I usually start with weak testing and move into strong testing when I need to be more thorough.

Overall, learning Equivalence Class Testing has made my approach to software testing more strategic and manageable. It’s a method that makes sense of the chaos and helps me feel more in control of my testing process. If you’re new to testing, or just looking for ways to make your tests more efficient, I highly recommend giving this method a try. You’ll save time, energy, and still get great results.

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

J UNIT 5 TESTING

Recently, I dove into unit testing with JUnit 5 as part of my software development journey. Unit testing helps ensure that individual parts of a program work correctly by writing small, focused tests. JUnit 5 is the framework that is used to write these tests for Java applications, and it makes the process simple and efficient.

The first things first, JUnit 5 uses something called annotations to define test methods. The most important one is @Test, which marks a method as a test case. These methods test small units of code, like individual methods in a class, to make sure they return the expected results.

Here’s a simple example of a test method I wrote to check the area of a rectangle:

import static org.junit.jupiter.api.Assertions.assertEquals;

@Test
void testRectangleArea() {
Rectangle r1 = new Rectangle(2, 3);
int area = r1.getArea();
assertEquals(6, area); // Checking if the area is correct
}

In this case try and write these small test cases to check specific outputs, and if something doesn’t match what you expect, JUnit will let you know right away.

The Structure of a Test Case

There are three simple steps you can follow for each test case:

Assert: Compare the result with what you expect using something called an “assertion.

Arrange: Set up the objects or data you are testing.

Act: Call the method you want to test.

For example, here is another test to check if a rectangle is a square:

@Test
void testRectangleNotSquare() {
Rectangle r1 = new Rectangle(2, 3);
boolean isSquare = r1.isSquare();
assertFalse(isSquare); // Checking if it’s not a square
}

In this case, using assertFalse helps to confirm that the rectangle is not a square.

Common JUnit Assertions

JUnit 5 offers several assertion methods, and I quickly got the hang of using them. Here are a few that I used the most:

  • assertEquals(expected, actual): Checks if two values are equal.
  • assertFalse(condition): Checks if a condition is false.
  • assertTrue(condition): Checks if a condition is true.
  • assertNull(object): Verifies if something is null.

These assertions make it easy to confirm whether a piece of code behaves as expected.

Managing Test Execution

One thing that surprised me was that test methods don’t run in any specific order by default. This means each test should be independent of the others, which encourages better organization. I also learned about lifecycle methods like @BeforeEach and @AfterEach, which allow you to run setup and cleanup code before and after each test case. For example, @BeforeEach can be used to initialize objects before each test:

@BeforeEach
void setup() {
// Code to run before each test
}

In conclusion, Learning unit testing with JUnit 5 has been a great experience. It helps me write reliable code and catch bugs early. By writing small tests and using assertions, I can quickly confirm that my programs work as they should. JUnit 5 makes testing simple, and I look forward to improving my skills even more in the future!

If you’re new to testing like I was, JUnit 5 is definitely a great place to start!

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

A Beginner’s Guide to Software Quality Assurance and Testing

In today’s fast-paced digital world, software is at the core of nearly everything we do—whether it’s managing bank accounts, connecting with friends, or working from home. With so many people depending on technology, ensuring that the software we use is safe, reliable, and user-friendly is more important than ever. This is where Software Quality Assurance and Testing come in.

What is Software Quality Assurance?

Software Quality Assurance is all about making sure that the software developed by companies meets a certain standard of quality. It’s not just about finding bugs after the software has been built; it involves creating guidelines, processes, and checks to ensure software is being built the right way from the start.

Here’s a simple way to think about it: Software Quality Assurance and Testing is like quality control in a factory. Just as a factory ensures that each product coming off the line meets specific standards, Software Quality Assurance and Testing ensures that software does the same.

Key Functions of Software Quality Assurance and Testing:

  • Process Monitoring: Ensuring that software development follows defined processes and standards.
  • Code Review: Examining the code to catch errors before the software is released.
  • Defect Prevention: Putting measures in place that reduce the chance of defects occurring in the first place.

What is Software Testing?

Testing, on the other hand, comes after the development process. It focuses on checking the actual software product to make sure it works as expected. Think of it like test-driving a car before it hits the market.

Software Testing involves running the software through various scenarios to make sure that everything functions smoothly and no bugs are present. It is crucial because even a small bug can cause significant problems for users, and companies could lose their reputation or customers if their software doesn’t work well.

Types of Software Testing:

  • Manual Testing: Testers use the software like a real user would, performing various actions to check for bugs.
  • Automated Testing: Automated scripts run tests on the software to save time and effort on repetitive tasks.
  • Functional Testing: Ensures the software behaves correctly according to requirements.
  • Performance Testing: Verifies how well the software performs under pressure (for example, when thousands of users are using it at once).
  • Security Testing: Identifies vulnerabilities that could expose users to data breaches or other risks.

Why Software Quality Assurance and Testing Are Important

You may wonder, why go through all this trouble? Well, poor-quality software can lead to disastrous results for both users and companies. Imagine if an e-commerce website crashed during Black Friday sales or a banking app exposed sensitive user data—that’s a nightmare scenario!

Here’s why SQA and Testing are critical:

  1. Minimizing Bugs: Testing catches problems early, so developers can fix them before they impact users.
  2. Improving Security: Testing helps find security holes that hackers could exploit, protecting users from cyber threats.
  3. Enhancing User Experience: Reliable, bug-free software creates a better user experience and increases user satisfaction.
  4. Cost Efficiency: Fixing bugs early is much cheaper than addressing problems after software has been released.
  5. Building Trust: Well-tested software builds trust with users, boosting brand reputation and customer loyalty.

How Software Quality Assurance and Testing Affect Everyday Software

Every time you open an app or visit a website, there’s a good chance that it has gone through rigorous quality assurance and testing processes. From banking apps ensuring secure transactions to streaming platforms delivering smooth experiences, Software Quality Assurance and Testing plays a major role in the seamless digital experiences we enjoy daily.

Even the smallest error—like a slow-loading webpage or a glitchy feature—can ruin the user experience, which is why companies invest heavily in making sure their software is as close to perfect as possible. The result? Fewer complaints, better user retention, and a competitive edge in the marketplace.

The Growing Demand for Quality Software

With the continuous rise of new apps, websites, and technologies, the need for high-quality software is more significant than ever. As businesses shift to digital solutions, software development teams face the challenge of delivering robust, reliable software in increasingly shorter timelines.

This demand for quality, combined with the complexity of modern applications, has led to growing opportunities in the field of Software Quality Assurance and Testing Whether you’re a developer, a project manager, or someone interested in tech, understanding the importance of Software Quality Assurance and Testing and how testing works can be a valuable skill in today’s job market.

Conclusion

Software Quality Assurance and Testing are essential for delivering reliable, secure, and user-friendly products in today’s tech-driven world. From preventing bugs to ensuring smooth performance, these processes ensure that the software we depend on every day works as it should.

As technology continues to evolve, the demand for well-tested, high-quality software will only grow. Whether you’re a tech enthusiast or just someone who relies on apps and websites, Software Quality Assurance and Testing and Testing ensure a safer, smoother digital experience for everyone.

So, next time you use a glitch-free app or enjoy a seamless online shopping experience, you can thank the Software Quality Assurance and Testing and Testing teams working behind the scenes to make it possible!

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

Understanding Copyright and Licensing in Software Development

In today’s digital age, software development plays a crucial role in various industries. As a software developer, it’s important to have a solid understanding of copyright and licensing to protect your work and ensure compliance with legal requirements. In this blog post, we’ll explore the key concepts of copyright and licensing in the context of software development.

1. Copyright Basics:

Copyright is a legal protection that grants exclusive rights to the creators of original works, including software. It gives developers the right to control how their software is used, reproduced, distributed, and modified. Copyright protection is automatic, meaning your software is protected as soon as it’s created.

2. Open Source Licenses:

Open source software is a popular approach in software development, allowing developers to share their code with others. Open source licenses, such as the GNU General Public License (GPL) or the MIT License, provide permissions and restrictions for using, modifying, and distributing the software. These licenses promote collaboration and innovation within the developer community.

3. Proprietary Licenses:

Proprietary software is protected by licenses that restrict how it can be used, modified, or distributed. These licenses are typically more restrictive than open source licenses and often require users to purchase a license or agree to specific terms and conditions. Examples of proprietary licenses include the End-User License Agreement (EULA) commonly seen in commercial software.

4. Choosing the Right License:

When developing software, it’s important to choose the right license that aligns with your goals and intentions. Consider factors such as the level of control you want over your software, the degree of collaboration you seek, and the potential impact on future users and developers. Consulting with legal professionals can help you navigate the complexities of licensing.

5. License Compliance:

Once you’ve chosen a license, it’s crucial to ensure compliance with its terms. This includes properly attributing the original authors, providing copies of the license, and adhering to any restrictions or obligations outlined in the license. Failing to comply with license requirements can lead to legal consequences and damage your reputation as a developer.

In conclusion, Copyright and licensing are essential aspects of software development. Understanding these concepts empowers developers to protect their work, collaborate effectively, and contribute to the growth of the software development community. Whether you choose open source or proprietary licensing, make sure to comply with the terms and consider seeking legal advice

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

Working Locally And Upstream.

As a student of Computer Science and currently taking a class of Software Process Management, my journey through this course specifically involves a lot of learning, experimenting, and finding better ways to upgrade as a student in this field. In this blog post, I shall share some of the things I have learnt and we’ll delve into the concept of working locally and upstream, highlighting its significance and the benefits it gives in contributing to open-source projects.

What Is “Working Locally and Upstream”?

Before I go into the why and how, let’s clarify what working “locally” and “upstream” means in the context of open source:

  1. Working Locally: When you work locally, you are making changes and improvements to open-source software on your personal development environment. You might be fixing bugs, adding features, or simply experimenting with the code. This is your playground to test, experiment, and learn.
  2. Working Upstream: Once you’ve made changes locally and are confident in your code, the next step is to contribute your changes to the official or “upstream” repository. Upstream is where the original project is maintained, and your contributions become part of the official codebase.

Why Would one Work Locally?

  1. Learning and Experimentation: Working locally allows you to experiment freely. You can try out new ideas, make mistakes, and learn from them without the pressure of affecting the main project.
  2. Skill Development: This is a perfect opportunity to hone your coding, debugging, and collaboration skills. You’ll gain valuable experience that can be applied in your coursework and future career.
  3. Portfolio Building: Every contribution you make locally is a valuable addition to your portfolio. It showcases your practical experience and commitment to open source.

Why Should you Consider Contributing to the Upstream?

  1. Community Engagement: Contributing upstream allows you to be part of a wider community. Your code becomes part of a larger ecosystem, and you collaborate with experienced developers from all over the world.
  2. Impact: Your contributions have a real impact. The changes you make can benefit not only the project but also countless other users and developers who rely on it.
  3. Networking: Working upstream introduces you to industry professionals and like-minded individuals. This networking can be a stepping stone to internships, job opportunities, and mentorship.

How to Get Started Working locally and upstream.

  1. Choose a Project: Find an open-source project that aligns with your interests or field of study. Popular platforms like GitHub offer a wide selection.
  2. Fork the Repository: Forking creates a copy of the project in your GitHub account, which you can work on without affecting the original code.
  3. Make Local Changes: Clone your forked repository to your local machine. Make the desired changes, test them thoroughly, and commit your work.
  4. Make a Pull Request: Once you’re satisfied with your changes, submit a pull request to the original repository. This is your way of proposing your contributions to the upstream maintainers.

In conclusion, Working locally and upstream in open source is a valuable experience for a lot of software developers. It not only helps you grow as a developer but also connects you with a global community of like-minded individuals. So, dive in, fork your first repository, and explore.

Here is where you can find some open source projects to work with:

https://github.com/

https://gitlab.com/

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

More About Using And Mastering Git.

In software, we often hear the phrase git and caught up wondering what it is about. Here is a light description of what git is. Git is a distributed version control system (DVCS) that allows you to track changes in your codebase, collaborate with others, and maintain a complete history of your project. Developed by Linus Torvalds in 2005, Git has since gained widespread adoption due to its speed, flexibility, and robust branching and merging capabilities.

Before we dive into Git commands, it’s crucial to set up Git on your machine: That involves installation and configuration. This is where you Download and install Git from https://git-scm.com. Follow the installation instructions for your operating system and configure it using your name and email address using the following commands, git config –global user.name “Your Name” and git config –global user.email “your@email.com”.

When you move deeper into git commands, this is where it gets interesting playing around with these commands and getting to see what they can do. Some of the git commands include;

  1. git init: Initialize a new Git repository in your project directory. This command sets up the necessary Git files and folders.
  2. git clone: Copy an existing Git repository from a remote server to your local machine. For example, to clone a repository from GitHub.
  3. git add: Stage changes for commit. You can specify individual files or use . to stage all changes in the current directory.
  4. git commit: Create a new commit with the staged changes, providing a commit message to describe the changes made.
  5. git status: Check the status of your working directory. This command shows untracked files, modified files, and files staged for commit.
  6. git pull: Fetch and merge changes from a remote repository into your local branch.
  7. git push: Push your local changes to a remote repository. This is essential for collaborating with others.
  8. git branch: List all branches in your repository, and see which branch you’re currently on.
  9. git checkout: Switch between branches or commits. To create a new branch and switch to it, use: git checkout -b new-branch
  10. git merge: Merge changes from one branch into another. For example, to merge the changes from feature-branch into main: git checkout main and then git merge feature-branch
  11. git log: View a log of all commits in the repository, including commit messages, authors, and timestamps.

As you go even deeper, you discover more advanced git commands such as ;

  1. git stash: Temporarily save changes that are not ready for a commit. You can later apply these changes or clear the stash.
  2. git rebase: Combine commits from one branch onto another, resulting in a cleaner commit history.
  3. git reset: Unstage changes, move the HEAD to a different commit, or even remove commits from the branch entirely.
  4. git cherry-pick: Select specific commits from one branch and apply them to another.

All these commands can also be found in a git installed terminal by typing git help in that event that you don’t have time to look for them on the Internet. In conclusion, Mastering Git and its essential commands is a critical skill for developers. Git enables efficient version control, collaboration, and project management. By understanding these core commands, you’ll be better equipped to navigate your software development projects, whether working solo or as part of a team. So, start using Git in your development workflow, and you’ll find that it’s an invaluable tool that streamlines your work and keeps your codebase organized.

From the blog CS@Worcester – MY_BLOG_ by Serah Matovu and used with permission of the author. All other rights reserved by the author.

The Power of Community and Collaboration in Software Process Management.

In the world of software development, there is an old saying “two heads are better than one” that has taken on a whole new meaning. Modern software development is often a complex interplay of various skills and perspectives, and it is through a community and in collaboration that the collective genius of a team truly shines. By working together, developers can leverage their unique strengths to produce code that is both efficient and elegant.

Collaboration within a community means the free exchange of knowledge. Developers can share their insights, tips, and tricks, leading to a collective increase in skills. This not only benefits the individual but also enhances the overall quality of the software produced.

Community involvement often means peer review becomes a standard practice. Code reviews by fellow developers help identify and rectify issues before they become critical, ensuring a higher standard of code quality.

A strong community fosters diverse expertise. When developers with varied backgrounds and skillsets come together, they bring fresh ideas and problem-solving techniques to the table. This diversity can be a catalyst for innovation, leading to the creation of more robust software solutions.

Efficiency and productivity are crucial in software development, where tight deadlines and shifting project requirements are the norm. Community and collaboration bring a host of benefits in these areas. This usually entails task allocation, shared responsibility and furthermore some feedback given. This ensures full effective productivity in a team.

As we look to the future, the role of community and collaboration in software process management is likely to expand. With the advent of remote work and online collaboration tools, developers from different continents can seamlessly work together.

GitHub, the largest platform for hosting and collaborating on code, has seen exponential growth, with millions of developers contributing to projects daily. Platforms like GitLab and Bitbucket also play crucial roles in promoting community-driven software development.

Furthermore, open-source projects continue to thrive. The Linux Foundation, in its annual report, highlighted a growing number of open-source projects, reflecting the sustained interest in community-driven development.

In conclusion, the power of community and collaboration in software process management cannot be understated. By coming together, sharing knowledge, and working towards a common goal, developers can drive innovation, enhance efficiency, and foster a strong sense of togetherness in the ever-evolving world of software development. The success of the entire industry is built upon these foundations of unity and shared expertise, and it continues to thrive thanks to the collaborative efforts of developers around the globe.

From the blog CS@Worcester – Site Title by Serah Matovu and used with permission of the author. All other rights reserved by the author.

Welcome to Serah’s Blog

Hello there! Welcome to my blog where we shall be exploring the realm of software process management and everything I.T. Doesn’t matter whether you have an idea of what this entails or you’re experienced , all that counts is understanding how to effectively manage and process software and how to successfully deliver your project. Sit back and explore with me!

From the blog CS@Worcester – Site Title by Serah Matovu and used with permission of the author. All other rights reserved by the author.