Bit by Bit - SQL Client Throws Saving Float[] Into Vector - SOLVED

 Surprise Solution Populating Vectors

The Issue

I have been working for several hours on a RAG system for AI and SQL Server now has Vector datatype for RAG and semantic temporal data solutions. SQL 2025 officially introduces this feature with a few wrinkles. There are a few database level switches that need to be enabled first.

ALTER DATABASE YourDb SET COMPATIBILITY_LEVEL = 170;

ALTER DATABASE SCOPED CONFIGURATION SET PREVIEW_FEATURES = ON;

This next oddity (for the lack of better term) If you use VS and Object or SQL Server explorer, It will sometimes reset the dimensions on a configured Vector column. I didn't test for the exact conditions, patience was thin. If you try to use queries in VS2026 involving the vector columns you will get errors that will not let you proceed. This was in VS2026 Insiders build. It has to do with the compatibility level and preview features.

       I was able to successfully work with the tables in SSMS 22.1+.  The next hurdle was trying to populate the RAG db. specifically the Vector column. SqlClient was throwing complaining there was no mapping from single to a native type or a more bizarre exception that I was trying to pass invalid Json into the Vector column. Which I wasn't trying to.

       At 4:30 in the morning I am trying to tackle this situation, I have 2 AI's that were stumped also, Windows copilot on one screen and copilot in VS neither one solved it cleanly, I was packing the floats into bytes and passing them as binary.

Solution

        After scratching our collective heads for a while I opened SSMS and asked the AI in that app to confirm the solution, it's still GitHub copilot but it is focused on SQL. It was long shot but at nearly 5 am a longshot is welcome. Drum roll please... The current official path for populating Vector columns with floats[] delivered from embedding models is to pass them in as a Json string.! Yes string, nvarchar or nchar, SQL server translates this string into the floats that the column is expecting.

  ```using (var cmd = new SqlCommand("INSERT INTO dbo.embeddings (id, vector_col) VALUES (@id, @vec)", conn))

{

    cmd.Parameters.AddWithValue("@id", 1);

    

    // Pass vector as JSON string

    float[] embedding = { 0.1f, 0.2f, 0.3f };

    string vectorJson = $"[{string.Join(",", embedding)}]";

    

    cmd.Parameters.Add("@vec", SqlDbType.NVarChar).Value = vectorJson;

    cmd.ExecuteNonQuery();

}```

 

         Why Not Binary?

• SqlDbType.Vector may not be available in current client libraries (preview feature)

• Binary conversion requires knowledge of internal format (8-byte header + float data)

• String/JSON approach is officially supported and simpler

Confirmation

No, you don't need to convert to binary. Use string parameters with JSON array format - this is the intended client interaction model for VECTOR columns.

Windows 10 Dead? -- Absolutely Not Grab It Now!

Windows 10 Dead? Absolutely Not — Here’s Why You Should Grab It Now

For years, tech headlines have declared Windows 10 “dead,” “unsupported,” or “obsolete.” But the reality is far more interesting — and far more useful for everyday users, IT pros, and hardware tinkerers.

Despite the noise, Windows 10 remains one of the most stable, compatible, and widely supported operating systems available today. And if you know where to look, it’s still possible to install, activate, and run it safely on modern hardware.

Why Windows 10 Still Matters in 2025

• Massive hardware compatibility — Windows 10 runs on older systems and modern CPUs without the TPM/secure‑boot drama.

• Enterprise‑grade stability — Many organizations continue to rely on Windows 10 because of its predictable behavior and mature driver ecosystem.

• Lower resource usage — Compared to Windows 11, Windows 10 often performs better on mid‑range or older hardware.

• Still receiving security updates — Extended support paths and enterprise channels continue to deliver patches.

The Real Reason People Think Windows 10 Is “Dead”

Microsoft’s messaging has been inconsistent. Marketing pushes Windows 11, while enterprise documentation quietly maintains Windows 10 support channels. This creates confusion — and that confusion leads to myths.

