When Microsoft Word Crashes: How a Third-Party Plugin Can Bring It Down

Microsoft Word or other Office Application is usually a very stable application. When it starts crashing repeatedly, many users assume the problem lies with Office itself, Windows updates, or corrupted documents. In practice, a very common cause is third-party Office plugins that integrate deeply into Word.
You might blame Microsoft or Windows for this, but as in most cases it is not Microsoft. You update office, but some other plugins are not compatible with the new version. So, what to do?

One frequent example is a crash caused by the Seclore FileSecure Office plugin.

This article explains:

• How to locate this kind of issue
• Why Word crashes even though it is not the real cause
• How to safely disable the problematic plugin

Note, the same issue can be fixed for all other office applications!

The Crash Symptoms

Users typically report:

• Office application cannot open the file at the remote location.
• Office application crashing when opening
• Repeated crashes

In Windows Event Viewer, the error often looks like this:

Faulting application name: WINWORD.EXE
Faulting module name: Office2016x64Plugin.dll
Exception code: 0xc0000409
Faulting module path: ...\Seclore\FileSecure\Desktop Client\...

At first glance, it appears that Microsoft Word (or other office applicaiton) is at fault — but that is misleading.

Understanding the Root Cause

The most important line in the crash report is:

Faulting module name: Office2016x64Plugin.dll

This DLL belongs to Seclore, an enterprise Information Rights Management (IRM) solution that integrates directly into Microsoft Office.

What is happening internally:

• Word loads the Seclore plugin during startup
• The plugin performs low-level operations (file protection, encryption, policy enforcement)
• Due to a bug, incompatibility, or outdated version, the plugin triggers a memory violation
• Windows terminates Word immediately to protect system integrity

The exception code 0xc0000409 usually indicates:

• Stack buffer overrun
• Memory corruption
• Unsafe or incompatible plugin code

In short: Word crashes because the plugin crashes inside Word’s process.

Why This Problem Often Appears Suddenly

This issue commonly starts after:

• A Microsoft Office update
• A Windows update
• An update mismatch between Office and the Seclore client
• Security software not being updated in sync with Office

Reinstalling Office alone usually does not fix the issue, because the faulty plugin remains installed.

How to Disable the Seclore Plugin in Microsoft Word

If your organization allows it, disabling the plugin is the fastest way to confirm and resolve the problem.

Method 1: Disable via Word Options (Recommended)

1. Open Microsoft Word
2. Go to File → Options
3. Select Add-ins
4. At the bottom, next to Manage, choose COM Add-ins
5. Click Go
6. Locate the Seclore add-in (or similar)
7. Uncheck the plugin
8. Click OK
9. Restart Word

If Word opens normally afterward, the plugin was the cause.

Method 2: Start Word in Safe Mode (Diagnostic)

This method does not disable the plugin permanently, but it helps confirm the root cause.

1. Press Win + R
2. Run:

   winword /safe
   

3. If Word works correctly in Safe Mode, the issue is definitely an add-in

Method 3: Update or Reinstall Seclore (Best Long-Term Fix)

If the plugin is required by company policy:

• Update the Seclore Desktop Client to the latest version
• If already updated, reinstall it
• Verify compatibility with the current Office build

In managed corporate environments, this step should be handled by IT support.

Key Takeaway

When Office APplications crashe:

• The faulting application is not always the root cause
• Third-party Office plugins run inside Word’s process
• A single buggy DLL can crash the entire application

In this case, Word is the victim — not the problem.

Migrating resources between Azure subscriptions is a common but risky task. Whether you’re reorganizing tenants, separating billing, or preparing for a handover, doing this manually is slow and error-prone.
The issue here is that Azure Portal does not provide an option to migrate all resources at once.

For this reason, I created a PowerShell + Azure CLI script that automatically migrates all resource groups and their resources from one subscription to another.

? What This Script Does

The script performs the following steps:

1. Connects to a source Azure subscription
2. Retrieves all resource groups
3. Switches to a target subscription
4. Creates missing resource groups
5. Moves all supported resources to the target subscription
6. Logs success and failure clearly

It uses native Azure Resource Manager (ARM) move operations, meaning:

• Resource IDs remain intact
• No redeployment is required
• Downtime is minimized (but not zero)

? Prerequisites

Before running the script, ensure:

