Working with Remote Branches in Git: Push, Pull, and Track Changes

Interactive Git tutorial: Main branch & colorful remote branches pulse, connected by data streams, illustrating seamless collaboration

Welcome to Git and Version Control Hub, your go-to resource for mastering Git! Ever wondered how to effectively collaborate on projects using remote branches? This tutorial, "Working with Remote Branches in Git: Push, Pull, and Track Changes," will demystify the process, providing a comprehensive Git remote branches tutorial. Uncover the secrets to seamless team workflow and efficient code management – and that's just the beginning! Dive in to unlock the full potential of Git's branching and merging capabilities.

Git Remote Branches Tutorial: Push, Pull, and Track Changes

Table

Understanding Git Remote Branches: A Comprehensive Guide

What are Remote Branches in Git?

In Git, remote branches are essentially branches that exist in remote repositories. Think of a remote repository as a version of your project hosted on a different server, often used for collaboration, backup, or deployment. When you clone a repository from a service like GitHub or GitLab, Git automatically sets up a remote connection, typically named origin, pointing to that remote repository. Remote branches are references to the state of branches in these remote repositories. They are not directly checked out or worked on like your local branches. Instead, they serve as bookmarks to the branches on the remote server, allowing you to see the work of your collaborators and integrate their changes into your local repository.

These remote branches mirror the branches in the remote repository, providing a snapshot of the project's history and branch structure as it exists remotely. You can view these remote branches, compare them to your local branches, and use them as a basis for creating new local branches or merging changes. For instance, if a remote repository on origin has a branch named develop, you'll see a remote branch in your local repository, often represented as origin/develop. This origin/develop is your local reference to the develop branch on the origin remote. It gets updated when you fetch changes from the remote, keeping you informed about the remote branch's evolution.

Why Use Remote Branches in Git? [Collaboration, Backup, Feature Isolation]

Remote branches are fundamental to collaborative workflows in Git. They enable multiple developers to work on the same project without directly interfering with each other's work. Each developer can work on their local branches and then push these branches to the remote repository, making their changes accessible to the team. This collaborative aspect is crucial for team projects, allowing for parallel development and efficient code integration. Without remote branches, effective team-based version control would be significantly more challenging.

Beyond collaboration, remote branches also serve as a crucial backup mechanism. When you push your local branches to a remote repository, you are effectively creating a backup of your work on a separate server. This is vital for data security and disaster recovery. If your local machine fails or data is lost, the remote repository acts as a safe and accessible backup.

Furthermore, remote branches facilitate feature isolation. Teams can use branching strategies, like Gitflow, where feature branches are pushed to the remote, allowing for isolated development and review of new features before they are integrated into the main codebase. This isolation reduces the risk of introducing bugs into stable branches and streamlines the feature development process.

Pushing Local Branches to Remote Repositories

Preparing Your Local Branch for a Remote Push

Before pushing your local branch to a remote repository, it's essential to ensure your local branch is in a clean and ready state. The first step is to commit all your changes. Use git status to check for any unstaged or uncommitted changes. Stage any modified or new files using git add <filename> or git add . for all changes, and then commit them with a descriptive message using git commit -m "Your commit message". A clear commit history makes it easier for collaborators to understand the changes you are pushing.

Secondly, it's good practice to ensure your local branch is up-to-date with the remote branch you intend to push to, especially if you are working in a collaborative environment. Use git fetch origin to retrieve the latest changes from the origin remote without merging them into your local branch. Then, you can use git rebase origin/<branch_name> (if you prefer a clean, linear history) or git merge origin/<branch_name> (if you prefer to preserve merge commits) to integrate the remote changes into your local branch. Resolving any potential merge conflicts locally before pushing is crucial to ensure a smooth push process and avoid disrupting the remote repository's state.

The git push Command: Syntax and Options

The fundamental command for sending your local commits to a remote repository is git push. The basic syntax is git push <remote_name> <local_branch_name>:<remote_branch_name>. Here, <remote_name> is the name of the remote repository (typically origin), <local_branch_name> is the name of the branch you want to push from your local repository, and <remote_branch_name> is the name you want to give to the branch in the remote repository. If you want to push your local feature-branch to a remote branch also named feature-branch on origin, you can often simplify this to git push origin feature-branch. Git is smart enough to infer the remote branch name if it matches the local branch name.

