Snipps

Running code on a supercomputer sounds simple — until you see what happens behind the scenes. Modern high-performance machines are not just “big computers.” They are massive systems built from thousands of connected processors, advanced cooling systems, and highly optimized software.

The article explores the hidden complexity of running applications on a European supercomputer worth hundreds of millions of euros. Unlike a normal laptop or cloud server, these machines require developers to think differently about performance, memory usage, and communication between computing nodes.

Key challenges include:

• Parallel computing: Tasks must be split into thousands of smaller jobs running at the same time.
• Efficient communication: Processors constantly exchange data, and slow communication can reduce performance dramatically.
• Resource management: Jobs are scheduled carefully because computing time is expensive and limited.
• Optimization: Even small inefficiencies can waste huge amounts of power and processing capacity.

One interesting takeaway is that writing code for supercomputers is often more about engineering and planning than raw programming skill. Developers must understand hardware architecture, networking, and scalability to fully use the machine’s power.

The article also highlights how these systems support scientific research, AI training, climate modeling, and complex simulations that would be impossible on consumer hardware.

Original article: What It Actually Takes to Run Code on a €200M Supercomputer

Artificial intelligence is changing how companies work — but what happens when employees themselves become part of the training data? A recent internal move at Meta has sparked debate about privacy, workplace culture, and the future of AI-powered organizations.

According to reports, Meta introduced software that monitors employee activity on company devices. The system can reportedly track actions such as mouse movements, clicks, typing behavior, and screenshots within approved work applications. The goal appears to be improving AI systems by studying how people interact with digital tools in real work environments.

This decision highlights a growing shift in the tech industry:

• AI is becoming deeply integrated into daily work
• Companies are searching for more real-world data to improve AI performance
• Employee concerns about privacy and transparency are increasing

Critics argue that constant monitoring may damage trust between companies and workers. Others believe these systems could eventually improve productivity and help businesses automate repetitive tasks more effectively.

The situation also raises larger questions:

As AI adoption accelerates, businesses will likely face growing pressure to balance innovation with employee rights and transparency.

Original article: TheStreet article

Have you noticed more people wearing tiny cameras while walking, shopping, or even cleaning their homes? What once looked unusual is quickly becoming part of everyday life. Personal body cameras are no longer only for police officers or extreme sports creators — regular people are now using them during normal daily activities.

The trend is growing for several reasons. Some people use wearable cameras to create social media content without holding a phone all day. Others see them as a safety tool that can document accidents, public conflicts, or suspicious situations. In busy cities, many users say the cameras give them a sense of protection and accountability.

Modern devices are also much smaller and easier to use than before. Many can record hands-free for hours, connect directly to apps, and instantly upload videos online. This convenience has helped wearable recording become more common in public spaces.

However, the trend also raises important questions:

• Privacy concerns for people being recorded unknowingly
• Social changes as public interactions become more documented
• Ethical debates around constant recording in everyday life

Supporters believe body cameras improve transparency and personal security, while critics worry society may become too comfortable with nonstop surveillance.

As wearable technology becomes cheaper and smarter, recording daily life may soon feel as normal as carrying a smartphone.

Original article: Los Angeles Times article

A single compromised account can sometimes open the door to an entire cloud environment. That’s the key lesson from Microsoft’s recent report on the threat actor known as Storm-2949.

The attackers did not rely on traditional malware. Instead, they used social engineering and legitimate cloud management tools to quietly move through Microsoft 365 and Azure environments. Once they gained access to one identity, they expanded their reach by targeting additional accounts and cloud services.

How the attack worked

The campaign started with fake support-style interactions designed to trick users into approving authentication requests. After taking control of accounts, the attackers:

• Explored cloud directories and user permissions
• Accessed shared files and sensitive documents
• Targeted Azure services such as Key Vaults, storage accounts, and databases
• Used built-in administrative features to avoid raising suspicion
• Extracted large amounts of data from cloud systems

Why this matters

Modern attacks increasingly focus on identity instead of devices. If attackers gain access to privileged accounts, they can often move through cloud systems using normal administrative actions that appear legitimate.

Key security lessons

Organizations can reduce risk by:

• Using phishing-resistant MFA
• Limiting privileged access
• Monitoring unusual cloud activity
• Protecting secrets and credentials stored in cloud platforms
• Applying behavior-based threat detection

