All posts by : chebby

  For this task you will create a number of classes that provide information about the personnel in an organisation. You will write a Manager class and a Worker class, each of which will subclass a Person class. A Person will have a name, just a String, and an identity number, which is an integer. As no-one is just a person, the constructor of the Person class will only be used by constructors of derived classes. The name will be provided when an instance of a derived class is created. The identity should be automatically generated during construction and must be unique. No person, either manager or worker, can have the same identity number as another person. You should also ensure that the identity numbers of managers and workers cover separate ranges of integers (e.g. 1 – 99 for managers and 100 – 999 for workers), so that an identity number can be used, in the human organisation but not in your program, to discern whether a person is a manager or a worker.

There is a relationship between managers and workers that needs to be incorporated in the

corresponding classes. Each manager is the leader of a team of workers. In particular, a manager leads

exactly one team and a worker belongs to exactly one team. The system must allow for workers to be

moved from one team to another, managers to be moved from leadership of one team to leadership of

another, as well as for the appointment and retirement of personnel. For the current assignment task a

simplifying assumption will be that we do not need a class to represent a team’s work area. Instead the

manager-worker relationships will be incorporated by each Manager object maintaining a list of

Worker references, representing the team, and each Worker object maintaining a Manager reference,

representing the team leader.

The following state and functionality should be provided for these classes:

• The Person class will maintain name and      identity fields, as described above, and the derived

Manager and Worker classes will add the fields necessary to implement their

interrelationships.

• Appropriate constructors will allow the name      and identity fields of Manager and Worker

objects to be initialised properly. Note that, although the identity field will be inherited,

its initialisation depends on the particular derived class. Full initialisation of the fields

implementing manager-worker interrelationships would not be done at this stage, but they

must be in an appropriate state for testing.

• Getters for fields will be provided in      appropriate classes.
• Appropriate toString methods will be      provided as required to simplify the display of object

state. Where an object’s state contains a reference to a person, include that person’s identity

number in the string.

• For setting up, changing, or nullifying the      field values implementing manager-worker

interrelationships you need to make changes in the state of both a Manager object and a

Worker object. There are different ways to do this. For example, for moving a worker

between teams, one way is to provide the Worker class with a movetoTeamOf instance

method that accepts a Manager reference. The code of this method could first make some

checks (e.g. are either of the current and new Manager references null or are they the same?)

before removing the current worker from the team of the current manager, changing the

worker’s manager and then moving the worker to the new manager’s team. Note that this

would access instance methods of Manager for removing a worker from a team and for

adding a worker to a team. A similar approach applies for setting up a new worker and for

removing a worker from the system; the changes must be done so as to ensure the

information system remains in a stable state, which cannot be left as a responsibility of client

code.

• Changing team managers is another operation on      manager-worker interrelationships that

needs to be done, and with care. It might be implemented via a switchTeams instance method

of the Manager class that accepts the reference of another manager, but you need to make

sure that this switches all the Manager references held by the respective teams. You also

need to implement functionality for removing a manager from the system, which will only

occur if a newly created manager is available as a replacement, and adding an additional

manager, whose team could then be populated by client code applying some combination of

creating new workers and moving workers using functionality described above.

Write a TestPersonnel class to test the functionality of the classes you have developed. It will be done

without user interaction and will provide the following sequence of actions, using good design techniques such as in the appropriate use of methods:

• Create a single list for the people in the      organisation, which is a list containing Person

references for managers and workers.

• Provide code to create some managers (3 will      do) and some workers (12 will do) and add

them to the list. Assign the workers in turn to the different managers.

• Display the state of all the people in the      organisation.
• Add 3 new workers to the organisation,      assigning them in turn to the different managers.
• Display the state of all the people in the      organisation.
• Remove from the organisation the first 2      workers in the list of people.
• Display the state of all the people in the      organisation.
• Add a new manager to the organisation,      reassigning the first worker in the list of people to

