GIT

DKN

Streamlining Power Platform ALM with Native Dataverse Git Integration

Managing the application lifecycle in Power Platform has always involved balancing the needs of citizen developers, professional developers, and IT administrators. With the introduction of native Git integration in Dataverse, Microsoft has significantly simplified this process — making source control accessible to the entire team without requiring deep DevOps expertise.

What Is Dataverse Git Integration?

Dataverse Git integration allows development teams to synchronize solutions and solution objects across one or more Microsoft Dataverse environments using a supported Git provider such as Azure DevOps or GitHub. The integration is built natively into the solutions experience in Power Apps (make.powerapps.com), meaning makers can interact with source control directly through familiar interfaces — no extra tooling required.

The core recommendation: use Git integration with developer environments only. Use build pipelines to create solution artifacts, and use Pipelines in Power Platform to handle deployments to test and production.

ALM in Power Platform — The Bigger Picture

Power Platform already includes robust out-of-the-box ALM capabilities: solutions as containers for platform objects, environment management, and deployment via pipelines. Git integration takes this further by providing a streamlined, native path to version control — one that works for both makers and developers alike.

Key Benefits of Using Git Integration

  • Source Control as the Source of Truth: Previously, many organizations relied on maker environments as the de facto source of truth simply because non-native Git integration required specialized IT skills to set up. Native Git integration removes that barrier — it can be enabled in just a few steps and offers a familiar interface for all team members.
  • Safety, Auditing, and Compliance: By adopting Git integration, teams automatically follow Software Development Lifecycle (SDLC) best practices. This includes version control, code reviews, and static analysis — all contributing to higher quality, more reliable, and more secure solutions. Traceability and audit trails are built in, helping teams meet compliance requirements.
  • Short-Lived Development Environments: Because your environment’s customizations and configurations are stored in source control, you can spin up new development environments quickly and tear them down just as fast. This reduces storage overhead, encourages experimentation, and enables faster iteration cycles.
  • Fusion Development Teams: Teams that blend low-code makers and professional developers (“fusion teams”) benefit enormously. Each contributor can work independently in their own environment and collaborate by syncing to a shared repository — enabling parallel development without stepping on each other’s work.
  • Protection and Recovery: Storing solutions in source control provides a reliable safety net. If unintended changes occur in an environment, you can quickly restore to any previous version.

Key Concepts to Understand

Unmanaged vs. Managed Solutions

Solutions stored in source control originate from unmanaged solutions in a maker’s environment. Makers can freely add, remove, and update objects that sync to source control when committed. Managed solutions, on the other hand, are built from source control and deployed into downstream environments (test, production) where they cannot be directly edited. This separation ensures source control remains the single source of truth and that all changes flow through the proper channels.

File Formatting for Solution Objects

Git integration introduces a new, human-readable file format for solution objects stored in source control. This format makes it easier to review changes over time. A key improvement: solution objects are no longer duplicated per solution — instead, they’re stored once and can be shared across multiple solutions in the same repository and folder, reducing redundancy.

Code-First Development with Git

Power Platform supports both low-code and code-first development paths. Code-first developers using tools like the Power Platform CLI, Visual Studio, and VS Code extensions can now be fully integrated into the same Git workflow as low-code makers.

Without Git integration, managing code-first objects like Power Apps component framework (PCF) controls and Dataverse plug-ins was difficult — these objects are deployed as compiled assets and aren’t directly editable in the maker portal. Git integration bridges this gap, giving code-first developers a native home in the workflow.

Best Practice: Build Process for Code-First Objects

When code-first objects (such as plug-ins or PCF controls) are deployed directly to an unmanaged solution and then committed to source control, only the compiled (binary) version is stored — not the source code. This can lead to two versions of the same object in the repository, causing confusion and potential drift.

The recommended approach is to build code-first objects through a formal solution build process and import the generated unmanaged solution into the maker environment. This keeps source code as the single source of truth and the built artifacts in sync. You can automate this with Azure Pipelines or GitHub Actions workflows that generate artifacts for use in Power Platform pipelines and Git sync processes.

Getting Started

If your organization is looking to modernize its Power Platform ALM practices, native Dataverse Git integration is a compelling starting point. It lowers the barrier to entry for source control adoption, supports both makers and developers, and integrates naturally with existing Azure DevOps or GitHub workflows.

To dive deeper, check out the official Microsoft documentation on Dataverse Git Integration Overview, and explore how Azure DevOps and GitHub repositories can supercharge your team’s delivery process.

Source: Microsoft Learn — Power Platform ALM documentation

DKN

Upgrade the GitHub CLI