One of the most commonly used and important options with git push is -u or --set-upstream. When you push a new local branch to a remote repository for the first time, using git push -u origin <branch_name> sets up upstream tracking. This means that your local branch is now configured to track the remote branch specified. Once upstream tracking is set, you can simply use git push and git pull without specifying the remote name and branch name in subsequent operations, as Git will remember the tracked remote branch. Other useful options include --force (use with extreme caution as it can overwrite remote changes) and --dry-run (to simulate a push without actually performing it, useful for previewing the push operation).

Pushing a New Local Branch to a Remote Repository: git push -u origin <branch_name>

Let's say you've created a new local branch called feature/login-form to develop a new login form for your web application. After committing your work on this branch, you want to push it to the remote repository so your team can review it and integrate it. To push this new branch to the origin remote and set up upstream tracking, you would use the command:

git push -u origin feature/login-form

In this command, git push initiates the push operation. -u or --set-upstream tells Git to establish a tracking connection between your local feature/login-form branch and the remote origin/feature/login-form branch. origin specifies the name of the remote repository you are pushing to, and feature/login-form is the name of your local branch that you want to push and also the name you want to give to the branch on the remote. After successfully executing this command, Git will output information about the push process, including the branches being pushed and any new commits. From this point forward, when you are on the feature/login-form branch, you can simply use git push to push further changes and git pull to fetch and merge changes from the remote origin/feature/login-form branch, simplifying your workflow.

Handling Push Errors: Troubleshooting Tips

Pushing to remote repositories isn't always seamless, and you might encounter errors. A common error is a "rejected push" due to "non-fast-forward updates". This typically happens when the remote branch has diverged from your local branch – meaning someone else has pushed changes to the remote branch after you last fetched. Git prevents a direct push in this scenario to avoid overwriting remote changes without your awareness. To resolve this, you must first fetch and integrate the remote changes into your local branch before pushing again. Use git pull origin <branch_name> to fetch and merge the remote changes. If there are merge conflicts, you'll need to resolve them locally, commit the resolved changes, and then retry the git push.

Another common issue is authentication failures. This can occur if your credentials are not correctly configured for the remote repository. Ensure you have correctly set up your SSH keys or have provided the correct username and password if using HTTPS. Check your remote repository settings and Git configuration to verify your authentication method. Firewall or network issues can also prevent successful pushes.

Ensure that your network connection is stable and that there are no firewall rules blocking Git's communication with the remote repository. If you are pushing large files, you might encounter errors related to repository size limits. Services like GitHub and GitLab have limits on file sizes and repository sizes. Consider using Git Large File Storage (LFS) for managing large files if needed, or ensure your repository size is within the limits.

Pulling Changes from Remote Branches: Staying Up-to-Date

The git pull Command: Updating Your Local Repository

The git pull command is your primary tool for retrieving and integrating changes from remote branches into your local repository. In essence, git pull is a convenience command that combines two operations: git fetch followed by git merge. It first fetches the latest changes from the specified remote branch and then automatically merges those changes into your current local branch. This keeps your local repository synchronized with the remote repository, ensuring you have the most recent code and updates from your collaborators.

When you execute git pull origin <branch_name>, Git will reach out to the origin remote, download any new commits from the specified <branch_name> that are not present in your local repository, and then attempt to merge these changes into your currently checked-out local branch. If your local branch is tracking a remote branch (upstream tracking is set), you can often simply use git pull without specifying the remote name and branch name. Git will automatically pull from the tracked remote branch. Regularly using git pull is crucial in collaborative workflows to stay synchronized with the team's progress and avoid working with outdated code, reducing the risk of merge conflicts and integration issues later on.

Pulling Specific Remote Branches

While git pull origin <branch_name> is used to update your local branch with changes from a corresponding remote branch, you might sometimes need to pull changes from a specific remote branch into a different local branch, or even just examine the remote branch's state without affecting your current branch. In such cases, you can explicitly specify both the remote branch and the local branch you want to merge into.

For example, if you are working on your feature/login-form branch and you want to incorporate the latest updates from the origin/develop branch into your current branch, you can use the command git pull origin develop. This command will fetch changes from the origin/develop branch and merge them into your currently active branch, which in this case is feature/login-form. Alternatively, if you simply want to inspect the changes in a remote branch without immediately merging them into your current branch, you can first fetch the changes using git fetch origin develop. This will update your local representation of the origin/develop branch (i.e., origin/develop). You can then examine these changes using git log origin/develop or compare them to your local branch using git diff feature/login-form origin/develop before deciding to merge or not.