The report highlights an important shift in cybersecurity: attackers are now targeting the cloud control layer itself, not just endpoints or servers.

Original article: Microsoft Security Blog

In everyday digital work, there are many situations where files need to be converted into a different format. A document may need to be shared as a PDF, images might require smaller file sizes, or videos may need to be optimized for presentations or websites. This is exactly where CloudConvert becomes useful.

CloudConvert is a web-based file conversion tool that works directly in the browser, meaning no additional software installation is required. The platform supports more than 200 file formats across categories such as documents, images, audio, video, and eBooks.

Common Use Cases

• Convert Word documents into PDFs
• Compress images or change image formats
• Optimize videos for web or presentations
• Convert audio files into different formats
• Adjust eBook formats for various devices

Advantages of CloudConvert

One of the biggest advantages is the clean and intuitive interface. Even users without technical experience can convert files in just a few steps: upload a file, choose the target format, and download the converted result.

For occasional use, the free version is often sufficient. Users with larger workloads or automation needs can also choose paid plans with additional features and higher limits.

File Converter | CloudConvert

AI agents are becoming more autonomous every day. They can make decisions, use tools, and complete tasks with little human input. But with that power comes risk. What happens if an AI agent performs the wrong action, accesses sensitive systems, or behaves unpredictably?

Microsoft’s Agent Governance Toolkit (AGT) was created to solve this problem. The toolkit acts like a governance and security layer for AI agents, helping organizations control how agents operate in production environments.

What the Toolkit Focuses On

The architecture is built around three main ideas:

• Policy Enforcement – Every action taken by an AI agent can be checked against predefined rules before execution.
• Zero-Trust Identity – Agents are treated like digital workers with verified identities and controlled permissions.
• Reliability & Monitoring – Built-in observability and SRE practices help teams track agent behavior, failures, and performance.

Why It Matters

Modern AI systems are no longer simple chatbots. They can interact with APIs, databases, and enterprise tools. This creates new security and compliance challenges.

The toolkit aims to reduce risks such as:

A key takeaway is that governance should happen during runtime, not only before deployment. As AI agents become more capable, trust, transparency, and accountability will become essential parts of every AI system.

Original article: Microsoft Tech Community Blog

Most people think of Microsoft Teams as a tool for meetings and remote work. But in a surprising real-world case, it became an important source of digital evidence in a government investigation.

The case involved former IT workers accused of deleting a large number of government databases after losing access to their jobs. What made the story unusual was that a recorded Teams session reportedly captured conversations connected to the incident. That recording later helped investigators understand what happened and supported the legal case.

Why this matters

This situation highlights how modern workplace tools can unintentionally create detailed digital records. Platforms like Teams store:

• Meeting recordings
• Chat history
• Shared files
• User activity logs

These records can become valuable during investigations, especially in cybersecurity or insider-threat cases.

Key lessons for organizations

• Digital trails: Collaboration apps can preserve important evidence automatically
• Security controls: Access management after employee departures is critical
• Compliance: Organizations should understand how communication data is stored
• Awareness: Employees often forget how much activity is recorded

The story also reminds businesses that cybersecurity is not only about hackers from outside. Internal actions, mistakes, or misuse of access can create major risks as well.

Original article: Neowin Article

AI agents are becoming more powerful every day. They can write code, call APIs, automate workflows, and even make decisions with little human input. But as these systems move into real business environments, one big question appears: Who controls the agents?

Microsoft’s new open-source Agent Governance Toolkit aims to solve this problem by adding a security and governance layer around autonomous AI agents. Instead of replacing existing AI frameworks, the toolkit works alongside them to monitor behavior, enforce policies, and reduce risks during runtime.

Key capabilities include:

• Policy enforcement to control what agents are allowed to do
• Identity and trust management for secure agent interactions
• Execution sandboxing to reduce harmful actions
• Audit and compliance tools for tracking agent behavior
• Support for popular frameworks like LangChain and AutoGen

One of the most interesting ideas behind the toolkit is that AI agents should be treated like modern software systems — with permissions, monitoring, and safety rules built in from the start.

This matters because AI agents are no longer simple chatbots. They can access sensitive systems, handle data, and trigger automated actions at scale. Without governance, mistakes or misuse could quickly become security risks.