Step 1: Check Your Current Version

Before upgrading, it’s helpful to know which version you are currently running. Open your terminal and type:

Bash

gh --version

If you see a version number and a notification that a newer version is available, it’s time to update!

Step 2: Upgrade Based on Your OS

macOS

If you installed GitHub CLI using Homebrew (the most common method for Mac users), upgrading is a simple one-liner:

Bash

brew upgrade gh

Windows

On Windows, your upgrade path depends on how you originally installed it:

  • WinGet:PowerShellwinget upgrade --id GitHub.cli
  • Chocolatey:PowerShellchoco upgrade gh
  • Scoop:PowerShellscoop update gh
  • MSI Installer: If you used the .msi installer, simply download the latest version from the official releases page and run it; it will overwrite the old version.

Linux

For Linux users, you’ll typically use your package manager.

  • Ubuntu / Debian / Raspberry Pi OS:Bashsudo apt update sudo apt install gh
  • Fedora / CentOS:Bashsudo dnf upgrade gh
  • Arch Linux:Bashsudo pacman -Syu github-cli

Step 3: Verify the Upgrade

Once the process finishes, verify that you are on the latest version by running the version command again:

Bash

gh --version

Bonus: Keeping Authenticated

Upgrading shouldn’t affect your login status, but if you ever run into permission issues after an update, you can re-authenticate easily:

Bash

gh auth login

DKN

Git hub co pilot – A simple Introduction

Git Hub Copilot: A Simple Introduction

If you’re a software developer, chances are you’ve heard of GitHub and its ecosystem of tools and services. Recently, GitHub introduced Copilot, a powerful new feature that aims to change the way developers write code. In this blog post, we’ll explore what GitHub Copilot is, how it works, and what benefits it offers to the development community.

What is GitHub Copilot?

GitHub Copilot is an AI-powered pair programmer developed by GitHub and Microsoft. It suggests code snippets as you type, helping you to write more efficient and elegant code. The idea behind Copilot is to assist developers in their coding process by automating repetitive tasks and providing insights that can enhance the overall quality of the codebase.

How Does Copilot Work?

Copilot operates by analyzing the code in your repository and the vast amount of open-source code available on GitHub. It then uses this information to generate relevant code suggestions based on the context of your current work. The suggestions are dynamically updated as you code, offering real-time assistance throughout your development process.

Key Features

  • Code Completion: Copilot predicts and suggests code as you type, saving you time and effort.
  • Contextual Suggestions: The suggestions are contextually relevant, making them more useful and applicable to your specific coding situation.
  • Integration: Copilot integrates seamlessly with GitHub and Visual Studio Code, making it easy to use alongside your existing tools.
  • Customization: You can control the suggestions and fine-tune the AI to better suit your coding style.

Benefits of Using GitHub Copilot

  1. Enhanced Productivity: By automating the generation of code snippets, Copilot allows developers to focus more on the high-level logic of their applications rather than the minutiae.
  2. Code Quality: Copilot suggests well-structured and optimized code, which can lead to a more maintainable and efficient codebase.
  3. Learning Opportunities: For beginners or those looking to improve their coding skills, Copilot can provide valuable insights and examples.
  4. Collaborative Coding: Copilot can be used in pair programming scenarios, where multiple developers can work together on a codebase, improving the overall quality of the code.

Getting Started with GitHub Copilot

To start using Copilot, you’ll need to sign up for a GitHub account and install the GitHub desktop app or integrate it with Visual Studio Code. Once set up, simply open your repository and start coding. Copilot will begin offering suggestions as you type.

Tips for Using Copilot Effectively

  • Experiment with Suggestions: Try accepting and integrating Copilot’s suggestions to see how they fit into your code.
  • Customize Settings: Adjust Copilot’s preferences to better align with your coding style and preferences.
  • Review and Modify: While Copilot can save time, always review and modify the suggested code to ensure it meets your project’s requirements.

Conclusion

GitHub Copilot is a fascinating tool that leverages AI to assist developers in their coding journey. By providing real-time code suggestions and insights, Copilot can significantly enhance productivity and code quality. Whether you’re a seasoned developer or just starting out, Copilot is worth exploring to see how it can benefit your projects.

Are you ready to try GitHub Copilot? Sign up for a GitHub account and give it a go. Who knows, it might just change the way you write code!

DKN