Resolving Merge Conflicts During a Pull

Merge conflicts are a common occurrence when pulling changes from remote branches, especially in collaborative projects where multiple developers are working on the same files. A merge conflict arises when Git cannot automatically integrate changes from the remote branch into your local branch because there are overlapping modifications in the same lines of code. When a git pull results in merge conflicts, Git will pause the merge process and indicate the files with conflicts.

To resolve merge conflicts, you need to manually edit the conflicted files. Git inserts conflict markers into the files, typically denoted by <<<<<<<, =======, and >>>>>>>. The section between <<<<<<< HEAD and ======= represents your local changes, and the section between ======= and >>>>>>> origin/<branch_name> represents the changes from the remote branch. You need to carefully review these sections, decide which changes to keep, and edit the file to resolve the conflict. After resolving all conflicts in a file, you need to stage the file using git add <filename> to mark it as resolved. Once all conflicted files are staged, you can complete the merge process by running git commit. Git will automatically create a merge commit message. It's crucial to thoroughly test your code after resolving merge conflicts to ensure that the integration is correct and that no new issues have been introduced.

Git Fetch vs. Git Pull: Understanding the Difference

While both git fetch and git pull are used to retrieve changes from remote repositories, they operate differently and serve distinct purposes. The key difference lies in what happens after retrieving the changes. git fetch is solely focused on retrieving changes. When you run git fetch origin, Git contacts the origin remote and downloads any new commits and branch updates that your local repository doesn't have. Crucially, git fetch does not automatically merge these changes into your local working branches. It only updates your local remote-tracking branches (like origin/main, origin/develop). You can then inspect these fetched changes and decide how and when to integrate them.

On the other hand, git pull is a more aggressive command. As mentioned earlier, git pull is essentially a git fetch followed immediately by a git merge. When you run git pull origin <branch_name>, Git fetches the changes from the specified remote branch and then automatically attempts to merge those changes into your current local branch. This makes git pull a convenient way to quickly synchronize your local branch with its remote counterpart. However, this automatic merging can sometimes lead to unexpected merge conflicts if your local branch has diverged significantly from the remote branch. Therefore, git fetch provides more control and allows you to review changes before integrating them, while git pull is a quicker way to synchronize your local branch, but with the potential for immediate merge conflicts.

Tracking Remote Branches: Setting Upstream Tracking

What is Upstream Tracking in Git?

Upstream tracking in Git establishes a direct link between a local branch and a corresponding remote branch. When a local branch is set to track a remote branch, Git remembers this relationship and simplifies subsequent Git operations related to remote interaction. This tracking relationship is particularly beneficial when you frequently push and pull changes to and from a specific remote branch. It streamlines your workflow by reducing the need to repeatedly specify the remote name and branch name in commands.

Think of upstream tracking as setting a default "partner" for your local branch on the remote repository. Once set up, Git knows which remote branch your local branch is associated with. This simplifies commands like git push and git pull. Without upstream tracking, Git might not know where to push your local commits or from where to pull remote updates if you just use git push or git pull without specifying the remote and branch names. Upstream tracking makes these common operations more intuitive and less verbose, especially in collaborative projects where you are constantly interacting with remote repositories.

Setting Upstream Tracking with git branch --set-upstream-to

You can establish upstream tracking for a local branch using the command git branch --set-upstream-to=<remote_name>/<remote_branch_name> <local_branch_name>. Let's say you have a local branch named feature/new-api and you want to track the remote branch origin/feature/new-api. You would use the following command while being on the feature/new-api branch:

git branch --set-upstream-to=origin/feature/new-api feature/new-api

Alternatively, if you are already on the feature/new-api branch, you can shorten the command to:

git branch --set-upstream-to=origin/feature/new-api

Even shorter, when pushing a new local branch for the first time, as we saw earlier, using git push -u origin <branch_name> is a convenient way to both push the branch to the remote and set up upstream tracking in one step. Once upstream tracking is set, you can simply use git push and git pull from your feature/new-api branch without needing to specify origin feature/new-api each time. Git will automatically infer the remote and branch from the upstream tracking information.

