5 Essential Cybersecurity Practices Every Software Developer Must Follow

 With cyber threats evolving rapidly, security can no longer be an afterthought handled solely by the IT or operations team. Security must start in the IDE—a concept known as **Shift-Left Security**.

Here are five essential practices every developer must implement:

1. Never Hardcode Secrets:

Always use environment variables or secure secret managers (like AWS Secrets Manager or HashiCorp Vault) for API keys, database credentials, and tokens.

2. Automate Dependency Scanning:

 Integrate tools like Snyk or GitHub Dependabot to catch vulnerabilities in third-party libraries before they hit production.

3. Implement Strict Input Validation:

 Never trust user input. Sanitize and validate all incoming data on both the client and server sides to prevent SQL injection and XSS attacks.

4. Enforce the Principle of Least Privilege:

 Ensure that microservices, database accounts, and internal APIs only have access to the exact resources they need to function—nothing more.

5. Regular Code Reviews and SAST:

 Use Static Application Security Testing (SAST) tools to scan your codebase automatically during your CI/CD pipeline builds.

Cheers,

Samitha

How to Fix Excel Dates Copying Incorrectly into SSMS (SQL Server Management Studio)

 If you have ever tried copying date cells straight from Excel into SQL Server Management Studio (SSMS) and ended up with weird numbers or import errors, you are not alone.

When you copy standard date cells, Excel places both the formatted view and the raw serial number onto your system clipboard. SSMS often captures that raw serial number instead of the actual date string, causing formatting conflicts.

Here is a quick, foolproof workaround to ensure your dates paste correctly every single time.

The Solution: Use Excel's TEXT Function

To force SSMS to accept your data as a proper date during a direct copy-and-paste, you need to convert the dates into a clean text format in Excel first.

1. Create a temporary helper column next to your original data. Use the TEXT function to convert the date into standard ISO format (YYYY-MM-DD). For example, if your original date is in cell A2, enter this formula in your helper column:

Excel

=TEXT(A2, "yyyy-mm-dd")

Drag this formula down for all rows, then copy these new text-formatted values (and **Copy > Paste Values** if you want to strip the formulas).

2. Verify the destination column type:

In SQL Server Management Studio, make sure the target column type is explicitly set to `DATE` or `DATETIME` (and not `INT` or `FLOAT`). If the column is numeric, SSMS will force the pasted text back into a number.

3. Paste the data into the SSMS grid:

•  Right-click your table in SSMS and select **Edit Top 200 Rows**.
• Scroll down to the bottom, empty row marked with an asterisk (`*`).
• Click the row selector header on the far left, and press `Ctrl + V` to paste.

Verification: Click away from the pasted row to commit the changes. The dates should save successfully as `YYYY-MM-DD` calendar dates instead of numbers.

Cheers,

Samitha

GitHub Copilot vs. Cursor AI: Which Coding Assistant Wins in 2026?

Artificial Intelligence has completely revolutionized how we write code. Gone are the days of manually looking up syntax or boilerplate templates. Today, developers have powerful AI tools integrated right into their workflows. Two names dominate the landscape: **GitHub Copilot** and **Cursor AI**.

Let’s break down how they compare:

GitHub Copilot:

The pioneer of mainstream AI code completion. It integrates seamlessly as an extension into VS Code, JetBrains, and other IDEs. It excels at inline code suggestions and multi-file context understanding.

Cursor AI:

A standalone fork of VS Code built from the ground up specifically for AI pair programming. Features like deep codebase indexing, the "Composer" mode for multi-file edits, and chat panels make it feel like a true co-pilot rather than just an autocomplete tool.

Which one should you choose? 

If you love your current IDE setup and want reliable, fast inline suggestions, GitHub Copilot is a safe bet. If you want a deeper, conversational workflow that can refactor your entire project structure automatically, Cursor AI currently takes the crown for raw innovation.

Cheers

Samitha