this new manager.

• Display the state of all the people in the      organisation.

Topic Name:  Enhancing Cyber Security in Healthcare-with the help of Artificial Intelligence

Need the ppt for that as well.

Reading resource:

Se Yeon Choi, Goo Hyeok Chung, & Jin Nam Choi. (2019). Why are we having this innovation? Employee attributions of innovation and implementation behavior. Social Behavior & Personality: An International Journal, 47(7), 1–13. https://doi.org/10.2224/sbp.8124 http://search.ebscohost.com/login.aspx?direct=true&AuthType=shib&db=pbh&AN=137631636&site=eds-live&custid=s8501869&groupid=main&profile=eds_new

Research Paper:

This week’s journal article focuses on attribution theory and how it influences the implementation of innovative technologies.  Two types of employee attributions are noted in the article (intentionality and deceptive intentionality); please review these concepts and answer the following questions:

1. Provide a high-level overview/ summary of the case study
2. Note how constructive intentionality impacts innovation implementations
3. Find another article that adds to the overall findings of the case and note how attribution-based perspective enhances successful innovation implementations.  Please be explicit and detailed in answering this question.

Google Scholar is a great source for research.  Please be sure that journal articles are peer-reviewed and are published within the last five years.

The paper should meet the following requirements:

• 3+ pages in length (not including title page or references)
• APA guidelines must be followed.  The paper must include a cover page, an introduction, a body with fully developed content, and a conclusion.
• A minimum of five peer-reviewed journal articles.

The writing should be clear and concise.  Headings should be used to transition thoughts.  Don’t forget that the grade also includes the quality of writing.

Note: plagiarism check required, APA7 format, include References, within 8hrs

1. Some say that analytics, in general, dehumanize managerial activities, and others say they do not. Discuss arguments for both points of view.
2. What are some of the major privacy concerns in employing intelligent systems on mobile data?
3. Identify some cases of violations of user privacy from current literature and their impact on data science as a profession.
4. Search the Internet to find examples of how intelligent systems can facilitate activities such as empowerment, mass customization, and teamwork.

International Foodies is an importer of exotic foods from all over the world. You landed a summer internship with the company and discovered that their product lists and the suppliers they buy from are stored in Excel workbooks. You offer to help by using your newly gained knowledge of Access to create a relational database for them. You will begin by importing the workbooks from Excel into a new Access database. Your manager mentions that she would also like a table that specifies food categories so that you can relate the products you sell to specific categories in the database. You will create a table from scratch to track categories, create relationships between the tables, and create some baseline queries.

Start Access. Open the downloaded   Access file named Exp19_Access_Ch2_Cap_Foodies. Grader has automatically added   your last name to the beginning of the filename. Save the file to the   location where you are storing your files.

You   will examine the data in the downloaded Excel worksheets to determine which   fields will become the primary keys in each table and which fields will   become the foreign keys so that you can join them in the database.
 

  Open the Suppliers.xlsx Excel   workbook, examine the data, and close the workbook. Open the Products.xlsx Excel workbook, examine   the data, and close the workbook.
 

  You will import two Excel workbooks that contain supplier and product   information into the database.
 

  Click the External Data tab, click   New Data Source, point to From File in the Import & Link   group, and then select Excel.   Navigate to and select the Suppliers.xlsx   workbook to be imported as a new table in the current database. Select First Row Contains Column Headings.   Set the SupplierID field Indexed option to Yes (No Duplicates). Select SupplierID   as the primary key when prompted and accept the table name Suppliers. Do not save the import   steps.

Import   the Products.xlsx workbook, set the   ProductID Indexed option to Yes (No   Duplicates), and select ProductID   as the primary key. Accept the table name Products.

Change   the Field Size of the QuantityPerUnit field to 25   in Design view of the Products table. Set the Field Size of ProductID and   CategoryID to Long Integer. Save   the changes and open the table in Datasheet view. Open the Suppliers table in   Datasheet view to examine the data. Close the tables.

