DEV Community: Jawad Hayat

Looking to Contribute to Open Source Startups Using .NET and Angular

Jawad Hayat — Fri, 05 Jul 2024 04:23:31 +0000

Hi everyone,

I'm Jawad, a junior software engineer with a passion for .NET and Angular. With 3 years of experience in machine learning, app support, and .NET development, I'm eager to contribute to open source startups.

I'm looking for startups using .NET and Angular to contribute to and grow my skills. Any recommendations?

Thanks!

7 strategies to master git reset:

Jawad Hayat — Thu, 04 Jul 2024 10:32:52 +0000

1. Understand the Basics

Grasp what git reset does.

It changes the state of your repository.

It can move the HEAD, change the index, and adjust the working directory.

2. Use --soft for Safe Resets

When you use git reset --soft, it keeps changes in the index.

This is perfect for undoing commits but keeping your changes staged.

3. Apply --mixed for Moderate Resets

The default git reset --mixed keeps changes in your working directory but unstages them.

This helps when you want to edit your changes before committing again.

4. Go Hard with --hard

git reset --hard wipes changes from the index and working directory.

Use this only when you are sure you want to discard all local changes.

5. Reset to a Specific Commit

Point to a specific commit by using git reset .

This rewinds your repository to that commit, making it easy to undo mistakes.

6. Be Cautious with Branches

Always ensure you're on the correct branch before resetting.

Resetting the wrong branch can cause loss of important work.

7. Combine with git reflog

Use git reflog to view the history of HEAD changes.

It helps you recover commits after a reset, ensuring you don't lose valuable work.

Mastering git reset can save you from many headaches.

Use these strategies to handle your repository with confidence.

Mastering Common Git Commands: A Developer's Guide

Jawad Hayat — Wed, 03 Jul 2024 10:59:07 +0000

As developers, we often interact with version control systems, and Git is one of the most popular tools out there. Whether you’re just starting out or looking to brush up on your Git skills, this guide covers some of the most common Git commands you’ll use in your day-to-day development work.

1. git init

git init

The git init command initializes a new Git repository. This is the first step to start tracking a project with Git.

2. git clone

git clone <repository-url>

git clone is used to copy an existing Git repository from a remote server to your local machine. It’s typically the first command you run when starting to work on an existing project.

3. git status

git status

The git status command shows the current state of the working directory and staging area. It lets you see which changes have been staged, which haven’t, and which files aren’t being tracked by Git.

4. git add

git add <file>
git add .

git add stages changes to be included in the next commit. Use git add <file> to stage a specific file or git add . to stage all changes in the directory.

5. git commit

git commit -m "Your commit message"

The git commit command captures a snapshot of the project’s currently staged changes. The -m option allows you to add a commit message directly from the command line.

6. git push

git push <remote> <branch>

git push uploads your local commits to the remote repository. Typically, the remote repository is named origin, and the main branch is named main or master.

7. git pull

git pull <remote> <branch>

git pull updates your local repository with changes from the remote repository. It’s a combination of git fetch (which downloads new data) and git merge (which integrates that data).

8. git branch

git branch
git branch <branch-name>

git branch is used to list, create, or delete branches. Running git branch without arguments lists all local branches in the current repository. Use git branch <branch-name> to create a new branch.

9. git checkout

git checkout <branch-name>

git checkout is used to switch between branches in your repository. It updates the files in the working directory to match the version stored in that branch.

10. git merge

git merge <branch-name>

git merge integrates changes from one branch into the current branch. This command is crucial for combining the work done in different branches.

11. git log

git log

The git log command shows the commit history for the repository. It’s a great way to review changes and understand the project’s development history.

12. git stash

git stash
git stash pop

git stash temporarily shelves changes you’ve made to your working directory so you can work on something else. git stash pop restores the stashed changes.

Conclusion

Mastering these Git commands will significantly enhance your productivity and version control practices. Git is a powerful tool, and knowing how to use it effectively is a crucial skill for any developer. Practice these commands, and soon you'll handle Git with ease and confidence.

Happy coding!

My Learning Journey in CI/CD with Local IIS Server

Jawad Hayat — Tue, 02 Jul 2024 07:57:29 +0000

As a backend developer, I recently dived into the world of CI/CD while working with Angular. Here’s a quick overview of my process:

1. Create a Web API Project: Started with a new project and pushed the code to a GitHub repo.
2. Configure GitHub Actions: Set up the .NET build and test action by creating a workflow directory and a YAML file in .github.
3. Set Up Self-Hosted Runner:

Configured a new runner in GitHub Actions settings.
Ran provided commands in PowerShell as an administrator to set up the runner locally.
Verified the runner is working correctly in GitHub Actions settings. 4. Test the Configuration: Pushed changes to the master branch to ensure the jobs run successfully. 5. Install IIS Server: Created a website and bound it to a physical path on my PC. 6. Publish and Deploy Logic: Updated the YAML file for publishing and deploying to IIS.