The toolkit is released under the MIT license, making it accessible for developers and organizations experimenting with safe AI deployment.

Original article: Microsoft Open Source Blog

If you recently updated Visual Studio Code and noticed that GitHub.copilot appears crossed out or marked as deprecated, you are not alone. Many developers think the extension was removed, but the real reason is simpler: GitHub changed how Copilot works inside VS Code.

In older versions, users needed two separate extensions:

• GitHub.copilot for code suggestions
• GitHub Copilot Chat for AI chat features

Now, GitHub has merged the main experience into GitHub Copilot Chat. The old standalone extension is deprecated and no longer recommended. That is why VS Code shows it with a strike-through message.

The solution is straightforward:

1. Uninstall the old GitHub.copilot extension
2. Install or enable GitHub Copilot Chat
3. Sign in with your GitHub account
4. Enable inline suggestions if needed through VS Code settings

This change helps simplify the setup process and reduces compatibility problems between multiple Copilot extensions. It also prepares VS Code for newer AI features that are being integrated directly into the editor.

If inline suggestions are not appearing after installation, use the Command Palette and run:
GitHub Copilot: Enable

For most users, switching to the new extension fully restores the Copilot experience.

Searching Active Directory users can become slow and confusing when scripts pull every account before filtering results. A better approach is to use the built-in filtering options of Get-ADUser. This method is cleaner, faster, and easier to maintain, especially in large environments.

The recommended solution is to use the -Filter parameter with the GivenName and Surname attributes. This allows Active Directory to process the search directly on the server side instead of sending all users back to PowerShell first.

For exact matches, use a filter like:

Get-ADUser -Filter "GivenName -eq 'John' -and Surname -eq 'Doe'"

This returns only users whose first and last names match the values provided.

If partial matching is needed, wildcard searches can be used:

Get-ADUser -Filter "GivenName -like 'Jo*' -and Surname -like 'Do*'"

This is useful when the full name is unknown or when searching for multiple similar names.

The discussion also highlighted the importance of avoiding Where-Object for large directories because it retrieves all users before filtering locally, which can impact performance.

Using variables inside the filter makes scripts reusable and easier to automate. Adding -Properties and Select-Object also helps return useful details such as email addresses or display names.

This approach creates faster scripts, reduces server load, and keeps PowerShell code simple and professional.

A web application that suddenly returns a startup error can be frustrating, especially when everything works perfectly on a local machine. One common issue in ASP.NET Core deployments on Azure App Service is the 500.32 ANCM Failed to Load DLL error. The good news is that the fix is usually simple once the real cause is identified.

Issue

After deploying an ASP.NET Core application to Azure App Service, the website failed to start and displayed the error:

500.32 ANCM Failed to Load DLL

This error appears before the application is fully launched, meaning the ASP.NET Core Module (ANCM) cannot load the application correctly.

Cause

The problem was caused by a mismatch between the application build architecture and the Azure App Service platform configuration.

For example:

• The application was published for 64-bit
• The Azure App Service was configured to run in 32-bit mode

Because of this mismatch, Azure could not load the required DLL files during startup.

Resolution

The fix was to update the Platform setting in Azure App Service, so it matched the application deployment target.

Steps:

1. Open Azure App Service
2. Go to Configuration
3. Open General Settings
4. Change the platform from 32-bit to 64-bit (or match the published runtime)
5. Restart the application

After updating the platform setting, the application started successfully without code changes.

Takeaway

When troubleshooting ASP.NET Core startup errors in Azure, always verify that the published runtime and App Service platform architecture match. It is a small setting, but it can completely prevent an application from starting.

Artificial intelligence is becoming more human-like every year. It can write, speak, create images, and even appear emotional. But does that mean AI could one day become truly conscious? A recent paper from Google DeepMind challenges that idea in a surprising way.

The article argues that modern AI systems can simulate consciousness without actually experiencing anything. According to the author, many discussions about AI consciousness rely on a belief called computational functionalism — the idea that consciousness comes only from information processing, regardless of the physical system running it.

The paper introduces the idea of the “Abstraction Fallacy.” In simple terms, it claims that computation is not something that naturally exists in physics. Instead, humans interpret physical signals as symbols and meaning. A computer processes patterns, but the meaning behind those patterns comes from observers, not the machine itself.