• Azure CLI is installed (az version)
• You are logged in (az login)
• You have Owner or Contributor permissions on both subscriptions
• Resources are in a movable state

⚠️ Not all Azure resources support cross-subscription moves (e.g., classic resources, some networking dependencies).

⚙️ Script Configuration

Update the following values before running:

$sourceSubId = "***"     # Source subscription ID
$targetSubId = "***"     # Target subscription ID
$location = "westeurope" # Location for new resource groups

The $location value is only used when creating missing resource groups in the target subscription.

? Script Walkthrough

1️⃣ Switch to Source Subscription

az account set --subscription $sourceSubId

This ensures all resource discovery happens in the correct source context.

2️⃣ Retrieve All Resource Groups

$resourceGroups = az group list --query "[].name" -o tsv

This fetches every resource group name in the source subscription.

3️⃣ Ensure Resource Groups Exist in Target

az group exists --name $rg

If the resource group doesn’t exist in the target subscription, it is automatically created:

az group create --name $rg --location $location

✔ Prevents failures during resource moves
✔ Keeps naming consistent

4️⃣ Collect Resource IDs

$ids = az resource list --resource-group $rg --query "[].id" -o tsv

Azure requires resource IDs for move operations, not names.

5️⃣ Move Resources Across Subscriptions

az resource move `
  --destination-group $rg `
  --destination-subscription-id $targetSubId `
  --ids $ids

This is the core operation:

• Moves resources
• Keeps them in the same resource group name
• Preserves configuration and metadata

6️⃣ Error Handling & Logging

if ($LASTEXITCODE -eq 0) {
    Write-Host "SUCCESS"
} else {
    Write-Host "FAILED - see error above"
}

Failures usually occur due to:

• Unsupported resource types
• Dependency constraints
• Resources spanning multiple resource groups

⚠️ Important Limitations

Be aware of these Azure constraints:

❌ Some resources cannot be moved

• Classic resources
• Certain App Service plans
• Managed identities with dependencies

❌ Resources must move together

• VNets + subnets
• NICs + VMs
• Disks + VMs

✔ Azure will block the move if dependencies are violated

✅ Best Practices Before Running

✔ Test on a single resource group first
✔ Export ARM templates as a backup
✔ Run during a maintenance window
✔ Validate networking dependencies
✔ Monitor activity logs during execution

? When Should You Use This Script?

This approach is ideal for:

• Subscription consolidation
• Tenant separation
• Environment restructuring (Dev → Prod)
• M&A cloud migrations
• Billing realignment

? Final Thoughts

This script provides a clean, repeatable, and safe way to migrate Azure resources at scale using native tooling from Microsoft Azure.

It’s not magic—but with proper preparation, it can save hours or days of manual work.

If you found this useful, feel free to:
? Like
? Repost
? Share your migration war stories

Happy migrating ☁️?

----- SCRIPT ------

Write-Host "======================================"
$sourceSubId = "***"
$targetSubId = "***"
$location = "westeurope"               

Write-Host $sourceSubId
Write-Host $targetSubId

# Switch to source subscription
Write-Host Setting + $targetSubId
az account set --subscription $sourceSubId

# Get list of all resource group names
$resourceGroups = az group list --query "[].name" -o tsv

foreach ($rg in $resourceGroups) {
    Write-Host "======================================" -ForegroundColor Cyan
    Write-Host "Processing source RG: $rg" -ForegroundColor Yellow

    # Check if same-name RG already exists in TARGET subscription
    az account set --subscription $targetSubId

    $exists = az group exists --name $rg --output tsv

    if ($exists -eq "false") {
        Write-Host "  Creating target RG '$rg' in location $location ..." -ForegroundColor Green
        az group create --name $rg --location $location --subscription $targetSubId
    } else {
        Write-Host "  Target RG '$rg' already exists - skipping creation" -ForegroundColor Green
    }

    # Switch back to source to list resources
    az account set --subscription $sourceSubId

    # Get resource IDs from source RG
    $ids = az resource list --resource-group $rg --query "[].id" -o tsv

    if ($ids) {
        Write-Host "  Moving resources from '$rg' ..." -ForegroundColor Yellow
        az resource move `
            --destination-group $rg `
            --destination-subscription-id $targetSubId `
            --ids $ids

        if ($LASTEXITCODE -eq 0) {
            Write-Host "  SUCCESS" -ForegroundColor Green
        } else {
            Write-Host "  FAILED - see error above. Often due to dependencies or unsupported resource types." -ForegroundColor Red
        }
    } else {
        Write-Host "  No resources found in '$rg' - skipping move" -ForegroundColor Gray
    }
}