How to Exclude the Docs Folder from MSBuild and Static Web Assets in .NET

 If you are managing a .NET solution where documentation files reside in a root-level docs folder, you might run into issues where MSBuild or static web assets unnecessarily scan, compile, or include these files in your build output.

You can easily prevent this by adding a targeted MSBuild configuration to your project file (.csproj).

The MSBuild Snippet

Add the following <ItemGroup> snippet directly into your project's .csproj file:

<ItemGroup>
     <!-- Prevent static web assets and MSBuild from scanning the docs folder -->
     <Content Remove="..\..\docs\**" />
     <None Include="..\..\docs\**" />
</ItemGroup>

Why Use This?

• Content Remove: Stops MSBuild from treating the files inside the parent docs directory as web content or publishable assets.

• None Include: Ensures that while the files are ignored by build pipelines and static asset scanners, they still remain visible within your solution explorer (depending on your IDE settings) without triggering build actions.

• Path Traversal (..\..\): Adjust the number of ..\ segments depending on how deep your .csproj file is nested relative to the root docs folder

Cheers,

Samitha

Fixed: Visual Studio Git Changes Not Showing Modified Files

 

Fixing the "Git Changes Not Showing Modified Files" Issue in Visual Studio

Have you ever made a bunch of code changes, only to look over at the Git Changes window in Visual Studio and see... nothing? It’s a frustrating glitch that can grind your workflow to a halt.

This issue is usually caused by file-system watcher sync lags, multi-repository root settings, or a minor UI state desynchronization. Fortunately, it’s usually quick to fix. Here are the most effective ways to troubleshoot and resolve the problem:

1. Manually Refresh the Git Status

Visual Studio relies on background file watchers to detect changes in your workspace. If it misses an update:

• Click the Refresh icon (the circular arrow) at the top of the Git Changes window.

• Run git status in an external terminal (such as Git Bash or the Developer Command Prompt) to verify if Git itself recognizes the modifications.

• How to verify: If the command line shows your modified files but Visual Studio doesn't, you are dealing with a pure UI sync glitch.

2. Close and Reopen the Git Changes Window

A quick way to force Visual Studio to re-initialize the tool window control is to toggle it off and back on:

• Close the Git Changes tab.

• Go to the top menu and select View > Git Changes (or press Ctrl + 0, Ctrl + G).

3. Check for Multiple Repositories or Solution Roots

If your solution contains projects spread across different folders or Git submodules, Visual Studio might simply be looking at the wrong repository context:

• Look at the top of the Git Changes window to check the active repository context.

• Use the repository selector dropdown to ensure you are targeting the exact root folder where your files were modified.

4. Review Excluded Files and .gitignore Rules

Sometimes files fail to show up because they match a newly added or updated .gitignore rule, or because Visual Studio's filters are hiding them:

• Double-check if your untracked files were accidentally ignored.

• Ensure your view filters aren't hiding untracked or specific file types.

5. Restart Visual Studio or Clear the Component Cache

If the underlying Git integration service has crashed or locked up internally:

• Restart Visual Studio completely.

• If the problem persists, clear the MEF component cache by deleting the %LocalAppData%\Microsoft\VisualStudio\[Version]\ComponentModelCache folder. This forces Visual Studio to rebuild its internal component extensions on the next launch.

Have you encountered other Git quirks in Visual Studio? Let us know how you solved them in the comments below!

How to Fix Weird .NET Build Errors Using dotnet clean and NuGet Cache Clearing

If you work with .NET long enough, you will eventually run into a baffling build error where your code looks completely correct, but the compiler stubbornly refuses to cooperate. Often, the culprit isn't your code—it's stale build artifacts or corrupted package caches.

In this quick guide, we’ll look at two powerful commands every .NET developer should have in their toolkit: dotnet clean and dotnet nuget locals all --clear.

What does dotnet clean do?

When you build a .NET project, the compiler generates temporary files, compiled binaries, and cache files stored inside the bin/ and obj/ directories of your project folder.

The dotnet clean command deletes these build outputs (the contents of the bin and obj folders).

