SOFTWARE DESIGNING

SD1 : Eclipse , EJB , Guava , Hibernate , Java , Java XML , Java Zip , Java-8 , Java Beans , JavaFx , Jbpm5 , JDB , JDBC , JFreeChart

SD3 :JavaScript , jQuery , jQueryUI , Jython , Lua , Numpy , PyGTK , PyQt , Python

SD5 : C , C++, Java , Visual Basic, C#, Python-3 , Python Forensics , Python Panda , RSpec , Ruby , Sed , Tcl/Tk , VBScript

SD7 : C++, OOPS, jMeter , JSoup , JOGL , JPA , JSON , JSP , JUnit , log4j , Lucene , Maven , PDFbox

SD9 : C , C++, Java , Visual Basic, C#, Servlets , Spring , Spring AOP , Spring Batch , Spring JDBC , Spring MVC , Spring Web Services , Struts 2.x , Swing


1) 7258-Python assignment

Assignment Description

You are tasked with creating an application that uses a GUI that simulates a simple money manager. This tool is used to track all spending of an individual.
The assignment is broken up into the following main components:
1.) The ability to provide a login screen to prevent other people from viewing the information contained in the tool
2.) The ability to view the current balance funds, add purchases made and deposits into the balance
3.) The ability to save the transactions to a file so that you can log in, add transactions to the application, log out and then return to find all of the transactions still there – i.e. the data is persistent.
4.) The ability to display a graph of your spending broken down by
type – i.e. food, bills, rent.
5.) A Test Case that ensures that your simple money manager works as required.
Your submission should consist three Python scripts that implement the computer program (moneymanager.py, main.py and testmoneymanager.py).

Class Design – Money Manager Tool

The following design for MoneyManager
The following is the functionality of the class:
• add_entry – this adds a new entry into the money manager representing the spending of the user. This includes the amount spent and the type of item the money was spend on. It also removes the amount from the current balance. For the sake of simplicity the type of item the money was spent on can only be food, rent, bills, entertainment or other – any other type will raise an exception that should be handled
• Each transaction in the transaction_list is a tuple containing the word Deposit followed by an amount or EntryType followed by an amount
• The user the tool represents cannot go into a negative balance so the user cannot spend money that is not available in their user. So if they have $100 in their user and then want to add an entry to spend $150 an exception will be raised with a suitable error message which is caught and displayed in the main.py file where the operation was attempted.
• All error messages, such as those from exceptions, should be displayed in a pop-up message box
• The get_transaction_string method should loop over all the transactions in the transaction_list creating a string version (with newline characters) of all the transactions associated with the user.
• The save_to_file function should save the user_number, pin_number, and balance in that order to a file called <user_number>.txt followed by the transaction list string generated from the get_transaction_string() method. The name of the user file is NOT ‘<user_number>.txt’ – the name of the file is the ACTUAL USER NUMBER followed by “.txt”, so for an user with user_number 123456 the name of the user file would be 123456.txt.

MoneyManager

user_number: int
pin_number: String
balance: float
transaction_list: list of two-tuples
add_entry(amount, entry_type)
deposit_funds(amount)
get_transaction_string()
save_to_file()

The Main Python Script
Our main.py script will contain all the main logic for our program. It will allow us to:
• Enter a user number via an Entry field by using the keyboard,
• Enter a PIN number via an Entry widget (we can use the keyboard OR a series of buttons to enter the PIN),
• Once we are logged in we must be able to:
o See the balance of the user,
o Deposit money for the user,
o Add entries to represent spending of funds from our user (only up to the amount we have available),
o Display a plot of spending
o Log out of our user.
Every time a successful deposit or entry is made then a new transaction should be added to the user’s transaction list. When we log out then the user file is overwritten with the new user details including our new balance and any transactions if any have been made.
The format of the user text file is as follows (each value on separate lines):
user_number
user_pin
currentBalance
123456
7890
800.00
After these first three lines we may have a number of transactions, each of which is specified as two lines. A deposit is indicated by the word Deposit on one line and then the amount on the next like. For example a deposit of $500 would look like this:
Deposit
500.00
Similarly, a entry is also specified as two lines – first the word being the type of entry and then on the next line the amount, for example entries representing rent of $200 and bills of $250 would look like this:
Rent
200.00
Bills
250.00
You are provided with an example user file called 12345678.txt – this file along with others will be used to mark your assessment, so you should make sure that your final submission can use users in this format successfully.

Login Screen
When the application is first launched, it should open a window that is “500×660” pixels in size (use the window object’s geometry function to set this). Set the title of the window to “FedUni Money Manager” using the top-level window object’s winfo_toplevel().title() function.
The window uses the GridManager layout manager for placing GUI elements (e.g. ‘widgets’), it contains a Label that spans the top of the window saying “FedUni Money Manager” (font size is 28). On the next line is a label saying “User Number” and then an Entry widget for the user to type in their user number and an entry for the PIN number.
It then has a series of buttons from 0 through 9, along with a Log In button and a Clear/Cancel button.
Each time a number is pressed it is added to a string – for example, if the user pushed the 4 button then the 3 button then the 2 button and then the 1 button then the string should contain the text “4321”. By using the show=”*” attribute you can ‘mask’ the input so that anyone looking over your shoulder cannot see the exact pin number, they’ll just see “****” instead. When the Clear/Cancel button is pressed, or when a user “logs out” then this PIN string should be reset to an empty string.
When the Log In button is pressed then the program should attempt to open the file with the user number followed by “.txt” – so in the example below, because the user number entered was “123456”, the program will attempt to open the file “123456.txt”.
If that file could not be opened then a messagebox should display a suitable error message such as “Invalid user number – please try again!”. You will have to “try/catch” this risky functionality to avoid the program crashing – see the week 7 lecture materials if you need a recap.
If the user exists, then MoneyManager object should be created and the fields of the MoneyManager object should be set (e.g. user_number, pin_number, balance, and the transaction_list).
Because you don’t know how many transactions are stored for this user, after reading the first three lines you will need to attempt to read two lines and if they exist create a tuple of the transaction (i.e. it’s type and amount) and then add it to the MoneyManager object’s transaction_list – for example you may do the following in a loop:
# Try to read a line, break if we’ve hit the end of the file
line = read_line_from_user_file()
if not line:
break
else:
# read another line, create a tuple from both lines and append the # tuple to the the MoneyManager object’s transaction_list
The user screen has:
– A large “FedUni Money Manager” label at the top that spans 5 columns (font size is 22),
– A label with the user number followed by the actual user number displayed,
ITECH1400 – Foundations of Programming – SEM3/18
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 5 of 9
– A label with the current balance followed by the actual balance,
– A log out button which saves the user file (overwriting it) and causes all widgets to be removed from the screen and the log in screen displayed again,
– An “Amount” label followed by an amount Entry widget where you can type in how much to deposit or an entry added,
– Deposit and Withdraw buttons that deposit or withdraw funds using the MoneyManager classes methods to do so,
– A Text widget (i.e. multi-line text) that shows all the transactions associated with the user. The height of this widget is 10 lines and the width of the widget is 48 characters.
– To the right of the Text widget this is a scrollbar which can be used to scroll the Text widget (it is not really showing in the above screenshot because the Text widget does not have more than 10 lines worth of content), and finally
– At the bottom of the screen is a plot (histogram) of the spending of the user broken down by type
Below is the top section of the screen:

Money Manager Test Case
The final thing to do is to add a small test case consisting of five unit tests that ensure that the MoneyManager class’ deposit_funds and add_entry methods operate correctly.
You are provided with a stub of a testmoneymanager.py test case that already has the definitions of the five unit tests that you will write and a description of what they are testing. Your job is to write suitable assert statements into each of these unit tests so that they ensure the MoneyManager class’ deposit and add entry functions do operate as they should. You should be able to accomplish each unit test in a maximum of two lines of code per unit test.
Two things to remember:
1.) The setUp method is automatically executed before each unit test, so the balance gets reset to 1000.0 before each test, and
2.) If your unit test fails (and the test is correct) then you should modify your code so that it passes the test, not the test so that it matches up with what your code is doing!


2) EM0184-EM201944MAN124CN

Assignment Description

Topic – Name Identity Reorganization with the help of Spacy and Standford NER tool (For this assignment we need proper implementation of Spacy name identity recognizer tool and Stanford NER tool. please use only same file (Text) for both to recognize name identity. please provide deep comparison of Spacy with NLTK(Why Spacy is better then NLTK) and provide the deep comparison of Standford with Spacy (Why Standford better then Spacy))
Part1
1. Implementation and Evaluation of Spacy(In Jupyter note book (Python 3))
If your project requires simulations, describe how the simulations were done, which software was used, what the inputs to the simulations are and the results you got from the simulations. This section may contain tables, graphs etc.
1.1 Implementations (with screenshots)
Describe your implementation. With screenshots

1.2 Testing (with screenshots)
Every system that is implemented needs to be tested. It does not matter whether is a software project or hardware, or a whole system combining both hardware and software. In all cases test the system for performance and record your findings on how the system you just implemented has performed. Honesty is required at this stage. It is ethically required that you are honest if the system fails or performs optimally. It is not to be seen as a flaw or failure if your system does not perform as expected. Thomas Edison ran over 1000 failed experiments on his first light bulb before he got it right.

1.3 Results of the Project (with screenshots)
In this section show your major results.

1.4 Discussions/Analysis
Discuss your results, explaining them to those who will read your report. Be aware that you are the expert on this project and it is your responsibility to explain your results in details

1.5 Comparison with NLTK

2 Conclusions
Draw your conclusions here.

Part2
2. Implementation and Evaluation of Stanford NER(In Jupyter note book (Python 3))
If your project requires simulations, describe how the simulations were done, which software was used, what the inputs to the simulations are and the results you got from the simulations. This section may contain tables, graphs etc.
2.1 Implementations (with screenshots)
Describe your implementation. With screenshots

2.2 Testing (with screenshots)
Every system that is implemented needs to be tested. It does not matter whether is a software project or hardware, or a whole system combining both hardware and software. In all cases test the system for performance and record your findings on how the system you just implemented has performed. Honesty is required at this stage. It is ethically required that you are honest if the system fails or performs optimally. It is not to be seen as a flaw or failure if your system does not perform as expected. Thomas Edison ran over 1000 failed experiments on his first light bulb before he got it right.

2.3 Results of the Project (with screenshots)
In this section show your major results.

2.4 Discussions/Analysis
Discuss your results, explaining them to those who will read your report. Be aware that you are the expert on this project and it is your responsibility to explain your results in details

2.5 Comparison with Spacy

3 Conclusions
Draw your conclusions here.

4 References

 


 

3) SA0051-SA1701190040 ITECH1400 – Assignment 1 – Money Manager

Assignment Description

The assignment is broken up into the following main components:
1.) The ability to provide a login screen to prevent other people from viewing the information contained in the tool
2.) The ability to view the current balance funds, add purchases made and deposits into the balance
3.) The ability to save the transactions to a file so that you can log in, add transactions to the application, log out and then return to find all of the transactions still there – i.e. the data is persistent.
4.) The ability to display a graph of your spending broken down by
type – i.e. food, bills, rent.
5.) A Test Case that ensures that your simple money manager works as required.
Your submission should consist three Python scripts that implement the computer program (moneymanager.py, main.py and testmoneymanager.py).
You are provided with a ‘stub’ of each of these files which contain all the function declarations and comments which describe the role of the function and how it can be put together, but you will have to write the code for vast majority of the functions yourself. You are also provided with a stub of the moneymanagertestcase.py file.
Your final submission should be a zipped archive (i.e. ‘zip file’) containing your completed Python scripts.

Class Design – Money Manager Tool
• add_entry – this adds a new entry into the money manager representing the spending of the user. This includes the amount spent and the type of item the money was spend on. It also removes the amount from the current balance. For the sake of simplicity the type of item the money was spent on can only be food, rent, bills, entertainment or other – any other type will raise an exception that should be handled
• Each transaction in the transaction_list is a tuple containing the word Deposit followed by an amount or EntryType followed by an amount
• The user the tool represents cannot go into a negative balance so the user cannot spend money that is not available in their user. So if they have $100 in their user and then want to add an entry to spend $150 an exception will be raised with a suitable error message which is caught and displayed in the main.py file where the operation was attempted.
• All error messages, such as those from exceptions, should be displayed in a pop-up message box
• The get_transaction_string method should loop over all the transactions in the transaction_list creating a string version (with newline characters) of all the transactions associated with the user.
• The save_to_file function should save the user_number, pin_number, and balance in that order to a file called <user_number>.txt followed by the transaction list string generated from the get_transaction_string() method. The name of the user file is NOT ‘<user_number>.txt’ – the name of the file is the ACTUAL USER NUMBER followed by “.txt”, so for an user with user_number 123456 the name of the user file would be 123456.txt.

The Main Python Script

• Enter a user number via an Entry field by using the keyboard,
• Enter a PIN number via an Entry widget (we can use the keyboard OR a series of buttons to enter the PIN),
• Once we are logged in we must be able to:
o See the balance of the user,
o Deposit money for the user,
o Add entries to represent spending of funds from our user (only up to the amount we have available),
o Display a plot of spending
o Log out of our user.
Every time a successful deposit or entry is made then a new transaction should be added to the user’s transaction list. When we log out then the user file is overwritten with the new user details including our new balance and any transactions if any have been made.
The format of the user text file is as follows (each value on separate lines):
user_number
user_pin
balance
123456
7890
800.00
0.33
After these first four lines we may have a number of transactions, each of which is specified as two lines. A deposit is indicated by the word Deposit on one line and then the amount on the next like. For example a deposit of $500 would look like this:
Deposit
500.00
Similarly, a entry is also specified as two lines – first the word being the type of entry and then on the next line the amount, for example entries representing rent of $200 and bills of $250 would look like this:
Rent
200.00
Bills
250.00
You are provided with an example user file called 12345678.txt – this file along with others will be used to mark your assessment, so you should make sure that your final submission can use users in this format successfully.
You are also provided with a video demonstration of the completed assignment along with this document. Your application should match this user interface and function in the same way.

Login Screen
When the application is first launched, it should open a window that is “500×660” pixels in size (use the window object’s geometry function to set this). Set the title of the window to “FedUni Money Manager” using the top-level window object’s winfo_toplevel().title() function.
The window uses the GridManager layout manager for placing GUI elements (e.g. ‘widgets’), it contains a Label that spans the top of the window saying “FedUni Money Manager” (font size is 28). On the next line is a label saying “User Number” and then an Entry widget for the user to type in their user number and an entry for the PIN number.
It then has a series of buttons from 0 through 9, along with a Log In button and a Clear/Cancel button.
Each time a number is pressed it is added to a string – for example, if the user pushed the 4 button then the 3 button then the 2 button and then the 1 button then the string should contain the text “4321”. By using the show=”*” attribute you can ‘mask’ the input so that anyone looking over your shoulder cannot see the exact pin number, they’ll just see “****” instead. When the Clear/Cancel button is pressed, or when a user “logs out” then this PIN string should be reset to an empty string.
When the Log In button is pressed then the program should attempt to open the file with the user number followed by “.txt” – so in the example below, because the user number entered was “123456”, the program will attempt to open the file “123456.txt”.
If that file could not be opened then a messagebox should display a suitable error message such as “Invalid user number – please try again!”. You will have to “try/catch” this risky functionality to avoid the program crashing – see the week 7 lecture materials if you need a recap.
If the user exists, then MoneyManager object should be created and the fields of the MoneyManager object should be set (e.g. user_number, pin_number, balance, and the transaction_list).
Because you don’t know how many transactions are stored for this user user, after reading the first four lines you will need to attempt to read two lines and if they exist create a tuple of the transaction (i.e. it’s type and amount) and then add it to the MoneyManager object’s transaction_list – for example you may do the following in a loop:
# Try to read a line, break if we’ve hit the end of the file
line = read_line_from_user_file()
if not line:
break
else:
# read another line, create a tuple from both lines and append the # tuple to the the MoneyManager object’s transaction_list
The user screen has:
– A large “FedUni Money Manager” label at the top that spans 5 columns (font size is 22),
– A label with the user number followed by the actual user number displayed,
– A label with the current balance followed by the actual balance,
– A log out button which saves the user file (overwriting it) and causes all widgets to be removed from the screen and the log in screen displayed again,
– An “Amount” label followed by an amount Entry widget where you can type in how much to deposit or an entry added,
– Deposit and Withdraw buttons that deposit or withdraw funds using the MoneyManager classes methods to do so,

