File transfer protocols

Authors Avatar

File transfer protocols

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.

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 *)


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.

Join now!

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


Architectural Design

2. Description

3.


Narrative Description

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.

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 ...

This is a preview of the whole essay