But for users who value:

• predictable UI behavior

• stable registry and system APIs

• compatibility with legacy tools

• lower overhead

…Windows 10 remains a powerful, practical choice.

Who Should Still Use Windows 10?

• Developers who need consistent behavior across builds

• Forensic analysts who rely on stable system internals

• IT pros maintaining mixed‑hardware fleets

• Everyday users who prefer a familiar interface

• Tinkerers building custom rigs or repurposing older hardware

How to Safely Install Windows 10 Today

(This section boosts SEO by answering a common search intent.)

1. Download the official ISO from Microsoft’s site.

2. Create a bootable USB using Rufus or the Windows Media Creation Tool.

3. Install normally — activation still works with valid Windows 7/8/10 keys.

4. Apply the latest cumulative updates.

5. Disable unnecessary telemetry if desired.

Final Thoughts

Windows 10 isn’t dead — it’s simply not fashionable. But for users who value stability, compatibility, and control, it remains one of the best operating systems available today.

If you’re building a new system, reviving an old one, or simply want an OS that stays out of your way, Windows 10 is still absolutely worth installing.

AI Gets Lost in Visual Studio’s New Solution Philosophy

AI Gets Lost in Visual Studio’s New Solution Philosophy

More Hidden Whimsical “Fixes”

This wasn’t a random experiment. I set out to test a small, focused conversational language model — evaluating footprint, memory usage, and response quality. I used Windows Copilot to generate a step-by-step guide, formatted for ingestion by GitHub Copilot in VS2026 Enterprise Insiders Edition.

• Instructions were placed in /docs
• A .github directory defined preferences and minimal intervention
• Copilot was instructed to follow the guide and build the model autonomously

I kicked it off and moved to another machine.

The Breakdown Begins

Copilot asked for one confirmation, then proceeded. Later, I returned to a curious prompt:

“I performed tasks x.y.z and tried to run Build… but couldn’t find anything to build.”

It had created projects — but couldn’t build them. I added a solution file, linked the projects, and added a shared .shproj at the root to glob folders not tied to a project. A setup I’ve used for years.

Still, Copilot couldn’t see:

• The .shproj file
• The solution file
• The folders it had just created

I cleared the .vs cache and restarted. Everything looked fine on my end. But Copilot still couldn’t see the shared project — and I couldn’t even share it back into the chat context.

Introducing the Broken “Fix”

I had a hunch. Copilot confirmed it:

Microsoft has tied solution/project visibility to GitHub and .git manifests.

If a folder isn’t under Git control — or listed in the manifest — it’s invisible to Copilot.

There are exceptions. If you start with folders and instruct Copilot to begin, it can see them. But once Git enters the picture, visibility becomes conditional.

This hidden dependency on a third-party tool violates every coding commandment I’ve followed for 40 years.

The Solution File: From Container to Index

What It Used to Be:

• A container
• You could add folders directly
• Globs worked
• Git was optional

What It Is Now:

• An index
• Tracks only .csproj, .shproj, and virtual folders
• Non-project folders are invisible
• Globbing is no longer supported

You can hack around it with a shared project and globbing — but it’s fragile and unnecessary. The old format was clean, granular, and Git-agnostic.

Why This Breaks Formal Coding Commandments

Depending on Git/GitHub for core visibility violates foundational principles:

• Never depend on external tooling for core functionality
• The IDE should be self-sufficient
• Indexing should be explicit and reproducible

By tying Copilot’s vision to Git, Microsoft has made local, private, and experimental projects second-class citizens. That’s absurd. Scratchpads and prototypes deserve clarity without being forced into a repo.

The Bigger Lesson

Audit-grade clarity requires explicit contracts:

• .sln should manifest all files
• .csproj / .shproj should contain source
• Git should be optional provenance — not mandatory visibility

When the solution file lost its container role, the AI lost its anchor. It could generate — but not see. That’s not just a bug. It’s a design failure.

Closing Thought