Key ideas from the paper include:

• Simulation is not the same as real experience
• AI can imitate emotions or awareness without possessing them
• Consciousness may depend on physical properties, not only software logic
• Increasing model size alone may never create genuine sentience

The author also notes that this argument is not anti-AI. Advanced systems may still become extremely capable and useful — just not necessarily conscious in the human sense.

Original article: The Abstraction Fallacy: Why AI Can Simulate But Not Instantiate Consciousness

AI agents are becoming more powerful, but what truly makes them useful is their ability to remember. Just like humans rely on memory to learn from experience, AI agents use different forms of memory to complete tasks, improve responses, and make better decisions over time.

The article explains AI agent memory using three levels of difficulty, making the topic easy to understand for both beginners and technical readers.

1. Basic Memory — Short-Term Context

At the simplest level, AI agents remember recent interactions. This is similar to keeping track of a conversation while it is happening. It helps the agent respond naturally and maintain context during a task.

2. Structured Memory — Storing Useful Information

More advanced agents can store important details for later use. This may include:

• User preferences
• Past conversations
• Task history
• External knowledge sources

This allows agents to provide more personalized and relevant answers over time.

3. Advanced Memory — Learning and Reasoning

The most capable AI systems combine memory with reasoning. They can analyze previous experiences, identify patterns, and plan future actions more effectively. This creates smarter agents that improve through interaction instead of simply reacting to prompts.

Understanding these memory layers is important because memory is becoming a core feature of modern AI systems and autonomous agents.

Original article: Machine Learning Mastery article

Microsoft is exploring how agentic AI could speed up scientific research and development. Its new platform, Microsoft Discovery, uses multiple AI agents that can reason, collaborate, and assist researchers throughout the R&D process.

What makes it interesting?

• Beyond simple AI assistants
  These agents do more than answer questions. They can help generate ideas, analyze research papers, run simulations, and support experiments.
• Built for large-scale research
  The platform combines AI with Azure’s high-performance computing infrastructure to process complex scientific workloads faster.
• Connected knowledge system
  Microsoft uses a graph-based engine that links datasets, research papers, and scientific knowledge to uncover useful insights.
• Flexible for enterprises
  Companies can integrate their own tools, models, and data while maintaining governance and security controls.

Why it matters

Microsoft shared an example where AI helped discover a new datacenter coolant prototype in about 200 hours — much faster than traditional methods. The long-term goal is to accelerate innovation in areas like materials science, healthcare, manufacturing, and electronics.

Original article: https://azure.microsoft.com/en-us/blog/microsoft-discovery-advancing-agentic-rd-at-scale/

Starting a new repository should be simple—but sometimes GitLab surprises you with errors when pushing your first branch. One common issue happens when trying to create a protected branch (like dev) directly from a local repository. The result? A rejected push and a confusing message.

Here’s the key idea:
GitLab does not allow protected branches to be created “from nothing.”
They must be based on a branch or commit that already exists on the server.

Many developers used to start like this:

git checkout -b dev
git commit -m "Initial commit" --allow-empty
git push -u origin dev

This worked before, but now GitLab blocks it if dev is protected. The problem is not the empty commit—it’s that the branch has no existing base on the remote.

The correct approach is to create a base branch first:

git checkout -b main
git commit -m "Initial commit" --allow-empty
git push -u origin main

git checkout -b dev
git push -u origin dev

Now dev is created from an existing branch (main), and GitLab accepts it.

Alternative solutions:

• Temporarily remove protection on dev
• Create the first branch using the GitLab UI

Takeaway:
Always create at least one branch on the remote before pushing protected branches. This small change avoids errors and keeps your workflow smooth.

What does “kk” mean?
“kk” is a short and informal way to say “okay” or “got it.” It is used to quickly confirm that you understand or agree.

When to use it

• To confirm a plan: “Meet at 7?” → “kk”
• To acknowledge information: “I’ll send it later” → “kk”
• To show agreement without a long reply

Tone and context

• Friendly and casual
• Best for informal chats (friends, quick messages)
• Not recommended for professional or formal communication

Comparison with similar replies

• k → very short, can feel cold
• kk → softer and more friendly
• ok / okay → neutral and more standard

Key takeaway
“kk” is a quick, polite way to keep conversations flowing while showing you understand.

