The Coco Framework is an open-source system that enables high-scale, confidential blockchain networks.

Coco achieves this by designing specifically for confidential consortiums, where nodes and actors are explicitly declared and controlled. Based on these requirements, Coco presents an alternative approach to ledger construction, giving enterprises the scalability, distributed governance and enhanced confidentiality they need without sacrificing the inherent security and immutability they expect.

https://azure.microsoft.com/en-us/blog/announcing-microsoft-s-coco-framework-for-enterprise-blockchain-networks/

The garbage collector is a tool for managing the heap.

You allocate to the stack when you’re defining things in a local scope where you know exactly the memory block size you need, such as primitive data types, arrays of a set size, etc.

The stack is a self-managing memory store that you don’t have to worry about – it’s super fast at allocating and clearing memory all by itself.

For other memory allocations, such as objects, buffers, strings, or global variables, you allocate to the heap.

Compared to the stack, the heap is not self-managing. Memory allocated to the heap will sit there throughout the duration of the program and can change state at any point in time as you manually allocate/deallocate to it. 

https://dev.to/thecodeboss/programming-concepts-garbage-collection

A SaaS company:

• Programmable SMS: An API to exchange text and picture messages.
• Programmable Voice: An API and intelligent services to build the exact call experience you want with just a few lines of code.
• Elastic SIP Trunking: Local carrier connectivity

https://www.twilio.com/

Asymptotic Notations are languages that allow us to analyze an algorithm’s running time by identifying its behavior as the input size for the algorithm increases. This is also known as an algorithm’s growth rate.

http://bigocheatsheet.com/

https://www.khanacademy.org/computing/computer-science/algorithms

Problem: You can use event-driven architecture to solve the distributed data management challenges in a microservices architecture. However, one major challenge with implementing an event-driven architecture is atomically updating the database and publishing an event. Consider, for example, the Create Order use case. The service that implements this use case must perform two operations: insert a row into the ORDER table and publish an OrderCreated event. It is essential that both operations are done atomically. If only one operation happened because of a failure then the system would behave incorrectly.

The standard way to atomically is to use a distributed transaction involving a database and a message broker. However, for the reasons described earlier this is exactly what we do not want to do.

Event Sourcing is an architectural pattern.

http://eventuate.io/whyeventsourcing.html

The HTTP 407 Proxy Authentication Required client error status response code indicates that the request has not been applied because it lacks valid authentication credentials for a proxy server that is between the browser and the server that can access the requested resource.

This status is sent with a Proxy-Authenticate header that contains information on how to authorize correctly.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/407

$filter: The expression specified with $filter is evaluated for each resource in the collection, and only items where the expression evaluates to true are included in the response.

serviceRoot/People?$filter=FirstName eq 'Scott'

$orderby: The $orderby system query option allows clients to request resources in either ascending order using asc or descending order using desc.

serviceRoot/People('scottketchum')/Trips?$orderby=EndsAt desc

$count: The $count system query option allows clients to request a count of the matching resources included with the resources in the response.

serviceRoot/People/$count

$select: The $select system query option allows the clients to requests a limited set of properties for each entity

serviceRoot/Airports?$select=Name, IcaoCode

$top & $skip: The $top system query option requests the number of items in the queried collection to be included in the result. The $skip query option requests the number of items in the queried collection that are to be skipped and not included in the result.

serviceRoot/People?$top=2

$expand: The $expand system query option specifies the related resources to be included in line with retrieved resources.

serviceRoot/People('keithpinckney')?$expand=Friends

http://www.odata.org/getting-started/basic-tutorial

http://anthonysciamanna.com/2017/06/18/tdd-is-not-a-testing-practice.html

• faster feedback loop for developers
• The benefits of TDD and the near instantaneous feedback cycles it produces are addictive and extremely valuable.
• Many benefits exist beyond software design, the creation of unit tests, and the executable documentation that unit tests serve as.
• It is essential that safe learning environments are created so that developers can learn and practice without feeling like it will only interfere with their ability to “ship features faster”.
• Often people believe that the primary justification for practicing TDD is the creation of unit tests. This illustrates the most common misunderstanding of TDD: that TDD is a testing practice.
• When practicing TDD, a high quality unit test suite is a secondary benefit. It can even be considered a side-effect of the practice.
• TDD requires developers to learn evolutionary software design techniques and how to incrementally develop features.
• TDD often facilitates developer collaboration. When combined with pair programming, in a practice called Ping Pong Pair Programming, TDD creates a powerful workflow, opportunities for team collaboration, and helps create a culture of mentoring on development teams. It does this by creating extremely short feedback cycles within the pairing session, ideal for mentoring developers.

Accenture, Microsoft Team Up on Blockchain-Based Digital ID Network

Blockchain, first developed as a public ledger of all transactions in the digital currency bitcoin, is increasingly being used to securely track data in other fields.

