File Transfer Protocols Essay Sample

essay
  • Pages: 16
  • Word count: 4,195
  • Rewriting Possibility: 99% (excellent)
  • Category: computer

Get Full Essay

Get access to this section to get all help you need with your essay and educational issues.

Try it free!

File transfer is the process of transmitting complete files from one computer to another. To achieve a successful transfer, both sending and receiving devices must establish the protocol (set of rules) by which they will communicate. Various protocols are commonly recognised but they vary in their performance and suitability for particular tasks. Some examples are described below.

FTP

File Transfer Protocol (FTP) allows large amounts of information to be transferred between computers very conveniently. FTP originated with the UNIX operating system and was to transfer files of all types between remote computer systems. A popular application of is for the uploading and downloading of Web site pages.

ASCII

This is only appropriate for text files, which contain no control characters. Thus it cannot be used to transfer files produced with a word processor, spreadsheet or graphics package. Neither can it transfer command (COM) or executable (EXE) files, or files in compressed (ZIP, for ex) form. Apart from this, the protocol is not good at controlling errors.

Xmodem

A file-transfer protocol used for asynchronous communications. It is commonly used in communications packages. The Xmodem protocol transfers data in blocks of 128 bytes, giving each transmitted frame a sequential block number; this number is used to identify the location of errors. A checksum (see Block Check Characters) is attached to each block to check transmission errors. Its ability to find and correct errors makes it suitable for the transfer of files, which must retain their integrity, such as program files.

Zmodem

Is one of the most advanced protocols, being much faster than Xmodem. Its error correction controls are absolutely reliable.

CCITT V42bis

This protocol includes a data compression (through encoding, data is reduced in volume) technique and error detection and correction. Both the sending and receiving modem must possess the error correction facility.

Implementation

Top Down implementation is one way to achieve implementation of software. This involves coding, testing and debugging each module in turn starting with the top level and working down. This means that each new module fits naturally into the module hierarchy.

Starting with the control module i.e. Songs; we code, test, debug and retest it etc. This involves calling Set_Up, Process_Votes and Menu, even though these have not yet been coded. Therefore, we create test stubs to ensure that we can test that the Songs module achieves its function. A Test Stub can simply consist of a statement which will display a message showing that the module has been called correctly, or it may consist of a set of statements which simulate the operation of the module in order to return results to the calling

module which is under test.

At this stage, the program would look like this

Program Songs(Input, Output);

Type

String20 = Packed Array[1. .20] Of char;

String25 = Packed Array[1. .25] Of char;

PosInt = 0. .MaxInt;

Songs_Record = Record

Song_Title_string20;

Artist : String25;

No_of_Votes : Poslnt

End;

Songs_Table_Type = Array(‘A’..’B’] Of Songs_Record;

(* 1 Set_Up *)

Procedure set_Up(Var Songs_Table :_Songs_Table_Type);

Begin (* Set_Up *)

writeln(‘Set_Up’)

End; (* Set_Up *)

(* 2 Process_Votes *)

Procedure Process_Votes(Var_Songs_Table : Songs_Table_Type; Var Total_Votes : PosInt);

Begin (* Process_Votes *)

Writeln( ‘Process_Votes’)

End; (* Process_Votes *)

(* 3 Menu *)

Procedure Menu(songs_Table : Songs_Table_Type; Total_Votes : PosInt);

Begin (* Menu *)

Writeln( ‘Menu’)

End; (* Menu *)

(* 0 – Songs *)

(* calls Set_Up to load song details into the table, Process_Votes to input votes and collate them,

and Menu to offer options *)

Var

Songs_Table : Songs_Table_Type; Total_Votes : PosInt;

Begin (* Songs *)

Set_Up(Songs_Table);

Process_Votes(Songs_Table, Total_Votes);

Menu(Songs_Table, Total_Votes);

End. (* Songs *)

When this module has been tested to our satisfaction, we can then move on and code the next module in turn i.e. Set_Up.

Program Songs(Input, Output);

Type

Strings20 = Packed Array(1..20] of Char;

String20 = Packed Array(1. .25] Of Char;

PosInt = 0…. MaxInt;

Songs_Record = Record

Song_Title : String20;

Artist : String25;

No_Of_Votes :PosInt

End;

Songs_Table_Type = Array[‘A’.. ‘Z’] of Songs_Record;

(* 1.1 Initialise *)

Procedure Initialise(Var Songs_Table a Songs_Table_Type);

Begin (* Initialise *)

Writeln( ‘Initialise’)

End; (* Initialise *)

(* 1.2 Load *)

Procedure Load(Var Songs_Table: Songs_Table_Type);

Begin (* Load *)

Writeln( ‘Load’)

End; (* Load *)

* 1 Set_Up *)

(* calls Initialise to blank all entries in table, and Load to input song details from file *)

Procedure Set_Up(Var Songs_Table : Songs_Table_Type);

Begin (* Set_Up *)

Initialise(Songs_Table);

Load(Songs_Table);

End; (* Set_Up *)

(* 2 Process_Votes *)

Procedure Process_Votes(Var Songs_Table : Songs_Table_Type; Var Total_Votes : PosInt);

