Students will develop privacy policy and protocols for a highly regulated organization in the United States that will have a mix of remote, work from home, and multiple business offices. The privacy policy will need to address all work locations in support of the privacy of confidential information. Consider elements such as shared workspaces in the home and workplace, printing, telephone conversations, use or personal devices (computers and phones), access to the internet, etc.
week 2
Instructions will be in the attachment.
Contracting & Service Level Agreements
Discuss in 500 words or more the top 5 details that should be included in your cloud SLA.
Use at least three sources. Include at least 3 quotes from your sources enclosed in quotation marks and cited in-line by reference to your reference list. Example: “words you copied” (citation) These quotes should be one full sentence not altered or paraphrased. Cite your sources using APA format. Use the quotes in your paragaphs. Stand alone quotes will not count toward the 3 required quotes.
Write in essay format not in bulleted, numbered or other list format.
Use the web or other resources to research at least two criminal or civil cases in which recovered files played a significant role in how the case was resolved.
Use the web or other resources to research at least two criminal or civil cases in which recovered files played a significant role in how the case was resolved.
Use your own words and do not copy the work of another student.
Microsoft Access Discussion Easy
Let’s Pause and Reflect on your journey with the MICROSOFT ACCESS relational database management application.
Please identify at least one new feature/function discussed this week in the application and explain why you feel it may be useful to you and/or others.
You’re almost there!!! You should be able to see the ‘light at the end of tunnel’ with your journey through Microsoft Office…Are you planning for future use of these applications?
Please share how you plan to regularly and practically utilize the skills acquired in this class moving forward. How will you keep up your practice in using these applications?
ASSIGNMENT RUBRIC – Wrap Up Extra Credit: Participating in this week’s wrap up thread and satisfying all the criteria of the assignment rubric listed below is worth 0.50 points towards the overall course grade. Click on the Reply link below to make your post.
Points
Identifies and explains a useful feature/function of the application covered in the current week
0.20
Shares substantive response to additional Wrap Up questions
0.20
Satisfies minimum word count requirement = 100 words
0.10
Total Points
0.50
Cyber Security planning & management
Compare and contrast two difference cloud computing services (Amazon Web Service and Microsoft Azure). Explain the differences and the similarities and select your choice of providers if you had to make the decision for your business. Write up a comparison on the services offered (2 pages maximum).
These two links may offer some additional information for this assignment but you are encouraged to use additional sources for your project/assignment.
It is essential that you use your own words (do not just copy and paste from the Internet).
https://aws.amazon.com/security/introduction-to-cloud-security/
https://azure.microsoft.com/en-us/
Research Current Legal Rulings
Please submit your work using the table below as an example in a three to four-page report with APA cited references to support your work. You may add or remove additional columns as needed.
In this unit, you will see information about laws that have been passed several years ago, but you may not see all of the updates and changes that the government makes. To see these updates (rulings), you can search the Federal Register at https://www.federalregister.gov/. This an ongoing information source that summarizes all of the activity of the federal government that required a vote or action.
For this assignment, search the Federal Register for five cases that interest you. A list of possible search topics is listed to help you get started.
- Go to: the Federal Register. https://www.federalregister.gov/.
- Use the Search bar to find rulings related to your topic.
- Then select “rule” for Type (left side menu). This will reduce your search to only show the final rulings (not proposed solutions or public announcements).
- Read through a few of the rulings – you will see a summary of the case, which usually will describe the event that has prompted the need for this law. You will then see the resolution, These are the items that will direct you when you create a compliance plan for your organization.
- Finally, think about potential breaches and what this ruling may NOT have addressed. List a few of the questions that you may still have about this direction from the courts. (critical thinking about what else you would need to do to be in compliance with a ruling like this particular case).
Possible topics for your search:
- Anti-malware
- compliance/auditing
- forensics
- ID management
- Intellectual property
- Managed security service providers (MSSPs)
- Messaging safeguards
- Patch management
- Perimeter defenses
- Security information management (SIM)
- Security event management (SEM)
- Incident response
- Transaction security
- Wireless security
Select five of these laws and summarize the law, suggest a compliance plan, and identify possible breaches. Use the following chart format for your summary.
c++
all i need is these two files
Create VectorContainer.hpp
Create SelectionSort.hpp
Test SelectionSort.hpp using the VectorContainer.hpp class you made
# Strategy Pattern
In this lab you will create a strategy pattern for sorting a collection of expression trees by their `evaluate()` value, which you will pair with different containers to see how strategies can be paired with different clients through an interface to create an easily extendable system. This lab requires a completed composite pattern from the previous lab, so you should begin by copying your or your partner’s code from the previous assignment into your new repo, making sure it compiles correctly, and running your tests to make sure everything is still functioning correctly.
You will start this lab by creating two expression tree containers: one that uses a vector to hold your trees (class `VectorContainer`) and one that uses a standard list (class `ListContainer`). Each of these container classes should be able to hold any amount of different expressions each of which can be of any size. You will implement them both as subclasses of the following `Container` abstract base class, which has been provided to you in container.h. You should create each one independently, creating tests for them using the google test framework before moving on. Each container should be it’s own commit with a proper commit message. Optionally you can create each one as a branch and merge it in once it has been completed.
class Container {
protected:
Sort* sort_function;
public:
/* Constructors */
Container() : sort_function(nullptr) { };
Container(Sort* function) : sort_function(function) { };
/* Non Virtual Functions */
void set_sort_function(Sort* sort_function); // set the type of sorting algorithm
/* Pure Virtual Functions */
// push the top pointer of the tree into container
virtual void add_element(Base* element) = 0;
// iterate through trees and output the expressions (use stringify())
virtual void print() = 0;
// calls on the previously set sorting-algorithm. Checks if sort_function is not
// null, throw exception if otherwise
virtual void sort() = 0;
/* Functions Needed to Sort */
//switch tree locations
virtual void swap(int i, int j) = 0;
// get top ptr of tree at index i
virtual Base* at(int i) = 0;
// return container size
virtual int size() = 0;
};
Notice that our Container abstract base class does not have any actual STL containers because it leaves the implementation details of the container to the subclasses. You **must use the homogeneous interface above for your sort functions, and you are only allowed to manipulate the containers through this interface, not directly**. This will allow you to extend and change the underlying functionality without having to change anything that interfaces with it.
## Sorting Classes
In addition to the containers you will also create two sort functions capable of sorting your containers, one that uses the [selection sort](https://www.mathbits.com/MathBits/CompSci/Arrays/Selection.htm) algorithm and one that uses the [bubble sort](https://www.mathbits.com/MathBits/CompSci/Arrays/Bubble.htm) algorithm (you may adapt this code when writing your sort functions). They should both be implemented as subclasses of the `Sort` base class below which has been provided. You should create each one independently, creating tests for them using the google test framework before moving on. Each sort class should be it’s own commit with it’s own proper commit message. When creating tests for these sort classes, make sure you test them with each of the containers you developed previously, and with a number of different expression trees.
“`c++
class Sort {
public:
/* Constructors */
Sort();
/* Pure Virtual Functions */
virtual void sort(Container* container) = 0;
};
sort.hpp
#ifndef _SORT_HPP_
#define _SORT_HPP_
#include “container.hpp”
class Container;
class Sort {
public:
/* Constructors */
Sort();
/* Pure Virtual Functions */
virtual void sort(Container* container) = 0;
};
#endif //_SORT_HPP_
base.hpp
#ifndef _BASE_HPP_
#define _BASE_HPP_
#include
class Base {
public:
/* Constructors */
Base() { };
/* Pure Virtual Functions */
virtual double evaluate() = 0;
virtual std::string stringify() = 0;
};
#endif //_BASE_HPP_
container.hpp
#ifndef _CONTAINER_HPP_
#define _CONTAINER_HPP_
#include “sort.hpp”
#include “base.hpp”
class Sort;
class Base;
class Container {
protected:
Sort* sort_function;
public:
/* Constructors */
Container() : sort_function(nullptr) { };
Container(Sort* function) : sort_function(function) { };
/* Non Virtual Functions */
void set_sort_function(Sort* sort_function); // set the type of sorting algorithm
/* Pure Virtual Functions */
// push the top pointer of the tree into container
virtual void add_element(Base* element) = 0;
// iterate through trees and output the expressions (use stringify())
virtual void print() = 0;
// calls on the previously set sorting-algorithm. Checks if sort_function is not null, throw exception if otherwise
virtual void sort() = 0;
/* Essentially the only functions needed to sort */
//switch tree locations
virtual void swap(int i, int j) = 0;
// get top ptr of tree at index i
virtual Base* at(int i) = 0;
// return container size
virtual int size() = 0;
};
#endif //_CONTAINER_HPP_
Example
#ifndef _LISTCONTAINER_HPP_
#define _LISTCONTAINER_HPP_
#include “container.hpp”
#include
#include
#include
class Sort;
class ListContainer: public Container{
public:
std::list
//Container() : sort_function(nullptr){};
//Container(Sort* function) : sort_Function(function){};
//void set_sort_funtion(Sort* sort_function){
// this -> sort_function = sort_function;
//}
void add_element(Base* element){
baseList.push_back(element);
}
void print(){
for(std::list
if(i == baseList.begin()){
std::cout <<(*i) -> stringify();
}
else{
std::cout << ", " << (*i) -> stringify();
}
}
std::cout << std::endl;
}
void sort(){
try{
if(sort_function != nullptr){
sort_function -> sort(this);
}
else{
throw std::logic_error(“invalid sort_function”);
}
}
catch(std::exception &exp){
std::cout << "ERROR : " << exp.what() << "n";
}
}
//sorting functions
void swap(int i, int j){
std::list
for(int f = 0; f < i; f++){
first++;
}
Base* temp = *first;
std::list
for(int s = 0; s < j; s++){
second++;
}
*first = *second;
*second = temp;
}
Base* at(int i){
std::list
for(int a = 0; a < i; a++){
x++;
}
return *x;
}
int size(){
return baseList.size();
}
};
#endif //_LISTCONTAINER_HPP_
bubblesort.hpp
#ifndef __BUBBLESORT_HPP__
#define __BUBBLESORT_HPP__
#include "sort.hpp"
#include "container.hpp"
class BubbleSort: public Sort{
public:
void sort(Container* container){
memContainer = container;
int flag = 1;
int numLength = memContainer->size();
for(int i = 1; (i <= numLength) && (flag == 1); i++){
flag = 0;
for(int j = 0; j < (numLength - 1); j++){
if(memContainer->at(j+1)->evaluate() < memContainer->at(j)->evaluate()){
memContainer->swap(j+1, j);
flag = 1;
}
}
}
}
};
#endif // __BUBBLESORT_HPP__
Java GUI Assignment
This assignment needs to be completed in 36 hours
Risk Management and Mitigation Planning
Assignment Content
- You are the new IT Project Manager for the organization you chose in Week 1, and the CFO is needing a risk assessment for migrating from SQL Server 2008 r2® database to SQL Server 2016. The migration will lead to the expansion of the cloud data centers worldwide.
The CIO feels the risk is too high and wants you to develop an Information Guide Handout and Risk Information Sheet for upper management to describe the risks and management of the risks for the impending migration.
Part A:
Create a 1- page (does not include title or reference pages) Information Guide Handout to present to upper management, comparing risk management practices to use in the migration that includes:- How risk mitigation strategy planning can reduce the likelihood and/or impact of risks
- How often risks will be reviewed, the process for review, and who will be involved
- The roles and responsibilities for risk management
- Adequate references to support your findings, information, and opinions
- A recommendation for the best risk management practice for this migration
- Part B:
Using the sample shown below, create a 4- to 5- page (does not include title or reference pages) Microsoft® Excel® Risk Information Sheet for at least five potential risks which might be encountered during the conversion. At least three of the five risks you choose should be project-management related.Risk Information Sheet
- Risk Description
- Probability
- Impact
- Rationale
- Risk Mitigation
- Details/Outcome
Please note the following: - The risk description should fully describe the risk.
- The probability is the likelihood which the risk will occur (i.e., low, medium, or high).
- The impact is how the organization will be affected if the risk does occur (i.e., low, medium, or high).
- The rationale should explain the reasons for your probability and impact assessments.
- The mitigation strategy should explain how each risk will be addressed.
- There should be one risk information sheet for each risk identified.
- Include APA-formatted citations when necessary.