Monthly Archives: June 2023

Case Study 11.1: It’s an Agile WorldThis case illustrates a common problem in software and IT development, where programmers and IT staff are anxious to lock in specifications as early as possible so they can “get to work” without having to worry about invasive or disruptive input from the end users.  Unfortunately, what typically happens is that the finished product is not what the users needed or thought they needed and a long list of fixes and modifications are needed to make it work correctly.  This case is based on a true story in a hospital IT department that routinely struggled with these sorts of user conflicts until they sifted to an Agile methodology.Questions

1. Why does the classic waterfall project planning model fail in this situation?  What is it about the IT department’s processes that leads to their finished systems being rejected constantly?
2. How would an Agile methodology correct some of these problems?  What new development cycle would you propose?
3. Why are “user stories” and system “features” critical components of an effective IT software development process?
4. Using the terms “Scrum,” “Sprint,” and “User stories,” create an alternative development cycle for a hypothetical software

Text-

Title: Project Management 

ISBN: 9780134730332 

Authors: Pinto 

Publisher: Pearson 

Edition: 5TH 19

 Provide a reflection of at least 500 words (or 2 pages double spaced) of how the knowledge, skills, or theories of this course 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.

  you will identify 10 controls from the NIST 800-171 Security controls download spreadsheet.  You will then document those 10 controls in your security plan section 13. 

An increasing concern for privacy and widespread availability of encryption products has led to the use of encryption for individual files and even entire devices. Briefly discuss the current state of encryption with respect to forensic investigation.

Assignment 1: 250 words excluding references – Need it by 03/24

How is the implementation of network security similar and different between on-perm and cloud environments? Give some examples.
How is the management of network security similar and different between on-perm and cloud environments? Give some examples.

Assignment 2: Need it by 03/25
Discuss the best practices for implementing an access control system – 2 pages (double spaced) excluding references

 Implement Gale-Shapley Algorithm for computing Stable Marriage Assignment in any language, such as Python, Java, C++ or MATLAB, using the approach and data structures described in the first two Chapters of the Kleinberg and Tardos text. The input file should include number of subjects, n, preference list for men and women one line for each. n m1: w11, w12, …, w1n … … mn: wn1, wn2, …, wnn w1: m11, m12, …, m1n … … wn: mn1, mn2, …, mnn a) Write a function to create preference lists for men and women. Function should take number of men (women), say n, create preferences and output them. b) Write the output, explicitly checking to see that it is a stable match (It requires a separate function to check). Turn in sample inputs and corresponding outputs in separate files. c) Run the algorithm on several instances of the problem for n = 10 with different input files and plot the variation in the running time. d) Run the algorithm on several instances of the problem for n = 10 with the same input file and plot the variation in the running time. e) Run the algorithm on problem instances with n = 10, 15, 20, 50, 100, and plot the average running time as a function of the problem input size (n). f) Run the algorithm on several instances of the problem for n = 10 with the same input file, let a different man start proposing and output the matches. 

As a warm-up for writing the Polynomial class for Project 1, write a simple class called Quadratic for representing and using quadratic equations. A quadratic equation is any equation of the form f(x) = ax2 +bx + c (and is just a polynomial with degree 2). Your class will have:
one instance variable: an integer array with exactly 3 slots, one for each coefficient
a constructor which takes three integer arguments a, b, and c and stores them in the array, which the constructor creates; a in slot 2, b in slot 1, etc. so the coefficient is at the index that corresponds to the associated power of x
one accessor method that returns the coefficient array when called
a method roots that returns a two-element array containing the roots of the quadratic. Use the quadratic equation from algebra.
a method evaluate that returns the result of evaluating the quadratic for any given real number x
a method toString that returns a String representation of a quadratic function; for example, the function x2 + 3x – 4 will be represented by the string x^2 + 3x – 4.
Having toString available allows us to pass a Quadratic object to the various System.out.print functions and get readable output.
Include a main method to unit test your constructor and methods. It should create at least three Quadratic objects and call the three methods on various values. As in the project, this method should produce output that completely documents each test and the results, so it is clear at a glance what works and what doesn’t.
Coding and Documentation Requirements
Document the complete specification for each method you develop, including preconditions, postconditions, complexity, and throws clauses if applicable. Pay particular attention to possible errors that these methods can produce if the preconditions on inputs and intermediate computations are not checked. In general you want to throw exceptions rather than produce error messages.
Generate HTML documentation using Javadoc and post it on your hive.sewanee.edu web page.