Why use it?

To force a completely fresh build from scratch.

To resolve issues where old compiled files aren't being updated properly during incremental builds.

Before packaging or publishing your application to ensure no old artifacts sneak in.

Bash

dotnet clean

(Note: This only affects the local project directory and does not delete your source code.)

What does dotnet nuget locals all --clear do?

While dotnet clean clears local project build outputs, NuGet handles external library dependencies. .NET stores downloaded NuGet packages in global machine caches (such as http-cache, global-packages, and temp) so it doesn't have to re-download them every time.

The dotnet nuget locals all --clear command completely wipes out all local NuGet caches across your machine.

Why use it?

To fix stubborn package restore errors (e.g., NU1101, NU1202).

When a package download was interrupted or corrupted, causing constant build failures.

To force .NET to fetch fresh copies of packages from NuGet.org (useful when working with prerelease packages or packages with the same version number updated locally).

Bash

dotnet nuget locals all --clear

When should you use them together?

If you are experiencing mysterious build errors that won't go away after a standard rebuild, try running them in sequence as a "nuclear option" to reset your local environment:

 # 1. Clean local build artifacts

dotnet clean

# 2. Clear all global NuGet caches

dotnet nuget locals all --clear

# 3. Restore dependencies and rebuild fresh

dotnet restore

dotnet build

Sql Server offset 0 usage

 In SQL Server, OFFSET 0 ROWS instructs the database to skip exactly zero rows before returning data.

On its own, skipping zero rows doesn't change the output, but when paired with the FETCH NEXT clause, it becomes the standard, ANSI-compliant way to implement pagination (specifically, grabbing the "first page" of results).

Basic Syntax

SQL

SELECT column_name(s)
FROM table_name
ORDER BY sort_column
OFFSET 0 ROWS 
FETCH NEXT n ROWS ONLY;

e.g 1: The "First Page" of Results

Imagine you have an Employees table, and you are building a UI that displays 5 employees per page, starting with the highest earners.

To get Page 1, you use OFFSET 0:

SQL

SELECT EmployeeID, FirstName, LastName, Salary
FROM Employees
ORDER BY Salary DESC
OFFSET 0 ROWS 
FETCH NEXT 5 ROWS ONLY;

How it works:

1. ORDER BY Salary DESC: Sorts the employees from highest to lowest salary.

2. OFFSET 0 ROWS: Starts at the very first row of that sorted list (skips nothing).

3. FETCH NEXT 5 ROWS ONLY: Grabs exactly 5 rows and stops.

(To get Page 2, you would change it to OFFSET 5 ROWS FETCH NEXT 5 ROWS ONLY).

e.g 2: Dynamic Pagination in a Stored Procedure

The most common real-world use case for OFFSET 0 is inside stored procedures where pagination math is calculated dynamically using variables.

When a user requests Page 1, the math automatically calculates to OFFSET 0.

SQL

DECLARE @PageNumber INT = 1; -- The user wants the 1st page
DECLARE @PageSize INT = 10;  -- The user wants 10 records per page

SELECT EmployeeID, FirstName, LastName, Department
FROM Employees
ORDER BY LastName ASC
-- The math: (1 - 1) * 10 = 0. So this resolves to OFFSET 0 ROWS
OFFSET (@PageNumber - 1) * @PageSize ROWS 
FETCH NEXT @PageSize ROWS ONLY;

Important Rules

• ORDER BY is Mandatory: You cannot use OFFSET without an ORDER BY clause. The database needs a definitive sorting order to know exactly which rows it is skipping.

• FETCH is Optional: You can use OFFSET without FETCH. If you write OFFSET 10 ROWS without a FETCH clause, SQL Server will skip the first 10 rows and return everything else.

• No mixing with TOP: You cannot use TOP and OFFSET-FETCH in the same query block. OFFSET-FETCH was introduced in SQL Server 2012 specifically as a more robust replacement for using TOP for pagination.

Cheers

Samitha