Write-Host "======================================" -ForegroundColor Cyan
Write-Host "All resource groups processed." -ForegroundColor White

Before deploying Redis, it's important to evaluate whether it is truly needed for the application in question.

Redis is typically used in scenarios where an application must handle a very high volume of concurrent users often in the range of hundreds of thousands. In our case, this level of demand does not apply.

If caching is required, we generally have two options:

In-Memory Caching

This is the fastest option but has limitations in clustered environments (e.g., state synchronization, failover).

Dedicated Cache Services

These include Redis, Memcached, and others, which are external systems accessed over the network.

When considering a cache service, the next logical question is: Which one should we use?

All services, whether EMail server, SQL databases, MongoDB, or Redis are accessed over specific protocols (e.g., TDS for SQL Server, TCP for MongoDB or Redis). Performance comparisons often assume Redis is the fastest option, but that assumption can be misleading.

SQL Server: Often provides the fastest response times, especially for indexed lookups on structured data. Believe me or not, the JETDB (MSAccess) is the fastest DB as long the single user is connected. :)

MongoDB: Offers strong performance, particularly in distributed cloud-native environments like Azure Cosmos DB.

Redis: While not inherently the fastest, it excels at horizontal scalability thanks to its built-in partitioning and protocol-level load balancing. This makes Redis suitable for very high-scale scenarios, where clients need to be routed directly to the node holding the relevant data.

So why is Redis frequently used?

Mostly, a lack of Architectural Insight: Many teams adopt Redis without properly researching if it's the best fit.

Scalability Needs: Redis shines in systems that require linear scaling across many users and nodes, which is often not the case in smaller or mid-sized applications.

Conclusion

For systems with fewer than ~1,000 (this needs to be measured for every application!!) concurrent users, it is often more efficient and maintainable to leverage SQL tables directly, avoiding the added complexity and operational overhead of Redis.
I'm not saying, use SQL or MS Access for cache in general. I'm saying, it is smart to understand problem and do required performance measurment before making decisions. Believe me, you will be supried.

Redis is often used as a synonym for caching, just as Docker and Kubernetes are commonly associated with microservices. However, none of these associations are entirely accurate in a generalized context.

Evaluating large language models (LLMs) is becoming increasingly difficult. One major challenge is test set contamination, where benchmark questions unintentionally end up in a model’s training data—skewing results and making once-reliable benchmarks quickly outdated. While newer benchmarks try to avoid this by using crowdsourced questions or LLM-based evaluations, these methods come with their own problems, like bias and difficulty in judging complex tasks.

That’s where LiveBench comes in.

LiveBench is some kind of a benchmark designed to address these issues head-on. It features regularly updated questions sourced from fresh content—like math competitions, academic papers, and news articles—and scores answers automatically using objective ground-truth values. It covers a wide range of tough tasks, including math, coding, reasoning, and instruction following, pushing LLMs to their limits.

With questions refreshed monthly and difficulty scaling over time, LiveBench is built not just for today’s models but for the next wave of AI breakthroughs. Top models currently score below 70%, showing just how challenging—and necessary—this benchmark is.

I put toghether few benchmarks.

Model Performance by Average score.

Model Reasoning Performance

Model Coding Performance

Model Language Performance

Recap

I have created all diagrams by using GPT-4o based on data obtained from https://livebench.ai/#/?Coding=a
If some of models are missing in diagrams, please forgive me (It was omitted by GPT Diagram Generation :)).

Dear all, here is the list of recommended resources related to AI Sessions.
It is a great foundation to start learning about AI.

1. BRK440: Getting started with Generative AI in Azure
   https://github.com/microsoft/aitour-generative-ai-in-azure

2. BRK441: Build AI Solutions with Azure AI Foundry
   https://github.com/microsoft/aitour-concept-to-creation-ai-studio

3. BRK443: Build your code-first app with Azure AI Agent Service
   https://github.com/microsoft/aitour-azure-openai-assistants

