Chapter 5 System Software Review Material

Program library

pre-written code/functions/routines that can be imported/called in another program

Purpose of the Operating System

● To hide the complexities of the hardware from the user

● To provide a platform for software to run

● To provide a user interface

File management tasks carried out by an OS

● Secondary storage space is divided into file allocation units

● Space on secondary storage is allocated to particular files

● Maintains/creates directory structures

● Specifies the logical method of file storage e.g. FAT or NTFS

● Provides file naming conventions

● Controls user access // implements access rights // implements password protection // Makes file sharing possible

● Controls access to the file by other software

● Specifies tasks that can be performed on a file e.g. open, close, delete, copy, create, move, etc

● Allows searching for a file

Process management tasks performed by an OS

● Manages the scheduling of processes // Decides which process is to be run next

● Allows multi-tasking/multi-processing

○ ... by ensuring fair access, handling priorities and handling interrupts

● Manages / allocates which resources the processes require

● Facilitates the sharing and exchange of data between processes

● Prevents interference between processes // conflict resolution

Hardware management tasks performed by an OS

● Installs device drivers

○ ... to allow communication between peripherals and computer

● Sends data and receives data to and from peripherals

○ ... such as to an output device and from an input device

● Handles buffers for transfer of data

○ ... to ensure smooth transfer between devices that transmit and receive at different speeds

● Manages interrupts / signals from the device

Memory management tasks performed by an OS

● Controls the movement of data between RAM, processor, VM etc

● Allocates memory to processes

Security management tasks performed by an OS

● Creates accounts/passwords

● Provide / upgrade firewall / anti-malware

How memory management and process management support multi-tasking

● Memory management:

○ Stores data from all currently running programs concurrently in RAM

○ Stops the data from overwriting each other in RAM/primary storage

○ Decides which processes should be in main memory

○ Makes efficient use of memory

● Process management:

○ Allows one process to be paused whilst another process can be actioned

○ Decides which process is to be run next

○ Switches between processes to allow them to share the use of the processor

○ Identification/description of scheduling

Purpose of utility software

● To help users to set-up / configure / analyse / optimise / maintain the computer

● ... by for example, making memory allocation more efficient

● ... by for example, checking the system for faults

The need for defragmentation software

● Over time saving and deleting of small files fragments the disk

● ... the software makes (individual) files contiguous

● ... so access time to the files is improved

● ... because head movement is reduced

The need for disk contents analysis/disk repair software

● To identify and mark bad sectors

● To restore corrupted files

● To recover lost data (due to hardware failure)

The need for file compression

● To reduce the size of files

● ... which saves storage and memory space

● ... and reduces transmission time

The need for disk formatter

● To prepare a disk for use // set up the file system

● To partition the disc

● To delete all the data from the disc

The need for back-up software

● To allow data to be retrieved / restored when lost

● To make regular duplicate copies of data

● To automatically make a duplicate copy of data...

● ... so the user does not have to remember to backup data

The need for virus checker

● Makes more RAM available for programs to run

● ... because it removes software that might be taking up memory / replicating

How a program library can be used while writing a computer program

● Program libraries store pre-written functions and routines

● The program library can be referenced/imported

● The functions/routines can be called in the program

Benefits to the programmer of using program libraries

● Saves programming/testing time as code does not have to be written/rewritten from scratch // code does not have to be tested

● Code is already tested so it is more robust/likely to work

● The programmer does not need to maintain the library // library routines are updated automatically

● Can perform complex calculations that the programmer may be unable to do

● Makes code more easily readable

Benefits to the programmers of creating a program library

● Subroutines can be shared / reused

● ... between team members who are working independently

● ... without having to rewrite/re-test them which saves the programmers' time

● A program library provides continuity between programs/programmers

● Individual programmers can contribute their specialisms to the library // Individual programmers can use the specialisms of others

Benefits of a programmer using a library with DLL files

● Maintenance not needed to be done by the programmer

● ... because the DLL is separate from program

● The calling program does not need recompilation by the programmer when a DLL file changes

● ... because the DLL file can be updated independently of the calling program

● ... updates will apply to all programs that use the DLL file

Benefits to the developer of choosing to create a Dynamic Link Library (DLL)

● (main) memory requirements for program is reduced

○ ... as dynamic link library is loaded only once / when required

● the executable file size of the program using the DLL will be smaller

○ ... because the executable does not contain (all) the library routines

● maintenance not needed to be done by the programmer

○ ... because the DLL is separate from program

● no need to recompile the main program when changes are made to DLL

○ ... because changes / improvements/ error correction to the DLL file code are done independently of the main program

● A single DLL file can be made available to several application programs

○ ... Saving space in memory / easing the pressure on memory

The operation of a compiler

● Attempts to translate the whole source code

● Creates a separate error report at the end of the translation process

● If translation successful / no errors creates an executable file

The operation of an interpreter

● Reads each line then translates it and executes it

● Stops when an error is encountered // displays errors where it finds them

Why it is easier to debug the program code using an interpreter instead of a compiler

● The interpreter will stop when an error is found

● ... so the error can be corrected in real-time, and the result of changes seen immediately

● Only one error is displayed at a time

... so fewer errors to correct simultaneously and no dependent errors

• The developer can test when incomplete

• Allows the developer to make real-time changes

The reasons why the need to create an executable file makes the compiler the appropriate choice when the program is complete

● Program can be distributed without source code

● ... so it cannot be edited/stolen/plagiarised

● Users do not require the translator to run the program

● ... so time is not spent retranslating by user

The benefits of using the compiler during testing

● Creates an executable file

● ... so the code can be tested multiple times without having to recompile

● ... so repeated testing takes less time

Drawbacks of using a compiler compared to an interpreter during program development

● Larger amounts of source code take time to compile

● Slower to produce the object code than an interpreter

● Code cannot be changed without recompilation

● The program will not run if there are any errors

● Errors cannot be corrected in real-time

● One error may result in other false errors being reported

● Cannot easily test specific sections of the source code // cannot easily test unfinished source code

State one reason why some high-level languages are partially compiled and partially interpreted

● Partially compiled programs can be used on different platforms as they are interpreted when run

● Code is optimised for the CPU as machine code is generated at run time

● Source code does not need recompiling so more efficient to run

Features of IDE

● For presentation

○ Prettyprint: colour code keywords so the user can identify any errors

○ Expand and collapse code blocks: sections of source code that are part of the same block can be expanded to see the content or collapsed so that the overall code is seen

○ Auto-indentation // auto-formatting: automatically indents/formats code as the user types so that the structure is clear // aids readability

● For coding

○ Context-sensitive prompts: gives suggestions for code as the user types instead of having to write/remember the code

○ Auto-correct: corrects spelling mistakes so that user has fewer errors to correct

● For initial error detection

○ Dynamic syntax checks: highlight / underline / colour syntax errors as the code is entered

● For debugging

○ Single stepping: run the program one line at a time and check the variable contents / program flow // show the effect of each line of code

○ Breakpoints: stops the code running on a set line to view the current status/variable contents/program flow

○ Report window: shows the values in variables/data structures and how they change when each line is run