We are happy to announce the availability of .NET 8, the latest LTS version of one of the world’s leading development platforms, starting today. .NET 8 delivers thousands of performance, stability, and security improvements, as well as platform and tooling enhancements that help increase developer productivity and speed of innovation 

SQL Server 2019 is designed to solve challenges of the modern data professional including:

• Store enterprise data in a data lake and offer SQL and Spark query capability overall data
• Reduce the need for Extract, Transform, and Load (ETL) applications by eliminating data movement
• Integrate and secure machine learning applications with scalable performance
• Reduce the need for application and query changes to gain a boost in performance
• Increase confidential computing of data through hardware enclaves
• Increase application and database uptime and availability through features like ADR (Advanced Database Recovery)
• Extend the power of the T-SQL language in a secure and robust fashion
• Run applications and deploy databases across multiple operating systems and platforms with compatibility
• Reduce the risk of upgrades while using new SQL capabilities when you are ready though inbuilt database compatibility levels 

 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

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;
        }
    }

Today we’re excited to announce our support and collaboration on a new Stage 0 proposal to bring optional and erasable type syntax to JavaScript. Because this new syntax wouldn’t change how surrounding code runs, it would effectively act as comments. We think this has the potential to make TypeScript easier and faster to use for development at every scale. We’d like to talk about why we’re pursuing this, and how this proposal works at a high level.

Best practices in Android development 

I wrote this post to prove that thinking behind of DNTFrameworkCore completely different from ABP (at least in most sections)  

<statemachine xmlns="http://statelessdesigner.codeplex.com/Schema">
  <settings>
    <itemname>BugTrackingStateMachine</itemname>
    <namespace>StatelessTests</namespace>
    <class>public</class>
  </settings>
  <triggers>     
    <trigger>Assign</trigger>
    <trigger>Defer</trigger>
    <trigger>Resolve</trigger>
    <trigger>Close</trigger>
  </triggers>
  <states>     
    <state start="yes">Open</state>
    <state>Assigned</state>
    <state>Deferred</state>
    <state>Resolved</state>
    <state>Closed</state>
  </states>
  <transitions>
    <transition trigger="Assign" from="Open" to="Assigned" />
    <transition trigger="Assign" from="Assigned" to="Assigned" />
    <transition trigger="Close" from="Assigned" to="Closed" />
    <transition trigger="Defer" from="Assigned" to="Deferred" />
    <transition trigger="Assign" from="Deferred" to="Assigned" />
    <transition trigger="Resolve" from="Assigned" to="Resolved" />
  </transitions>
</statemachine>

<statemachine xmlns="http://statelessdesigner.codeplex.com/Schema">
  <settings>
    <itemname>RequestPromotionStateMachine</itemname>
    <namespace>StatelessTests</namespace>
    <class>public</class>
  </settings>
  <triggers>     
    <trigger>Complete</trigger>
    <trigger>RequestInfo</trigger>
    <trigger>Deny</trigger>
    <trigger>Approve</trigger>
    <trigger>ManagerJustify</trigger>
  </triggers>
  <states>     
    <state start="yes">RequestPromotionForm</state>
    <state>ManagerReview</state>
    <state>PromotionDenied</state>
    <state>VicePresidentApprove</state>
    <state>Promoted</state>
  </states>
  <transitions>
    <transition trigger="Complete" from="RequestPromotionForm" to="ManagerReview" />

    <transition trigger="RequestInfo" from="ManagerReview" to="RequestPromotionForm" />
    <transition trigger="Deny" from="ManagerReview" to="PromotionDenied" />
    <transition trigger="Approve" from="ManagerReview" to="VicePresidentApprove" />

    <transition trigger="ManagerJustify" from="VicePresidentApprove" to="ManagerReview" />
    <transition trigger="Deny" from="VicePresidentApprove" to="PromotionDenied" />
    <transition trigger="Approve" from="VicePresidentApprove" to="Promoted" />
  </transitions>
</statemachine>

Since we shipped .NET Standard 2.0 about a year ago, we’ve shipped two updates to .NET Core 2.1 and are about to release .NET Core 2.2. It’s time to update the standard to include some of the new concepts as well as a number of small improvements

Let them paste passwords
Allow your website to accept pasted passwords - it makes your site more secure, not less.