A Text widget (i.e. multi-line text) that shows all the transactions associated with the user. The height of this widget is 10 lines and the width of the widget is 48 characters.
– To the right of the Text widget this is a scrollbar which can be used to scroll the Text widget (it is not really showing in the above screenshot because the Text widget does not have more than 10 lines worth of content), and finally
– At the bottom of the screen is a plot (histogram) of the spending of the user broken down by type
Money Manager Test Case
The final thing to do is to add a small test case consisting of five unit tests that ensure that the MoneyManager class’ deposit_funds and add_entry methods operate correctly.
You are provided with a stub of a testmoneymanager.py test case that already has the definitions of the five unit tests that you will write and a description of what they are testing. Your job is to write suitable assert statements into each of these unit tests so that they ensure the MoneyManager class’ deposit and add entry functions do operate as they should. You should be able to accomplish each unit test in a maximum of two lines of code per unit test.
Two things to remember:
1.) The setUp method is automatically executed before each unit test, so the balance gets reset to 1000.0 before each test, and
2.) If your unit test fails (and the test is correct) then you should modify your code so that it passes the test, not the test so that it matches up with what your code is doing!


 

4) SA0050-SA1701190037 MNG03218 MIS

Assignment Description

To evaluate your capability to use a systematic process (i.e., SDLC discussed in Topic 4 of the subject) to make a comprehensive proposal to a sponsor to get approval for selecting, developing, and implementing an information system (also loosely called implementing an information system in the UIG), which could help the chosen organization by :
Improving an existing system
Introducing a new system
Creating a new business opportunity
Improving organisational productivity

For the purpose of better utilizing the content and knowledge discussed in the unit, Suggested Information Systems for Assignment 2 include:
ERP systems, CRM systems, SCM Systems, Decision Support Systems, Executive Information Systems, Enterprise Portals, Data Warehouse & Data Mining Applications, Data Analytics/Business Intelligence/Business Analytics Applications, and Knowledge Management Systems, and Collaboration Systems.
Alternatively an integrated information system with combined features of several systems mentioned above.
The focus of A2 is NOT on an App or a RFID type applications, but a system directed above.

 


 

5) 232121 – HOW TO IDENTIFY HUMAN NAME IN MACHINE LEARNING BY USING JUPYTER PYTHON

Assignment Description

1) downloading and installing anaconda.
2) find out jupiter notebook, which will come automatically after downloading anaconda.
3)downloading data from the internet or any other sources and uploading them in the jupiter notebook
4)identifying the human name from the jupiter notebook
5)use any of the tool like spacy, or NLTK .
6) take all of the screenshot and put a brief discussion how you did it.
7) do everything step by step and take screenshot as much as you can.

 


 

6) 227797-java programming

Assignment Description

Assignment 2
This assignment will apply your knowledge of the following areas:

Fundamentals of Programming
Data Types and Variables
Screen output and Keyboard Input
Parsing and Casting
Mathematics
Introduction
Develop a Java application used by teachers to calculate student marks.

Glossary
Weighted Average
A method of computing a set of numbers in which some elements of the set carry more importance (weight) than others.
Specifications
Develop a program that will allow a teacher to calculate a student’s final mark.

Input
The user will input the following data from the keyboard:

Student’s name
Total marks achieved on Assignments (out of 140)
Total mark achieved on Mid-term Exam (out of 60)
Total mark achieved on the Final Exam (out of 85)
Note: No data validation is required for this assignment. You will assume that all data entered by the user is valid. When testing your program, only enter valid data. When your assignment is evaluated, only valid data will be entered.

Processing
Once the student’s data is entered, the program will calculate the students final mark as a percentage.

Assignments are worth 15% of the final mark
The Mid-term Exam is worth 40% of the final mark
The Final Exam is worth 45% of the final mark
When the final mark is calculated, the program will print a report and the program will end.

The report will display a summary of the marks achieved in each category and the final mark rounded to two decimal places. E.g. 62.05

Output
Format:

Final Mark Calculator

Enter the student’s name: {student_name}
Enter {student_name}’s mark for Assignments (Max. 140): {assignments_mark_input}
Enter {student_name}’s Mid-term Exam mark (Max. 60): {midtermexam_mark_input}
Enter {student_name}’s Final Exam mark (Max. 85): {finalexam_mark_input}

Grade Report
————
Student: {student_name}

Assignments: {assignments_mark}/140 worth 15%
Mid-term Exam: {midtermexam_mark}/60 worth 40%
Final Exam: {finalexam_mark}/85 worth 45%

Final Mark: {calculated_final_mark}
IMPORTANT: All {text} must be substituted with input or program generated output in your program.

Assignment 3
This assignment will apply your knowledge of the following areas:

Selection Statements
Introduction
Develop a solution for validating and converting date values to a specific format.

Glossary
Leap Year
A year containing one additional day to keep the calendar year synchronized with the astronomical year.
Specifications
Design and develop a program that will validate and convert values of a date to the following format: mmmm d, yyyy (ie. January 1, 2012).

Input
The program will accept three inputs from the keyboard:

Day
Month
Year
Note: You will assume that all data entered by the user is the proper data type. When testing your program, only enter data that is the proper data type. When your assignment is evaluated, only required data types will be entered.

Validation
The following is a list of rules outlining valid data:

A valid month value is within the range 1 to 12 inclusive. (January is 1).
A valid day value:
April, June, September and November have 30 days in their months.
February has 28 days in its month, except for leap years when it has 29 days.
Remaining months all have 31 days in their months.
The year value must be entered as four digit year, where the lowest year value is 1582.
A leap year is any year value that is divisible by 4, but not divisible by 100 unless it is also divisible by 400.
Error messages:

{day} is an invalid day value.
{month} is an invalid month value.
{year} is an invalid year value.
{day} is an invalid day value for the month specified.
Note: the error messages above are listed in order of priority.

Processing
The program will accept day, month and year values for a date they wish to convert. Your program must test whether the date values entered by the user are valid. Validation should only take place after all input is accepted.

If the date is valid, the program will print the converted version of the date.

If the date is invalid, an error message is printed to the user.

Note: There is the potential that the date values entered could have multiple validation errors. Your program must display only the first error that is found.

Output
Format:

Day: {day_input}
Month: {month_input}
Year: {year_input}

{response}
Example of a valid date response:

January 1, 2012
Example of a invalid date response:

77 is an invalid month value.
IMPORTANT: All {text} must be substituted with input or program generated output in your program.

Assignment 4
This assignment will apply your knowledge of the following areas:

Loops
File Input
Introduction
Develop a Java application which will process a file containing credit card numbers.

Specifications
Your Java application will be used to validate credit card number stored in a data file.

Input
The application’s input will be stored in a file called creditcardnumbers.txt. This file will be read from the application’s current directory. When the data file does not exist in the application’s current directory, a message is displayed on the screen and the program will end. When the data file exists but does not contain any data, a message is displayed on the screen and the program will end.

For output specifications, reference the Output section of this document.

Input File Structure
The records within the data file contain one field (credit card number). Each line in the file contains a single record.

Example:

4929253776358751
4716026803447186
4539032933695186
5473350227612088
Processing
For each record in the data file validate the credit card number.

When an accepted credit card number is valid, print a message to the screen indicating the number is valid.

When an accepted credit card number is invalid (see Data Validation), print an invalid message to the screen. The invalid message will include a description of the validation error. Only one invalid message is display per credit card number.

Note: Considering an accepted credit card number could have an incorrect number of digits and incorrect check digit, the program should only print a single invalid message.

When a credit card number is not an accepted credit card number, it is considered rejected. No message is printed for rejected credit card numbers.

When the file has been completely processed, print a report of processing statistics.

Processing statistics include:

Total records in the file
Count of valid accepted credit card numbers
Count of invalid accepted credit card numbers
Count of rejected credit card numbers
For output specifications, reference the Output section of this document.

Data Validation
The following table outlines accepted credit card characteristics:

Type Number of digits Starts with
Mastercard 16 – 19 51 – 55
Visa 13 – 16 4
American Express 15 34, 37
Credit card numbers are validated based on the following rules (in order):

Number starts with the digits of an accepted card type
Number is the correct number of digits for the card type
Check digit is correct
Credit card numbers that do not start with the digits of an accepted card type are considered rejected.

Check Digit Algorithm
An accepted credit card with the proper amount of digits must end with a specific digit called the check digit. The algorithm for verifying the check digit is as follows:

Drop the last digit from the card number. The last digit is the check digit.
Reverse the digits.
Multiply the digits in odd positions (1, 3, 5, etc.) by 2.
Subtract 9 from any result higher than 9.
Sum all the digits.
The check digit (the last number of the card) is the amount that you would need to add to get a multiple of 10 (Modulo 10)
Example:

Step Digits Total
Original Number: 4 5 5 6 7 3 7 5 8 6 8 9 9 8 5 5
Drop the last digit: 4 5 5 6 7 3 7 5 8 6 8 9 9 8 5
Reverse the digits: 5 8 9 9 8 6 8 5 7 3 7 6 5 5 4
Multiple odd positioned digits by 2: 10 8 18 9 16 6 16 5 14 3 14 6 10 5 8
Subtract 9 to numbers over 9: 1 8 9 9 7 6 7 5 5 3 5 6 1 5 8
Sum: 1 8 9 9 7 6 7 5 5 3 5 6 1 5 8 85
Mod 10: (85 + 5) % 10 is zero

Output
Data file does not exists:
Format:

*** {file_name} does not exist. ***
Example:

*** creditcardnumbers.txt does not exist. ***
Data file has no data:
Format:

*** {file_name} is empty. ***
Example:

*** creditcardnumbers.txt is empty. ***
Valid Credit Card Number
Format:

{card number} is a valid {card_description} number.
Sample:

341272341827718 is a valid American Express number.
Invalid Credit Card Number
Format:

{card_number} has an invalid {error_description}.
Samples:

51292537758751 has an invalid number of digits.
5129253776358751 has an invalid check digit.
Note: Each valid/invalid message is printed on its own line with no blank lines between them.

Processing Statistics
Format:

[blank_line]
***
[blank_line]
Records processed: {number_of_records_processed}
=======================
Mastercard: {number_mastercard_valid} ({number_mastercard_invalid})
Visa: {number_visa_valid} ({number_visa_invalid})
American Express: {number_amex_valid} ({number_amex_invalid})
Rejected: {number_of_rejected}
Note: numbers are right aligned.

Sample:

***

Records processed: 26
=======================
Mastercard: 14 (2)
Visa: 2 (0)
American Express: 1 (0)
Rejected: 7

Assignment 5
This assignment will reinforce your knowledge of the following areas:

Methods
File Output
Introduction
Develop an application that will validate the data in a file containing inventory information.

When the validation of the file is successful, the program will display a message indicating validation was successful. When the validation of the file is unsuccessful, the program will indicate how many errors were found in the file. Each error is written to a log file.

Specifications
Input
The application’s input will be stored in a file called inventory.txt. This file will be read from the application’s current directory.

When the data file does not exist in the application’s current directory, a message is displayed on the screen and the program will end.

When the data file exists in the application’s current directory but does not contain any data, a message is displayed on the screen and the program will end.

Input File Structure
Each line in the file contains a single record. All records within the data file contain five fields delimited by commas.

Format:

id,sku,quantity_on_hand,order_point,order_quantity
Field Information:

id (integer)
represents the unique record identifier.
sku (alphanumeric)
(stock-keeping unit) represents the unique identifier for the product sold by the business.
quantity_on_hand (integer)
represents the number of units of the product currently in stock.
order_point (integer)
represents the number of units of a product on hand when a purchase order for its replenishment is to be issued.
order_quantity (integer)
represents the number of units to be ordered for the product.
Example:

1,AB123,14,5,10
2,A0234,-4,0,14
Note: When creating test data, ensure all fields contain a value and the value is the proper data type.

Processing
For each record in the data file, validate the fields according the rules specified in the Data Validation section of this document.

When validation of the inventory file is complete, the program will do one of two tasks:

When no validation errors are found, print a message to the screen indicating there are no errors.
When validation errors are found, print a message to the screen indicating how many errors were found. Each error is logged to the validation_errors.txt.
See Output section for output specifications and format.

Data Validation
SKU
The format of the SKU is two letters followed by two or more of numbers.

Examples of valid SKUs:

AB1234
AD12
ZZ62534
Examples of invalid SKUs:

A1234
A1B234
ZD9
Z9
Z
Error Description

Invalid format
Quantity on hand
The quantity on hand must be a value greater or equal to zero.

Error Description

Value less than zero
Order Point
The order point must be a value greater or equal to zero.

Error Description

Value less than zero
Order Quantity
The order quantity must be a value greater than zero.

Error Message

Value less than or equal to zero

File Output
When a record contains invalid data, output validation error data to a file named validation_errors.txt. The validation_errors.txt must be created in the application’s current directory. A record can contain more than one field that is invalid. All invalid fields must be recorded in the error data file.

Validation error record format:

record_id,field_name,field_value,error_description
Example:

77,sku,12345,Incorrect format
88,order_quantity,-4,Value less than or equal to zero
99,quantity_on_hand,-99,Value less than zero
Note: Each time the program runs, the program will delete the validation_errors.txt file. The validation_errors.txt file is only generated when errors are found in the data.

Screen Output
Inventory file does not exists:
Format:

*** {file_name} does not exist. ***
Example:

*** inventory.txt does not exist. ***
Inventory file has no data:
Format:

*** {file_name} is empty. ***
Example:

*** inventory.txt is empty. ***
Inventory file validated successfully:
Format:

Validating {file_name}…

Validation completed with no errors.
Example:

Validating inventory.txt…

Validation completed with no errors.
Inventory file contains invalid data:
Format:

Validating {file_name}…

Validation completed with {number_of_errors} errors.

ID Field Value Description
—– ——————– ——————– —————————–
{id} {field_name} {field_value} {error description}
Column maximum length:

ID: 5
Field: 20
Value: 20
Description: no limit
Each column is separated by two spaces.

Example:

Validating inventory.txt…

Validation completed with 3 errors.

ID Field Value Description
—– ——————– ——————– —————————–
1 sku 12345 Invalid format
7 order_quantity 0 Value less than or equal to zero
10 order_point -1 Value less than zero

Assignment 6
This assignment will reinforce your knowledge of the following areas:

Arrays
Two-dimensional Arrays
Introduction
Develop an application that will process a file containing shipping data and will generate an shipping report.

Specifications
Input
The application’s input is stored two files:

orders_validated.txt
carton_info.txt
Order Data
Order data is stored in a file called orders_validated.txt. This file has already been validated and will be read from the application’s current directory.

When the data file does not exist in the application’s current directory or the file is empty, a message is printed on the screen and the program will end. See Output section for output specifications and format.

NOTE: The data in the orders_validated.txt file must contain only valid data. Data validation is not required for this assignment.

Record Structure
Each line in the file contains a single record. Each record contains four fields delimited by commas.

Format:

id,customer_name,number_of_units_ordered,region_id
Field Information

id
represents the unique record identifier.
customer_name
represents the name of the customer which placed the order.
number_of_units_ordered
represents the number of units ordered.
region_id
represents the sales region the customer is located in. Its value is always between 1 and 4 (inclusive)
Examples:

1,Good Buy,530,1
2,Future Buy,945,4
3,Willmart,2380,4
IMPORTANT: To ensure optimal performance, the order data input files must only be read through a maximum of once in your program.

Carton Information Data
Carton information data is stored in a file called carton_info.txt. The file will be read from the application’s current directory.

When the data file does not exist in the application’s current directory or the file is empty, a message is printed on the screen and the program will end. See Output section for output specifications and format.

NOTE: The data in the carton_info.txt file must contain only valid data. Data validation is not required for this assignment.

Record Structure
Each line in the file contains a single record. Each record contains three fields delimited by commas. The file must sorted by the capacity field in ascending order. The capacity field of each record must have a unique value.

Format:

carton_description,carton_abbreviation,capacity
Field Information

carton_description
represents the description of the carton.
carton_abbreviation
represents a shortened version of the carton description. The value of the abbreviation is one or two characters (uppercase).
capacity
represents the number of widgets that completely fills the carton. The value of capacity for each record must be unique. The smallest capacity must be the value 1.
Example:

Single,S,1
Small,SM,10
Medium,M,50
IMPORTANT: To ensure optimal performance, the carton information input files must only be read through a maximum of twice in your program.

Processing
Your program must print a report (to the screen) detailing the quantity of each carton type needed to ship all orders to the customers in all four sales regions. Output the report where quantities are displayed by carton capacity in descending order.

The quantity of cartons for a single order can be determine using the following rules:

Larger cartons are preferred over smaller cartons.
Example:

Example Record:

1,Good Buy,533,3
Number of widgets to ship: 533

Carton Capacity
S 1
SM 5
M 30
L 100
Result:

Carton Quantity required for shipment
S 3
SM 0
M 1
L 5
Each order indicates the sales region it is to be shipped to. The number of cartons for each capacity are added to the totals for the specified region.

Result:

Carton Region 1 Region 2 Region 3 Region 4 Total
S 0 0 3 0 3
SM 0 0 0 0 0
M 0 0 1 0 1
L 0 0 5 0 5

Output
Input File Does Not Exist
Format:

*** {file_name} does not exist. ***
Example:

*** orders_validated.txt does not exist. ***
Input File Contains No Data
Format:

*** {file_name} is empty. ***
Example:

*** orders_validated.txt is empty. ***
Report
Format:

12345678901234567890123456789012345678901234567890123456789012
Region
————————————————————–
Carton | 1 2 3 4 Total
————————————————————–
XX | ##,### ##,### ##,### ##,### ###,###
————————————————————–
Sample:

Region
————————————————————–
Carton | 1 2 3 4 Total
————————————————————–
XL | 1,003 30 300 10,000 11,333
L | 45 67 13 1,000 1,125
M | 70 150 99 77 396
S | 14 25 35 90 164

Assignment 7
This assignment will reinforce your knowledge of the following areas:

OOP Encapsulation
Classes
Objects
Introduction
Develop an application that will report the transaction data for bank accounts.

Specifications
Required Resources
This assignment must be completed using the provided BlueJ project. This project includes a class called AssignmentHelper. This class must be used to complete your assignment. Read the documentation for the AssignmentHelper class prior to developing your assignment to ensure you understand how the class will be used to complete your assignment.

Input
The application’s input is stored two types of files:

accounts.txt
accountid_transactions.txt
Note: The “accountid” part of the file name is substituted with the account’s identification. E.g. 97867564534231_transactions.txt

Account Data
Data for all accounts is stored in a file called accounts.txt and will be read from the application’s current directory.

When the data file does not exist in the application’s current directory, a message is printed on the screen and the program will end.

NOTE: The data in the accounts.txt file must contain only valid data. Data validation is not required for this assignment.

Record Structure
Format:

account_identification,account_holder,balance,annual_interest_rate
Field Information

account_identification
represents the unique account identification for the bank account holder.
account_holder
represents the full name of the account holder.
balance
represents the current balance of the account. An account balance can be a negative value.
annual_interest_rate
represents the annual rate of interest.
Sample:

97867564534231,Al Igator,1000.30,.025
Account Transaction Data
The transactions for each account is stored in a stored in a file called accountid_transactions.txt, where the “accountid” part of the file name is substituted with the accounts identification. E.g. 97867564534231_transactions.txt.

This file is validated and sorted in ascending order by month. The file will be read from a sub-directory called “transactions” within the application’s current directory.

If an account’s transaction file does not exist or is empty, an entry is written to an error log file (see Output) and processing continues.

NOTE: The data in the accountid_transactions.txt file must contain only valid data (with the exception of being blank). Data validation is not required for this assignment.

Record Structure
Each line in the file contains a single record. Each record contains three fields delimited by commas.

Format:

transaction_type,amount,month
Field Information

transaction_type
represents the type of transaction. The values of this is either 1 or 2. 1 represents a deposit transaction. 2 represents a withdrawal transaction.
amount
represents the amount of funds used in the transaction.
month
represents the month the transaction was performed in. The values of this field range from 1 to 12.
Example:

1,500,1
1,30,1
2,100,1
1,900,2
IMPORTANT: To ensure optimal performance, the input files must only be read through once in your program.

Class Design
BankAccount Class Diagram
Class Diagram

Member Information
Fields
accountIdentification – a unique alphanumeric value used to identify the account.
accountHolder – the full name of the account holder.
balance – the amount of the money in the account.
annualInterestRate – the rate that interest is accumulated annually.
Methods
BankAccount() – used to construct a BankAccount with default values for account identification, account holder’s full name, balance and annual interest rate.
BankAccount(String, String) – used to construct a BankAccount with an assigned account identification and account holder’s full name, with the other fields set to their defaults.
BankAccount(String, String, double, double) – used to construct a BankAccount with assigned values for all fields.
getAccountIdentification() : String – returns the account identification of the BankAccount.
setAccountIdentification(String) – modifies the BankAccount’s account identification.
getAccountHolder() : String – returns the BankAccount holder’s full name.
setAccountHolder(String) – modifies the BankAccount holder’s full name.
getAnnualInterestRate() : double – returns the annual interest rate assigned to the BankAccount.
setAnnualInterestRate(annualInterestRate : double) – modifies the BankAccount’s annual interest rate.
getBalance() : double – returns the balance of the BankAccount.
deposit(double) – adds an amount of money to the balance of the BankAccount. When the amount to deposit is a negative value, the BankAccount balance should not be changed.
withdraw(double) – subtracts an amount of money from the balance of the BankAccount. When the amount to withdraw is a negative value, the BankAccount balance should not be changed.
getMonthlyInterest() : double – returns the amount of monthly interest accumulated for the BankAccount based on the current balance. For BankAccount balances less than $1,000, no interest is accumulated.
toString() : String – returns a String representation of a BankAccount (see Output).
Default Values for Fields

account identification: blank
Account Holder: blank
Balance: zero
Annual Interest Rate: zero
Processing
Your program will process the transactions for all bank accounts and print a report to the screen detailing the current balance of each account after applying the transactions. The report will also include a total of all account balances.

For each account listed in the the accounts data file, do the following:

Open the account’s transaction file.

Note: If the account’s transaction file cannot be opened, write an entry to the error log file.

Read the accounts transactions and apply the transactions to the account.

Note: At the end of each month, deposit interest into the account.

When the transaction file is completely processed, print the account to the report.

When all accounts have been processed, print the total of balances for all accounts.

Example:
Account Data

97867564534231,Al Igator,1000.30,.025
Transaction Data

1,500,1
1,30,1
2,100,1
1,900,2
2,50.99,2
2,23.34,2
1,1000,3
2,500,4
The following table illustrates the balances (after depositing interest) of the BankAccount at the end of each month.

Month Balance
1 $1,433.28
2 2,263.66
3 3,270.46
4 2,776.23
The balance after processing transactions is $2,776.23.

Output
Account File Does Not Exists
Format:

{filepath} does not exist.
Sample:

accounts.txt does not exist.
Account File is Empty
Format:

{filepath} is empty.
Sample:

accounts.txt is empty.
BankAccount
A BankAccount object is represented as a String in the following format:

1234567890123456789012345678901234567890123456789012345678901234567890
############## XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX $#,###,###.##
Place Holders
account identification (left aligned)
Account Holder (left aligned, maximum 30 characters)
Balance (right aligned, formatted as currency)
Sample:

97867564534231 Al Igator $3,456.04
Report
Format:

1234567890123456789012345678901234567890123456789012345678901234567890
Account # Holder Balance
——————————————————————-
############## XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX $#,###,###.##
——————————————————————-
Total $###,###,###.##
Sample:

Account # Holder Balance
——————————————————————-
97867564534231 Al Igator $3,456.04
31425364758697 Jed I. Knight $1,138.00
——————————————————————-
Total $4,594.04
Error Log
Errors will be logged in a file called errors.txt. This file is located in the application’s current directory.

Note: The log file is not recreated or overwritten during each run. Log entries will be appended to the end of the file.

Transaction File Not Found
Format:

Account {account_number} transaction file does not exist.
Sample:

Account 97867564534230 transaction file does not exist.
Transaction File Is Empty
Format:

Account {account_number} transaction file is empty.
Sample:

Account 97867564534230 transaction file is empty.

Assignment 8
This assignment will reinforce your knowledge of the following areas:

Inheritance
Polymorphism
Abstract classes and methods
Interfaces
Introduction
Develop an application that will process payroll data.

Specifications
Class Design
Your program must implement the classes in the provided UML Class Diagram.

Class Diagram

Member Information
Employee
An Employee is created with a name, id and shift code
getName: retrieves the name of the Employee
getID: retrieves the ID of the Employee
getShift: retrieves the shift code of the Employee
getPay (abstract): retrieves the amount of money the Employee is paid
toString: retrieves the String representation of a Employee
ShiftSupervisor
A ShiftSupervisor is created with a customer name, id, shift code, salary and annual bonus
getSalary: retrieves the amount of salary paid to the ShiftSupervisor
getAnnualBonus: retrieves the amount of annual bonus paid to the ShiftSupervisor
setSalary: modifies the amount of salary paid to the ShiftSupervisor
setAnnualBonus: modifies the amount of annual bonus paid to the ShiftSupervisor
getPay: ShiftSupervisors are paid an annual salary plus an annual bonus. Use the supervisor’s annual pay amount to calculate their bi-weekly pay.
toString: retrieves the String representation of an ShiftSupervisor
ProductionWorker
A ProductionWorker is created with a name, id, shift code, rate of pay and hours worked
getRateOfPay: retrieves the amount paid to the ProductionWorker per hour
getHoursWorked: retrieves the number of hours worked by ProductionWorker
setRateOfPay: modifies the amount paid to the ProductionWorker per hour
setHoursWorked: modifies the number of hours worked by ProductionWorker
getPay: ProductionWorkers are paid a flat rate for each hour they work. If a ProductionWorker works the night shift, they are paid time and half (rate * 1.5).
toString: retrieves the String representation of a ProductionWorker
TeamLeader
A TeamLeader is created with a name, id, shift code, rate of pay, hours worked and monthly bonus
getMonthlyBonus: retrieves the amount of bonus paid to the TeamLeader monthly
getMonthlyBonus: modifies the amount of bonus paid to the TeamLeader monthly
getPay: TeamLeaders are paid the same as a ProductionWorker, except they also receive a bonus.
toString: retrieves the String representation of a ProductionWorker
Note: All employees are paid biweekly.

Utility Class
A static class is available to assist you in completing this assignment. Read the documentation before starting your program to determine how it will help you.

Note: this use of this class is optional for this assignment.

Input
The application’s input is entered by the user using the keyboard. The following data is captured:

Capture the following data for all employees:

Employee ID
Employee name
Shift code
Position code
The following data is captured specifically for each position type:

Production Worker and Team Leader
Hours worked
Rate of pay
Team Leader
Monthly bonus
Shift Supervisor
Annual pay
Annual bonus
Input Validation
Employee ID
Value less than or equal to zero: “Invalid employee ID!”
Employee Name
No characters: “Invalid employee name!”
Shift code
Not 1 or 2: “Invalid shift!”
Position code
Not 1 – 3: “Invalid employee type!”
Hours worked
Less than or equal to zero: “Invalid number of hours worked!”
Rate of Pay
Less than zero: “Invalid rate of pay!”
Monthly bonus
Less than zero: “Invalid bonus amount!”
Annual pay
Less than or equal to zero: “Invalid salary amount!”
Annual bonus
Less than zero: “Invalid bonus amount!”
Processing
Your program will process order data to generate a formatted payroll report. Your program will allow the entry of one or more employees.

When the user indicates there are no more employees to enter, the program will generate a report which includes the following:

A list of all employees entered, sorted by Employee ID in ascending order.
A summary of total payroll paid to employees of each position.
The total payroll paid to employees.

Output
Program Heading:

JavaBeans Manufacturing
Payroll Application
———————–
Employee Data Entry:

Employee ID: {input}
Employee name: {input}
Shift (1-Day or 2-Night): {input}

1. Production Worker
2. Team Leader
3. Shift Supervisor

Position (1, 2 or 3): {input}
Production Worker Data Entry:

Hours worked: {input}
Rate of pay: {input}
Production Worker Output:

Employee ID: {number} Name: {name}
Position: Production Worker
Shift: {shift} Hours: {hours} ROP: ${rate} Pay: ${biweekly_pay_amount}
Team Leader Data Entry:

Hours worked: {input}
Rate of pay: {input}
Monthly bonus: {input}
Team Leader Output:

Employee ID: {number} Name: {name}
Position: Team Leader
Shift: {shift} Hours: {hours} ROP: ${rate} Bonus: ${bonus} Pay: ${biweekly_pay_amount}
Shift Supervisor Data Entry:

Annual salary: {input}
Annual bonus: {input}
Shift Supervisor Output:

Employee ID: {number} Name: {name}
Position: Shift Supervisor
Shift: {shift} Salary: ${salary} Bonus: ${bonus} Pay: ${biweekly_pay_amount}
Entering another employee:

{print_employee}

Another employee? (y/n): {input}

{…Employee data entry…}
Data Entry Validation Error Messages

Invalid employee ID!
Invalid employee name!
Invalid shift!
Invalid employee type!
Invalid number of hours worked!
Invalid rate of pay!
Invalid salary amount!
Invalid bonus amount!
Invalid y/n response!
Payroll Report:

Payroll Report
==============
{List of employees sorted by Employee ID}

Total Payroll by Position
————————-
Production Worker: ${total}
Team Leader: ${total}
Shift Supervisor: ${total}

Total Payroll: ${total}

 


 

7) EM0170-EM201883ARF1218PYTH

Assignment Description

Write a program that prompts the user to enter an oligonucleotide sequence, such as TATGAGCCCGTA. If the user entered a valid oligo sequence consisting only of the characters A, C, G, or T, the program should then display the reverse complement of that sequence, in this case TACGGGCTCATA, along with text indicating that it is the reverse complement. After displaying the reverse complement, the program should then prompt the user to enter another sequence. The program should continue this pattern of prompting the user for a new oligo sequence and displaying its reverse complement until the user enters a sequence with at least one character that is invalid (i.e. a character other than A, C, G, or T). At this point, the program should end its run with a message that mentions that an invalid character was found, with no further prompting to the user. I need it as a Python script.


 

8) EM0164-EM201848MAL1212PYTH

Assignment Description

you designed a program to implement the game of Pig. This week, we will expand on that game by using a few patterns that we have learned, specifically the Proxy and Factory patterns.
For this assignment, we will expand on last week’s assignment in two ways:
1. You will now be able to play against the computer, where the computer will follow some
predefined strategy
2. You can now play a timed version of the game: if the game lasts longer than one minute, the
winner is whoever had the most points at the time.
You will implement the computer player as an inherited class from the base Player class. This will help
differentiate the computer player from a human one, which will be in its own class. You will also design a
PlayerFactory class, that will instantiate the correct Player class. For the timed version of the game, you
will implement this as a Proxy pattern on the Game class. This class will use all the same methods as the
Game class, but will keep track of time and when time is up, determine a winner.
Playing Against the Computer
In order for the computer to make decisions in this game, the computer must have some kind of strategy.
For this assignment, have the computer use the following strategy: given the computer’s score x, the
computer will hold at the lesser of 25 and 100 x;
otherwise, the computer will roll. This strategy should
be implemented in a new class, called ComputerPlayer, that inherits from the Player base class.
To determine what kind of players to use, your program should now accept two arguments, a –player1
and –player2 argument, each of which can be “human” or “computer”. Yes, your computer can
potentially have two computer players playing against one another.
Now that you have a new class, you should design a Factory class that will instantiate either a human or
computer player, depending on the input. The Game class should use this Factory when initializing the
game
Timed Version of Pig
Your next task is to write a Proxy to the Game class, called TimedGameProxy, which will follow all the same
exact rules of Pig as before, but will introduce a timed aspect: the game will continue until either someone
scores 100, or one minute has elapsed since the start of the game. This proxy should keep track of the
time the game starts, and should check that no more than one minute has gone by since then at every
step. In order to activate this feature, your program should take in a –timed parameter.


 

 

9) EM0151-TG18MUL0412PYTH

Assignment Description

Create a Chat application consisting of a chat client and a chat server. The client and server must be written in Python and must use sockets.

Introduction

The chat application allows multiple chat clients to connect to a chat server. Connected clients can:
1. list the members already logged in,
2. log in with a username,
3. exchange messages with other logged in users,
4. log out.
The server has to accept and maintain connections to all the clients and relay chat messages between them.

Chat Client Overview

The chat client application has to do the following tasks:
1. Connect to a chat server. The client obtains the server IP address and the port it is listening on. Then, the client immediately attempts to connect to the server socket using TCP.
2. Accept commands from the user. The client must be able to handle the following commands. Parameters are enclosed in <>:
a. login <username>
b. list
c. sendto <username> <message>
d. logout
e. exit
Each line must begin with a command. The parameters (if any) are separated by a space. The commands and parameters are described in more detail below. In order to implement these commands correctly, the client will have to send and receive the following messages to/from the server:
a. Send messages to the server. The client must be able to send the following messages to the server.
i. login message
ii. list message
iii. sendto message
iv. logout message
b. Accept incoming messages from the server. The client must be able to properly react to the following messages.
i. LIST message
ii. RESPONSE message
iii. SENDTO message

Commands from client to server

We now present the commands that a client must handle. Note: whenever a client prints an error message, it should not perform any other action.