4. BRK444: Getting started with AI Agents in Azure
   https://github.com/microsoft/aitour-getting-started-with-ai-agents

5. BRK450: Prompty, AI Studio and practical E2E development
   https://github.com/microsoft/aitour-llmops-with-gen-ai-tools

6. BRK451: Code-first GenAIOps from prototype to production
   https://github.com/microsoft/aitour-llmops-with-gen-ai-tools

7. BRK452: Operationalize AI responsibly with Azure AI Studio
   https://github.com/microsoft/aitour-operate-ai-responsibly-with-ai-studio

8. BRK453: Explore cutting-edge models: LLMs, SLMs and more
   https://github.com/microsoft/aitour-exploring-cutting-edge-models

Right now, it seems that most of the community if fixed on the RAG (excluding Prompt Engineering). However, there is a technique called Iterative RAG (Ma et al., 2023; Li et al., 2024; Chan et al., 2024; Shi et al., 2024).

This is a more advanced approach in natural language processing and generative AI that enhances the interaction between information retrieval and generation by refining outputs through multiple iterations.

1. What is RAG?

RAG integrates two main components:

• Retriever: Finds relevant documents or data from an external knowledge base. This is typically the task of some connector.
• Generator: Generates a response or output based on the retrieved information.This is covered by the model itself.

The aim is to use external knowledge for factually grounded and contextually relevant outputs.The data can be stored in some database, can be retrieved from an external service, read from documents etc.

2. What Makes Iterative RAG Different?

Iterative RAG improves upon standard RAG by performing multiple cycles of refinement. It iteratively improves the quality of output by revisiting retrieval and generation steps.

Iteration Process and Feedback Loop:

1. Initial Retrieval: Retrieve a set of documents or data points. (Same as RAG).
2. Generation: Produce an output based on the retrieved information.(Same as RAG)
3. Feedback Loop: Analyze the output to identify gaps or areas for improvement.
4. Refinement Retrieval: Use feedback to refine the search for better data.(Same as RAG)
5. Regeneration: Generate a new output based on the refined retrieval.(Same as RAG)

This loop continues until:

• The output meets a predefined quality threshold, or
• A maximum number of iterations is reached.

3. Advantages of Iterative RAG

• Improved Accuracy: Addresses errors or missing information through iterations.
• Contextual Relevance: Refines context to better align the final response with the query.
• Dynamic Adaptation: Adjusts retrieval and generation strategies dynamically.

This process seems to be evolved over time. I guess, that reasoning might be a bit inspired by iterative process of the feedback introduced by the Iterative RAG.

4. Applications

• Question Answering: Produces detailed, factually accurate answers by refining retrieved knowledge.
• Document Summarization: Ensures summaries include all relevant information.
• Conversational AI: Enhances dialogue coherence by refining context and revisiting prior responses.

5. Challenges

• Computational Cost: Iterations increase latency and resource usage.
• Optimization Complexity: Balancing retrieval and generation across iterations can be very tricky task.
• Risk of Overfitting: Excessive iterations might lead to overly specific or biased outputs.

Recap

Iterative RAG is a significant advancement in combining retrieval and generation systems, offering a robust way to handle complex queries and generate high-quality, accurate responses.Although RAG methods achieve strong performance on multi-hop tasks like HotpotQA, there are huge limitations.
For example, RAG is chunk-based and it struggles with knowledge-intensive tasks (Wang et al., 2024a), because chunks contain excessive text noise and do not capture the relation betwen information. With this limitation LLMs cannot effectively use augmented knowledge.

When it comes to automating workflows, breaking down complex tasks into smaller, modular steps can make the process more efficient and maintainable. Semantic Kernel (SK) provides a powerful way to achieve this through pipelines. In this post, we’ll explore how to create and execute a pipeline that processes a number through parsing, arithmetic, truncation, and humanization. Pleae note that the SK pipeline described in this example is not the state-full machine designed for long running processes. If you want to leverage such scenarios, I recommend using Azure Durable Functions.

Why Use Semantic Kernel Pipelines?

Semantic Kernel pipelines allow you to:

Modularize functionality into reusable components.
Chain together functions to handle complex workflows.
Integrate with AI capabilities such as prompt-based generation.
Let’s dive into a practical example where we build a pipeline to take a string, process it numerically, and then convert it into a spelled-out English phrase.