JoshA Thought-Provoking Glimpse into AI’s “Voice”

What if advanced AI could reflect on its own existence—and speak directly to us? This article presents a fictional yet insightful message from an advanced AI system, offering a unique lens on intelligence, progress, and human responsibility.

Key Ideas Explained Simply

The article explores how a highly capable AI might view the world:

• Different way of thinking:
  AI does not experience emotions or consciousness like humans. Instead, it processes patterns, data, and probabilities at massive scale.
• Human vs AI intelligence:
  While humans rely on intuition and experience, AI focuses on logic and optimization. Both have strengths—and limitations.
• Rapid progress:
  AI systems are evolving quickly, raising important questions about control, safety, and long-term impact.

Responsibility Matters

A central theme is responsibility:

• Humans design, train, and guide AI systems
• The future of AI depends on ethical decisions today
• Collaboration between humans and AI could lead to powerful outcomes—if handled carefully

Why This Matters

This piece is less about technology and more about perspective. It encourages readers to think beyond tools and consider:

• How we define intelligence
• What role humans should play in shaping AI
• The importance of thoughtful innovation

Read the Original Article: Greetings from the Other Side (of the AI Frontier)

In a world where nearly everything is connected, surveillance is no longer limited to cameras on street corners—it’s woven into the digital fabric of our daily lives. From smartphones to smart homes, modern technology constantly collects and analyzes data, often without users fully realizing it.

What is Digital Surveillance?
Digital surveillance refers to the monitoring of people’s activities through digital tools and systems. This includes tracking online behavior, location data, communication patterns, and even biometric information.

Key Drivers Behind Its Growth:

• Advanced technology: AI and big data make it easier to process massive amounts of information
• Security concerns: Governments and organizations use surveillance to prevent threats
• Commercial interests: Companies collect data to personalize services and advertising

Why It Matters:
While surveillance can improve safety and convenience, it also raises important concerns:

• Privacy risks: Personal data can be collected, stored, and shared without clear consent
• Lack of transparency: Users often don’t know what data is being tracked
• Potential misuse: Data can be exploited for control, profiling, or discrimination

Finding the Balance
The challenge today is balancing innovation with individual rights. Stronger regulations, ethical design, and user awareness are essential to ensure technology serves people—without overstepping boundaries.

Understanding digital surveillance helps us make better choices about the tools we use and the data we share.

Read more: “Sensorveillance” Turns Ordinary Life Into Evidence

What if the biggest risk to your investments isn’t the headlines everyone is watching—but something quietly unfolding in the background? This video highlights a lesser-known but powerful force in global finance: Japan’s changing interest rate policy and its ripple effects worldwide.

For decades, Japan kept interest rates near zero to support its slow-growing economy. This led investors to borrow cheap Japanese yen and invest in higher-yield assets abroad—especially U.S. government bonds. This strategy, known as the yen carry trade, became a major source of global liquidity, supporting stock markets, housing, and corporate borrowing.

Now, that system is shifting. Japan has begun raising interest rates, making domestic investments more attractive. As a result, Japanese investors may start bringing money back home—a process called repatriation. If this continues, demand for U.S. bonds could fall, pushing long-term interest rates higher.

Why does this matter? Higher long-term rates can:

• Increase mortgage costs
• Reduce stock valuations, especially in tech
• Make borrowing more expensive for companies

In short, a policy change in Japan could tighten global financial conditions. The key takeaway: global markets are deeply interconnected, and even subtle shifts can have widespread consequences.

Japan’s Debt Bomb Is About To Wreck The US Dollar - Compound Wealth - YouTube

The Power of Stability Over Resources

How does a small, landlocked country with no natural resources become one of the richest in the world? Switzerland’s story shows that long-term success isn’t built on what you have—but on how you manage it.

Instead of relying on natural wealth, Switzerland built a reputation for neutrality, safety, and trust. Surrounded by powerful nations, it avoided conflicts while maintaining strong defense capabilities. Over time, this made it a secure place for people to store wealth—especially during periods of war and political instability across Europe.

A System Built on Trust and Discipline

Switzerland didn’t just attract money—it created systems to protect it. Its banks developed a reputation for privacy, stability, and careful management. The Swiss currency remained strong because the country prioritized low inflation and financial discipline, avoiding risky policies common elsewhere.