• login: sends a login message to register with the server using the provided username.
o Parameter(s): a string to be used as the username.
o Rules:
o The string may not contain any white space. Screen names are treated as case sensitive.
o Any extra parameters after the username must cause the client to print an error. The error must also be printed if the username is more than 20 characters in length or if the username is not present. The following is the error:
Bad username
o Examples:
o The following is an example of a valid command:
login John
o The following is an example of an invalid command:
login John Doe
• list: sends a list message requesting the list of users already logged in.
o Parameter(s): none
o Rules:
o Any extra parameters must cause the client to print the following error:
Invalid command
o Examples:
o The following is an example of a valid command:
list
o The following is an example of an invalid command:
list bob
• sendto: sends a sendto message to the server to communicate with another client.
o Parameters: The user name of the destination client and the text to send.
o Rules:
o If either or both of the parameters are missing or if the username contains more than 20 characters, the following error message should be printed to the console:
Bad username
o If there are more than 65535 characters of text, the following error message should be printed to the console:
Bad message
o Examples:
o The following is an example of a valid command:
sendto John Hello, how are you?
o The following is an example of an invalid command:
sendto JohnHello
• logout: sends a logout message to the server.
o Parameters: none.
o Rules:
o Any extra parameters must cause the client to print the error:
Invalid command
o The client should not close the connection with the server when executing this command. After executing this command, the client should still be able to execute the list and login commands.
o Examples:
o The following is an example of a valid command:
logout
o The following is an example of an invalid command:
logout Joe
• exit: closes the client socket and exits the program.
o Parameters: Takes no parameters
o Rules:
o Any extra parameters must cause the client to print the error:
Invalid command
o Examples:
o The following is an example of a valid command:
exit
o The following is an example of an invalid command
exit client

Protocol Overview: For each message that the client sends to the server the server will send a message back. For a successful list message the server will return a LIST message back. For all other messages or an unsuccessful list Message, the server will respond with a RESPONSE Message. The client never sends messages back in response to messages received from the server.

Messages Sent from Server to Client
The following is the structure for messages the client receives from the server.
• LIST message: sent in response to successful list messages received from the client.
• RESPONSE message: sent in response to all messages received from the client, except where list messages are appropriate.
o If the server finds that a list message from the client has a problem (i.e. the server cannot provide the list of logged in users), it will send a response message, NOT a list message.
o If result is ok, the client must print the following message:
Success
o If result is failure, the client must print the following message:
Failure
o If the result is malformed packet, there is something wrong with your code.
• SENDTO message: sent whenever another client wishes to communicate with us.
o Client should be able to receive this message whenever it is logged in.
o Whenever this message is received, the client application has to print the message in the form “<username>: <text message>” to the console. For example if Bob sends “Hi how are you?” to John, then John’s client should print out: Bob: Hi How are you?

 


10) 873957-Artificial intelligence and Blockchain

Assignment Description

Artificial Intelligence Assignment

1.Name of the programme used: SWISH FOR PROLONG
2. Documentation is needed which is suggested in the brief and the layout that has to be done.

A Problem Statement
The submitted work is a paper on the potential applications of blockchain technology combined with one or more techniques only from the list below:
• Rule-based systems, (including logic)
• Expert systems
• Search algorithms
• Finite-State-Machine

A.1 Software: As part the work for the paper, you are expected to develop a small piece of software that links blockchain and one or more techniques stated above. Your focus is not on the blockchain, but what can be done with it. You are NOT expected:
• To produce a blockchain;
• To use a blockchain;
• Or use blockchain operations.
Your role is to use the data that could have come from a blockchain, to complete a task. You CAN assume that the data has been processed into the form you need.

The full code will not be handed in for the assignment, but extracts of code can be used within the report to highlight important points. No demonstration will be required as standard, but the tutor reserves the right to see a demonstration of the solution if they need to for marking purposes.

A.2 Overall: It is up to you whether you focus
• on one area of blockchain and one or more of the techniques, generall;y
• focus on a specific topic within the area;
• focus on a specific technique within this area.
All are acceptable but all must comply with blockchain and specified AI technique from the list in the problem statement.

B Report
B.1 Basic Requirement
• One or more of the techniques specified, combined with blockchain is discussed;
• Blockchain basic concept is discussed briefly;
• Discussion of blockchain and AI in combination is discussed;
• Solution – Matches section A.1. You do NOT need to build a blockchain but assume the data in solution has come from a blockchain – you DON’T need to use any blockchain operations; just use the data that could have been stored in a blockchain. You can use solutions developed by others, but they must be appropriately referenced to show the source.
• Conclusions discuss the advantages and disadvantages of these techniques and blockchain based on the evidence.
• Satisfactory summary of appropriate literature is produced.
• Harvard referencing.
• The headings specified in C are used)

C Report
Your report is expected to include the following (please use the headings Introduction, Background, Solution, Conclusions; References)
• Approximately 2000 words – this total does not include code, tables, reference list and figures.
• Introduction
o Introduction to the problem and the report with any necessary references.
• Background
o An explanation of any theory, background research and references that are need for the reader to understand the problem
o Relevant background on Blockchain and AI to your problem with any necessary references.
• Solution
o The software is a requirement and should be used to demonstrate your argument. Therefore, the testing included should clearly support your argument as well.
o Reference any sources
• Conclusions
o A summary of what has been found from both literature and any experimentation you may have done
o A set of conclusions (justified by literature and experimental evidence) that you drew from the work and should include your opinion, ideally with the necessary supporting evidence:
• References.
o Remember Harvard Referencing only
o Any sources including but exclusively to those for code, images and references sources used must be referenced.


11) 868009-Computer science

Assignment Description

The preferred programing language is java. I would need documentation. I would like the project to be related to cyber security as well as the software that will be implemented is related to cyber security.

In that sense, I’d like us to continue working in the area of modeling security inside a hospital, which is related to what you wanted to do in the first place.

So the first step would then be for you to read the attached paper and try to understand it.

Once you’ve done that, I expect by next week, try to adapt the models from the paper into models applicable to a hospital.

Then I want you to come up with several “Models of Organizational Security Policies”. You should be able to find what these are from the paper.

Finally, you will have to implement the actual models and decision
making algorithms into a java software program.

 


12) 867218-Parallel programming

Assignment Description

The problem concerns parallel implementation of the N-queen problem on shared-memory
architectures using C++ standard thread library. The N-queen problem asks how N queens can be placed on
an NxN chessboard so that no two of them can attack each other. An N-queen problem can have multiple
solutions e.g. 8-queen problem has 92 distinct solutions. You are provided with a sequential code which for a
given N counts the number of solutions to the N-queen problem.
We know that a valid solution must have one queen per row. We start with placing the first queen on the first
row; as there is no other queen on the board yet, the first queen can be placed in any of the N columns on
the first row. At this stage, we have built N partially valid board state with one queen on the first row. Then,
for each valid board state, we consider all valid positions for the second queen on the second row; by the
end of this stage, we have built all partially valid board states with two queens on the first and the second
row. The procedure continues with placing the third queen on the third row and so on. Every time a complete
solution is found the counter is incremented. You can imagine that this algorithm traverses a complete tree of
(partially) valid board states and increments the counter whenever a complete solution is found. However,
there is no need to build this tree explicitly. To efficiently implement this algorithm, we can use recursion. The
given code uses a recursive function and bitwise operation to keep track of valid positions on the board. You
can find more details about this implementation here (http://www.cl.cam.ac.uk/~mr10/backtrk.pdf, page 2-3).
Task. The sequential code finds the valid positions for one queen and then recursively solves the problem for
(N-1) queens. The search space and so the computation time for N-queen problem grows exponentially. You
can time the given sequential code for various number of queens to see the increasing runtime. Your task for
this coursework focus on exploiting parallelism to solve the N-queen problem.
Given the structure of the sequential algorithm, a straightforward solution is to launch one (asynchronous)
thread for each valid position of the i-th queen on the i-th row, where each thread count the number of
solutions for the corresponding board states. However, this easy solution would launch too many threads,
with many of them just burning cpu cycles and not doing much useful computation, consequently your
parallel code would end up being much slower than the original sequential code.
However, dividing the main task in a recursive fashion is a good idea which suits the N-queen problem, you
just need to assign these recursively unfolding sub-problems to a limited number of threads. Instead of
starting a new thread for every recursive call, your program has to
i) launch a limited number of threads,
ii) store the unfolding sub-problems in a suitable data structure, and
iii) let a free thread to pick a sub-problem to solve. A free thread has nothing else to do, either because it has
finished processing all its sub-problems or because it is waiting for other threads.
Even though the number of threads in your parallel program is now bounded to a given maximum value, due
to overhead of launching threads and communication between them your parallel program will still be slower
than the sequential one; to see the performance benefit of using parallelism, your parallel recursive code
should switch to the sequential mode for smaller value of N, e.g. when N < 13.
Your tasks are the following:
1. Implement a parallel N-queen solver as described above. Your program must accept three parameters:
N (number of queens), the maximum number of threads, and the point where your program switches to
sequential mode.
2. Provide a short report (Maximum length: half page of a A4 size paper) on performance of your parallel
code. You need to report your platform specifications and your compiler settings as well as the observed
speedup for a few cases (3 cases is enough) where you start to see the benefit of parallelism. You need
to include the sequential and parallel run-times for each case as well as the parameter settings under
which you got the results.


13) 867590- web environment

Assignment Description

Assignment 2 is a practical investigation into the web environment. You will be required to document, demonstrate and explain your results to the tutor. Thus far we have performed a study of the Apache webserver and have examined several different aspects of its operation. For this assignment select two of the following software products
1. Microsoft Internet Information Services (https://www.iis.net/)
2. Nginx Server (https://www.nginx.com/)
3. Caddy Server (https://caddyserver.com/)
4. Nodejs (https://nodejs.org/)
You need to select five key areas from the following list for evaluation along with the two compulsory areas marked with an asterisk (*). (Total 7 areas). 1. User Authentication and Authorization 2. Secure communications 3. Monitoring and Logging 4. Virtual Hosting (or similar feature) 5. Configuring and running web programming languages 6. URL rewriting and redirection 7. Proxy configurations 8. Support for HTTP 1 and HTTP 2 * 9. Memory Usage *

 


14) PSS0002-PSS1112201804 COIT20256-ASSIGNMENT 1

Assignment Description

Your task in this assessment is to analyse the given problem, model, and design the required data structures using UML class diagrams. You will be implementing the software solution, applying efficient algorithms, inheritance, polymorphism, and exception handling. The topics required for this assessment task are from Weeks 1-5. Your Java Application should have an interactive Graphical User Interface (GUI) based on the JFrame class using SWING GUI components. You should also write a report, as specified in this document, demonstrating your conceptual knowledge.
2.1 Problem
Statistical data show that ready-to-eat (RTE) cereals account for the bulk (78.5%) of all breakfast foods. Often, fresh juice is accompanied by the breakfast cereals. A large variety, approximately over 4900, of products exist in the breakfast cereal category which widely varies in their nutrient content. Even though a nutrition panel with nutrition information is provided on the pack, it is very difficult for a consumer to make an informed decision quickly to choose a comparatively healthier product. Therefore, a processed food suitability assessor (PFSA) is suggested, which can enable consumers to make informed decision making on their choice of processed food items. You are invited to design and develop an initial prototype for the PFSA to provide listing of items with nutrition information and to enable a user to select a cereal and beverage which will then provide the total nutrition information for the selection. You will be developing the Java application with a GUI. You are given a .csv file named processedFoodData.csv (available at the Unit website) with necessary data that can be used. The processed food details available in the file include the amounts of energy in kilo joules, protein, fat, carbohydrate, sugar, and dietary fibre in grams/per serve, and sodium in milligrams per serve. This file also contains the item name, brand name, serve size, and unit. The file includes a list of cereals and beverages.
The users accessing the PFSA should able to view the following data:
1. List of a chosen cereal and beverage with individual and total nutrition information.
The PFSA should display the names of cereals and beverages in two separate ComboBoxes enabling the user to choose one item from each list. Once the items are selected the user should be able to click the ‘Display Choices’ button to display the details.
Additional processed food items in the categories of snacks and sweetened beverage will be added after testing and approving the prototype. This is not in your scope of work as it is only after the prototype gets approved.
2.2 Design Guidelines
You can use the following guidelines in your modelling and GUI design.
Graphical User Interface
The application should have a GUI for user interactions. This GUI should have the necessary components to enable the user to execute all the functions as provided in Section 2.1 above. You may use the guidelines provided below for your GUI design and implementation. Variations to the provided guidelines are acceptable as long as it meets the user requirements.
i) Top Panel
The top panel can have a Label and TextField, to display the label ‘User Name’ and enable the user to enter the name in the TextField. The second row of the top panel can have two ComoBoxes with two associated labels to display the list of cereals and beverages.
ii) Middle Panel
This panel can have a TextArea to display welcome message to the User and the food choices and nutrition values.
iii) Bottom Panel
This Panel can have a label “Command Buttons” and can contain the required Command Buttons of ‘Enter Data’, Display Choices’, ‘Clear Display’ and ‘Quit’.
A full GUI design diagram is not given to encourage you to design using your own colour choices and other attributes for the GUI components.
The functions of the four Command Buttons are given below.
Initialisation
Your application should start by loading the data from the data file and filling the ComboBoxes with the food and beverage list. The list of food and beverage items and associated nutrient values are given in the data file (processedFoodData.csv) available at the Unit website.
Enter Data Button
The user enters the name using the TextField and selects food and beverage items using the list filled in the ComboBoxes. Once the user clicks the ‘Enter Data’ your application should store the entered data in appropriate data structures and display a message in the TextArea addressing the user by name and giving appropriate guideline to display the User’s food choices and nutrition information. Display error messages if the user hasn’t entered name or chosen items.

An example display is shown below. You can design and choose your own wordings for the message to make it user friendly.
You should also display appropriate error messages to help the user to complete the entry.
Display Choices Button
The user clicks this button to view the details of the food and beverage chosen using the ComboBoxes. Display appropriate error messages if the user clicks this button before choosing items and clicking the ‘Enter Data button’.
An example display is shown below.
Clear Display Button
Clicking on the “Clear Display” button should clear all contents from the TextArea, the TextField, and the data structures storing the user’s selection. The ComboBoxes will still have the list loaded.
Quit
The “Quit” button should allow the user to exit from the application.
Data Structures
You may follow the class design given below. You should read the specification carefully and design the classes using UML class diagrams and include the attributes with correct data types and all the methods, clearly indicating public or private. Clarify your doubts during the design stage so that your implementation can be less error prone and faster to complete.
i) Item class
This is a generic class and include appropriate fields to store:
an itemName
a category.
This class should have:
a parameterised constructor, accessor, mutator methods,
a toString() method.
Hello Mary Welcome to Processed Food Assessor System
Click the displayChoices button to view details of your choices
Food Type Item Name Brand Serve Size Unit Energy Protein Fat Carb Sugar Fibre Sodium
cereal Uncle Tobys Plus Antioxidant Uncle Tobys 40 gm 595.00 2.90 0.60 28.10 8.50 4.50 80.00
Beverage Original Juice Co.Orange Juice Original Juice 200 ml 356.00 1.60 0.60 18.00 16.00 1.20 14.00
Total 951.00 4.5 1.20 46.10 24.50 5.70 94.00

ii) Nutrient class
This class stores the nutrient name and nutrient amount. This class should have a parameterised constructor, accessor, mutator methods, and a toString() method.
iii) DataFile class
This class will have a parameterised constructor that takes the filename to be processed.
Include an ArrayList<> type attribute to read and load the data from the file.
Include a method to load data from the given file named ‘processedFoodData.csv’ available from the Unit website and return the ArrayList<>.
Use necessary file handing exceptions.
iv) ProcessedFood class
This class extends the Item class.
In addition to the inherited attributes, this class stores:
the brand name,serve size,serve unit (gm, or ml) an ArrayList of Nutrient objects to store the nutrient details.
This class should have a parameterised constructor, copy constructor, a default constructor, accessor, mutator methods, and a toString() method.
v) ProcessFoodGUI class
This class should have all the GUI components as described under the Graphical User Interface Design section. This class stores the data file name, creates the DataFile object and invokes its method to read and load the data from the file. This class will initialize the GUI components and use the loaded data from the file to set values for the comboBoxes. This class will have a userName attribute to store the entered user name. This class will have the main method and starts the application.

 


15) 833353-Data Analysis

Assignment Description

I have a hypothesis testing code made up I want to interface it with spark for more detailed visualization and try my code for streaming data and big data as well.

I want a code which works on any data be it a big data or a streaming data. it should work like a self monitoring hypothesis testing code. that’s my aim . I want a use of spark since its best for streaming data and also we have pakages in python which support spark.

there are many software to perform hypothesis testing on data, But I wanted to develop a code which not only performs hypothesis and shows results but also shows visualizations. and when it comes to streaming data, at every time the new data is added it should update and monitor by itself. Long story short a code which does mathematical calculations and shows them on graphs and results in such a way that a non user can understand what is hypothesis and is able to interpret the results.

 


16) 7235-python

Assignment Description

Build a simple dice application using python language

Developing two -player game.

The plyers roll 6-sided dice each and get points depending on what they roll. there are 5 rounds in a game. In each round each player rolls the two dice.

The rules are:

The points rolled on each players dice are added to their score.

If the total is an even number, an additional 10 points are added to their score.

If total is an odd number, 5 points are subtracted from their score.

The score of a player can not go below 0 at any point.