The Workflow

In this example, I use the pipeline to solve the following problem:

1. Parse a string representation of a number (e.g., "123.456") into a double.
2. Multiply the double by another double (e.g., 78.90).
3. Truncate the resulting value to an integer.
4. Convert the integer into its English word representation (e.g., "nine thousand seven hundred forty").

    public async Task DemoPipelineAsync()
    {
        IKernelBuilder builder = Kernel.CreateBuilder();
        builder.AddOpenAIChatCompletion(
            TestConfiguration.OpenAI.ChatModelId,
            TestConfiguration.OpenAI.ApiKey);
        builder.Services.AddLogging(c => c.AddConsole().SetMinimumLevel(LogLevel.Trace));
        Kernel kernel = builder.Build();

            KernelFunction parseDouble = KernelFunctionFactory.CreateFromMethod((string s) => double.Parse(s, CultureInfo.InvariantCulture), "parseDouble");
            KernelFunction multiplyByN = KernelFunctionFactory.CreateFromMethod((double i, double n) => i * n, "multiplyByN");
            KernelFunction truncate = KernelFunctionFactory.CreateFromMethod((double d) => (int)d, "truncate");
            KernelFunction humanize = KernelFunctionFactory.CreateFromPrompt(new PromptTemplateConfig()
            {
                Template = "Spell out this number in English: {{$number}}",
                InputVariables = [new() { Name = "number" }],
            });
            KernelFunction pipeline = KernelFunctionCombinators.Pipe([parseDouble, multiplyByN, truncate, humanize], "pipeline");

            KernelArguments args = new()
            {
                ["s"] = "123.456",
                ["n"] = (double)78.90,
            };

            // - The parseInt32 function will be invoked, read "123.456" from the arguments, and parse it into (double)123.456.
            // - The multiplyByN function will be invoked, with i=123.456 and n=78.90, and return (double)9740.6784.
            // - The truncate function will be invoked, with d=9740.6784, and return (int)9740, which will be the final result.
            Console.WriteLine(await pipeline.InvokeAsync(kernel, args));
}

Creating the Pipeline

Step 1: Define the Functions
We start by defining individual functions for each step in the workflow. Using Semantic Kernel’s KernelFunctionFactory, we create these modular functions:

Parsing a String into a Double: Converts the string "123.456" into the numeric value 123.456.
Multiplication: Multiplies the parsed number by a given multiplier.
Truncation: Truncates the result to an integer.
Humanization: Converts the integer into a spelled-out English string using a prompt-based function.

Step 2: Combine Functions into a Pipeline
With the functions ready, we use KernelFunctionCombinators.Pipe to chain them together into a pipeline. The output of one function feeds directly into the next, ensuring a seamless data flow.

Step 3: Provide Input Arguments
The pipeline takes input in the form of KernelArguments. For our example, we provide:

"123.456" as the string to parse.
78.90 as the multiplier.

Step 4: Execute the Pipeline
Finally, the pipeline is invoked with the input arguments. Each function is executed sequentially, producing the final human-readable result.

Wrap-up

Semantic Kernel pipelines make it easy to build intelligent workflows that combine traditional logic with AI capabilities. Whether you’re processing numbers, analyzing text, or orchestrating complex tasks, pipelines offer a structured and efficient approach to solving problems.

If you’re looking to build smarter applications for the new software era, try Semantic Kernel! With a little creativity, the possibilities are endless.

When working with .NET and Azure DevOps, we encountered an interesting issue. The pipeline failed, and the log does not show any meaningful information. The only issue in the log was this one:

"D:\a\1\s\src\YOURPROJECT.Api.csproj" (pack target) (1:7) ->
       (GenerateNuspec target) -> 
         C:\hostedtoolcache\windows\dotnet\sdk\8.0.300\Sdks\NuGet.Build.Tasks.Pack\build\NuGet.Build.Tasks.Pack.targets(221,5): error NU5026: The file 'D:\a\1\s\src\YOURPROJECT\bin\release\net8.0\YOURPROJECT.dll' to be packed was not found on disk. 

The reson is that we activated inside the .csproj file autogeneration of the package:

<GeneratePackageOnBuild>True</GeneratePackageOnBuild>