Part I. The Polynomial ClassConstruct a class for representing polynomials as described in Exercise 13, part (a), page 57 of the text, subject to the modifications given below.Store the coefficients in an array of type double (not int as suggested in the text); the coefficient of the k-th term should be stored in index k of the array. This means the array will be at least as big as the degree of the polynomial, even if the coefficients of some terms are zero. For example, the coefficients of the polynomial x5 + 0.3×3 + 0.5×2 – 0.9x + 5 would be stored as [5.0, -0.9, 0.5, 0.4, 0.0, 1.0]Modify the exercise as follows:
As stated above, the coefficients array will hold items of type double.
The constructorpublic Polynomial(int degree)will create a coefficients array large enough to hold the number of coefficients given by the parameter degree.
The coefficient parameter to setCoefficients will be of type double.Override the methods toString and equals. For example:
The string representation of x2 + 2 should be x^2 + 2
The string representation of x5 + 0.3×3 + 0.5×2 – 0.9x + 5 should be x^5 + 0.3x^3 + 0.5x^2 – 0.9x + 5
Two Polynomial objects are equal if they have the same degree and coefficients.
Part II. Polynomial Test ClassWrite a test program in a separate class file, as described in Exercise 13, part (b). Many software developers advocate documenting test cases first, then using those as a guide in writing the test program.Document test cases for each method (especially evaluate) in a separate file called README.TEST; this gives you something to check against. For example, to test evaluate a test case will consist of:a specific polynomial
the input parameter to evaluate
the expected result returned by the method
Test at least 5 different polynomials of various sizes (including just 1 term); for each polynomial, test at least 3 inputs to evaluate (consider a positive value, a negative value, and 0). Test cases must be turned in along with the program. Also, I will be applying my own tests. All test cases (both mine and yours) must pass for full credit.Note: a wise computer scientist once said that tests can show the presence of bugs in a program, but not their absence. There is no such thing as too many test cases.Part III. Inheriting from PolynomialUsing inheritance, create a class that represents a specific family of polynomials used to create the Logistic Map: rx(1 – x) = rx – rx2, where r can be any real number. The only instance variable needed will represent r; initialize it using a parameter in the constructor. Be sure to consider:what should be inherited from the Polynomial class? what should not?
are the access modifiers for instance variables in the superclass appropriate for inheritance?
how will the constructor work?
Add a section of test cases for this type of polynomial to your test docs and your test class.Coding and Documentation Requirements
When writing your project, remember to follow the style guidelines; in particular, include a comment block at the top of each source file giving your name, e-mail address, and project number.
Document the complete specification for each method you develop, including preconditions, postconditions, computational complexity, and throws clauses if applicable.Produce documentation using Javadoc and post it on your web page.
Deliverables
For each project you will turn in these files:a file README containing instructions on how to compile and run your program, where to find your Javadocs online, and a description of any issues or known bugs.
a file README.TEST containing your test cases; show which if any tests did not pass by turn-in time
all Java files required to build and run the program(s)
These files are to be turned in as follows: zipped into a single archive file, emailed to me. My system recognizes ZIP, GZ, and TAR files automatically.
Do not include binary files (such as .class files) as sometimes Gmail will flag those as malware and not send them.
In addition, hand in printouts of the source files you developed or modified (even when you e-mail the code) either in the bin outside my office or beginning of next class meeting.

what is computer explain ?

In the first part, you will complete a partially-implemented web crawler program. In the second,

you will use Java classes from the package java.util.concurrent to divide the workload

among multiple threads of control. 


Download the starting code in this zip file. Inside the src directory are two

subdirectories: spider contains the (partially complete) sequential web crawler for use with Part

1, and concurrentSpider contains the threaded web crawler code for use with Part 2.  This code

uses classes from the Java class library for parsing HTML files and pulling out links

(java.net.url among others).

Part 1 – Sequential Web Crawler.

1. In this part, you will complete a program that is able to “crawl the web” starting from a

given URL. A detailed problem specification and descriptions of the provided classes can

be found in the first section of Concurrent Data Structures in Java. Complete the tasks

given in the To Do sections and the Try This section.

2.

3. The finished program should output the URLs it processes as it crawls the website.

Capture this output in a file.

4.

5. There will be a check-in date to make sure nobody is waiting until the last minute to

complete this part. I will ask for copy of your Spider.java file to ensure everyone is

making progress.

Part 2 – Multi-threaded Web Crawler.

1. Production-quality web crawlers divide the work of following links from multiple web

pages among multiple versions of themselves, using a Java (and operating system)

concept called threads (you used threads in CSci 157 whenever you

programed ActiveObjects). Each thread must share the data structures being used,

which can cause problems if (for example) two instances try to remove from the work

queue at the same time. Because our Queue implementations are not thread-safe, they

cannot be used in this version. Instead, we can use implementations provided by the Java

package java.util.concurrent. Unfortunately the interface these classes

implement is different from the QueueInterface. For example, the method add is

used instead of enqueue, and peek or poll instead of dequeue.  


2. A detailed problem specification can be found in the second section of Concurrent Data

Structures in Java. An outline of the concurrent solution and the problems that concurrent

data structures solve can be found in the third section. 

3. Complete the tasks given in the To Do sections and the Try This section of section two.

Deliverables

For this project you will turn in:

• a README file for each part, containing SHORT instructions on how to compile and run

each program and a description of any issues or known bugs. You do not need to describe

the program itself.

• all Java files required to build and run the program(s), using the same file structure as the

provided zip file

These files are to be turned in as follows: zipped into a single archive file, emailed to me.

Do not include binary files (such as .class files); sometimes Gmail flags those as malware and

won’t send them.

Write a code in c++ programming language to get the desired output