the person with the highest score at the end of the 5 rounds wins.

 


17) 843408-Computer science

Assignment Description

You will use your software renderer you have been developing in order to create your own 3D demonstration. Your submission must be a Win32 application written in C++ and using only GDI calls for all graphical functionality (i.e. use of APIs such as OpenGL or DirectX are forbidden). Your submission must clearly demonstrate the use of the features of your software 3D renderer in a creative way.
Please note the following requirements: –
• All features implemented must be demonstrated clearly in your submission. You should use code in your submission to control enabling and disabling of the features.. Do not provide user controls, etc. Your demonstration must be completely standalone. You will not be given credit for any features in your renderer that are not demonstrated.
• On-screen text should clearly indicate the current features being demonstrated at all times. This should include the form of rendering being shown (wireframe, flat, Gouraud, etc), what lighting is being demonstrated and any other information you feel would be useful. The objective is that the text should clearly explain what is being shown. You will be given details of how to add text to your display later in the module.
As well as the functionality implemented, the stability, performance and coding style will be graded.
Implementation Log
When you submit your assignment for marking, you will also need to submit an implementation log detailing the work you have done in this module towards the assignment. You are to start a diary recording everything you do on the application you are building in this module, starting from 2pm on 22nd October 2018 (i.e. immediately after the lecture in week 5). This should include the work you do in the practical sessions for this module, as well as the work you do on your own time. You must record every occasion you work on this application separately. For example, if you work on your application on eight separate occasions in a week, I would expect to see eight entries in your diary for that week.
5CC509 Page 3 Assignment 2018/2019
Each entry in the diary should be in the following format:
Date and time work started on this session
Amount of time spent working on the application in this session
A description of the work done in this session. If problems are encountered, you should include a brief description of the problem and how you overcame it. You should also describe how you have tested your work.
Your implementation log will be used during the marking of your assessment as an aid to assessing the application you submit.
Deliverables
You must submit a zip file to the submission point on Course Resources by the due date and time. Your zip file must be named <Your student number>.zip. For example, if your student number is 123456789, then your zip file would be named 123456789.zip.
Please do not use any compression system other than zip (i.e. don’t use .rar, .7z, etc). This is because the tools used to download your submissions for marking and uncompress them only work with zip files.
Your zip file needs to contain the following:
• A folder called ‘Standalone’ that contains the Release version of your executable, along with any other files needed in order for your demonstration to run. It is your responsibility to ensure that your demonstration will run from a folder on a machine in MS213 or MS214.
• A folder called ‘Source’ containing the complete Visual Studio 2017 solution. Please remove any unnecessary files before creating your zip file. In particular, delete the .vs folder and any Debug or Release folders. This will significantly reduce the size of the zip file you submit and make it much easier for you to submit.
• A copy of your Implementation Log in either Word (.doc or .docx) or PDF format.
• A completed copy of the Feature Checklist document that details the features you have implemented.

 


18) 844270-Computer science

Assignment Description

Programs must compile and run under C++.

Dijkstra’s algorithm finds the shortest path from a given node to all other nodes.
1) We observe that we can modify this algorithm to stop as soon as a particular node is reached;
thus producing an algorithm to find the shortest path between a specific pair of points.
However, this algorithm may involve the consideration of a number of points which do not lie
on the final shortest path.
We now consider 2 alternatives:
2) We can modify the algorithm to add nodes to the solution based on an A* criterion derived
from the Euclidean (straight line) distance from each candidate node to the desired end node.
3) We can attempt to improve our efficiency by modifying Dijkstra’s algorithm to start at both
the source and destination nodes and to construct two partial solution trees in parallel until
one node is in both partial solution trees.
Your task is to:
1. Code the modified Dijkstra’s algorithm to search from the start node out.
2. Code the A* variant.
3. Code the proposed improved algorithm.
Input consists of the following data:
1) The number of nodes in the graph.
2) A set of triples containing the node number, its X-coordinate and its Y coordinate – one triple
for each node in the graph.
3) The number of edges in the graph.
4) A set of triples consisting of two node numbers and a cost – one triple for each edge in the
graph.
5) A pair of node numbers representing the start and end nodes between which a path must be
found.
Output consists of the following data:
 The length of the shortest path from solution 1:
 The path (ordered list of nodes) from solution 1:
 The number of additional nodes in the solution tree for solution 1 (those not in the shortest
path that were added to the selected set):
 The length of the shortest path from solution 2:
 The path (ordered list of nodes) from solution 2:
 The number of additional nodes in the solution tree for solution2 (those not in the shortest
path that were added to the selected set):
 The length of the shortest path from solution 3:
 The path (ordered list of nodes) from solution 3:
 The number of additional nodes in the solution tree for solution 3 (those not in the shortest
path that were added to the selected set).
Notes: The graph is undirected, so each edge connects the pair of nodes specified in both directions.
Do not use the STL.
The graph will not have more than 100 nodes.
Your program should print an appropriate error message if no path exists between the
specified nodes.
Programs must compile and run under gcc (C programs), g++ (C++ programs), java or python.
Programs which do not compile and run will receive no marks. Programs should be appropriately
documented with comments.
In addition to the source file ass3.c or ass3.cpp you should also submit a text file containing a brief
discussion of your results. You should talk about the relative efficiency of each of the three proposed
approaches and note any problems that may arise with each of them
submit -u user -c csci203 -a 3 ass3.c ass3.txt
or
submit -u user -c csci203 -a 3 ass3.cpp ass3.txt
Where your unix user name should appear instead of user.
The following image shows the graph, with node numbers, for which test data is provided.


19) 832561-Computer Science Assignment Help

Assignment Description

Programs must compile and run under JAVA.

Dijkstra’s algorithm finds the shortest path from a given node to all other nodes.
1) We observe that we can modify this algorithm to stop as soon as a particular node is reached;
thus producing an algorithm to find the shortest path between a specific pair of points.
However, this algorithm may involve the consideration of a number of points which do not lie
on the final shortest path.
We now consider 2 alternatives:
2) We can modify the algorithm to add nodes to the solution based on an A* criterion derived
from the Euclidean (straight line) distance from each candidate node to the desired end node.
3) We can attempt to improve our efficiency by modifying Dijkstra’s algorithm to start at both
the source and destination nodes and to construct two partial solution trees in parallel until
one node is in both partial solution trees.
Your task is to:
1. Code the modified Dijkstra’s algorithm to search from the start node out.
2. Code the A* variant.
3. Code the proposed improved algorithm.
Input consists of the following data:
1) The number of nodes in the graph.
2) A set of triples containing the node number, its X-coordinate and its Y coordinate – one triple
for each node in the graph.
3) The number of edges in the graph.
4) A set of triples consisting of two node numbers and a cost – one triple for each edge in the
graph.
5) A pair of node numbers representing the start and end nodes between which a path must be
found.
Output consists of the following data:
 The length of the shortest path from solution 1:
 The path (ordered list of nodes) from solution 1:
 The number of additional nodes in the solution tree for solution 1 (those not in the shortest
path that were added to the selected set):
 The length of the shortest path from solution 2:
 The path (ordered list of nodes) from solution 2:
 The number of additional nodes in the solution tree for solution2 (those not in the shortest
path that were added to the selected set):
 The length of the shortest path from solution 3:
 The path (ordered list of nodes) from solution 3:
 The number of additional nodes in the solution tree for solution 3 (those not in the shortest
path that were added to the selected set).
Notes: The graph is undirected, so each edge connects the pair of nodes specified in both directions.
Do not use the STL.
The graph will not have more than 100 nodes.
Your program should print an appropriate error message if no path exists between the
specified nodes.
Programs must compile and run under gcc (C programs), g++ (C++ programs), java or python.
Programs which do not compile and run will receive no marks. Programs should be appropriately
documented with comments.
In addition to the source file ass3.c or ass3.cpp you should also submit a text file containing a brief
discussion of your results. You should talk about the relative efficiency of each of the three proposed
approaches and note any problems that may arise with each of them
submit -u user -c csci203 -a 3 ass3.c ass3.txt
or
submit -u user -c csci203 -a 3 ass3.cpp ass3.txt
Where your unix user name should appear instead of user.
The following image shows the graph, with node numbers, for which test data is provided.

 


20) 7204-software Design

Assignment Description

application mockup needs balsamiq wireframes designed for each report
the mockups should be original for all groups and you must use the “BALSAMIQ” software to develop them

This is a capstone team based project course. Your project is to create the full design and functional
requirements specification of a Mobile Application. Detailed guidelines are provided for each of
your assessment tasks which will culminate in a team Final Project Report and individual Critical
Reflection Essays.
Choose your client and delivery format:
The first decision your project team needs to make is to choose your client. Select an existing
business, organization, or institution. Design an original *Mobile Application for the selected
organisation which can potentially help them to better serve their organisation’s goals; improve
public awareness, increase efficiency and/or profits, etc. Since a Free App won’t generate any
revenue the estimated costs for development and ongoing maintenance must be justified by other
intrinsic benefits related to the application. Again you must be able to identify and provide realistic
supporting arguments that these intrinsic benefits justify the development and ongoing
maintenance costs of your Free App. Here are a few suggested resources to help you generate
some ideas for your project:
Lifestyle, productivity, reference, entertainment, finance, games and many more are potential
options. And yes, designing a game is also an option as long as it meets the guidelines. As you are
considering various mobile application categories keep in mind the requirements for the Final
Project Report that you will be developing. Try to find the best match between your preferred
application category, the interests and skills of your team members and the requirements for the
Final Project Report.
Choose an appropriate application delivery format:
 responsive web site, or
 smart device application which runs on phones and/or tablets.
* NOTE: An original mobile application is not a copy of an existing mobile application. While it can
be inspired by an existing work, the general rules for a derivative work will apply – the
transformation, modification or adaptation of the original work must be substantial and the
derivative work must be distinctly different from the original.
Required Information for Project Reports
Regardless of your chosen organisation or delivery format, all project reports must include the
information discussed below. If you don’t know how to find/develop the required information
please ask your Project Supervisor. All of the deliverable information discussed below builds on the
course work covered in the Information Technology Management major. Exemplar’s selected from
past team Final Project Reports will be posted to the StudyDesk. However, while reviewing the
exemplar’s provided, please keep in mind that the types of mobile applications permitted changes
from year to year, and so do the required business analysis activities. Your assignments must
conform to the requirements outlined for this course offering.
Table 1 below provides an outline of the expected contents of your two project reports.
Table 1 Contents of project reports
Project Specification Report:
 Letter of Transmittal
 Title Page
 Table of Contents
 Executive Summary
 Project Background
 Purpose
 Solution
 Project Schedule
 Conclusion
 References & Appendices (as
necessary)
Final Project Report:
 Letter of Transmittal
 Title Page
 Table of Contents
 Executive Summary
 Project Background
 Purpose
 Solution
 Anticipated Benefits
 User Demographics
 Mock-up
 User’s Guide
 Business Analysis Tasks
o Use Case Scenarios
o Mapping of Use Case
Scenarios to User Interface
o Document Object Models
 Recommendation
 Conclusion
 References & Appendices (as
necessary)
The detailed project schedule for your Project Specification Report should split all of the tasks
required for all of your assessments into sub- tasks. All sub-tasks must be allocated to individual
team members. Your project schedule should start the day after you submit your Project
Nomination form and must include ALL student activities personal or school/work related which will
impact on the project.
The project schedules detailed project tasks will form the basis for what your team develops for the
rest of the semester.

 


21) SA0025-SA04092018091 ITECH5403 – Assignment 2

Assignment Description

You are tasked with creating a program for a pizza shop –however, as this is a comparative languages course,
you will be creating the same application in the following programming languages:
 C,
 Python,
 Java and
 Lisp.
As you implement the application in each language, you should keep notes on the features of the languages
used, which you found useful, as well as any issues or complications which arose due to the complexity or lack
of any language features. A brief discussion based on these programming features for each individual
language accompanying each implementation is required. Finally, a comparative overview of the languages
highlighting applicability based on your experience in the design, implementation and debugging of your code
is also required.
If you foresee or encounter any complications, you may opt to implement or incorporate additional language
features which may be lacking, i.e. data structures. This can be done via:
 Your own implementation,
 Through libraries, or
 Via the incorporation of existing source code. You can use code found on the Internet, but use of any
existing code must be referenced.
Program Specification
Users may order one or more pizzas, where each pizza may be either: small, medium or large.
Small pizzas cost $5, medium pizzas cost $8 and large pizzas cost $12.
All pizzas come on a tomato base (for our pizza shop, this will be the only option), and will have the topping
cheese by default, at no extra cost. Users may choose up to a maximum of four additional toppings (bringing
the total to five) from the following list, where each topping adds an additional $1 to the price of the pizza:
 Bacon,
 Olives,
 Ham,
 Mushrooms,
ITECH5403 – Comparative Programming Languages
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 2 of 4
 Pineapple,
 Salami,
 Anchovies.
A pizza order consists of an order for one or more pizzas, where each pizza has a size, and may optionally include a list
of up to four additional toppings.
Each pizza order must be marked as either to be collected or to be delivered.
If the pizza is to be collected then the order requires a name and a phone number to be valid.
If the pizza is to be delivered then a name, phone number and address are required to be valid. In addition, if the order
total is less than $30 then an $8 delivery fee is added to the total.
The application must be error tolerant and capable of accepting keyboard input to store a number of pizza orders in
memory (they do not have to be persisted to file), as well as displaying an order summary which include details of all
orders, including:
 The details of each pizza in the order,
 The total cost of the order, and
 The name, phone number and (if required) address of the person who made the order.
Suggested Development Environments
Codeblocks for C ’99
Code::Blocks can be downloaded from: http://www.codeblocks.org/downloads/binaries
To create a new C project is:When you create a project, choose File | New and then Console Application, and
then choose C as the programming language.
IDLE for Python
Python, including the IDLE development environment can be downloaded from:
https://www.python.org/downloads/
Eclipse for Java 7 or Java 8
Eclipse may be freely downloaded from: http://www.eclipse.org/downloads/
Eclipse does not come with the Java JDK, which must the downloaded separately from:
http://www.oracle.com/technetwork/java/ … index.html
Ensure that your Eclipse type and Java type match –i.e. 32-bit Java for 32-bit Eclipse, or 64-bit Java for 64-bit
Eclipse. If you mix and match it won’t work.
GNU CLisp for Common Lisp
CLISP 2.49 can be sourced from: http://sourceforge.net/projects/clisp/f … t/download
Any good text editor would be suitable for writing the source code.
ITECH5403 – Comparative Programming Languages
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 3 of 4
Additional Documentation – Language Suitability Report
The design of each programming language incorporates a number of decisions about the language which
make it more or less suitable for given tasks. During your implementation of the pizza program in each of the
languages you should make notes about the language features which exist or do not exist, and which have
therefore made program development easier or more difficult.
Where a language has not provided a feature which would have been useful to the implementation of the
program, or where the complexity of using a language feature has been high you should remark upon it and
briefly discuss a mechanism or feature of another language which would have made development easier.
After completing the application in all languages(or as many as you can), discuss the comparative ease of
implementation in terms of the design, implementation and debugging for each programming language,
including how robustness issues were addressed.


22) 822728-Software Engineering Fundamentals

Assignment Description

Read the following two online articles.
1. www.toptal.com/swift/from-objective-c-to-swift
2. www.infoworld.com/article/2920333/mobile-development/swift-vs-objective-c-10-
reasons-the-future-favors-swift.html
Write 2 paragraphs, about 15 lines, describing the features of Objective-C or/and Swift
that lead to better quality software (less faults).

Review the following tutorials and start using git. If you already know and prefer to use
cvs or subversion, that is fine. Just be aware that for your project you are required to
use some Version Control System.
1. guides.github.com/introduction/git-handbook/
2. www.atlassian.com/git/tutorials/learn-git-with-bitbucket-cloud
Write 3 benefits of using a version control system.

These projects have been cited as projects that have caused significant damage to the
reputation of software development professionals and companies.
1. The Space Shuttle Software costed $10 Billion USD, (this is millions of dollars
more than planned). It was delivered 3 years late. It had serious quality issues:
The first launch of Columbia was canceled because of a synchronization problem
with the Shuttle’s 5 on-board computers. The error was traced back to a change
made 2 years earlier when a programmer changed a delay factor in an interrupt
handler from 50 to 80 milliseconds. The likelihood of the error was small enough,
that the error caused no harm during thousands of hours of testing. Substantial errors
still remained while software in operation: Astronauts were supplied with a book of
known software problems named “Program Notes and Waivers”.
2. The Canadian Government portal. Original plan was to consolidate 1,500 Canadian
government websites into a single portal on a single platform. In over three years,
only 10,000 webpages of a total 17 million had successfully been migrated. The
original budget was $9.4 million and soon was revised to $28 million.
3. In 2013, the BBC has scrapped a 98m digital production system, which its director general said had “wasted a huge amount of license fee payers’ money”. The
Digital Media Initiative was set up in 2008 but was halted in autumn 2013 having
never become fully operational. “I have serious concerns about how we managed
this project,” BBC director general Tony Hall said. An independent review has been
launched “to find out what went wrong and what lessons can be learned”, he said.
The Digital Media Initiative (DMI) was intended to transform the way staff developed, used and shared video and audio material and was seen as an important part
of a move of resources to Salford.
Chose one case, then write 2 paragraphs (10 to 15 lines) to discuss what potential software
engineering principles or guidelines reported in the media as being violated and leading
to the resulting failures.
Find in the WEB a description of the software crisis.