Benefits of Tracking Remote Branches

Tracking remote branches offers several advantages that streamline your Git workflow, particularly when working with remote repositories frequently. Firstly, it simplifies push and pull operations. Once upstream tracking is set, you can use the concise commands git push and git pull without needing to specify the remote name and branch name each time. Git automatically knows the associated remote and branch from the tracking information. This reduces typing and makes your workflow more efficient.

Secondly, tracking remote branches provides helpful status information. Git uses tracking information to display the relationship between your local branch and its upstream remote branch. Commands like git status and git branch -v will show you if your local branch is ahead, behind, or diverged from its tracked remote branch. This information is invaluable for understanding the synchronization status of your branches and for making informed decisions about pushing and pulling changes. For example, if git status tells you your branch is ahead of origin/main by 3 commits, you know you have 3 local commits that need to be pushed to the remote.

Viewing Tracking Information: git branch -vv

To check the upstream tracking status of your local branches, you can use the command git branch -vv. This command lists your local branches along with detailed information, including their tracking status and the last commit on each branch. The -vv option (verbose verbose) provides extra output, specifically showing the upstream branch that each local branch is tracking, if any.

When you run git branch -vv, the output will show a list of your local branches. For each branch that is tracking a remote branch, you will see something like branch_name commit-hash [remote_name/remote_branch_name]: status. The status part is particularly useful. It will tell you if your local branch is ahead of, behind, or both ahead and behind the tracked remote branch. For example, you might see feature/login-form a1b2c3d [origin/feature/login-form]: ahead 2. This indicates that your feature/login-form branch is tracking origin/feature/login-form and is ahead by 2 commits, meaning you have two local commits that have not yet been pushed to the remote. If a branch is not tracking any remote branch, the tracking information in the output will be absent. This command is essential for quickly understanding the relationship between your local branches and their remote counterparts.

Working with Remote Branch Changes: Advanced Scenarios

Deleting Remote Branches: git push origin --delete <branch_name>

Sometimes, you need to delete remote branches, for example, after a feature branch has been merged into the main branch and is no longer needed. Deleting remote branches helps keep the remote repository clean and organized. You cannot directly delete a remote branch from your local repository. Instead, you use git push with a special syntax to instruct the remote repository to delete the branch.

The command to delete a remote branch is git push origin --delete <remote_branch_name>. For example, to delete the remote branch feature/login-form from the origin remote, you would use:

git push origin --delete feature/login-form

When you execute this command, Git sends a request to the origin remote to delete the feature/login-form branch. After successful deletion, the remote branch will no longer exist in the remote repository. It's important to ensure that you have the necessary permissions to delete branches on the remote repository. Also, be cautious when deleting remote branches, especially shared branches, as it can impact other collaborators who might be relying on that branch. It's generally good practice to communicate with your team before deleting shared remote branches.

Rebasing Local Branches Against Remote Branches [Careful Usage]

Rebasing a local branch against a remote branch is an advanced Git technique that can help maintain a cleaner, linear project history. Rebasing essentially replays your local branch's commits on top of the latest commits from the remote branch. This results in a commit history without merge commits, making the project history easier to follow. For example, if you have a local branch feature/branch and you want to rebase it onto the latest origin/main, you would first fetch the latest changes from origin/main using git fetch origin main. Then, while on your feature/branch, you would run git rebase origin/main.

However, rebasing against remote branches should be used with caution, especially in collaborative environments. Never rebase commits that have already been pushed to a shared remote branch. Rebasing rewrites commit history by creating new commits with different commit IDs. If you rebase commits that have already been pushed and shared, it can cause significant confusion and conflicts for your collaborators. Their local repositories will have a different history than the rewritten history on the remote, leading to problems when they try to pull or push changes. Rebasing is generally safer to use on local feature branches that have not yet been shared or pushed to a remote repository. If you are working collaboratively, it's often safer and simpler to use git merge to integrate changes from remote branches, as merging preserves the commit history and avoids the potential pitfalls of rewriting history.

Best Practices for Managing Git Remote Branches

Consistent Naming Conventions for Branches