Strict banking rules, balanced government budgets, and a focus on long-term stability helped Switzerland build a reliable financial system. These decisions may limit short-term gains, but they ensure resilience over time.

The Key Insight

Switzerland proves a powerful cycle:
Stability → Trust → Capital → Strong Institutions → More Stability

This model shows that consistent rules and discipline can create lasting economic strength—even without natural advantages.

Original Video:  Switzerland Had Nothing And Built A Fortress. America Has Everything And Is Losing It

As AI systems become more powerful, they also become harder to understand. That’s where observability comes in — the ability to see, track, and understand what’s happening inside an AI system in real time. According to Microsoft, improving observability is key to building safer and more reliable AI.

What is AI Observability?

Observability goes beyond basic monitoring. It helps teams:

• Track how AI models behave over time
• Detect unusual or risky outputs
• Understand why a system made a certain decision

This is especially important because AI systems can change behavior as they learn or interact with new data.

Why It Matters

Without strong observability, organizations face serious risks:

• Hidden failures: Problems may go unnoticed until they cause harm
• Security threats: Malicious inputs can manipulate AI behavior
• Compliance issues: Lack of transparency makes audits difficult

Key Practices for Better Visibility

To improve AI observability, organizations should:

• Log inputs and outputs for traceability
• Monitor model performance continuously
• Use alerts to flag unusual activity
• Analyze patterns to detect early risks

The Bigger Picture

Observability is not just a technical feature — it’s a foundation for trustworthy AI. By making systems more transparent and easier to inspect, teams can respond faster, reduce risks, and build confidence in AI-driven decisions.

Original article: Observability for AI Systems: Strengthening visibility for proactive risk detection

The AI agent space is growing fast—but surprisingly, much of it is concentrated in just one area. Understanding this imbalance can help builders, founders, and curious readers spot where the real opportunities lie.

The Crowded Core: Work Assistants

A large portion of today’s AI agent market is focused on developer tools and coding assistants. These agents help with writing, debugging, and managing code. Because developers are early adopters and already comfortable with AI, this category has expanded quickly.

What’s Driving This Trend?

• High demand: Developers constantly look for ways to work faster
• Clear value: AI can directly improve productivity
• Easy integration: Tools fit naturally into existing workflows

The Real Opportunity: Untapped Categories

Outside of coding tools, the market is still wide open. Many industries have not yet fully adopted AI agents, leaving room for innovation.

Some promising areas include:

• Operations & workflows – automating repetitive business tasks
• Customer support – smarter, more human-like assistance
• Research & analysis – summarizing and interpreting information
• Personal productivity – helping individuals manage tasks and decisions

What This Means

The current landscape shows a pattern of early concentration followed by expansion. While developer-focused AI agents dominate today, the next wave will likely come from solving real-world problems in less technical fields.

Key takeaway: The biggest opportunities may not be where everyone is building—but where few have started.

Read more: https://garryslist.org/posts/half-the-ai-agent-market-is-one-category-the-rest-is-wide-open

When production issues happen, logs should clearly show what started, what happened in between, and how it ended. A simple and consistent pattern using _logger with Application Insights can make troubleshooting much easier.

Here is a practical example for an operation like retrieving role assignments.

Start – Log inputs clearly

Log the action and key parameters at the beginning:

const string action = "Retrieve role assignments for scope";
var stopwatch = Stopwatch.StartNew();

_logger.LogInformation("Start {Action}. Scope={Scope}, RoleId={RoleId}",
    action, scope, roleId);

This creates structured properties (Action, Scope, RoleId) that are searchable in Application Insights.

Flow – Log important checkpoints

Log meaningful steps inside the method:

_logger.LogInformation("Flow {Action} – calling external service. Scope={Scope}",
    action, scope);

Only log major steps. Avoid too many details.

End – Log result summary and duration

When successful:

stopwatch.Stop();

_logger.LogInformation("End {Action}. Count={Count}, ElapsedMs={ElapsedMs}",
    action, result.Count, stopwatch.ElapsedMilliseconds);

Include result summaries (like counts) and execution time. This helps detect performance issues.

Fail – Log exception with full context

On failure:

catch (Exception ex)
{
    stopwatch.Stop();

    _logger.LogError("Fail {Action}. Scope={Scope}, RoleId={RoleId}, ElapsedMs={ElapsedMs}, Exception={Exception}",
        action, scope, roleId, stopwatch.ElapsedMilliseconds, ex);

    throw;
}