Review the following.
1. The report of an interview with Jennifer Lynch: www.infoq.com/articles/standishchaos-2015 on the “Standish Group 2015 Chaos Report”.
2. The video “The art of doing twice as much in half the time”
www.youtube.com/watch?v=s4thQcgLCqk by Jeff Sutherland
(en.wikipedia.org/wiki/Jeff_Sutherland).
Find in the WEB a copy of the Agile Manifesto. Write 2 paragraphs, (10-15 lines) about
why still software development projects still fail. That is, argue why software building is
a complex activity.


23) EM0038-WPS1811SUMITECH5403

Assignment Description

You are tasked with creating a program for a pizza shop – however, as this is a comparative languages course, you will be creating the same application in the following programming languages:
 C,
 Python,
 Java and
 Lisp.
As you implement the application in each language, you should keep notes on the features of the languages used, which you found useful, as well as any issues or complications which arose due to the complexity or lack of any language features. A brief discussion based on these programming features for each individual language accompanying each implementation is required. Finally, a comparative overview of the languages highlighting applicability based on your experience in the design, implementation and debugging of your code is also required.
If you foresee or encounter any complications, you may opt to implement or incorporate additional language features which may be lacking, i.e. data structures. This can be done via:
 Your own implementation,
 Through libraries, or
 Via the incorporation of existing source code. You can use code found on the Internet, but use of any existing code must be referenced.
Program Specification
Users may order one or more pizzas, where each pizza may be either: small, medium or large.
Small pizzas cost $5, medium pizzas cost $8 and large pizzas cost $12.
All pizzas come on a tomato base (for our pizza shop, this will be the only option), and will have the topping cheese by default, at no extra cost. Users may choose up to a maximum of four additional toppings (bringing the total to five) from the following list, where each topping adds an additional $1 to the price of the pizza:
 Bacon,
 Olives,
 Ham,
 Mushrooms,
ITECH5403 – Comparative Programming Languages
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 2 of 4
 Pineapple,
 Salami,
 Anchovies.
A pizza order consists of an order for one or more pizzas, where each pizza has a size, and may optionally include a list of up to four additional toppings.
Each pizza order must be marked as either to be collected or to be delivered.
If the pizza is to be collected then the order requires a name and a phone number to be valid.
If the pizza is to be delivered then a name, phone number and address are required to be valid. In addition, if the order total is less than $30 then an $8 delivery fee is added to the total.
The application must be error tolerant and capable of accepting keyboard input to store a number of pizza orders in memory (they do not have to be persisted to file), as well as displaying an order summary which include details of all orders, including:
 The details of each pizza in the order,
 The total cost of the order, and
 The name, phone number and (if required) address of the person who made the order.
Suggested Development Environments
Codeblocks for C ’99
Code::Blocks can be downloaded from: http://www.codeblocks.org/downloads/binaries
To create a new C project is: When you create a project, choose File | New and then Console Application, and then choose C as the programming language.
IDLE for Python
Python, including the IDLE development environment can be downloaded from: https://www.python.org/downloads/
Eclipse for Java 7 or Java 8
Eclipse may be freely downloaded from: http://www.eclipse.org/downloads/
Eclipse does not come with the Java JDK, which must the downloaded separately from: http://www.oracle.com/technetwork/java/ … index.html
Ensure that your Eclipse type and Java type match – i.e. 32-bit Java for 32-bit Eclipse, or 64-bit Java for 64-bit Eclipse. If you mix and match it won’t work.
GNU CLisp for Common Lisp
CLISP 2.49 can be sourced from: http://sourceforge.net/projects/clisp/f … t/download
Any good text editor would be suitable for writing the source code.
ITECH5403 – Comparative Programming Languages
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 3 of 4
Additional Documentation – Language Suitability Report
The design of each programming language incorporates a number of decisions about the language which make it more or less suitable for given tasks. During your implementation of the pizza program in each of the languages you should make notes about the language features which exist or do not exist, and which have therefore made program development easier or more difficult.
Where a language has not provided a feature which would have been useful to the implementation of the program, or where the complexity of using a language feature has been high you should remark upon it and briefly discuss a mechanism or feature of another language which would have made development easier.
After completing the application in all languages (or as many as you can), discuss the comparative ease of implementation in terms of the design, implementation and debugging for each programming language, including how robustness issues were addressed.


24) EM0062-EM201830AMA924JAVA

Assignment Description
Write a java program to traverse a directory structure (DirWalker.java) of csv files that contain csv files with customer info. A simple sample in provided in with the sample code but you MUST will run against a larger data set.
• Your updated readme from first day of class must be completed (see lecture notes on Brightspace for more info)
• The program should use (SimpleLogging.java) java logging for both info and all possible checked exceptions
• Some lines in the file will contain incomplete records and should be ignored (and logged)
– Counted as skipped rows,
• Program must use csv library (SimpleCsvParser.java)
• At the end the program should log – Total execution time – Total number of valid rows – Total number of skipped rows
• Submit repo in and eclipse & project files to GitHub
• Submit result file to directory ”Output” in repo
• Submit output log file from Linux to” output” directory
• Data Columns First Name, Last Name, Street Number, Street, City, Province, Country, Postal Code, Phone Number, email AddressBonus Points – Add the date to the defined in the directory structure as a date data column (yyyy/mm/dd)


25) EM0048-EM1867ASH2109PROG

Assignment Description

You are tasked with creating a program for a pizza shop –however, as this is a comparative languages course,
you will be creating the same application in the following programming languages:
 C,
 Python,
 Java and
 Lisp.
As you implement the application in each language, you should keep notes on the features of the languages
used, which you found useful, as well as any issues or complications which arose due to the complexity or lack
of any language features. A brief discussion based on these programming features for each individual
language accompanying each implementation is required. Finally, a comparative overview of the languages
highlighting applicability based on your experience in the design, implementation and debugging of your code
is also required.
If you foresee or encounter any complications, you may opt to implement or incorporate additional language
features which may be lacking, i.e. data structures. This can be done via:
 Your own implementation,
 Through libraries, or
 Via the incorporation of existing source code. You can use code found on the Internet, but use of any
existing code must be referenced.
Program Specification
Users may order one or more pizzas, where each pizza may be either: small, medium or large.
Small pizzas cost $5, medium pizzas cost $8 and large pizzas cost $12.
All pizzas come on a tomato base (for our pizza shop, this will be the only option), and will have the topping
cheese by default, at no extra cost. Users may choose up to a maximum of four additional toppings (bringing
the total to five) from the following list, where each topping adds an additional $1 to the price of the pizza:
 Bacon,
 Olives,
 Ham,
 Mushrooms,
ITECH5403 – Comparative Programming Languages
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 2 of 4
 Pineapple,
 Salami,
 Anchovies.
A pizza order consists of an order for one or more pizzas, where each pizza has a size, and may optionally include a list
of up to four additional toppings.
Each pizza order must be marked as either to be collected or to be delivered.
If the pizza is to be collected then the order requires a name and a phone number to be valid.
If the pizza is to be delivered then a name, phone number and address are required to be valid. In addition, if the order
total is less than $30 then an $8 delivery fee is added to the total.
The application must be error tolerant and capable of accepting keyboard input to store a number of pizza orders in
memory (they do not have to be persisted to file), as well as displaying an order summary which include details of all
orders, including:
 The details of each pizza in the order,
 The total cost of the order, and
 The name, phone number and (if required) address of the person who made the order.
Suggested Development Environments
Codeblocks for C ’99
Code::Blocks can be downloaded from: http://www.codeblocks.org/downloads/binaries
To create a new C project is:When you create a project, choose File | New and then Console Application, and
then choose C as the programming language.
IDLE for Python
Python, including the IDLE development environment can be downloaded from:
https://www.python.org/downloads/
Eclipse for Java 7 or Java 8
Eclipse may be freely downloaded from: http://www.eclipse.org/downloads/
Eclipse does not come with the Java JDK, which must the downloaded separately from:
http://www.oracle.com/technetwork/java/ … index.html
Ensure that your Eclipse type and Java type match –i.e. 32-bit Java for 32-bit Eclipse, or 64-bit Java for 64-bit
Eclipse. If you mix and match it won’t work.
GNU CLisp for Common Lisp
CLISP 2.49 can be sourced from: http://sourceforge.net/projects/clisp/f … t/download
Any good text editor would be suitable for writing the source code


26) 178777 – Software Technologies

Assignment Description

Task 1 – Access the workbooks and create a database
Create a Python script (db_create.py) to perform the following tasks:
 Open the excel files.
 Create a SQLite database with two tables, one for each excel file. Each column in the excel
files should correspond to a column in the tables. Make sensible decisions for attribute types.
 Import the data from the excel files to the corresponding tables in the database.
Task 2 – Query the database
Create a Python script (sql_food.py) to perform the following tasks:
 List the distinctive businesses that have had at least 1 violation ordered alphabetically to the
console and then write their name, address, zip code and city into a new database table
called “Previous Violations”.
 Print a count of the violations for each business that has at least 1 violation to the console
along with their name ordered by the number of violations. *SQL Hint: Group By*
Task 3 – Excel via Python
Create a Python script (excel_food.py) to perform the following tasks:
 Create a new workbook named “ViolationTypes.xlsx”.
 Create a sheet named “Violations Types”.
 Query the database and calculate the number of each type of violation based on violation
code.
 Write the relevant data into the worksheet you created. This should show the total number
of violations, then list how that is broken down by violation code, including the description
of the violation code. For example:
Task 4 – Numpy in Python
Create a Python script (numpy_food.py) to perform the following tasks:
 Query the database and retrieve data to calculate the average violations for every month
between July 2015 and December 2017 for each postcode.
 Use MatPlotLib to plot the follow data over time:
o The violations per month for the postcode(s) with the highest total violations
o The violations per month for the postcode(s) with the greatest variance (difference)
between the lowest and highest number of violations for all months.
o The average violations per month for ALL of California (all postcodes combined)
o The violations per month for all McDonalds and Burger Kings. This will require a new
query as it is not grouped by postal code.
 For 7810ICT students:
o Query the Violations table and retrieve all distinct violation codes and descriptions
o Using Regular Expressions (NOT SQL), filter the resulting data to print out a list of all
violation codes and descriptions that involve the word ‘food’. You should add this
violation listing as an appendix to your report.
Task 5 – Report
After developing all of your scripts, you need to take the information and present it in a brief
executive-style report. You may use the provided template as is, modify it, or come up with your
own. Do not simply paste data from the console/excel into each section in the template – present
the data in a professional manner.


27) 31716-system analysis and design

Assignment Description

Assessment 1 – Systems Analysis
Lecturer: xxx
Tutor: xxxx
Prepared by:
Student Name: xxx
Student Number: xxx

Table of Contents
1. Introduction 1
Aim of the Report 1
2. Approach to Systems Development 2
3. Systems Requirements 3
Functional Requirements 3
Non-Functional Requirements 3
4. Project Cost and Benefit Analysis 5
5. Project Schedule 7
Work Breakdown Structure 7
Gantt chart 8
6. System Information Requirement Investigation Techniques 10
Stakeholders Involved 10
Requirements Investigation Techniques 10
7. Reflections and Conclusions 11
REFERENCES 12

1. Introduction

International Charity Foundation (ICF) is the private auxiliary store and the administrator of ICF is Mr. Colin MacFarlane. The association offers help, instructive, and restorative help to youngsters with the goal that they may understand their potential. The association alongside its accomplice firms and organizations offers help to more than 3,000 individuals on a week after week premise. There are manual procedures followed in ICT that is raising issues, for example, manual handling of the structures by the staff, insufficient checking of salary and gifts, inaccessibility of the staff individuals to accept telephone calls, and wastage/lack of provisions. A mechanized data framework is required to be executed with the accompanying targets.
• To execute online enrolment process and a brought together database to store the greater part of the data.
• To enable the clients to make gifts from the site as a one-time or repeating instalment technique (Pomffyova and Bartkova 2016).
• To oversee and track the provisions, wage, and costs for every one of the branches.
• To upgrade the fulfilment levels of the people and offices related with ICF.
Aim of the Report
The report aims to bring out the detailed description of the system and its analysis & design aspects.

2. Approach to Systems Development
The framework advancement approach that has been chosen and prescribed for the data framework for ICF is agile philosophy for framework improvement. It is a procedure that is impromptu in nature and will ensure that the data framework being created for ICF is adaptable. According to the agile techniques, the necessities of the framework will be put in an item build-up. The improvement of the framework will be done in the iterations and these are alluded as sprints in the agile wording. Each sprint will acquire a sub-set of the necessities from the item excess and will put it in the sprint overabundance. One sprint will keep going for a time of 4 to a month and a half and the necessities in the sprint excess will be executed and achieved toward the finish of the sprint. In this way, the greater part of the prerequisites from the item excess will be executed.

The technique has been suggested for the framework since it is from the versatile arrangement of strategies for framework advancement. The data framework that will be created for ICF will be required to be refreshed later on because of the consideration of different highlights. ICF is growing at a fast scale and the quantity of clients will likewise increase in the years to come. There are mechanical progressions that are likewise happening which may prompt the rise of new and creative advances. Thus, there might be changes as far as client desires, framework highlights, and mechanical highlights that might be required to be finished. These progressions won’t be conceivable to actualize in the non-agile and non-versatile frameworks. With the utilization and usage of agile techniques, the final product will give versatile item that might be changed according to the necessity (Tewary and Kosalge 2013). The client criticism is one of the fundamental properties of agile. Criticism will be gathered from the client about the client encounter and the framework will be enhanced according to the remarks. This will give the last item as per the client wants and desires.
3. Systems Requirements
Functional Requirements
• To give a protected access to the clients with a choice to enlist and sign in to the framework utilizing multi-overlap validation measure.
• To enable the kids to see the online application shape and select to ICF by filling and presenting the frame on the web.
• To permit the administrator staffs to see the demand set by the understudy and get the data from the database to process the shape.
• To enable the people and associations to influence gifts, to support programs, and make grants utilizing the site of ICF.
• To ensure that the gifts can be set aside a few minutes instalment or as repeating instalments also (Muhairat 2010).
• The framework will recognize the client when a gift is made and an email will be sent on the enrolled id for the same.
• To enable the customer to print or download the united explanation utilizing their records.
• To ensure that robotized following of the provisions is made and the reports are distributed to arrange the provisions according to the outcomes (Sunner and Bajaj 2016).
• To monitor salary and costs with the goal that announcements are created appropriately
Non-Functional Requirements
• The data framework for ICF must incorporate accessibility of the framework as one of the fundamental and compulsory prerequisite under this class.
• The framework and the majority of its segments must incorporate the framework nature of execution for improved client encounter.
• The data framework for ICF must incorporate unwavering quality of the framework as one of the vital and obligatory prerequisite under this classification.
• The framework and the greater part of its segments must incorporate the framework nature of ease of use for improved client encounter.
• The data framework for ICF must incorporate versatility of the framework as one of the essential and compulsory prerequisite under this classification (Ahmad, Belloir and Bruel 2015).
• The framework and the greater part of its segments must incorporate the framework nature of viability for upgraded client encounter.
• The data framework for ICF must incorporate security of the framework as one of the fundamental and compulsory prerequisite under this class.
• The framework and the majority of its segments must incorporate the framework nature of heartiness for upgraded client encounter.

4. Project Cost and Benefit Analysis
There are a few costs related with the task and the aggregate spending plan of the venture has turned out to be $250,000. These incorporate the cost of advancement, one-time costs of devices, asset costs, testing costs, preparing costs, operational and support costs, and conclusion costs. The usage of the data framework at ICF will result in decrease of the staffing costs and will likewise yield streamlining of the utilization of provisions. The aggregate benefits got therefore are $305,712. The cost benefit examination has been finished by applying a markdown rate of 10% and it has been discovered that the venture will result in an Internal Rate of Return as 9% with the Net Present Value as $2,289.

Project Costs

Project Benefits

Cost-Benefit Analysis

5. Project Schedule
Work Breakdown Structure
Gantt chart

The undertaking plan that has been created is sensible as the timetable takes after the technique that has been chosen for the venture. There are activties that have been incorporated for each iteration or undertaking stage and these activties are given the length wherein the apportioned assets will have the capacity to effortlessly achieve the activties. There is likewise a hazard examination done ahead of time to guarantee that the movement term has a degree to manage a corresponsing hazard if there should be an occurrence of its event.

