When writing scripts in YAML (such as for Azure DevOps pipelines), using colons :
inside commands like Write-Host
can sometimes trigger validation warnings in tools like Visual Studio.
This happens because YAML uses colons to define key-value pairs, and it may confuse your script as malformed YAML if colons aren't properly handled.
Here's how to avoid the issue:
✔️ Recommended Solutions
1. Use multi-line block with |
Best for longer scripts or when readability matters.
steps: - powershell: | Write-Host "Value is: 42"
2. Quote single-line scripts
Wrap the whole command in single or double quotes.
steps: - script: "Write-Host 'Value is: 42'" displayName: 'Print Value'
❌ Avoid this pattern:
When working with software versions like 1.0.2
or 3.45.12-SNAPSHOT
, it's common to use regular expressions (regex) to validate or extract these patterns. This Snipp shows you a simple and effective way to match such version numbers using regex.
1.0.2
3.32.34
3.45.12-SNAPSHOT
These are typical semantic version numbers and may optionally include a suffix like -SNAPSHOT
.
^\d+\.\d+\.\d+(?:-SNAPSHOT)?$
^
— Start of the string\d+
— One or more digits (major, minor, patch)\.
— Dots separating version parts(?:-SNAPSHOT)?
— Optional suffix (non-capturing group)$
— End of the string1.0.2
3.32.34
3.45.12-SNAPSHOT
1.0
3.2.4-RELEASE
a.b.c
This pattern is useful when validating software version inputs in forms, logs, or build scripts.
When configuring GitLab CI/CD pipelines, two common keywords—rules:
and only:
—determine when a job should run. While they can seem similar, they have key differences in flexibility and functionality.
rules:
– The Modern Wayrules:
is the recommended and more powerful approach. It lets you control job execution using:
when: never
, when: manual
, etc.)Example:
rules: - if: $CI_COMMIT_BRANCH =~ /^feature|issue\/.*$/ changes: - global.json - src/**/* - if: $CI_COMMIT_BRANCH == "dev" && $CI_COMMIT_MESSAGE =~ /\[nopublish\]/ when: never
Tipp: To detect changes to a file in the repo's root (like global.json
), just add the filename without a path:
only:
– The Legacy Filteronly:
is simpler but limited. It matches jobs based on:
It cannot check file changes or commit messages.
Example:
only: - /^feature\/.*$/ - main - dev
Use rules:
for:
Stick with only:
only for very simple setups or when updating legacy code.
Behind Nvidia’s AI dominance is a software platform most people have never heard of — CUDA. Created in 2004 by Ian Buck, CUDA began as a side project and turned into a secret weapon that powers everything from ChatGPT to cutting-edge robotics.
While rivals focus on building faster chips, CUDA gives Nvidia something harder to copy: an ecosystem. With over 900 libraries and deep adoption across industries, it’s why 90% of AI workloads run on Nvidia hardware today. Buck, once a startup founder, now leads the team defending and evolving this strategic edge — and some say he may even be in line to lead Nvidia next.
Curious how one quiet innovation shaped the future of AI?
Read the full story at Meet Ian Buck, the Architect of CUDA, Nvidia's $3.5 Trillion Moat - Business Insider
Open source software (OSS) has evolved from a niche hobby to the backbone of mission-critical systems—from cloud infrastructure to AI platforms and government services. Today, embracing OSS isn’t optional; it’s a strategic choice offering several key benefits:
However, businesses must also navigate challenges: support isn’t automatic (so consider vendor-backed services), choose active and well-governed projects, and understand licensing implications before adoption .
By forging smart open source strategies—engaging with communities, investing in support, and contributing back—companies can accelerate growth, control costs, and stay ahead in an evolving digital landscape.
Original link: https://towardsdatascience.com/why-open-source-is-no-longer-optional-and-how-to-make-it-work-for-your-business/
When writing YAML scripts for CI/CD pipelines, it's important to use the correct file path format and handle special characters properly. A common issue developers face is using Windows-style backslashes (\
) in paths, which YAML and many tools like Visual Studio interpret as escape characters. Another is forgetting to quote paths that contain special characters like *
.
To avoid these issues, follow these simple practices.
Always use forward slashes /
in your paths. This format works on all platforms and avoids YAML parsing errors.
Instead of: {project}\publish\bin
Use:
{project}/publish/bin
If your path includes special characters such as *
, wrap the string in double quotes. This tells YAML to treat the entire string as a literal value, not as a command or reference.
Correct usage:
"{project}/publish/bin/*"
These small adjustments help make your YAML files more robust and portable.
Windows 11 supports the use of both Bluetooth and wired audio devices at the same time:
This setup allows audio to be played through both Bluetooth and wired devices concurrently.
Combining base URLs with relative paths in .NET can lead to errors if not handled carefully. This guide shows a safe and reusable way to do it using two methods: one that works with Uri
objects and another that accepts strings for convenience.
Here's the core method that safely combines a Uri
with a relative path:
public static string SafeCombineUrl(Uri? baseUri, string relativePath) { try { if (string.IsNullOrWhiteSpace(relativePath)) { return baseUri?.ToString() ?? string.Empty; } if (baseUri == null) { return relativePath; } return new Uri(baseUri, relativePath).ToString(); } catch (Exception ex) { return $"[InvalidUrl={ex.Message}]"; } }
To make it easier to use with strings, add this helper method:
public static string SafeCombineUrl(string baseUri, string relativePath) { try { Uri? baseUriObj = null; if (!string.IsNullOrWhiteSpace(baseUri)) { baseUriObj = new Uri(baseUri, UriKind.Absolute); } return SafeCombineUrl(baseUriObj, relativePath); } catch (Exception ex) { return $"[InvalidBaseUri={ex.Message}]"; } }
relativePath
is empty, it returns the base URL.When working with JsonElement
in C#, calling methods like TryGetProperty
on a default or uninitialized JsonElement
can cause runtime exceptions. This usually happens when the JsonElement
has not been properly assigned a value.
To avoid this issue, always check whether the JsonElement
is valid before accessing its properties. A safe way to do this is by checking its ValueKind
.
Here’s a safer extension method that returns a string property only if it exists and the element is valid:
public static string? GetStringProperty(this JsonElement element, string propertyName) { if (element.ValueKind == JsonValueKind.Undefined) return null; return element.TryGetProperty(propertyName, out var prop) && prop.ValueKind == JsonValueKind.String ? prop.GetString() : null; }
This ensures that your code won’t throw an InvalidOperationException
when the JsonElement
is default
.
Use this method when reading from JSON documents where property existence isn’t guaranteed.
When writing unit tests for a custom DelegatingHandler
, you might try calling:
var response = await handler.SendAsync(request, cancellationToken);
But this will cause a compiler error. Why? Because SendAsync
in DelegatingHandler
is protected, meaning you can't call it directly from your test project.
Use HttpMessageInvoker
, which is designed to work with any HttpMessageHandler
(including DelegatingHandler
). It provides a public SendAsync
method, so you can easily test your handler:
var handler = new YourCustomHandler { InnerHandler = new DummyHandler() // Replace with mock/stub as needed }; var invoker = new HttpMessageInvoker(handler); var response = await invoker.SendAsync(request, cancellationToken);
This allows you to simulate HTTP requests through your custom handler, without using HttpClient
.
DelegatingHandler
is a subclass of HttpMessageHandler
.HttpMessageInvoker
takes any HttpMessageHandler
and exposes a public way to send HTTP requests.protected SendAsync
.Use a mock InnerHandler
to control the behavior of the response. This helps you test how your DelegatingHandler
reacts to different scenarios.