"Without an identity you can't access education, financial services, healthcare, you name it. You are disenfranchised and marginalized from society," David Treat, a managing director in Accenture's financial services practice, said in an interview.

"Having a digital identity is a basic human right."

https://www.nytimes.com/reuters/2017/06/19/business/19reuters-microsoft-accenture-digitalid.html

RSS: Residual Sum of Squares

It is a measure of the discrepancy between the data and an estimation model.

A small RSS indicates a tight fit of the model to the data. It is used as an optimality criterion in parameter selection and model selection.

RSS is the sum of the squares of residuals (deviations predicted from actual empirical values of data).

In statistics and optimization, errors and residuals are two closely related and easily confused measures of the deviation of an observed value of an element of a statistical sample from its "theoretical value".

Residual of an observed value is the difference between the observed value and the estimated value of the quantity of interest.

https://en.wikipedia.org/wiki/Errors_and_residuals

https://en.wikipedia.org/wiki/Residual_sum_of_squares

Language Understanding Intelligent Service (LUIS) enables developers to build smart applications that can understand human language and react accordingly to user requests.

LUIS uses the power of machine learning to solve the difficult problem of extracting meaning from natural language input, so that your application doesn't have to.

Any client application that converses with users, like a dialog system or a chat bot, can pass user input to a LUIS app and receive results that provide natural language understanding.

Key Concepts:

• Utterance
• Intents
• Entities

https://www.luis.ai

A distributed ledger (also called shared ledger) is a consensus of replicated, shared, and synchronized digital data geographically spread across multiple sites, countries, or institutions.

There is no central administrator or centralised data storage.

A peer-to-peer network is required as well as consensus algorithms to ensure replication across nodes is undertaken.

One distributed ledger design is through implementation of a public or private blockchain system. But all distributed ledgers do not have to necessarily employ a chain of blocks to successfully provide secure and valid achievement of distributed consensus, a Blockchain is only one type of data structure considered to be a distributed ledger.

https://www.infoq.com/news/2017/06/Microsoft-Blockchain-POC

The Duck test is a humorous term for a form of abductive reasoning.

If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

The test implies that a person can identify an unknown subject by observing that subject's habitual characteristics. It is sometimes used to counter abstruse, or even valid, arguments that something is not what it appears to be.

https://en.wikipedia.org/wiki/Duck_test

In computer programming, duck typing is an application of the duck test in type safety. It requires that type checking be deferred to runtime, and is implemented by means of dynamic typing or reflection.

Duck typing is concerned with establishing the suitability of an object for some purpose. With normal typing, suitability is assumed to be determined by an object's type only. In duck typing, an object's suitability is determined by the presence of certain methods and properties (with appropriate meaning), rather than the actual type of the object.

https://en.wikipedia.org/wiki/Duck_typing

C# sample:

using static System.Console;

class Duck
{
    public void Quack() => WriteLine("Quaaaaaack!");
    public void Feathers() => WriteLine("The duck has white and gray feathers.");
}

class Person
{
    public void Quack() => WriteLine("The person imitates a duck.");
    public void Feathers() => WriteLine("The person takes a feather from the ground and shows it.");
}

class Program
{
    static void InTheForest(dynamic obj)
    {
        obj.Quack();
        obj.Feathers();
    }

    static void Game()
    {
        Duck donald = new Duck();
        Person john = new Person();
        InTheForest(donald);
        InTheForest(john);
    }

    static void Main()
    {
        Game();
    }
}

Bayesian inference is a method of statistical inference in which Bayes' theorem is used to update the probability for a hypothesis as more evidence or information becomes available.

https://en.wikipedia.org/wiki/Bayesian_inference

https://www.scientificamerican.com/article/gopnik-artificial-intelligence-helps-in-learning-how-children-learn/

Contains methods to create types of objects locally or remotely, or obtain references to existing remote objects.

This class cannot be inherited.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

https://msdn.microsoft.com/en-us/library/system.activator(v=vs.110).aspx

A package to perform background processing in .NET and .NET Core applications. No Windows Service or separate process required.

Backed by persistent storage.

Open and free for commercial use.

https://www.hangfire.io/

https://twimlai.com

Microsoft DevSkim is a framework of IDE plugins and Language analyzers that provide inline security analysis in the dev environment as the developer writes code. It is designed to work with multiple IDEs (VS, VS Code, Sublime Text, etc.), and has a flexible rule model that supports multiple programming languages.

The idea is to give the developer notification as they are introducing a security vulnerability in order to fix the issue at the point of introduction, and to help build awareness for the developer.

https://marketplace.visualstudio.com/items?itemName=PavelBansky.MicrosoftDevSkim

Fuzzing or fuzz testing is an automated software testing technique that involves providing invalid, unexpected, or random data as inputs to a computer program.

The program is then monitored for exceptions such as crashes, or failing built-in code assertions or for finding potential memory leaks. Typically, fuzzers are used to test programs that take structured inputs.

https://en.wikipedia.org/wiki/Fuzzing