6. System Information Requirement Investigation Techniques
Stakeholders Involved
• Mr. Colin (Project Sponsor): The task prerequisites and business case particular will be present by Mr. Colin with the goal that the framework might be created likewise.
• Partners firms and people: ICF works with a ton many accomplice offices and their coordinated effort will be expected to comprehend the prerequisites.
• End-Users: Children, individuals, administrator, and other client will give their criticism to the framework.
• Suppliers: The partner gathering will give the apparatuses and hardware required for the venture.
• Project Team: The administration, operational, and specialized exercises will be completed by the asset.
Requirements Investigation Techniques
The three procedures that will be utilized for prerequisites examination will be interviews, perceptions, and brainstorming.
Interviews will be finished with the partners and different substances in the market to acquire the unmistakable comprehension of the client necessities and desires (Jamshed 2015). These will present a fair-minded diagram of the necessities of the framework. Perception of the present manual framework will be important to be done as such that the present arrangement of issues and issues can be acquired. The brainstorming procedure will prompt the investigation of new thoughts and ideas that might be utilized in the framework.

7. Reflections and Conclusions
ICF data framework will furnish the framework partners and clients with the benefit of streamlining of the considerable number of activities. The present issues in the association will be settled with the improvement and usage of the mechanized framework.
The constraints required with the framework incorporate the time and cost constraints. There is a financial plan of $250,000 distributed for the task alongside an expected time span of 120 days. These can’t be changed as the exertion assessed has been done in like manner and the due date of the conveyances is likewise determined to the premise of the same. The cost benefit investigation has been finished by applying a rebate rate of 10% and it has been discovered that the task will result in an Internal Rate of Return as 9% with the Net Present Value as $2,289. These showed up as the constraints. The group could figure out how to accomplish the undertaking goals as the framework was created as per the financial plan and timetable set-up. There were dangers and issues that surfaced and could be taken care of with the goal that none of the significant deviations could be watched. The consumer loyalty and commitment levels were additionally high.

REFERENCES
Ahmad, M., Belloir, N. and Bruel, J. 2015, Modeling and verification of Functional and Non-Functional Requirements of ambient Self-Adaptive Systems, Journal of Systems and Software, 107, pp.50-70.
Jamshed, S. 2014, Qualitative research method-interviewing and observation, Journal of Basic and Clinical Pharmacy, 5(4), p.87.
Muhairat 2010, UML Diagrams Generator: A New CASE Tool to Construct the Use-Case and Class Diagrams from an Event Table, Journal of Computer Science, 6(3), pp.253-260.
Pomffyova, M. and Bartkova, L. 2016, Take Advantage of Information Systems to Increase Competitiveness in SMEs, Procedia – Social and Behavioral Sciences, 220, pp.346-354.
Sunner, D. and Bajaj, H. 2016, Classification of Functional and Non-functional Requirements in Agile by Cluster Neuro-Genetic Approach, International Journal of Software Engineering and Its Applications, 10(10), pp.129-138.
Tewary, A. and Kosalge, P. 2013, Implementing service oriented architecture – a case study, International Journal of Business Information Systems, 14(2), p.164.


28) 32298-Case study and IT Research

Assignment Description

Assignment 3: Case study and IT Research
Length: Task A: 4 pages (2-column format); Task B: one pg
Submission method options: Alternative submission method
Task
back to top
Task A (10 marks):
‘’The Queensland Health implementation project failure
e is the largest IS failure in the
southern hemisphere to date, costing $1.25 billion
AUD. This case highlights the
importance of systematically analysing project fail
ure. It examines the case
organization details, royal commission report, audi
tor general report and 118 witness
statements pertaining to the Queensland Health impl
ementation project.
. ‘’

(Eaden and Sedera, 2014)

The Complete Case is Available from: https://pdfs.semanticscholar.org/f0c4/8 … c249ed.pdf

Based on the Case Above as well as your Own Research on IT Service Delivery, answer the following questions:

1. What were the key reasons for the IT implementation failure?
2) In your view, who is responsible for the failure and why?
3) Do some research on the use of IT by hospitals/health departments – give examples of success stories of the IT implementations and outline reasons for the success.
4) Why was ‘’WorkBrain’’ not utilized properly?
5) What would you recommend the Health Department to do to fix the current problems?

Task B (17 Marks):

Write a paper, 2000 words in length, on one of the topics below For this assignment, you need to plan, research, and, use your initiative to express the knowledge you learnt in this subject as well as your own independent thinking and reasoning.

Possible topics

Your attention in this paper can be focused on any of the following topics covered in our text such as for example:

• Emerging Business Technologies

• Raw Data Conversion/Mining

• Comparative Analysis of the ERP Applications

• IT Risk Management Strategies
• E-Commerce Models and/or Implementation Strategies.

• Mobile Technologies.

• Use of Social Media for Business.

• Enterprise Systems and Applications.

• Performance Management Using Data Visualization, Mashups, and Mobile Intelligence.

Approach

Choose a topic which you are interested in and/or which is related to your work. You should do this as early as possible. Once you have chosen a topic, read our text carefully followed by detailed research. Once this is done, you should set up a structure/a series of subtopics and decide what to write under each section (subtopic).

Here is a suggested structure (you don’t have to follow it, but your own structure must be logical):

Abstract: a condensed summary. If someone reads your abstract only, he/she should understand your main points. You may want to write this section last;

Index terms: list the key words used in your paper;

Introduction: introduce the topic you are going to write about. This section must be related to the topics you learnt during the Session. However, you should branch out by carrying out your own research to enhance this section;

Subtopics and supporting argument: write a series of body paragraphs with sub-points;

Conclusion: Many students get confused between the conclusion and the abstract. In the conclusion, you can reflect on how your topic relates to larger issues; evaluate the concepts you have presented; issue a call for action on the part of your audience; ask questions generated by your findings; make predictions, recommend a solution or give a personal statement about the topic.

With your structure in order, you have a skeleton for your paper: you can now begin by writing out your analyses of the passages you have chosen. As you write and revise, you may have the need to add to your analyses or to re-order your chosen arguments. Using a structure as the skeleton for a paper in this way can carry you more than halfway to a completed draft.

Task C (5 marks):

1. Generate a Turnitin originality report and submit this report via Turnitin;

2. Submit an early draft to Turnitin for self-checking, then look carefully at all the matches marked in bold font and various colours in the self-check/originality report.

3. Answer the following questions to interpret the Turnitin originality report

a) Are any of the bold, coloured text matches in my self-check report missing in-text references? (We need to avoid plagiarism of ideas.)

b) Do any of the bold, coloured text matches in my self-check report include more than three words in a row copied from the original source without quotation marks? (We need to avoid plagiarism of language.)

c) Do direct quotations take up more than 10% of the essay? (We need to change some of the direct quotations to summaries and paraphrases so that at least 90% of every essay is written in our own words.)

d) Are any of the bold, coloured text matches in my originality report purely coincidental? (Sometimes our words coincidentally match with words in other online sources that we have never seen before and that are completely irrelevant to our research topic. If so, we do not need to change anything at all.)

e) Do any of the short strings of matching text indicate that my attempts at paraphrasing were not completely successful? (We need to avoid sham paraphrasing, one type of plagiarism, by using synonyms and changing the sentence structures completely. Remember that we should not copy more than three words in a row from the original without quotation marks.)

f) Have I synthesised all of the sources’ ideas into my essay by introducing each piece of source information with a signal phrase and by adding my own comments or interpretation to it in the following sentence? (We need to avoid dropped-in quotations and simply reporting facts or other people’s ideas because that approach means that instead of building our own arguments and writing our own essays, we are merely stringing together other people’s words and ideas.
Rationale
back to top
This assessment task will assess the following learning outcome/s:
• be able to describe the business value and processes of ICT services in an organisation and apply that knowledge and skill with initiative to a workplace scenario.
• be able to investigate, critically analyse and evaluate the impact of new and current ICT services to an organisation.
• be able to describe how effective IT Infrastructure Management requires strategic planning with alignment from both the IT and business perspectives in an organisation.
• be able to demonstrate the technical and communications skills that contribute to the operation of ICT services in an organisation.
• be able to reflect critically on the role of an enterprise architect in an organisation.
• be able to synthesise the theoretical, technical and management issues that deliver ICT services to an organisation.

 


29) SA0023-SA02092018059 SIT725 Assignment 2

Assignment Description

In assignment 1, you have investigated and analyzed a Web site/sub-site, and addressed
the issues that need to be improved or re-designed (if required). Consider that your analysis
report has been submitted to a board of the company (the owner of the Web site).
After reading your Web site/sub-site analysis report, the board of the company has
decided to improve the existing Web site in order to provide better services to its users.
You have been assigned to accomplish this job. The outcome of this assignment is
therefore continuation of your work from the analysis stage to the design stage on the same
Web site/sub-site and then prepare a design report.
This design report must be prepared using Web engineering principles and
methodologies. You can use Enterprise Architect as the CASE tool to prepare all your
design diagram for content, navigation, function and other models or any other tools.
Your report should contain the following sections which are also the requirements and
marking criteria of this assignment.
1. Completion of proposed product backlog
a. Write the product vision statement
b. Present your product backlog
You have used different modeling artefacts including use case diagram, description, usage
scenario, activity diagram, domain analysis and your selected website as a prototype in your
assignment-1. If required prepare more mockups, prototypes and modeling diagrams. Then
2
complete following tasks.
i. Decompose your epics and features into sufficient user stories and write
those in appropriate format
ii. Write acceptance criteria for each of those
iii. Use planning poker estimate approach to estimate those
iv. Use a priority scheme based on ROI
v. Complete your Product backlog. You need to identify 20 user stories by
using your initial product backlog in Assignment-1. Each feature needs to
be decomposed at least two user stories.
2. Working towards your sprint backlog- Design tasks:
Part-1: Product roadmap.
You are required to prepare a product roadmap which has at least three releases. Consider
each epic can be released in one release.
Each release in the roadmap should have clear goal which depends on following factors.
a. Market map (target customer, business value),
b. Market event,
c. Architecture map,
d. Feature/benefit map.
Part-2: UML Profile for Design Class models
A) UML Profile: You are required to develop an UML profile. In the profile, you need
to create stereotypes for your own web application project. You can create following
types of stereotypes:
a) Content classes
This can be different types of content (e.g. clothing product one type, book
product another type etc.).
b) Navigation classes
This can be different types (e.g. menu, search, index, home, any other
navigation node, navigation link and process link)
c) Process classes
The functions required to complete the users’ goals, these can be 1) user
observable function 2) Function which are required for internal processing
3
of classes — (class collaboration and manipulation of attributes) 3)
integrate application functions (i.e., business processes) which will be
needed into the navigation structure as part of user actions.
B) Design Class Diagrams using your UML profile
a. Prepare a content class diagram using UML profile and data tree that you
prepared in your assignment-1. Include contents related to one of the epics in
your product backlog.
b. Prepare a process class diagram using UML profile which are required for
one of the epics in your product backlog
C) Sequence diagram: Prepare a sequence diagram from a use case description related
to one of the epic used in (2. B) that you prepared in assignment-1, content and
process classes in (2.B)
D) Navigation and functional design:
a. Create navigation views using navigation classes and links (from
stereotyped) and user visible functions from your process classes (in your
process class diagram) and content classes (from your content class diagram)
in order to represent the Navigation semantic units (NSUs). Use your UML
profile in your project as a resource for process class diagram and your
content class diagram.
An example for NSU is given in Book: Roger A Pressman , “Software
Engineering: A Practitioners’ Approach”, Chapter 13: Navigation design—
page 388-389 ]. In addition to your practical class reference material, two
examples of UWE design description have been uploaded in the assignment2 folder.
b. Prepare a functional design view. Follow the steps of creating views as
demonstrated in practical classes and as described in the help documents of
Enterprise Architect in order to describe the functional design of your web
application. In this case, you need to use Web-Modeling language tool of
Enterprise Architect. You need to associate your process classes and
navigation classes from navigation design with the corresponding webmodeling classes.
You are required to use principles, techniques and models of n avigation
and functional design in this section.
Reference: use the textbook, lecture notes, tutorial/practical class and reading
materials on CloudDeakin, or UWE models uploaded in the assignment-2 folder).
Refer to WAE example models provided in the book: Roger S. Pressman and David Lowe
(2009): Web Engineering: A Practitioners Approach. McGraw-Hill, Function design chapter
or teaching materials for more details and examples.]
3. Sprint planning and sprint backlog
First, relate your release goal with the product backlog items, assume your team velocity
4
and estimate number of sprints per release. Demonstrate which PBIs are in which release
in your product backlog.
Sprint planning: Use a two-part sprint planning scheme
1. Sprint goal: Write the goal of each sprint. Consider each release will require two
sprints.
2. Capacity determinations: Determine the capacity of team and describe capacity
estimation in detail
Sprint backlog:
3. Prepare detail task breakdown for all feature-PBIs of one of the epics from your
product backlog, estimate, and refine your sprint goal if required. Considers all
analysis models and design while completing the task breakdown. These are the
actual tasks those will be accomplished in each sprint by the scrum members.
The tasks describe and indicate more detail for the implementation.
You need to breakdown all user stories of one of the epics from the product
backlog. Each user story needs to be decomposed into at least three tasks.
4. Summary
This part gives a brief summary of your report. From this summary, a reader should
know
1. What you have done for this report;
2. Your conclusions; and
3. Whether there are some problems to be solved in future


30) 188297 – managing software development

Assignment Description

Part 1 – Agile processes (14 marks)
Write a report on the SCRUM agile development methodology from the point of view of a
programmer trying to argue the case for management of Southern Cross University to adopt the
SCRUM methodology for internal system development and contracted (procured) system
development. You can assume the organisation has no experience in agile development processes
at all so you will need to provide detailed arguments (this is not true but for the purposes of the
assignment you should assume it is true).
Your report should be structured as follows:
1. An overview of Agile processes (3 marks).
2. An explanation of the SCRUM framework(3 marks).
3. Arguments for and against the adoption of SCRUM. You will need to reference authoritative
sources to convince your management (3 marks).
4. Clearly identify what sorts of projects would benefit and what sorts of projects will not
benefit (1 marks). This can be part of your point 3 arguments.
5. An explanation of two aspects of Agile methodologies (XP, SCRUM or other processes) that
could be adopted across the organisation, even if some systems were not appropriate for
SCRUM. Explain why this is a good idea. (Note that Part 2 of this assignment is an example
of one of these and you can include it here if you wish) (3 marks).
The report should not be more than 1500 words. You will not be penalised for going over the limit
but it may indicate you have too much detail or your writing is not precise. Feel free to use the above
items as major headings in your report/essay, a bit more concise of course. You should add a brief
Executive Summary and a brief Conclusion (1 mark).
Part 2 – Automatic document generation (6 marks)
Attached is a C# program where you should replace the current comments with the C# XML
comments. Your XML comments should contain at least examples of each of the following tags:
– <summary> and <remarks> (2 marks)
– <param> and <returns> (2 marks)
– <code> (1 mark)
– <see> (1 mark)
Note that your code does not have to compile but you could implement it in Visual Studio to iron out
problems. In other words, if you wish to avoid using Visual studio you can but you will need to be
careful to code syntax correct enough for the marker. Minor syntax errors will not be penalised. Please
note that you need to explain each of your C# XML comments. Comments without a good explanation
will not be marked/result in loss of marks.
namespace Ass2
{
//
// This program is for CMP73010 Assignment 2 (2017)
//
// It calls some functions that need commenting
//
class Program
{
//
// Mainline function
//
static void Main(string[] args)
{
int num1 = ReadNumber();
int num2 = ReadNumber();
FormatBinary(num1, “+”, num2, Add(num1,
num2)); Console.ReadLine();
}
//
// Read a single integer
//
public static int ReadNumber()
{
Console.Write(“Number:
“); try
{
return Convert.ToInt32(Console.ReadLine());
}
catch (FormatException)
{
Console.WriteLine(“illegal number
format”); return 0;
}
}
//
// Formatted operation output
//
public static void FormatBinary(int n1, string op, int n2, int result)
{
Console.WriteLine(“{0} {1} {2} = {3}”, n1, op, n2, result);
}
//
// Add two integers
//
public static int Add(int n1, int n2)
{
return n1 + n2;
}
}
}


31) EM0083-EM18191ASH2909OTH

Assignment Description