You   will create a new table that will enable International Foodies to associate   each product with a food category in the database.
 

  Create a new table in Design view. Add the following fields in Design view   and set the properties as specified:
 

  Add the primary key field as CategoryID   with the Number Data Type and Number assigned to a new category.   (type the period) as the Description. Set the Caption property to Category ID.
 

  Save the table as Categories.

   Add CategoryName with the Short Text Data Type and Name of food   category.   (type the period) as the Description. Change the field size to 15. Set the Caption property to Category Name and the Required property to Yes.

Add   CategoryDescription with the Long Text Data Type. Set the Caption property to Category Description. Switch to Datasheet view and save the   table when prompted. You will enter Category data into the table in the next step.

   You will add 8 records to the Categories table so that you have some sample   data to test in the database.
 

  Add the following records to the Categories table:

Category   ID Category Name   Category Description 

1 BEVERAGES  SOFT DRINKS, COFFEES, TEAS 

2 CONDIMENTS  SAUCES, RELISHES, SEASONINGS

3 CONFECTIONS  DESSERTS,   CANDIES, SWEET BREADS

4 DAIRY   PRODUCTS  CHEESES

5 GRAINS/CEREALS  BREADS, PASTA, CEREAL

6  MEAT/POULTRY  PREPARED   MEATS

7 PRODUCE  DRIED FRUIT, BEAN CURD

8 SEAFOOD  SEAWEED AND FISH

  Close the table.

You will create   the relationships between the tables using the Relationships window.
 

  Add all three tables to the Relationships window. Identify the primary key   fields in the Categories table and the Suppliers table and join them with   their foreign key counterparts in the related Products table. Select the Enforce Referential Integrity and Cascade Update Related Fields check boxes.   Save and close the Relationships window.

You   will use the Simple Query Wizard to create a query of all products that you   import in the seafood category.
 

  Add the ProductName, SupplierID, and CategoryID fields from Products (in that order). Save the query   as Seafood Products.

Add   a criterion in Design view, to include only products with 8 as the CategoryID.

Sort   the query results in ascending order by ProductName. Run, save, and close the   query.

You   want to create a query that displays actual category names rather than the   CategoryIDs. You are interested to know which meat and poultry products are   imported. You will copy the Seafood Products query and modify it to delete a   field, then add an additional table and field.
 

  Copy the Seafood Products query   and paste it using Seafood Or Meat/Poultry   as the query name.

Open   the Seafood Or Meat/Poultry query   in Design view and delete the CategoryID   column.

Add   the Categories table to the top   pane of the query design window. Add the CategoryName   field to the last column of the design grid and set the criterion as “Seafood” Or “Meat/Poultry”.   Run, save, and close the query.

You   will create a query that identifies suppliers and their associated products.   Because there is a relationship between the two tables, you can now pull data   from each of them together as usable information.
 

  Create a query in Design view that includes the Suppliers and Products   tables. The query should list the company name, contact name, phone (in that   order), then the product name and the product cost (in that order).

Sort   the query by company name in ascending order, then by product cost in   descending order. Run, close, and save the query as Company by Product List.

You   determine that the data in the Company by Product List query could be   summarized with a Total row. You will group the records by company name, and   then count the number of products you buy from each of them.
 

  Copy the Company by Product List query   and paste it using Summary of Company by   Product   as the query name.

Open   the Summary of Company by Product   query in Design view and delete the ContactName, Phone, and ProductCost columns.

Click   Totals in the Show/Hide group on   the Query Tools Design tab. Click in the Total   row of the ProductName field, click the arrow, and then select Count.   The records will be grouped by the company’s name and the products for each   company will be summarized.

Modify   the field name of the ProductName column as Product Count:   ProductName to make the field name more   identifiable. Click Run in the   Results group (20 records display in the Datasheet). The results display the   product count for each company that supplies your organization. Save and   close the query.