AI shouldn’t paint itself into blind boxes. Developers shouldn’t be forced into Git for visibility. And solution files shouldn’t be broken indexes when they used to be reliable containers.

If Microsoft restored the solution file’s original behavior, this entire problem would vanish.

Until then, we’re left documenting the irony: an AI that can generate code but can’t see its own work — trapped by broken design and misplaced dependency.

— Kyle

Microsoft Breaks Decades‑Old Configuration Hierarchy in Visual Studio 2026

Visual Studio 2026 Reverses Configuration Hierarchy — A Forensic Analysis

For over four decades, Microsoft built its empire on a foundation of consistency, reliability, and end-user trust. A hierarchical configuration model has long been in place — adopted across the software industry — where machine-level settings apply globally, solution-level settings override them contextually, and project-level settings take precedence when needed.

This model supports real-world complexity. A developer working across multiple clients can adjust solution-level settings without disturbing others. If a project manager has unique needs, a project-level config file resolves them. This isn’t an edge case — it’s standard practice.

And it works. Hundreds of products follow this model. Some even support root = true to declare a lower-level config as authoritative.

But in Visual Studio 2026 Insiders — Microsoft’s flagship IDE — that principle has been reversed. A late-night “fix” has shattered decades of consistency.

Visual Studio offers powerful tools: analyzers, fixers, style rules. Yet Microsoft no longer applies these tools consistently in its own infrastructure. Variable names, registry keys, assemblies, and WMI classes are riddled with inconsistencies: Windows, WINDOWS, microsoft.assembly, Microsoft.assembly, microsoft,windows.

With cross-platform compatibility now critical — Linux is case-sensitive, macOS is not, Windows is sometimes — consistency is more important than ever.

So why doesn’t Microsoft use its own guardrails?

🧨 The Inversion: Solution Scope Silenced

Open a solution today and you’ll see override messages like:

“Setting X was changed in the solution scope but ignored due to an override in the user scope.”

The solution — meant to define team-wide behavior — is now subordinate to personal user settings. Not by choice. Not by consent. By enforcement.

This isn’t autonomy. It’s phantom sovereignty — the illusion of control while the IDE discards your intent. No opt-in. No toggle. Just silent override.

Developers often adopt different coding styles. The current model lets them apply user settings globally without overriding each project. That’s fine — until it overrides the solution itself.

🧭 Compare That to NuGet: Nested Settings Done Right

• NuGet.config in the solution folder overrides the global config.
• Project-level settings override solution-level defaults.

NuGet honors hierarchy. It’s logical, predictable, and respectful. Visual Studio 2026’s override model is the opposite — brittle, opaque, and disruptive.

🧵 The Quilt of Contradictions: Windows as a Fractured Architecture

The override fiasco is just one thread. Windows itself has become a patchwork of disconnected modules — a system built by siloed teams.

Let’s pinpoint the contradictions:

• Group Policy vs Defender: Defender ignores Group Policy, even in enterprise environments.
• WMI vs PowerShell vs Settings UI: Three interfaces, three schemas, three outcomes.
• Perfmon vs Event Viewer vs Reliability Monitor: All claim to show system health. None share a schema.
• Task Scheduler vs Services vs Startup Apps: Three startup managers. No central authority.
• Registry vs Settings vs Local Group Policy Editor: Redundant paths. No reconciliation.

This isn’t extensibility. It’s entropy.

🧪 A GUI Misstep That Broke the OS — And It Wasn’t Mine

I used the Windows GUI to set a user profile path: G:\Users. No variables. No redirection. No network.

• The profile system collapsed.
• The user account was corrupted.

The GUI accepted the input. The system applied it. But the subsystems — profile loader, registry, ACL propagation — imploded. This wasn’t user error. It was a failure of internal validation logic.

When teams don’t collaborate, systems break. When validation isn’t shared, input becomes dangerous.

🏁 Training Wheels on a Race Car

This isn’t just regression. It’s insult.

Microsoft is applying end-user philosophies to professional tools. Guardrails. Training