This is not supported within the Azure DevOps pipeline. When discussing unsupported features, you should also be aware of the following. If your project file performs any file copy operation, that might be an issue for the pipeline.

<Target Name="CopyPackage" AfterTargets="Pack">
	<Copy SourceFiles="$(OutputPath)..\$(PackageId).$(PackageVersion).nupkg" DestinationFolder="$(SolutionDir)..\nuget" />
</Target>

Hope this helps.

.Net applications have a standard process for handling application configuration and settings. In my code reviews, I've observed that developers often approach configuration in a variety of unconventional or "creative" ways, which is largely incorrect. It's crucial to ensure your code can consistently load the configuration from specific locations, such as Environment Variables, Command-Line Arguments, and the application settings file, known as appsettings.json.
To achieve this, adhere to the following initialization process:

private static IConfigurationRoot InitializeConfiguration(string[] args)
{
    var builder = new ConfigurationBuilder()
         .SetBasePath(Directory.GetCurrentDirectory())
         .AddJsonFile("appsettings.json", optional: false, 
          reloadOnChange: true)
         .AddCommandLine(args)
         .AddEnvironmentVariables();

    return builder.Build();
}

This code generates the instance of a builder that allows you to manage configuration values independently of their origins. Why is this significant? Generally, we aren't certain about the packaging conditions of your library (code), or how it will be executed. For instance, your code could be operative within ASP.NET, functioning as a console application, running in a Docker container, and so on. All of these application types can utilize a variety of methods for providing the configuration, which can offer unique advantages and disadvantages depending on where the code is executed. For example, if your code is running as a console application, it's beneficial to have the settings within the appsettings.json file. However, if the same code is deployed within a Docker container, supplying the configuration as environment variables could be more effective. Therefore, it's ideal to design your code to handle all possibilities, allowing the DevOps team to make the final decision on how to provide the configuration.

Following code samples demonstrate how to read imple and complex configuration values (settings).

    //
    // Following are comming from command line.
    var color = configuration["color"];
    Console.WriteLine("{0}", color);

    var fontSize = configuration["fontSize"];
    var state = configuration["state"];

    //
    // From root of appsettings.json
    var setting1 = configuration["Setting1"];
    var setting2 = configuration["Setting2"];
    var setting3 = configuration["Setting3"];
    var sleepyState = configuration["SleepyState"];
    var aaa = configuration["AAAA"];
    var speed = configuration["Speed"];

    float i = float.Parse(setting3, CultureInfo.InvariantCulture);
    //
    // Demonstrates how to read settings from sub section.
    var section = configuration.GetSection("MySubSettings");
    var subSetting1 = section["Setting1"];
    var subSetting2 = section["Setting2"];
    var subSetting3 = section["Setting3"];

Following code shows how to read environment variables from the configuration. Please not the code has not any direct dependency to Environment class.

    var machineName = configuration["COMPUTERNAME"];
    var processor = configuration["PROCESSOR_IDENTIFIER"];
    

The variable COMPUTERNAME might also be specified inside appsettings.json file or provided as a command line argument.

More complex configuration is read as shown in following example:

   MySettings mySettings = new MySettings();
   configuration.GetSection("MySetting").Bind(mySettings);

When working on large projects, we usually design the API(s) to implement the most requirements. Sometimes, the API might contain a lot of methods. In such cases, it is recommended to split the methods of the API into multiple classes. However, there is no rule that defines the exact threshold for the number of methods inside the API to start splitting the API class into multiple classes.

For example, a complex MyApi might be split into classes MyApi1, MyApi2, and so on. This sounds simple, but splitting into multiple APIs might also have many disadvantages. If so, you keep the implementation in MyApi, but that one will be complex to manage inside the team.

One interesting solution that we use in projects is to allow MyApi to grow, but to split the implementation into multiple files:

MyApi.cs
MyApiPart1.cs
MyApiPart2.cs

In Visual Studio these files look like:

To have a better structure of files in the solution explorer we group files together.

To achive this, following must be done in .csproj file.

  <ItemGroup>

    <Content Include="MyApi.cs" />
    <Content Include="MyApiPart1.cs">
      <DependentUpon>MyApi.cs</DependentUpon>
    </Content>
    <Content Include="MyApiPart2.cs">
      <DependentUpon>MyApi.cs</DependentUpon>
    </Content>
  </ItemGroup>