Establishing and adhering to consistent naming conventions for your Git branches is crucial for project organization and team collaboration. Well-defined naming conventions make it easier to understand the purpose and context of each branch. A common practice is to use prefixes to categorize branches based on their type. For example, feature/ for feature branches (e.g., feature/user-authentication, feature/payment-gateway), bugfix/ or fix/ for bug fixes (e.g., bugfix/login-error, fix/typo-in-header), release/ for release branches (e.g., release/v1.2.0), and hotfix/ for hotfix branches (e.g., hotfix/security-vulnerability).

Using hyphens or underscores to separate words within branch names improves readability (e.g., feature/add-user-profile instead of feature/adduserprofile). Keep branch names concise and descriptive. Avoid overly long or ambiguous names. Document your team's branch naming conventions and ensure that all team members follow them consistently. This practice significantly improves branch management, makes it easier to search and filter branches, and enhances overall team communication regarding branching strategies.

Regular Updates from Remote Repositories

In a collaborative Git workflow, regularly updating your local repository with changes from remote repositories is essential to stay synchronized with your team's progress and prevent integration issues. Make it a habit to frequently use git fetch or git pull to retrieve the latest changes from remote branches, especially before starting new work or before pushing your own changes. How often you should update depends on the pace of development and the frequency of changes in your project. In active projects with multiple contributors, updating multiple times a day might be necessary.

Regularly pulling changes helps to minimize merge conflicts by integrating changes frequently and in smaller increments. It also ensures that you are always working with the latest codebase, reducing the risk of building features or fixing bugs on outdated code. Setting up reminders or incorporating update steps into your workflow (e.g., updating before starting each coding session, before creating a pull request) can help ensure consistent updates from remote repositories.

Code Review Workflow with Remote Branches

Remote branches are integral to effective code review workflows in Git. Branching strategies like Gitflow and GitHub Flow heavily rely on remote branches to facilitate code review processes. Typically, when a developer completes a feature or bug fix on a local branch, they push this branch to a remote repository. This remote branch then becomes the basis for a code review. On platforms like GitHub, GitLab, or Bitbucket, developers create "Pull Requests" or "Merge Requests" targeting a main integration branch (like main or develop) from their feature or bugfix remote branch.

The pull request serves as a request to merge the changes from the feature branch into the target branch. It also initiates the code review process. Team members can review the code changes in the pull request, provide feedback, suggest modifications, and discuss the implementation.

Once the code review is completed and approved, the pull request can be merged, integrating the changes into the main branch. This workflow ensures that all code changes are reviewed by peers before being integrated into the main codebase, improving code quality, reducing bugs, and promoting knowledge sharing within the team. Remote branches are the foundation for enabling this structured and collaborative code review process.

Proper Branch Management Strategies [Gitflow, GitHub Flow]

Effective branch management strategies are crucial for maintaining a well-organized and efficient Git repository, especially in team environments. Two popular branching strategies that heavily rely on remote branches are Gitflow and GitHub Flow. Gitflow is a more comprehensive branching model designed for managing larger projects with scheduled releases. It defines specific branch types like main, develop, feature, release, and hotfix branches, all of which are typically remote branches in a shared repository. Gitflow uses remote feature branches for developing new features, remote release branches for preparing releases, and remote hotfix branches for addressing urgent issues in production.

GitHub Flow is a simpler, more streamlined branching strategy often favored for continuous delivery workflows. It typically involves a single main branch and feature branches. All feature development is done in feature branches that branch off from main. Once a feature is complete, a pull request is created from the feature branch to merge into main. After review and merge, the code in main is deployed. Both Gitflow and GitHub Flow, along with other branching strategies, rely on remote branches as the central point of collaboration and integration. Remote branches enable teams to isolate development efforts, facilitate code review, manage releases, and maintain a clear and organized project history, regardless of the specific branching strategy employed.

Git Remote Branch Commands: Quick Reference Guide

git push: Pushing local changes to a remote branch

git push origin <branch_name>       # Push local branch to remote
git push -u origin <branch_name>    # Push and set upstream tracking
git push                           # Push to tracked remote branch

Sends local commits to a remote branch. -u sets up upstream tracking for simpler future pushes and pulls.

git pull: Pulling changes from a remote branch

git pull origin <branch_name>       # Pull from remote branch to local branch
git pull                           # Pull from tracked remote branch

Fetches and merges changes from a remote branch into the current local branch.

git fetch: Fetching remote branch information without merging