NEED TO Submit ‘producer.c’ and ‘consumer.c’ in the Linux machine.

Read the following document for programming assigment.

Download two programs ‘producer.c’ and ‘consumer.c’ and add your code there so that producer send a list of items to consumer. Producer read the item from a file ‘input.txt’.

In order to use shared memory library, compilation need to link a library ‘rt’. And since we will run two programs, we need to create two executables. See below.

Download ‘hw2.c’. It is a file that contains the definition of shared memory structure and a function to print current time. It is already included in ‘producer.c’ and ‘consumer.c’. You don’t need to change this file. You don’t need to compile it. ‘Producer.c’ and ‘consumer.c’ already include the file. Just keep ‘hw2.c’ in the same folder with other files.

‘read_example.c’ is an example file to show you how to read the input file and to show how to print with time stamps.

You need to copy ‘input.txt’ in the same folder and test as below.

Following is a sample run.

Run producer first. It need to read a number after another from the file and display while sending them to consumer. Since the consumer is not started, the buffer will become full soon and producer will wait.

Now run consumer as below. It need to display all items received. It keeps running until it gets end-of-item message ‘-1’

After consumer begins, the producer will also proceed to read all items from the file and end.

read_example.c:

#include

#include

#include “hw2.c”

int main()

{

        int     item;

        FILE    *fp;

        fp = fopen(“input.txt”,”r”);

        while(fscanf(fp, “%d”,&item)!= EOF){

                printf(“%s Read %d from the filen”,get_time(),item);

        }

        fclose(fp);

}

producer.c:

#include

#include

#include

#include

#include

#include

#include

#include “hw2.c”

int main()

{

        const int SIZE = sizeof(shm_structure);

        const char *name = “OS-ipark”; // ATTENTION: Change this using YOUR id to avoid conflicts with others

        int     item;

        FILE    *fp;

        int shm_fd;

        shm_structure *ptr;

        /* create the shared memory segment */

        shm_fd = shm_open(name, O_CREAT | O_RDWR, 0666);

        /* configure the size of the shared memory segment */

        ftruncate(shm_fd,SIZE);

        /* now map the shared memory segment in the address space of the process */

        ptr = mmap(0,SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);

        if (ptr == MAP_FAILED) {

                printf(“Map failedn”);

                return -1;

        }

        /*****************************************************

        Add your code here.

        Read one item after another from the file ‘input.txt’.

        And write it to the shared memory so the consumer can read.

        Need to wait if the buffer is full

        *****************************************************/

        printf(“Successn”);

        return 0;

}

input.txt:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

32

64

128

256

512

1024

2048

4096

11

22

33

44

55

66

77

88

-1

consumer.c:

#include

#include

#include

#include

#include

#include

#include “hw2.c”

int main()

{

        const char *name = “OS-ipark”; // ATTENTION: Change this to the same name you used in producer.c

        const int SIZE = sizeof(shm_structure);

        int shm_fd;

        shm_structure *ptr;

        int i;

        int item;

        /* open the shared memory segment */

        shm_fd = shm_open(name, O_RDWR, 0666);

        if (shm_fd == -1) {

                printf(“shared memory failedn”);

                exit(-1);

        }

        /* now map the shared memory segment in the address space of the process */

        ptr = mmap(0,SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);

        if (ptr == MAP_FAILED) {

                printf(“Map failedn”);

                exit(-1);

        }

        /***************************************************

        Add your code for consumer here.

        Read an item after another from the shared memory

        And display to screen using printf().

        Need to wait if the buffer is empty.

        Check if this displays all the items in ‘input.txt’ 

        except end-of-message signal ‘-1’

        ***************************************************/

        /* remove the shared memory segment */

        if (shm_unlink(name) == -1) {

                printf(“Error removing %sn”,name);

                exit(-1);

        }

        return 0;

}

hw2.c:

// Definitions for shared memory structure

