One easy way to determine information ownership is to think of CRUD—create, read

Question

One easy way to determine information ownership is to think of CRUD—create, read, update, and delete. If you cannot only read but also create, update, and/or delete information, then in some way you own that information because you are responsible for its quality. Here again, let’s consider your school as an example and focus on your personal and transcript information. That information includes your student ID, name, address, phone number, GPA, declared major, declared minor (if you have one), and courses completed (your transcript).

Part 1: Identify Create, Update, and Delete Privileges For each piece of information, first identify who has create, update, and delete privileges. Include any individuals or departments that have these sorts of information privileges. There may be several. If so, who is ultimately responsible for your personal and transcript information? Second, identify all the groups of people at your school who can only view (read) your information.

Part 2: Develop a CRUD Matrix Develop a CRUD matrix that outlines the relationships among the pieces of information and user privileges (example: http://ocean.otr.usm.edu/~w300778/is-doctor/pubpdf/sc2008.pdf).

Part 3: Write a Detail Document Write a detail document about the various business rules that define how the scenario described in Part 1 works with respect to information ownership and their relationships. Identify the appropriate relationships among the information, and define the minimum and maximum privileges associated with each relationship.

Explanation / Answer

public category TTTConsoleNonOO2P cipher = 2;

// Name-constants to represent the varied states of the sport
public static final int enjoying = 0;
public static final int DRAW = 1;
public static final int CROSS_WON = 2;
public static final int NOUGHT_WON = 3;

// the sport board and also the game standing
public static final int ROWS = three, COLS = 3; // range of rows and columns
public static int[][] board = new int[ROWS][COLS]; // game board in 2nd array
// containing (EMPTY, CROSS, NOUGHT)
public static int currentState; // this state of the sport
// (PLAYING, DRAW, CROSS_WON, NOUGHT_WON)
public static int currentPlayer; // this player (CROSS or NOUGHT)
public static int currntRow, currentCol; // current seed's row and column

public static Scanner in = new Scanner(System.in); // the input Scanner

/** The entry main methodology (the program starts here) */
public static void main(String[] args) {
// Initialize the game-board and current standing
initGame();
// Play the sport once
do else if (isDraw())
// Otherwise, no amendment to currentState (still PLAYING).
}

/** come back true if it's a draw (no additional empty cell) */
// TODO: Shall declare draw if no player will "possibly" win
public static Boolean isDraw() mountain pass = 0; gap < COLS; ++col) {
if (board[row][col] == EMPTY) {
come back false; // AN empty cell found, not draw, exit
}
}
}
come back true; // no empty cell, it is a draw
}

/** come back true if the player with "theSeed" has won once inserting at
(currentRow, currentCol) */
public static Boolean hasWon(int theSeed, int currentRow, int currentCol) {
come back (board[currentRow][0] == theSeed // 3-in-the-row
&& board[currentRow][1] == theSeed
&& board[currentRow][2] == theSeed
|| board[0][currentCol] == theSeed // 3-in-the-column
&& board[1][currentCol] == theSeed
&& board[2][currentCol] == theSeed
|| currentRow == currentCol // 3-in-the-diagonal
&& board[0][0] == theSeed
&& board[1][1] == theSeed
&& board[2][2] == theSeed
|| currentRow + currentCol == two // 3-in-the-opposite-diagonal
&& board[0][2] == theSeed
&& board[1][1] == theSeed
&& board[2][0] == theSeed);
}

/** Print the sport board */
public static void printBoard() mountain pass = 0; gap < COLS; ++col) every of the cells
if (col != COLS - 1)

Related Questions

Navigate

• Browse (All)
• Browse O
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.