Here’s the YAML script I used:

name: .NET

on:
 push:
 branches: [ "master" ]
 pull_request:
 branches: [ "master" ]

jobs:
 build-and-deploy:

 runs-on: self-hosted

 steps:
 - uses: actions/checkout@v4
 - name: Restore dependencies
 run: dotnet restore
 - name: Build
 run: dotnet build --no-restore
 - name: Test
 run: dotnet test --no-build --verbosity normal
 - name: Publish
 run: dotnet publish -c Debug -o dotnetcorewebapp .
 - name: Stop IIS
 run: iisreset /stop
 - name: Deploy to IIS
 run: Copy-Item -Path {Your Path}\* -Destination {Your Path} -Recurse -Force
 - name: List files in IIS
 run: Get-ChildItem -Path {Your Path} -Recurse
 - name: Start IIS
 run: iisreset /start

This journey has been a fantastic learning experience, enhancing my skills in automation and deployment. Looking forward to more such explorations!

Implementing Hangfire in .NET: A Beginner's Guide

Jawad Hayat — Mon, 01 Jul 2024 11:03:29 +0000

Introduction
Recently, I delved into the world of Hangfire, an open-source library that simplifies the process of scheduling and executing background tasks in .NET applications. Hangfire allows developers to run tasks in the background, ensuring that the main application remains responsive and efficient. In this post, I’ll share my experience and provide a step-by-step guide on implementing Hangfire in your .NET projects.

What is Hangfire?
Hangfire is a .NET library that provides a simple and reliable way to perform background processing in your applications. It offers features like:

Background task processing
Delayed and recurring jobs
Monitoring and dashboard capabilities

Step 1: Install Hangfire

Install-Package Hangfire

Step 2: Configure Hangfire

builder.Services.AddHangfire(config =>
{
    config.UseSqlServerStorage(builder.Configuration.GetConnectionString("DefaultConnection")); // Use your preferred storage here
});
builder.Services.AddHangfireServer();


// Map Hangfire Dashboard
app.UseHangfireDashboard();

Step 3: Creating Background Jobs

[HttpGet]
[Route("FireAndForgetJob")]
public ActionResult CreateFireAndForgetJob()
{
    BackgroundJob.Enqueue<TestJob>(x => x.WriteLog("Fire-and-Forget Job"));
    //BackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-Forget Job"));
    return Ok();
}

Step 4: Delayed and Recurring Jobs

[HttpGet]
[Route("DelayJob")]
public ActionResult CreateDelayJob()
{
    var scheduleDateTime = DateTime.UtcNow.AddSeconds(5);
    var dateTimeOffset = new DateTimeOffset(scheduleDateTime);
    BackgroundJob.Schedule<TestJob>(x => x.WriteLog("Delay-and-Schedule Job"), dateTimeOffset);
    //BackgroundJob.Schedule(() => Console.WriteLine("Delay-and-Schedule Job"),dateTimeOffset);
    return Ok();
}
[HttpGet]
[Route("ContinuationJob")]
public ActionResult CreateContinuationJob()
{
    var scheduleDateTime = DateTime.UtcNow.AddSeconds(5);
    var dateTimeOffset = new DateTimeOffset(scheduleDateTime);
    var jobID = BackgroundJob.Schedule<TestJob>(x => x.WriteLog("Delay-and-Schedule 2nd Job"), dateTimeOffset);
    //var jobID = BackgroundJob.Schedule(() => Console.WriteLine("Delay-and-Schedule 2nd Job"), dateTimeOffset);

    var job2ID = BackgroundJob.ContinueJobWith<TestJob>(jobID, x => x.WriteLog("ContinuationJob1 triggered"));
    var job3ID = BackgroundJob.ContinueJobWith<TestJob>(job2ID, x => x.WriteLog("ContinuationJob2 triggered"));
    var job4ID = BackgroundJob.ContinueJobWith<TestJob>(job3ID, x => x.WriteLog("ContinuationJob3 triggered"));
    return Ok();
}
[HttpGet]
[Route("RecurringJob")]
public ActionResult CreateRecurringJob()
{
    RecurringJob.AddOrUpdate<TestJob>("RecurringJob1", x => x.WriteLog("RecurringJob triggered"), "* * * * *");
    return Ok();
}

Step 5: Monitoring Jobs
Hangfire comes with a built-in dashboard that allows you to monitor the status of your background jobs. You can access the dashboard by navigating to /hangfire in your browser.

Conclusion
Hangfire makes it incredibly easy to add background processing to your .NET applications. Its simplicity and powerful features can significantly enhance the performance and responsiveness of your applications. By following the steps outlined in this guide, you can quickly get started with Hangfire and start leveraging its capabilities in your projects.