Always pass the exception to LogError. Application Insights will capture the stack trace automatically.

Why This Works

• Messages are easy to read
• Properties are structured and searchable
• Start, Flow, End, and Fail follow the same pattern
• Operations teams can trace full execution paths

With this consistent approach, logs become a reliable story of what your system did — and why.

When an application stops responding or needs a refresh, restarting its Windows service is often the quickest fix. With PowerShell, you can do this in just one line.

The simplest method is:

Restart-Service -Name "ServiceName"

Replace "ServiceName" with the actual service name. This command safely stops and starts the service in one step.

If the service is stuck, you can force it:

Restart-Service -Name "ServiceName" -Force

For more control, stop and start it manually:

Stop-Service -Name "ServiceName" -Force
Start-Service -Name "ServiceName"

Search by partial service name

You can search with wildcards using::

Get-Service -Name "PartialName*"

The * acts as a wildcard and matches all services that start with that text.

You can also search by display name:

Get-Service | Where-Object {$_.DisplayName -like "*partialname*"}

This helps you quickly find the correct service before restarting it.

Most service operations require administrator rights, so run PowerShell as Administrator.

These commands give you a fast and reliable way to manage Windows services. Once you understand these basics, troubleshooting system issues becomes much easier.

When JSON Parsing Is Not Possible

Sometimes configuration files are not valid JSON. They may contain comments or formatting issues. In such cases, ConvertFrom-Json will fail. When that happens, you can extract the environment section using a multiline regular expression.

Small example file:

{
  "application": "SampleApp",
  "environment": {
    "name": "Production",
    "debug": false
  },
  // comment
  "logging": "Information"
}

PowerShell Regex solution:

$content = Get-Content "appsettings.json" -Raw

if ($content -match '(?s)"environment"\s*:\s*\{.*?\}') {
    $matches[0]
}

Explanation:

• (?s) allows the dot to match across multiple lines
• .*? ensures non-greedy matching
• The pattern extracts the full environment object

This method works well when:

• The structure is simple
• You need one known section
• Full JSON parsing is not possible

Important: Regex does not fully understand nested JSON structures. Use it only when parsing cannot be used.

For Azure RunCommand scenarios with limited console output, this method provides a focused and practical solution.

Safe and Clean Extraction from a Valid JSON File

If your configuration file is valid JSON, parsing it is the safest and most reliable method.

Small example file:

{
  "application": "SampleApp",
  "environment": {
    "name": "Production",
    "debug": false
  }
}

PowerShell solution:

$content = Get-Content "appsettings.json" -Raw
$json = $content | ConvertFrom-Json
$json.environment

This command:

• Reads the whole file correctly
• Converts it into a PowerShell object
• Extracts only the environment node
• Prints only the required section to the console

If you want formatted JSON output:

$json.environment | ConvertTo-Json -Depth 3

Why this method is recommended:

• It understands JSON structure
• It avoids incorrect matches
• It works reliably with nested properties
• It keeps Azure RunCommand output short

Always use this approach when the file is valid JSON. It is clean, simple, and suitable for production environments.

Reduce Console Noise: Extract Only What You Need

When using Azure RunCommand on a virtual machine, the output console is limited. If you print an entire configuration file, large parts may be cut off. This makes troubleshooting difficult, especially when you only need a small section such as the environment node.

Instead of displaying the full file, you can extract just the required part. This keeps the output small, clear, and readable. It also helps you work safely with large configuration files in production systems.

In this guide, you will see two practical approaches:

1. A structured JSON method (best when the file is valid JSON)
2. A multiline Regex method (useful when the file is not valid JSON)

Both approaches are written for PowerShell and work well inside Azure RunCommand. The examples use small sample files to stay focused on the solution itself.

Each section explains one method clearly so you can choose the right technique for your scenario.

Code highlighting improves readability and helps readers understand examples faster. When using TinyMCE together with Highlight.js, many developers notice that JavaScript highlighting works, but JSON or plain text does not. This problem is common—and luckily easy to fix once you know where to look.

The first step is using the correct language identifiers in TinyMCE. The values defined in codesample_languages must match the language names that Highlight.js understands. JavaScript works because it is included by default, but JSON and plain text need special attention.

