All posts by : chebby

here is attach the program 

In chapter 4, the author describes four types of costs that blockchain technology can reduce. Which of the four cost types, if reduced through blockchain technology, would most impact the organization for which you currently work?  What would be the most visible impact on your job role? How could you minimize any negative impact?

1. Search Costs—How Do We Find New Talent and New Customers?

2. Contracting Costs—What Do We Agree to Do, Anyway?

3. Coordination Costs—How Should We All Work Together?

4. Costs of (Re-)Building Trust—Why Should We Trust One Another?

Strictly follow the instruction. 

APA format.

References are required

Begin with a title page (1)

Introduction Page (2)

All written assignments must comply with APA Format. Any assignment that does not comply with the APA format will receive a point deduction. Assignments in this class have a minimum weighting on formatting using APA of 20%+. 

In-Text APA is required.

A minimum of 3 paragraphs required for the weekly journal

Conclusion

Reference list

 What do you think were the critical factors that fueled the need for IT governance? In what ways did ISO affect the standards for network security? 

 Provide extensive additional information on the topic

Explain, define, or analyze the topic in detail

Share an applicable personal experience

After completing the reading this week, we reflect on a few key concepts this week:

1. Discuss what performance management is and how it influences effective teams.
2. Review table 11.1, define leadership behaviors (in your own words) and note which behaviors are beneficial at specific organizational activities (example: project planning, leading coworkers, etc…). Please note at least five organizational activities and be specific when responding.
3. Note at least two organizational capabilities and compare and contrast each.

Please be sure to answer all the questions above in the initial post.

Please ensure the initial post and two response posts are substantive. Substantive posts will do at least TWO of the following:

· Ask an interesting, thoughtful question pertaining to the topic

· Expand on the topic, by adding additional thoughtful information

· Answer a question posted by another student in detail

· Share an applicable personal experience

· Provide an outside source

· Make an argument

At least one scholarly (peer-reviewed) resource should be used in the initial discussion thread. Please ensure to use information from your readings and other sources from the UC Library. Use APA references and in-text citations.

Please run a Google search of the term, “United States Supreme Court Carpenter v. United States 2018.” 

Please write an essay of not less than 500 words, summarizing the court’s decision. 

Rubric for Assignment submission

Criterion                            Description                                      Points possible

Content    Student accurately summarizes the effects of this Court decision  35

Word Count                             At least 500 words                                            10

Citation                                    Correct legal citation                                          5

                                              Total Points possible                                           50

Assignment:
Provide a reflection of at least 500 words of how the knowledge, skills, or theories of this course(Emerging threats and counter measures) have been applied, or could be applied, in a practical manner to your current work environment. If you are not currently working, share times when you have or could observe these theories and knowledge could be applied to an employment opportunity in your field of study. 

Requirements:

• Provide a 500 word (or 2 pages double spaced) minimum reflection.
• Use of proper APA formatting and citations. If supporting evidence from outside resources is used those must be properly cited.
• Share a personal connection that identifies specific knowledge and theories from this course.
• Demonstrate a connection to your current work environment. If you are not employed, demonstrate a connection to your desired work environment.
• You should not, provide an overview of the assignments assigned in the course. The assignment asks that you reflect how the knowledge and skills obtained through meeting course objectives were applied or could be applied in the workplace.

Write a Linux bash shell script that should take an IP address as an argument from the command line and ping to that address. The script should output the result of the ping as either reachable or unreachable depending on the result of the ping. Two example outputs of the script may look like as below. Take the screen shot of the script itself and the outputs of the running script for 8.8.8.8 and 23.23.23.21 to submit.

————1——

$ ./yourname_script.sh 8.8.8.8

The IP address 8.8.8.8 is reachable

—————2————-

$ ./yourname_script.sh 23.23.23.21

The IP address 23.23.23.21 is not reachable

Do a bit of research on penetration testing techniques. Investigate and document the following

• Five network penetration testing techniques
• Advantages and disadvantages of each
• One notable social engineering test
• Possible negative implications of penetration tesing

Please write between 200 and 300 words

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

//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::iterator i = baseList.begin(); i != baseList.end(); ++i){

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::iterator first = baseList.begin();

for(int f = 0; f < i; f++){

first++;

}

Base* temp = *first;

std::list::iterator second = baseList.begin();

for(int s = 0; s < j; s++){

second++;

}

*first = *second;

*second = temp;

}

Base* at(int i){

std::list::iterator x = baseList.begin();

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__

What are the main reasons why a VPN is the right solution for protecting the network perimeter? Do they also provide protection for mobile devices? 300 words