This assignment will test your skills in designing and programming applications to specification and is worth 20% of your non-invigilated (type A) marks for this course. This is an INDIVIDUAL ASSIGNMENT – and while you may discuss it with your fellow students, you must not share designs or code or you will be in breach of the university plagiarism rules. This assignment should take you approximately 20 hours to complete.
Assignment Overview
You are tasked with creating an application that uses a GUI that simulates a simple banking interface similar to an ATM / online banking using the Python 3 programming language.
The assignment is broken up into five main components:
1.) The ability to provide an account id and a PIN (Personal Identification Number) to sign into a bank account,
2.) The ability to view the balance of the bank account and to deposit and withdraw virtual money into and out from the account,
3.) The ability to save transactions via file storage so that you can log in, deposit some money and then log out – and when you log back in that money is still there, and finally
4.) The ability to display a graph of projected earnings on the bank account via the compound interest accrued over a variable amount of time.
5.) A Test Case that ensures your BankAccount’s deposit
and withdraw functionality operates correctly.
Your submission should consist of three Python scripts that implement this application as described in the following pages: bankaccount.py, main.py along with a testbankaccount.py which contains a small test case with a few simple unit tests than ensure that your bank accounts deposit and withdraw methods operate correctly.
You are provided with a ‘stub’ of each of these files which contain all the function declarations and comments which describe the role of the function and how it can be put together, but you will have to write the code for vast majority of the functions yourself. You are also provided with a stub of the bankaccounttestcase.py file.
Your final submission should be a zipped archive (i.e. ‘zip file’) containing your completed Python scripts.
There is no word processed component to this second assignment.
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 2 of 10
Bank Account Class Design
The design for a BankAccount object is laid out in the following class diagram:
As you might imagine, the deposit(amount) function adds that money to the current balance of the account, and the withdraw(amount) function removes (i.e. subtracts) money from the current balance of the account. Each transaction in the transaction_list is a tuple containing either the word Deposit or the word Withdrawal followed by an amount, for example: (“Deposit”, 300.0) or (“Withdrawal”, 100.0).
The bank accounts in our program do not have an overdraft facility so the user cannot withdraw money they do not have – that is, if they had $200 in their account and they tried to withdraw more than $200 then the operation should fail and the withdraw function should raise an Exception with a suitable error message which is caught and displayed in the main.py file where the operation was attempted.
All error messages such as those from exceptions should be displayed in a pop-up messagebox.
The get_transaction_string method should loop over all the transactions in the transaction_list creating a string version (with newline characters) of all the transactions associated with the account.
The export_to_file function should save the account_id, pin_number, balance, and interest_rate in that order to a file called <account_id>.txt followed by the transaction list string generated from the get_transaction_string() method. The name of the account file is NOT ‘<account_id>.txt’ – the name of the file is the ACTUAL ACCOUNT ID followed by “.txt”, so for an account with account_id 123456 the name of the account file would be 123456.txt.
A full ‘walk-through’ video demonstrating the completed application and how it operates will be provided along with this assignment document.
BankAccount
account_ id : int
pin_ number: string
balance: float
interest_rate: float
transaction_list: list of two -tuples
deposi t(amount)
withdraw (amount)
get_transaction_string() export _to_file ()
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 3 of 10
Calculating Interest
To make it worthwhile for you to keep your money with a bank, the bank offers you an interest rate on your savings. Interest will be applied to the balance of an account once per month.
Let’s do an example – suppose you had $10,000 in a bank account and the bank paid you monthly interest at a rate of 3% per year. That would mean the bank pays you 3% of your balance divided by 12 (because there are 12 months in a year) per month. If we start our example on January and run it for a few months (and we don’t deposit or withdraw any money throughout the year) then we end up with our bank balance changing like this: Note: 3% divided by 12 is 0.25% per month – so we’ll multiply our balance by 1.0025 to get the new balance. Jan Feb Mar Apr May Jun Jul Aug Etc. 10,000.00 10,025.00 10,050.06 10,075.19 10,100.38 10,125.63 10,150.94 10,176.32 …
What’s happening here is that the interest is compounding – which just means that we get that 0.25% applied not only to our principle balance (i.e. the $10,000 we started with), but it also gets applied to the interest we earnt. Although 3% interest is very low (but in line with the best rates you’d get in Australia at the moment because interest rates are very low), over time this compounding makes a serious difference!
Because FedUni Bank is the greatest bank of all time, it offers all accounts an interest rate of 33%.
The Main Python Script
Our main.py script will contain all the main logic for our program. It will allow us to:
– Enter an account id via an Entry field by using the keyboard,
– Enter a PIN number via an Entry widget (we can use the keyboard OR a series of buttons to enter the PIN),
– Once we are logged in we must be able to:
o See the balance of our account,
o Deposit funds into our account,
o Withdraw funds from our account (only up to the amount we have available),
o Display a plot of our projected interest over the next 12 months as outlined above, and finally
o Log out of our account.
Every time a successful deposit or withdrawal is made then a new transaction should be added to the account’s transaction list. When we log out then the account file is overwritten with the new account details including our new balance and any transactions if any have been made.
The format of the account text file is as follows (each value on separate lines):
account_id
account_pin
balance
interest_rate
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 4 of 10
For example, account id 123456 with PIN 7890 and a balance of $800 with an interest rate of 33% would look like this:
123456
7890
800.00
0.33
After these first four lines we may have a number of transactions, each of which is specified as two lines. A deposit is indicated by the word Deposit on one line and then the amount on the next like. For example a deposit of $500 would look like this:
Deposit
500.00
Similarly, a withdrawal is also specified as two lines – first the word Withdrawal and then on the next line the amount, for example a withdrawal of $200 would look like this:
Withdrawal
200.00
You are provided with an example bank account file called 12345678.txt – this file along with others will be used to mark your assessment, so you should make sure that your final submission can use bank accounts in this format successfully.
You are also provided with a video demonstration of the completed assignment along with this document. Your application should match this user interface and function in the same way.
Login Screen
When the application is first launched, it should open a window that is “440×640” pixels in size (use the window object’s geometry function to set this). Set the title of the window to “FedUni Banking” using the top-level window object’s winfo_toplevel().title() function.
The window uses the GridManager layout manager for placing GUI elements (e.g. ‘widgets’), it contains a Label that spans the top of the window saying “FedUni Banking” (font size is 32). On the next line is a label saying “Account id” and then an Entry widget for the user to type in their account id and an Entry for the PIN number.
It then has a series of buttons from 0 through 9, along with a Log In button and a Clear/Cancel button.
Each time a number is pressed it is added to a string – for example, if the user pushed the 4 button then the 3 button then the 2 button and then the 1 button then the string should contain the text “4321”. By using the show=”*” attribute you can ‘mask’ the input so that anyone looking over your shoulder cannot see the exact pin number, they’ll just see “****” instead. When the Clear/Cancel button is pressed, or when a user “logs out” then this PIN string should be reset to an empty string.
When the Log In button is pressed then the program should attempt to open the file with the account id followed by “.txt” – so in the example below, because the account id entered was “123456”, the program will attempt to open the file “123456.txt”.
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 5 of 10
If that file could not be opened then a messagebox should display a suitable error message such as “Invalid account id – please try again!”. You will have to “try/catch” this risky functionality to avoid the program crashing – see the week 7 lecture materials if you need a recap.
If the account exists, then a BankAccount object should be created and the fields of the BankAccount object should be set (e.g. account_id, pin_number, balance, interest_rate, and the transaction_list).
Because you don’t know how many transactions are stored for this bank account, after reading the first four lines you will need to attempt to read two lines and if they exist create a tuple of the transaction (i.e. it’s type and amount) and then add it to the BankAccount object’s transaction_list – for example you may do the following in a loop:
# Try to read a line, break if we’ve hit the end of the file
line = read_line_from_account_file()
if not line:
break
else:
# read another line, create a tuple from both lines and append the # tuple to the the BankAccount object’s transaction_list
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 6 of 10
Account Screen
The account screen has:
– A large “FedUni Banking” label at the top that spans 5 columns (font size is 24),
– A label with the account id followed by the actual account id displayed,
– A label with the current balance followed by the actual balance,
– A log out button which saves the bank account file (overwriting it) and causes all widgets to be removed from the screen and the log in screen displayed again,
– An “Amount” label followed by an amount Entry widget where you can type in how much to deposit or withdraw,
– Deposit and Withdraw buttons that deposit or withdraw funds using the BankAccount classes methods to do so,
– A Text widget (i.e. multi-line text) that shows all the transactions associated with the account. The height of this widget is 10 lines and the width of the widget is 48 characters.
– To the right of the Text widget this is a scrollbar which can be used to scroll the Text widget (it is not really showing in the above screenshot because the Text widget does not have more than 10 lines worth of content), and finally
– A small graph of the projected cumulative interest over the next 12 months.
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 7 of 10
Bank Account Test Case
The final thing to do is to add a small test case consisting of five unit tests that ensure that the BankAccount class’ deposit and withdraw methods operate correctly.
You are provided with a stub of a testbankaccount.py test case that already has the definitions of the five unit tests that you will write and a description of what they are testing. Your job is to write suitable assert statements into each of these unit tests so that they ensure the BankAccount classs’ deposit and withdraw functions do operate as they should. You should be able to accomplish each unit test in a maximum of two lines of code per unit test.
Two things to remember:
1.) The setUp method is automatically executed before each unit test, so the balance gets reset to 1000.0 before each test, and
2.) If your unit test fails (and the test is correct) then you should modify your code so that it passes the test, not the test so that it matches up with what your code is doing!
Development and Marking Tips
You will need to bind all the numerical log in buttons to the <Button-1> event and the same function, and then extract which button was pressed to help ‘build up’ the PIN number text. To extract which widget triggered the function use event.widget[“text”].
You are provided with the complete function to remove all widgets from the top level window, the function to read a line from the account file which does NOT include the final “\n” newline character and most of the code to generate a graph and place it in your window – so you do not have to write these yourself.
The grid for the login screen has 3 columns and 6 rows, while the grid for the account screen has 5 columns and 5 rows. The fifth column on the account screen is the one holding the scrollbar.
Once you have your login screen working, it makes sense to set the account id variable and PIN number variables to ‘123456’ and ‘7890’ respectively so that they are already filled in when you launch the app and you can immediately click the “Log In” button to move to the account screen. Without this you will have to enter these values each time you run the program, which will be a nuisance.
When you are writing your code to save the bank account object to file be aware that if the function fails before closing the file then the file will now be blank (i.e. it will not contain any bank account details). As such, it’s probably best to keep a copy of the file close by so you can replace it if necessary.
The way this assignment is marked is a little different from assignment 1 where you could get marks for effort – that is, if something didn’t quite work as it should you would still get marks. This was because you were designing the code and its logical flow. In this assignment you are given a precise specification of how the application should work, and the marking guide is more along the lines of “did you implement this feature as specified?, did you implement that feature as specified?”.
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 8 of 10
The answer to these questions is largely a simple yes or no – if you did, you get the mark – and if you didn’t then you don’t get the mark. If your code doesn’t run at all (i.e. it produces an error on startup) then it means your code cannot possibly implement the functionality, and your marks will be severely affected. Nobody wants this – so even if you do not implement the entire suite of functionality, please make sure that your code at least runs!
As a final reminder, please do not add functionality that is not described in this document. Rather than being rewarded with extra marks you will be penalised for not matching the project specification – so please stay on spec!
Submission and Marking Process
You must supply your program source code files as a single compressed archive called:
ITECH1400_Assignment_2_<YOUR-NAME>_<YOUR-STUDENT-ID>.zip
Obviously replace <YOUR-NAME> and <YOUR-STUDENT-ID) with your own personal details!
Assignments will be marked on the basis of fulfilment of the requirements and the quality of the work. In addition to the marking criteria, marks may be deducted for failure to comply with the assignment requirements, including (but not limited to):
• Incomplete implementation,
• Incomplete submissions (e.g. missing files), and
• Poor spelling and grammar.
Submit your assignment to the Assignment 2 Upload location on Moodle before the deadline of Friday of week 11 at 5pm.
The mark distribution for this assignment is explained on the next page – please look at it carefully and compare your submission to the marking guide.
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 9 of 10
Assignment 2 – FedUni Banking
Student name: Student ID:
Item
Assessment Criteria
Weight
Mark
1
Window is correct size of 440×640 with title of “FedUni Banking”
1
2
“FedUni Banking” label is displayed in large font across top of login screen
1
3
Account id / PIN label exists near top left of login screen
1
4
Clicking PIN entry buttons result in adding that number to pin entry
1
5
All PIN number input is masked to be asterisks (i.e. **** not 7890)
1
6
Incorrect account id results in suitable error message box
1
7
Incorrect pin results in suitable error message box
1
8
Cancel / Clear button clears PIN entry only
1
9
Login button with valid account id and PIN logs in to account screen
1
10
“FedUni Banking” label is displayed across top of account screen
1
11
Account id is displayed on account number label
1
12
Account balance is displayed on account balance label
1
13
Log out button exists and returns user to login screen
1
14
Log out button saves account details to account file with any changes made
1
15
Amount label exists
1
16
Amount entry exists
1
17
Deposit button exists
1
18
Withdraw button exists
1
19
Clicking Deposit with legal value in amount entry adds to balance and add a suitable account transaction
2
20
Clicking Deposit with illegal value results in suitable error message box
1
21
Clicking Withdraw with legal value in amount entry subtracts from balance and adds a suitable account transaction
2
22
Clicking Withdraw with illegal value results in suitable error message box
1
23
Clicking Withdraw with insufficient funds results in suitable error message box
1
ITECH1400 – Foundations of Programming
School of Science, Engineering and Information Technology
CRICOS Provider No. 00103D Page 10 of 10
24
Multiline Text widget showing account transactions exists
1
25
Any new valid transaction made is displayed in the multiline Text widget
1
26
Multiline Text widget has a scrollbar which can scroll the text
1
27
Graph of interest exists and is correct for current balance showing next 12 months cumulative interest at bank account rate of 33% per annum
2
28
Graph of interest is updated when balance changes
1
29
BankAccount unit tests correctly test deposit / withdraw functionality
5


32) 750939- c sharp

Assignment Description

Task-1. Design and implement a custom environment for your maze game. This requires producing your own
unique hand-drawn map of the maze game environment and changing the HardCodedData file to reflect the
locations and items on your map. At least M (M>4) locations, including Exactly N (N>2) shops with a
condition M>N, must be included, as well as enough items to allow for proper testing of the game functionality.
For example, there must be sufficient items to verify that a player cannot collect an item if the weight restriction
has been met. Note: you should not retain the original locations or items from the provided code base in your
version of the game.
Task-2. Write down the functionalities as detailed in Lab 7 and Lab 8 according to Behavioral Driven
Development (BDD). For more details about BDD, see Appendix-1.
Task-3. Implement each of the following deliverables / milestones:
a. functionalities or scenarios developed in Task-2
b. commands to manage the various item management commands:
i. listItems, getItem and dropItem, to allow listing of all held items, collect a new item and drop
a held item.
ii. equipItem and unequipItem, to wear / wield a held item, and to stop wearing or wielding an
equipped item.
iii. purchaseItem and sellItem, to buy an item from a vendor and to sell an item to a vendor.
Ensure that weight restrictions are not exceeded and that the context for each command is
appropriate. For example, purchasing and selling of items should only occur in a shop.
c. basic combat functions, allowing a player to attack or to be attacked by a non-player character (NPC).
A player may flee combat or continue to attack until such time as one combatant loses all life points.
The end result must not be hard-coded, and neither the hostile NPCs nor player may have their attributes
configured in such a way that the final outcome is pre-determined. Note that combat functions should
only be available when the player is in the presence of a hostile NPC, and combat may take whatever
form is appropriate for your game context rather than being limited to just hits with a weapon.
Task-4. Produce a nice power-point/latex presentation (maximum 20 slides) describing the steps to play and how
it is implemented. Discuss about the role of design patterns in the game, clearly identifying the functionality
where design patterns have had an impact and how this has occurred. Reflect on the use of a development
methodology in creating the game. Clearly mention about an additional feature that could be incorporated in the
software. Show the BDD statements in a few slides that you have developed for Task-2.
Task-5. Prepare a Jira account (one account for a team), and create Tickets (story) that you are planning to do. A
jira ticket/story is a small job that is assigned to any of you and there is an estimation of how long it will take
time to finish the job. You can divide the jira board into 5 vertical sections: Ready to Development, In
Development, Ready to Test, In Test and Done. Once a ticket is ready to move from one column to another,
move it accordingly. Provide the user name and password in the report so that the Lecturer can verify
your development activity directly from your Jira account. Prepare a nice summary of your Jira activity
which will include the screenshot of your Jira board and the burndown chart.
CRICOS Provider No: 00103D 3/4

Individually:
Task-6: Prepare an individual report, to be submitted as a Word document or a PDF, which includes:
a. The student number and name of each person on your team (including yourself)
b. Sequence diagrams for two (2) of the item management commands, taken from separate groupings.
c. Statement of your own personal contribution to the assignment
d. A statement of your partner’s contribution to the assignment. Do not work with your partner or any
other person to complete your individual report. These must be unique and your own work. Please note
that assignments will NOT be marked and zero marks will be allocated if the individual statements of
personal and partner contributions are not submitted.
e. Maintain your timing using punchtime and submit the report in pdf format. Visit
http://punchtimeapp.com/ for more details about punchtime.