Performance is an expression of the amount of work that is done during a certain period of time. The more work a program does per unit of time, the better its performance. Put differently, the performance of a program is measured by the number of input (data) units it manages to transform into output (data) units in a given time. This translates directly into the number of algorithmic steps that need to be taken to complete this transformation. For example, an algorithm that executes 10 program statements to store a name in a database performs poorly compared to one that stores the same name in five statements.
Performance can be affected by the following:
- Performance of Physical Devices (i.e. Printer)
- Performance of System Resources (i.e. RAM, ROM, EPROM)
- Performance of Subsystems (i.e. using third party software)
Performance of Communication.
- Call back functions are one of the common tools used in communication optimization.
Application Look and Fell (i.e. GUI)
Common GUI Problems:
- Unexplained waiting time (i.e. adding progress bar)
- Illogical setup of user interface
- Problematic Interface Access (i.e. delay of rendering the instant controls)
- Not Sufficiently Aiding the Learning Curve (i.e. adding help pop-ups)
When Do Performance Problems Arise
Often a program is closely tailored to fit the current intended use, causing it to run into performance problems almost as soon as the slightest alteration is made to the way it is used—more often than not this is because developers work under strict time constraints
- Extending program functionality
- Code reuse
- Test cases and target systems
Side effects of long-term use
- Disk fragmentation
- Spawned processes that never terminate
- Memory leaks
- Memory fragmentation
- Files that are opened but never closed
- Interrupts that are never cleared
- Log files that grow too large
- Semaphores that are claimed but never freed (locking problems)
- Queues and arrays that exceed their maximum size
- Buffers that wrap around when full
- Counters that wrap to negative numbers
- Tasks that are not handled often enough because their priority is set too low
Put in mind the tradeoff between software flexibility and performance.
Software Footprint is used as measurement term of the software. Several aspects are considered as:
- Storage Requirement: when the program is inactive and stored on hard disk.
Runtime Memory Requirement: This is the amount of memory needed while the program is being executed.
- Data Structures
- Overlay Techniques
- Working Memory
- Memory Fragmentation
The main considerations for keeping footprint sizes in check are the impact on available resources and the impact on performance.
Also, a program’s usability is affected by the size of the runtime footprint. If a program uses a lot of internal memory, it might force the operating system to start swapping memory to the hard disk and back. Remember also that programs virtually never have the sole use of the system. When there is little free internal memory left, an increasingly large part of the memory that is temporarily not needed is swapped out onto the hard disk. The chance that a certain operation will require data that is not found in memory increases. The result is a hard disk that makes a lot of noise and programs that halt and stutter, causing overall slowdown and annoyance.
The ideal program, as seen by the user, has the following characteristics:
- It needs little user interaction.
- It has an intuitive user interface.
- It has a short learning curve.
- It is highly flexible.
- It contains, and is accompanied by, extensive but easily readable user documentation.
- It has no waiting times during user interaction; any slow actions be performed off line and so on.
- It has readily available information for users at any given time
The ideal program, as seen by the developer, contains the following attributes:
- It is geared toward future developments—added functionality, handling larger bases of data.
- It is easily maintainable.
- It has a good and intuitive design.
- It is accompanied by well-written technical documentation.
- It can be passed on to any developer