Begin (* Process_Votes *)

Writeln ( ‘Process_Votes’)

End; (* Process_Votes *)

(* 3 Menu *)

Procedure Menu(Songs_Table : Songs_Table_Type; Total_Votes : PosInt);

Begin (* Menu *)

Writeln( ‘Menu’)

End; (* Menu *)

(* 0 – Songs *)

(* Calls Set_Up to load song details into the table, Process_Votes to input votes and collate them,

and Menu to offer options *)

Var

Songs_Table : Songs_Table_Type; Total_Votes : Posint;

Begin (* Songs *)

Set_Up (Songs_Table);

Process_Votes(Songs_Table, Total_Votes);

Menu(Songs_Table, Total Votes);

End. (* Songs *)

A Test Plan should be constructed which indicates an incremental development where each module is to be tested in turn, with appropriate test stubs. For each test, expected results should be noted.

A Test Log indicates the results of each test run, whether the test is successful or not. If a test is successful and an error has been discovered then the code should be redesigned, amending pseudocode, recoded and retested.

The advantage of this method is that errors are likely to be localised to the module which is currently under test.

Architectural Design

1. Structure Chart

Reference

Chart

0

Songs

1

Set_Up

1.1

Initialise

1.2

Load

2

Process_ Votes

3

Menu

3.1

Display

3.2

Report

2. Description

Interface Description

No.

Calling Module

Called Module

Parameters

0

Songs

Set_Up

Songs_Table In/Out

2

Set_Up

Initialise

Songs_Table In/Out

3

Set_Up

Load

Songs_Table In/Out

4

Songs

Process_Votes

Songs_Table In/Out

Total Votes In/Out

5

Songs

Menu

Songs_Table In

Total_Votes In

6

Menu

Display

Songs_Table In

Report

Songs_Table In

Total_Votes In

3.

Narrative Description

No

Module

Description

0

Songs

Calls Set_up to set up the table,

Process_Votes to read votes from the keyboard and

Menu to offer options.

1

Set_Up

Calls, in turn, Initialise and Load.

2

Process_Votes

Reads in votes from the keyboard and increment the appropriate total.

3 Menu

justify;">Displays menu, accept choice, and call appropriate modules Display or Report

1.1

Initialise

Initialises all entries of the table.

1.2

Load

Reads in the song details from the file and store in a table.

3.1

Display

Displays the number of votes for an input song.

3.2

Report

Displays the percentage votes for each song.

Subprogram.

Stepwise Refinement is a process which takes an initial solution to a problem and refines each step until the algorithm is detailed enough for implementation in a suitable high level language.

Level 0

Level 1

Level 2

Since programs can become very large and consequently can involve a number of programmers in the development process, it is useful to have a way of splitting up a program into components each of which can be handled separately. This uses a facility called a subprogram.

The process of developing a solution as a collection of interconnected subprograms is called

Modular Design. Each module has a single complete function and is implemented using the particular subprogram facilities of suitable high level languages.

Pseudocode

Each programmer can be allocated a separate module / group of modules to work on in isolation.

Each module may ‘call’ lower level modules.

A module may be ‘called’ from more than one other nodule.

A subprogram is a way of grouping together statements which havea common purpose i.e. all statements help to produce a singleobjective. They allow a natural way of dividing an algorithm intoparts where each individual part can be handled separately andcarries out a single task for the problem.

This is a natural extension of the philosophy of stepwise refinement where subprograms may be executed in sequence, be part of a selection or be iterated.

A subprogram can be thought of as a small program which can carry out any of the functions of a program. A subprogram is “called” when it is needed, executed and then the processor returns control to the place where the subprogram was called from.

Although subprograms can be developed in isolation, by separate programmers, they have to communicate with other subprograms in the system, particularly, with regard to the data which is shared between a subprogram and its caller.

Subprograms communicate with the calling program through a well-defined interface which specifies the data being shared between the calling program and the subprogram. The interface allows the processor to suspend the calling program, transfer control to the subprogram and ‘pass’ any data specified down to the subprogram. Once the subprogram finishes executing, then the interface communicates any required data changes back to the calling program and returns control to the main program at the line immediately after the subprogram call.

A subprogram may be called any number of times within a program.

The subprogram heading specifies the subprogram name, the type of each piece of data which is expected and the nature of each piece of data, i.e. whether it is simply to be passed down in order to aid the function of the subprogram or whether it. is a value which is being changed or calculated as part of the function of the subprogram.

A piece of data which is being passed to/from a subprogram is called a parameter. A parameter has an associated data type e.g. integer.

A parameter can be specified as either value (reference) or variable depending on whether the subprogram is allowed to change the parameter value permanently. This allows the program to protect certain parameter values against accidental change.

e.g. Subprogram Add_Nos(Numl, Num2 : Integer; Var Result : Integer)

Here Num1 & Num2 are value parameters therefore the subprogram will expect to receive input values for each of these parameters every time the subprogram is called. These values can be supplied either as variable values or constants.

e.g. Call Add_Nos Using Numi, Num2, Result

Call Add_Nos Using 5, 6, Result