#define BUFFER_SIZE 10

typedef struct{

        int buffer[BUFFER_SIZE];

        int in;

        int out;

} shm_structure;

#include

char time_str[100];

char *get_time()

{

        time_t t=time(NULL);    // get time info (month, day, hour, min)

        struct tm *tm1 = localtime(&t); // convert to easy format

        struct timeval tv;

        struct tm *tm;

        gettimeofday(&tv, NULL);    // get time info (month, day, hour, min)

        tm=localtime(&tv.tv_sec);   // convert to easy format

        sprintf(time_str,”(%02d/%02d %d:%d:%d %d)”, tm1->tm_mon+1,tm1->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec, tv.tv_usec);

        return time_str;

}

Company Name: Dell

Environmental sustainability is defined as responsible interaction with the environment to avoid depletion or degradation of natural resources and allow for long-term environmental quality. The practice of environmental sustainability helps to ensure that the needs of today’s population are met without jeopardizing the ability of future generations to meet their needs.

Within our Thompson text, read Chapter 9 Assurance of Learning Exercise #1 related to Dell.

Now, click on the website link provided in the learning exercise description from our Thompson text, which will provide you with information to respond to the following:

• Prepare a list of 5 specific policies or programs that help Dell achieve its vision of driving      social and environmental change while still remaining innovative and      profitable.
• Describe how Dell’s environmental sustainability strategies provide valuable social benefits?
• Finally, explain how Dell’s strategies fulfill customer needs in a superior fashion while      simultaneously sustaining competitive advantage?

Submission Details: 

• Your analysis should be between 1000 to 1500 words.
• Incorporate a minimum of at least our course text and one non-course scholarly/peer reviewed source in your paper.
• All written assignments must include a coverage page, introductory and concluding paragraphs,      reference page, be double-spaced, and proper in-text citations using APA guidelines.

Dell Website Link: https://corporate.delltechnologies.com/en-us/index.htm

References:

Load the data file Crowdfunding_data_1000_projects.xlsx Download Crowdfunding_data_1000_projects.xlsxin a Pandas data-frame. Perform 70:30 split with 70% of records (rows) as train and rest 30 % of records as test using following three techniques:

1. Use Pandas functions head() and tail(), and create two data-frames with top 70 % records in the first data-frame, and remaining 30% records in the second data-frame (2 points).

2.  Use Pandas functions sample() and drop(), and create two data-frames with random 70% of records in the first data-frame and remaining 30% of records in the second data-frame (4 points). 

3. Use Scikit-learn package and create two data-frames with random 70% of records in the train data-frame and remaining 30% of records in test data-frame (4 points).

Upload one Jupyter Notebook file with code in the submission. 

one page to page and half more information in the word file and  sources should be a website journal sources

Please see below the discussion in response to the original question asked and respond as a peer using 150 or more words.

Original Question:  Explain SQL and its functions. What do you enjoy the most about learning SQL? What you find the most difficult? 

Peer Response:

Structured Query Language (SQL) is an interface programming language used to communicate with databases and is the standard for relational databases.  It can be used to create, modify, and query databases for information.  There are many functions within SQL available for use to include Data Definition Language commands which are used to define the structure of a database.  Some of these commands are create, alter, and drop.  There is also Data Manipulation Language which is used to modify the data within the database and some of these commands are insert, update, and delete (GeeksforGeeks, 2020).

What I enjoyed most about learning SQL was the hands-on using SQL Live to write and test actual SQL code.  The scripting functionality of the site was very intuitive and user friendly as well.  I appreciate how you could save your sessions as script and reload them at a later time.  I also liked the troubleshooting that could be done by reviewing the session to see which command blocks failed.  The most difficult part for me was trying to make the correlation between relational algebra and SQL.  The symbolic notation and theoretical basis for which SQL is built upon.  Another difficult are is the one to many and many to many notations as sometimes it would get confusing as to which notation went on which side of the line or arrow.