git fetch origin                   # Fetch all remote branches from origin
git fetch origin <branch_name>       # Fetch a specific remote branch

Retrieves changes from a remote repository without automatically merging them. Updates remote-tracking branches.

git branch --set-upstream-to: Setting up tracking for a local branch

git branch --set-upstream-to=origin/<remote_branch_name> <local_branch_name>
git branch --set-upstream-to=origin/<remote_branch_name> # When on <local_branch_name>

Establishes a tracking relationship between a local branch and a remote branch, simplifying push and pull operations.

git remote: Managing remote repositories

git remote -v                      # List configured remote repositories
git remote add <name> <url>        # Add a new remote repository
git remote remove <name>           # Remove a remote repository

Manages remote repository connections, allowing you to list, add, or remove remote repository configurations. Useful for working with multiple remotes.

Frequently Asked Questions

What is a Git remote branch and why is it important?

A Git remote branch is a reference to a branch on a remote repository, like GitHub. It's important because it allows you to track changes made by others and collaborate effectively.

How do I push a local branch to a remote repository?

You can push a local branch to a remote using the command git push <remote> <local_branch>. This will upload your local branch to the specified remote repository and create it if it doesn't exist.

How do I fetch and track a remote branch that someone else has created?

You can fetch the remote branch using git fetch <remote>. Then, create a local tracking branch with git checkout -b <local_branch_name> <remote>/<remote_branch_name>, which associates your local branch with the remote one.

What's the difference between git fetch and git pull when working with remote branches?

git fetch only downloads the remote branch information and objects, without merging them into your local branch. git pull, on the other hand, fetches and automatically merges the changes into your current branch.

How do I delete a remote branch?

You can delete a remote branch using the command git push <remote> --delete <remote_branch_name>. This command removes the branch from the remote repository.

Final Reflection: Mastering the Art of Collaborative Code

The ability to effectively manage remote branches in Git is no longer just a technical skill; it's the cornerstone of modern collaborative software development. In a world increasingly reliant on distributed teams and asynchronous workflows, understanding how to push, pull, and track changes across remote repositories is paramount to maintaining project integrity and fostering seamless teamwork.

The impact of Git and its branching model on the software landscape is undeniable. It has democratized code contribution, allowing developers from all corners of the globe to collaborate on projects of any scale. This power, however, comes with the responsibility of mastering the tools and techniques that enable effective collaboration. Version control is not just about backing up code; it's about enabling collaboration and innovation. This quote underscores the profound influence Git has had on shaping how we build software today, and the importance of understanding its intricacies.

As you navigate the complex world of Git, remember that each push, pull, and tracking operation is a step towards building something bigger than yourself. Embrace the power of remote branches, not just as a technical tool, but as a bridge connecting you to a global community of creators. Take the knowledge you've gained and apply it to your projects, your teams, and your career. The future of software development is collaborative, and your mastery of Git will be your key to unlocking its full potential.

Alright, here's a CTA tailored for an article titled "Working with Remote Branches in Git: Push, Pull, and Track Changes," targeting readers of GitAndVersionControlHub.com:

Unleash Your Git Power!

Thank you for delving into the world of remote branches with us! We hope you've gained valuable insights into streamlining your Git workflow and mastering collaboration. Now, let's put that knowledge into action.

Here's how you can take your Git skills to the next level:

  • Immediately try pushing a local branch to a remote repository to practice what you've learned! This is the best way to solidify your understanding.
  • Explore creating and tracking a new remote branch in a sample project. Experimenting is key to mastery!
  • Share this article with your fellow developers! Spread the Git knowledge and help your team improve their workflow.

What's one command you'll use today to better manage your remote branches? Share your experience in the comments below!


Olivia Beckett

Olivia Beckett is a highly sought-after DevOps engineer recognized for her specialization in Git-centric workflows. With a focus on enhancing team productivity and code integrity, Olivia excels at designing and implementing efficient branching strategies tailored to diverse project needs. Her expertise extends to the often-challenging domain of merge conflict resolution, where she guides teams through practical techniques and strategic approaches to minimize disruptions and maintain workflow continuity. Olivia is a strong advocate for structured Git methodologies, offering insightful tutorials and workshops on Git Flow, feature branching, and collaborative best practices that empower development teams to work harmoniously and deliver high-quality software.

Go up