Adding a Local Repository to GitHub Using GitHub CLI

 Create a new repository with GitHub CLI

  • Use the gh repo create command to create a repository for your project directly from the command line.
  • When prompted, choose “Push an existing local repository to GitHub” and enter your preferred repository name.
  • If you want the project to be created under an organization rather than your personal account, specify it as:gh repo create ORGANIZATION-NAME/PROJECT-NAME
  • Follow the interactive prompts
    • The CLI will guide you through setup options.
    • When asked whether to add the remote and push commits to your current branch, select Yes to complete the setup.
  • Skip prompts with command flags (optional)
    • To automate the process, include flags directly in your command:gh repo create --source=. --public --remote=origin --push
    • Here’s what each flag does:
      • --source=. → Uses your current directory as the repository source.
      • --public, --private, or --internal → Sets repository visibility.
      • --remote → Specifies the remote name (commonly origin).
      • --push → Pushes all existing commits to GitHub automatically.
  • Learn more
    • See the official GitHub CLI Manual for additional flags, examples, and usage tips.
DKN

Adding a local repository to GitHub using Git

🚀 Steps to Add a Local Repository to GitHub Using Git

  • Authenticate to GitHub on the command line
  • Create a new repository on GitHub
  • Copy the remote repository URL
    • On the repository’s Quick Setup page, click the copy icon next to the URL to copy it to your clipboard.
    • (You’ll use this URL in the next command.)
  • Open Git Bash
  • Navigate to your local project directory
    • Use the cd command to switch to the folder containing your local repository.cd path/to/your/project
  • Add the remote repository URL
    • Run the following command to link your local repo to the remote GitHub repo:git remote add origin REMOTE-URL
    • Replace REMOTE-URL with the actual GitHub repository URL you copied earlier.
    • More info: Managing remote repositories
  • Verify the remote connection
    • Confirm that the remote URL is set correctly by running:git remote -v
  • Push your local repository to GitHub
    • Upload your local files to the GitHub repository using:git push origin main
    • If your default branch is named something other than main (e.g., master or dev), replace main with your branch name.
    • Learn more: About branches
DKN

Clone a particular repo within a github org

The following post outlines a scenario where you need to clone a repo within a github organization .
To clone a repo you use
git clone https://github.com/YOUR-ORGANIZATION/REPO-NAME
however if you use it for a repo that resides within an organization , as of date you will end up with an error :
fatal: repository ‘https ://github.com/ORGNAME/REPO-Name.git/’ not found
The solution is to use the following comand
git clone https://username@github.com/YOUR-ORGANIZATION/REPO-NAME.git
You’ll be prompted to enter your password or token
Hope this helps someone who faces this issue .

DKN

Update Git on Windows

Upgrading Git on Windows: A Step-by-Step Guide

Git is an essential tool for developers, providing a robust version control system that is integral to modern software development. Keeping Git up-to-date ensures access to the latest features, improvements, and security patches. For Windows users, upgrading Git can be done through the command line with relative ease. Here’s a step-by-step guide to help you ensure your Git installation is current.

Step 1: Check Your Current Git Version

Before upgrading, it’s important to know which version of Git you’re currently running. Open Command Prompt or PowerShell and enter the following command:

git --version

This will display the version number of your installed Git.

Step 2: Update Git

The command to update Git on Windows depends on your current version. If you’re running a version between 2.14.2 and 2.16.1, use:

git update

For versions later than 2.16.1, the command changes to:

git update-git-for-windows

Running the appropriate command will either update your Git installation or inform you that you’re already using the latest version.

Step 3: Verify the Update

After running the update command, it’s a good practice to verify that the update was successful. Use the same command as in Step 1 to check your Git version again:

git --version

If the version number has changed, congratulations, you’ve successfully updated Git on your Windows machine!

Troubleshooting

If you encounter any issues or if your version of Git is older than 2.14.2, you may need to manually download the latest installer from Git’s official website and run it just like you would for a fresh installation.

By following these steps, you can keep your Git installation up-to-date and maintain a smooth workflow. Remember, staying current with software updates is not only about having the latest features but also about ensuring the security and efficiency of your development environment. Happy coding!

DKN

Git basics

Git Force Pull (ignore Local Changes)

For situations where we would like to ignore the local changes made to local git repo and just want to override it with the Remote upstream branch

when you run Git pull origin main For e.g
error: Your local changes to the following files would be overwritten by merge:Filename.txt
Please commit your changes or stash them before you merge.
Aborting

Solution :
Execute the Following :
git reset –hard HEAD (Note : it is double dash – -hard “
git pull origin main

Difference between git clone and git fork

git clone : Downloads a copy of a GitHub repo to your local machine .

git fork : Creates a copy of the Github repo to your git hub account . you can then clone this fork locallly and submit changes to the forked remote repo and also you may submit a pull request to the original repository owner to merge your changes if you intend to contribute to the original repo .