Making SQL Server run on Linux involves introducing what is known as a Platform Abstraction Layer (“PAL”) into SQL Server. This layer is used to align all operating system or platform specific code in one place and allow the rest of the codebase to stay opera
70 percent of the vulnerabilities Microsoft assigns a CVE each year continue to be memory safety issues.
The volatile keyword in C# is used to inform the JIT compiler that the value of the variable should never be cached because it might be changed by the operating system, the hardware, or a concurrently executing thread.
Comprehensive Rust 🦀
This is a three day Rust course developed by the Android team. The course covers the full spectrum of Rust, from basic syntax to advanced topics like generics and error handling. It also includes Android-specific content on the last day.
{
"version": "0.1.0",
// The command is tsc. Assumes that tsc has been installed using npm install -g typescript
"command": "tsc",
// The command is a shell script
"isShellCommand": true,
// Show the output window only if unrecognized errors occur.
"showOutput": "silent",
// args is the HelloWorld program to compile.
"args": ["HelloWorld.ts"],
// use the standard tsc problem matcher to find compile problems
// in the output.
"problemMatcher": "$tsc"
} "args": [
"--target", "ES5",
"--outdir", "js",
"--sourceMap",
"--watch",
"test.ts"
], 
error TS5023: Unknown option 'watch' Use the '--help' flag to see options.
15:33:52 - Compilation complete. Watching for file changes.
TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory);
var dictionary = new ConcurrentDictionary<string, string>();
var value = dictionary.GetOrAdd("key1", x => "item 1");
Console.WriteLine(value);
value = dictionary.GetOrAdd("key1", x => "item 2");
Console.WriteLine(value); item 1 item 1
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
namespace Sample
{
class Program
{
static void Main(string[] args)
{
var dictionary = new ConcurrentDictionary<int, int>();
var options = new ParallelOptions { MaxDegreeOfParallelism = 100 };
var addStack = new ConcurrentStack<int>();
Parallel.For(1, 1000, options, i =>
{
var key = i % 10;
dictionary.GetOrAdd(key, k =>
{
addStack.Push(k);
return i;
});
});
Console.WriteLine($"dictionary.Count: {dictionary.Count}");
Console.WriteLine($"addStack.Count: {addStack.Count}");
}
}
} dictionary.Count: 10 addStack.Count: 13
// 'GetOrAdd' call on the dictionary is not thread safe and we might end up creating the pipeline more // once. To prevent this Lazy<> is used. In the worst case multiple Lazy<> objects are created for multiple // threads but only one of the objects succeeds in creating a pipeline. private readonly ConcurrentDictionary<Type, Lazy<RequestDelegate>> _pipelinesCache = new ConcurrentDictionary<Type, Lazy<RequestDelegate>>();
namespace Sample
{
class Program
{
static void Main(string[] args)
{
var dictionary = new ConcurrentDictionary<int, Lazy<int>>();
var options = new ParallelOptions { MaxDegreeOfParallelism = 100 };
var addStack = new ConcurrentStack<int>();
Parallel.For(1, 1000, options, i =>
{
var key = i % 10;
dictionary.GetOrAdd(key, k => new Lazy<int>(() =>
{
addStack.Push(k);
return i;
}));
});
// Access the dictionary values to create lazy values.
foreach (var pair in dictionary)
Console.WriteLine(pair.Value.Value);
Console.WriteLine($"dictionary.Count: {dictionary.Count}");
Console.WriteLine($"addStack.Count: {addStack.Count}");
}
}
} 10 1 2 3 4 5 6 7 8 9 dictionary.Count: 10 addStack.Count: 10
public class LazyConcurrentDictionary<TKey, TValue>
{
private readonly ConcurrentDictionary<TKey, Lazy<TValue>> _concurrentDictionary;
public LazyConcurrentDictionary()
{
_concurrentDictionary = new ConcurrentDictionary<TKey, Lazy<TValue>>();
}
public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
{
var lazyResult = _concurrentDictionary.GetOrAdd(key,
k => new Lazy<TValue>(() => valueFactory(k), LazyThreadSafetyMode.ExecutionAndPublication));
return lazyResult.Value;
}
} This is just a list of all the things I've written on Windows authentication.
A 2016 study found that the economic impact of Daylight Saving , due to increased heart attacks, workplace accidents and cyberloafing (slacking off at work!) cost the US economy $434 million each year, there are a great many others that present similar evidence.
In 2019 the European Union voted to abolish daylight saving in 2021, similarly the “Sunshine Protection Act of 2021” is gaining traction in the US. Over the next decade I feel quite sure that most of the globe will reject daylight saving entirely.
