Today we continue to read up on compliance overview of Adobe Cloud Services.Adobe is able to meet these standards and regulations because it practices a bottom up physical layer securing approach called the Adobe Common Controls Framework and a top down software layer securing approach called the Adobe Secure Product Lifecycle. The former manifests as a set of Adobe specific controls that map to approximately a dozen security standards and the latter is a set of security activities that span several product development practices, processes and tools. Therefore there is a layering of software supported on both infrastructure and operations which is available over a physical layer. This is secured from both directions - top and bottom with the SPL and CCF.
The CCF is built so that it is not specific to any of the products. Instead teams can inherit control capabilities from other parts of the organization. This way a software engineer does not have to be concerned about data center security but they inherit it from the data center operations team. The CCF conceptual model promotes Adobe corporate standards such as business continuity, security governance, data privacy, and people resources over product engineering which is based on product operations and that in turn operates on Adobe Product cloud which assures physical and environmental security. The product engineering adopts the SPL approach and the product operations adopts enforces monitoring, configuration, asset management, change management, logical access and incident response. The CCF has approximately 273 common controls across  twenty control domains. These include asset management, backup management, Business continuity, change management, configuration management, data management, Identity and access management, Incident response, Mobile device management, network operations, people resources, risk management, security governance, service lifecycle, site operations, system design documentation, systems monitoring, third party management, training and awareness and vulnerability management.
Compliance is reviewed periodically.
#codingexercise
Yesterday we described a codingexercise to find the maximum product of a sequence in an array where the elements are not adjacents.if the integers were both positive and negative, we would have need to make sure the count of selected negatives is even. We would keep track of two products one with the negative integers only and the other regular.

The key observation here is that we skip the negatives and find the desired max among the positives. Then we take the negatives alone and find their desired max with the additional criteria that they have to be even in count. Whichever is greater dictates the list that will be included as is and elements of the other list will be included such that there are no adjacencies.
int GetMaxProductBothPositiveAndNegative(List<int>A)
{
var positives = A.Clone();
for (int i = 0; i < positives.Count; i++)
    if (positives[i] <= 0)
        positives[i] = 1;
var max_positives = GetMaxProductList(positives);
var negatives = A.Clone();
for (int i = 0; i < negatives.Count; i++)
    if (negatives[i] >= 0)
        negatives[i] = 1;
var max_negatives = GetMaxNegativeList(negatives);
return RemoveAdjacencies(max_positives, max_negatives, A).Product();
}

List<int> GetMaxPositiveList(List<int> A)

{
var ret = new List<int>();

assert( A.all(x => x > 0));

if (A == null || A.Count == 0) return 0;

int inclusive = A[0];

int exclusive = 0;

for (int i = 1; i < A.Count; i++)

{

var max = Math.max(inclusive, exclusive);
if (max == inclusive)
    ret.add(A[i-1]);

inclusive  = exclusive × A[i];

exclusive = max;

}

int last= Math.max(inclusive, exclusive);
if (last== inclusive)
    ret.add(A[A.count-1]);
return ret;

}