Author Archives: Serah Matovu

From Inheritance to Strategy: Lessons from the Duck Simulator

One of the primary obstacles in software design is ensuring that code remains easy to maintain and extend. Initially, inheritance seems like the clear answerplacing shared code in a superclass and allowing subclasses to override as necessary. However, as demonstrated in the classic Duck Simulator example, relying solely on inheritance can result in fragile designs.

From Inheritance to Strategy

In the first version of the Duck Simulator, all ducks derived from a base Duck class. This approach worked until we introduced unique ducks like RubberDuck (which squeaks instead of quacking and cannot fly) and DecoyDuck (which does neither). Suddenly, we found ourselves needing to override or disable inherited methods, leading to duplication and design issues such as viscosity and fragility. Transitioning to interfaces helped to declutter the design, but it also required us to replicate code across similar ducks. The true breakthrough arrived with the Strategy Pattern,

We extracted behaviors like flying and quacking into separate classes (FlyWithWings, FlyNoWay, Quack, Squeak, MuteQuack). Now, ducks possess behaviors rather than inheriting them. These behaviors can be altered at runtime, and new ones can be introduced without changing existing code. This transition underscored the principle of favoring composition over inheritance and illustrated the Open-Closed Principle: code is open for extension but closed for modification.

Design Principles in Action

The exercise reinforced several essential principles: High Cohesion: Each behavior class excels at a single task. Low Coupling: Ducks are indifferent to how they fly or quack, only that they can delegate to a behavior. Encapsulate What Varies: Changes in behavior are contained, not dispersed across subclasses. Collectively, these factors enhance the design’s flexibility and maintainability.

UML: Clearly Communicating Design

We also engaged in the practice of illustrating designs through UML diagrams. In contrast to code, UML offers a higher-level representation that clarifies relationships: Associations (for instance, a Student possessing a schedule of Course objects). Multiplicity (for example, a student may enroll in 0–6 courses). Inheritance and interfaces (such as Faculty extending Employee and implementing HasCourseSchedule). Tools like PlantUML enable us to create these diagrams in Markdown, facilitating easy adjustments and sharing.

Key Takeaways

Relying solely on inheritance frequently results in fragile designs. The Strategy Pattern addresses this issue by encapsulating behavior and employing composition. Guiding principles such as High Cohesion, Low Coupling, and Open-Closed promote cleaner designs. UML diagrams provide us with a common language to convey and analyze code. What began as a straightforward duck simulator evolved into an insightful lesson on the significance of design patterns. By embracing the Strategy Pattern and utilizing UML for design modeling, we discovered how to construct systems that are not only functional but also resilient, adaptable, and easy to maintain.

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

Dev Patterns : Focusing on software design and architeture patters.

Welcome to Dev Patterns. This blog will serve as a platform for looking at software development methods, design choices and architectural frameworks. The purpose of this is to document my learning journey as I advance n the computer science realm. Writing in this space will assist me monitor the progress, structure and share my ideas and also share various insights that might be beneficial to everyone with the same interest as me.

You can anticipate some interesting articles and information covering a range of subjects from coding practices to system design concepts, always keeping the overarching goal in focus: how we can create software that is dependable, maintainable, and efficient.

I am eager and excited to embark on this journey so sit back and enjoy with me. Welcome to my mind!

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

Why Test-Driven Development Boosts Code Quality

In the fast-moving world of software development, one approach stands out for promoting cleaner code, fewer bugs, and better design: Test-Driven Development (TDD). Instead of writing code first and testing later, TDD flips the script β€” you write the test first, watch it fail, then build just enough code to pass that test.

πŸš€ What is TDD?

Test-Driven Development is a simple but powerful cycle:

  1. Write a failing testΒ (Red)
  2. Write minimal code to pass the testΒ (Green)
  3. Refactor the codeΒ without changing its behavior (Refactor)

This process repeats for each small piece of functionality. Over time, it builds up a fully tested, reliable system.

🧩 A Real Example: Word Count Kata

Recently, I practiced TDD while solving a classic coding exercise called the Word Count Kata. The goal was to analyze a piece of text, count the words, ignore case and punctuation, and even filter out unwanted “stop words.”

Here’s how TDD helped guide the process:

  • First, I wrote a test expecting the wordΒ "hello"Β to be counted twice inΒ "Hello hello".
    ➑ The test failed (as expected).
    ➑ I then implemented the countWords method to pass it by converting the text to lowercase and splitting words properly.
  • Next, I tested a sentence with multiple words:Β "Hello world hello again".
    ➑ I wanted to make sure the system counted "hello" twice, and "world" and "again" once each.
  • Then, I challenged the code toΒ ignore punctuationΒ by testing a sentence likeΒ "This, is a test!".
    ➑ The code had to split words correctly, even when commas and exclamation marks appeared.
  • Moving to an intermediate stage, I added “stop words” likeΒ "the"Β andΒ "and", and made sure they were excluded from the count.
  • Finally, for the advanced part, I created a sorted list showing the most frequent words first, such asΒ "again 3"appearing beforeΒ "test 2".

By adding each test one by one, my code grew naturally and remained stable.

πŸ”₯ Why TDD Matters

Through this exercise, I experienced firsthand why TDD is powerful:

  • Confidence:Β Every time I changed the code, I knew instantly whether I broke something because all tests ran automatically.
  • Clarity:Β Writing tests forced me to think about theΒ expected behaviorΒ before diving into coding.
  • Design:Β Since I only built what was needed to pass the next test, the code stayedΒ simpleΒ andΒ focused.

Rather than rushing ahead and debugging messy errors later, TDD helped me build my project brick by brick, with each piece carefully tested.

🎯 Final Thoughts

Test-Driven Development isn’t just for “perfect coders.” It’s a learning tool, a design assistant, and a safety net. Even on a small assignment like the Word Count Kata, using TDD made my work cleaner, more organized, and far less stressful.

If you want to level up your coding habits, I highly recommend giving TDD a real try β€” one failing test at a time.

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

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.