Result is a variable parameter and therefore the subprogram will change/calculate a value which is to be returned to the calling program. Thus the subprogram will expect to receive the name of a variable of the required type where it is to store the returning value.

The subprogram call must contain a data value (of a suitable type) for each corresponding parameter in the subprogram heading.

When a subprogram is called the data values in the subprogram call (actual parameters) are passed down to the corresponding data values in the subprogram heading (formal parameters).

Since a subprogram can be used more than once within a system then it is necessary to allow different names to be used for formal and actual parameters.

e.g.Call Add Nos Using Nol, No2, Result

Exercise

Design an algorithm which will input 2 integer values, display a menu, read a choice and call an appropriate subprogram to add, subtract, divide, multiply these numbers returning the result of the calculation.

The Systems Development Cycle

System Testing and Implementation

Implementation is the stage where the system design is converted to a working system. This is arguably the most important stage of systems development, since a well designed system which is poorly implemented may. fail, whereas a badly designed system which is well implemented may survive.

The key to success is in planning for the implementation early in the design process, the main issues to be considered being :-

? site preparation

? hardware/software procurement

? system testing

? user education and training

? changeover

Outcome 6 of the Systems Development 2 Unit includes system testing, user education and training and changeover, and these topics are outlined in the following sections.

System Testing

System testing ensures that the system works accurately and efficiently before it is put into live operation.

All clerical and computer procedures are tested. Programs are tested individually and then in groups to verify program linkages. Hardware and communications links are also tested. The final stages of testing are the system trials involving user staff, this also being part of user training.

Test data for program testing should follow the guidelines of the Software Engineering Unit. System trials should be carried out in an operational environment, using test data from earlier time periods, or even parallel runs with the old system using live data.

The types of tests which should be considered for a system are as follows

Inputs- form design (ease of use)

– data transmission

– input validation and correction

Files- empty files

– addition/deletion/update

– access

– controls/security

Outputs- output documents/screens

– recipient understanding

ComputerProcedures- program linkages

– operating procedures

– recovery and security

– timings

Clerical Procedures- effects on other systems

– user understanding

– error correction

– timings

User Education and Training

The success of a new system is very much dependent on the attitudes of the people who use it.

Education aims to convince users of the benefits of the system to themselves, their department and the company. Management policy regarding re-deployment ,redundancy etc should be clearly stated.

while casualties may result from the introduction of new systems, there are also many positive aspects such as

? reducing very boring clerical activities

? upgrading of skills

? improving job satisfaction

d? Education, therefore, complements and is a pre-requisite to training.

e? Training enables users to understand their role in the new system, and prepares them for their own specific tasks. The users and people affected by the new system must be trained, and arrangements for release from normal duties must be made. Many different methods of training are available including

f? formal lectures

? discussions/seminars

? computer-assisted training (tutorial packages,help facilities etc)

? user manuals/quick reference guides

Usually a combination of methods will be chosen with an emphasis on ‘hands on’ experience.

Timing and pacing of training is also important, too early and users may forget aspects or become disinterested, too late and users will become flustered.

Training does not cease with implementation, but must meet needs of new staff and system changes.

changeover

Implementation may involve change from a manual system to a computer system or from one computer system to an other. In both cases the system data and procedures require to be changed.

A major task prior to changeover is file conversion. The data in existing clerical or computer files must be converted to the new system files, and this can be a massive task involving the preparation of thousands of records using data from a number of different sources. It is also essential that the new system data is accurate or system credibility will suffer.

Changeover is the period from the start of live running to the time the DP department withdraws system support, other than for maintenance.

? Methods of changeover depend on the particular circumstances of a system development project, and fall into the following categoriesdirect changeover

? parallel running

? pilot running

Direct changeover is the complete replacement of the old system by the new in one move. This may be appropriate when system testing has been exhaustive and users have complete confidence in the new system. Also if the system is totally new and there is no comparable ‘old system’, or if there is no staff available to operate a parallel run.

Parallel running is the method of processing current data using the old and new systems at the same time, then cross-checking results. It may be seen as an extension of testing, and generates confidence among users, however it places a strain on resources.

Pilot running may be used in two ways, either in retrospective running of data from previous time periods, after results have been obtained from the old system, or as a staged changeover where a complete logical section of records is chosen and committed to the new system without parallel operation in the old system. when this section is operating satisfactorily the remaining records are transferred.

The end of the changeover is signified by user acceptance of the new system. System performance must meet acceptance criteria previously established. Acceptance criteria would relate to factors such as response times, degree of reliability and tolerable error rate.

Test Narrative

An incremental development approach will be taken. This will involve each module being designed, coded and tested in turn before moving onto the next. This Top Down approach will allow newly written modules to fit naturally into the module hierarchy. Test stubs will be used to simulate the calling of modules which have not yet been coded.

Sorry, but A and B essays are only available for premium users

Choose a Membership Plan

We can write a custom essay on

File Transfer Protocols Essay Sample ...

According to Your Specific Requirements.

Order an essay

logo

Emma Taylor

online

Hi there!
Would you like to get such a paper?
How about getting a customized one?