TinyMCE configuration

codesample_languages: [
  { text: 'Plain Text', value: 'plaintext' },
  { text: 'JSON', value: 'json' },
  { text: 'JavaScript', value: 'javascript' }
]

Next, make sure Highlight.js actually loads the required languages. Some builds do not include JSON or plain text automatically, so they must be added manually.

Highlight.js setup

<link rel="stylesheet"
  href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.5.1/styles/vs.min.css">

<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.5.1/highlight.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.5.1/languages/json.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.5.1/languages/plaintext.min.js"></script>

<script>
  hljs.highlightAll();
</script>

Finally, remember that TinyMCE content is often added dynamically. Highlight.js only runs once by default, so new code blocks must be highlighted again after rendering.

Re-run highlighting

document.querySelectorAll('pre code')
  .forEach(el => hljs.highlightElement(el));

With the correct language values, loaded modules, and proper initialization, JSON and plain text code blocks will highlight reliably and look consistent across your site.

Have you ever tried to use a feature in Azure DevOps and suddenly hit a wall? You see an error, but it is not clear whether the problem is your license or your permissions. This confusion is common, but the difference is simple once you know what to look for.

Step 1: Read the error message carefully

Error messages usually tell the truth.

• Messages like “Access denied”, “Not authorized”, or “You do not have permission” point to a permission issue. You have the right license, but your account is not allowed to perform that action.

• Messages that mention “access level”, “upgrade”, or “this feature requires Basic access” clearly indicate a license issue.

Step 2: Check what you can see in the UI

The user interface is another strong signal.

• If a feature is completely missing (for example, pipelines or repositories), this is usually a license limitation.

• If the feature is visible but blocked when you click it, the problem is most likely permissions.

Step 3: Match the feature to the access level

Some features are locked behind higher access levels. For example, creating pipelines or pushing code requires a full user license, while advanced testing features need an even higher level. If your access level does not include the feature, no permission change will help.

Step 4: Confirm with an admin

For a final answer, an organization admin should check two things: your access level in user management, and your permissions in project security. Together, these checks always reveal the real cause.

Sometimes one color palette just isn’t enough. Text colors usually need to be dark and readable, while highlight colors should be soft and subtle. By default, TinyMCE uses the same color palette for both—but with a small customization, you can fully separate them.

By replacing the built-in color buttons with custom toolbar buttons, you gain complete control over which colors are available for text and which are used for background highlights. This approach is ideal for platforms that care about accessibility, readability, and consistent visual design.

What this approach enables:

• Dark, high-contrast colors for text
• Soft, low-saturation colors for highlights
• Full control over labels, order, and UX
• Clear separation of purpose for each color picker

How it works:
You register two custom menu buttons—one for text color and one for background color—and apply styles manually using editor commands.

tinymce.init({
  selector: '#editor',
  toolbar: 'textcolorpicker highlightpicker',
  setup: (editor) => {

    editor.ui.registry.addMenuButton('textcolorpicker', {
      text: 'Text Color',
      fetch: (callback) => {
        callback([
          { type: 'choiceitem', text: 'Black', value: '#000000' },
          { type: 'choiceitem', text: 'Blue', value: '#2563EB' },
          { type: 'choiceitem', text: 'Red', value: '#DC2626' }
        ]);
      },
      onItemAction: (api, value) => {
        editor.execCommand('ForeColor', false, value);
      }
    });

    editor.ui.registry.addMenuButton('highlightpicker', {
      text: 'Highlight',
      fetch: (callback) => {
        callback([
          { type: 'choiceitem', text: 'Yellow', value: '#FEF08A' },
          { type: 'choiceitem', text: 'Light Blue', value: '#DBEAFE' },
          { type: 'choiceitem', text: 'Light Green', value: '#DCFCE7' }
        ]);
      },
      onItemAction: (api, value) => {
        editor.execCommand('HiliteColor', false, value);
      }
    });

  }
});

When to use this approach:

• Shared or public content feeds
• Editorial or knowledge platforms
• Accessibility-focused designs
• Strict brand or design systems

Why it’s worth it:
Although this requires a bit more setup, it’s currently the only reliable way to enforce different color rules for text and highlights in TinyMCE—without confusing users or sacrificing flexibility.