RSS

Monthly Archives: September 2011

What we learnt in computing this week!

This week in computing we learnt about:

  • Macros
  • Scripting
  • Modularity
  • High Level Language Programming Constructs. (HLL)
  • Parameters
  • Procedures
  • Functions

A macro is a function which is recorded by the user. The user records a series of key presses and then assigns the set of key presses to a keystroke. This will perform all the key presses at once. This means that this set of key presses can be played back as many times as the user needs to at a later.

Scripting

Scripting is basically the same as a macro but the only difference is that the instructions are already programmed into the application. The user just has to choose what he/she wants to happen.

Benefits of Macros/Scripting

  • Complex commands can be carried out by a single keystroke.
  • More advanced users can set up pre-defined macros for beginners to make the application more simple.
  • There is more flexibility and functionality from an application which macros/ scripts can be created.
  • The user interface can be easily customized.

Modularity 

If a computer program is complex, it may be broken down into smaller, manageable pieces of code. This means the program is modular.

Modules/Subroutines.

A subroutine is a block of code which needs to be passed a paramneter and can be called back into the main program by typing the subroutines name. This saves the programmer time as they don’t have to copy and paste the code and they can be specifically designed.

Example!

In the game pacman, there are four ghosts. The movement rules for each ghost are the same, but the programmer doesnt want to have to copy and paste the same code four times. It would make more sense to create a subroutine. 

Example of subroutine code (move-ghost)

SUBROUTINE: move-ghost, (GhostName)

         IF GhostName at edge of wall THEN 

         Change GhostName direction

          ELSE 

          move GhostName in current direction 

          END IF 

END SUBROUTINE 

After the subroutine is created. For it to work it has to be called. Once it is called, it must be past a parameter, in this case it is one of the four ghosts. The parameter being past is a string variable (the ghosts name) When the parameter is past the subroutine will execute the code on the chosen ghost. For example the ghost “PINKY” needs to be moved: 

move-ghost (“PINKY”). Once this is called in the program. The subroutine will execute passing the parameter “PINKY”

Procedures and Functions.

There are also two types of subroutines a procedure and a function. 

  • Procedure produces an EFFECT 
  • Function produces a VALUE 

 

In the example above the subroutine is a procedure as it produces an effect. the effect is the moving of the ghost.

 

 

 

 

Parameters.

There are two types of parameters. An actual parameter and a formal parameter. 

An Actual Parameter is a parameter which is passed into the subroutine when it is called from another part of the program.

A Formal Parameter is a parameter that is used withing the subroutine definition.

Parameter passing

There are two ways that a parameter can be passed, by reference or by value. 

When the parameter is passed by reference, the value of the parameter is changed when it is passed through the subroutine.

When it is passed by value, the value of the parameter is not changed when it is passed through.

High Level Language Constructs (High Level Language vs Low Level Language).

A High Level Language (HLL) uses everyday language to make programming easier. Its features include arithmetic functions which instuctions can be written using the appropriate symbols ( +,-,*,/,^). There are also built in functions and these can be used as subroutines if necessary. One HLL instruction translates into several machine code instructions. A Low Level Language (LLL) is one that which humans will find difficult to understand, such as binary. It is much easier to write a program in HLL but a program written in LLL will run much faster as it is more efficient.

High Level Programming Constructs. 

 

  • Conditional Statements – IF,THEN,ELSE
  • CASE Statements – a more compact version of a Conditional statement.
  • Nested Loop – a loop within a loop.
  • Conditional Loop – Repeats until a condition is met.
  • Input Validation – Makes sure the users input is acceptable.

 

Advertisements
 
Leave a comment

Posted by on September 23, 2011 in Computing

 

The Last Three Stages of the Software Development Process!

The final three stages of the software development process are documentation, evaluation and maintenance.

Documentation

Documentation is created to help the user understand how to use a software program. There are a few documents created at this stage but the two most common are:

User Guide

Technical Guide

User Guide

The user guide explains to the user how to work the software program. It can be produced in paper format but now it is more likely to be produced as an online PDF downloadable file or as online help.

                                                          Technical Guide 

This piece of documentation explains to the user how to install the software, the version number of the software, the minimum amount of memory and processor speed need to run the program and any other programs or files that may be needed to run the program.

There are other types of documentation that are created at this stage. These are:

  • Quick Start Guide
  • FAQ’s
  • Shortcut Guide
  • Tutorials

Evaluation

At this stage in the process, the client and developer review the software program to check if it meets the software specification and also if it is fit for purpose.

The software program is evaluated by the following criteria:

  1. Robustness
  2. Reliability
  3. Portability
  4. Efficiency
  5. Maintainability

Maintenance 

The maintenance stage happens after the software has been handed over to the client and it is put into use. There are three different types of maintenance

  • Corrective
  • Perfective
  • Adaptive

Corrective Maintenance.

This type of maintenance is specifically to remove any coding errors and fix any bugs that are found within the program.

Perfective Maintenance. 

If the client asks for specific changes within the software program or for additional features.

Adaptive Maintenance. 

If the environment in which the software is used changes, (i.e. moves to a different company) then it may be necessary to alter the code so it fits with the new environment. Other ways include operating system change/upgrade or new hardware.

The most time consuming type of maintenance is perfective as this keeps the client and developer in touch, and the programming company making money because the client keeps asking for changes.

Factors which affect the Maintenance stage

New Applications: As the users of the software begin to gain experience with it. They will start to see ways it could be improved or features that could be beneficial.

Staff Mobility: Its a lot more simple to keep the same team of programmers on one specific program which they created. That rarely happens. So other programmers come and take over and unless the software is well documented, then maintenance becomes exceedingly difficult.

Too many Versions: As the software is updated or changed, the programming company may release a newer version. the problems which can occur are that the software might stop supporting certain operating systems and it can be difficult to track down code changes.

Insufficient Documentation: If there is not enough documentation (internal commentary, design documentation) to support the software. Then maintaining it becomes a difficult job.

Hardware/Software changes: If the external hardware, internal software which is needed to run the program or the operating system platform is upgraded. The maintenance requirements become affected.

The maintenance stage is seen to be the most costly stage of the software development process as there is so much to be considered at this stage. It is estimated that 40% and 70% of the overall costs throughout the development process are down to maintenance.

 
 

Software Development process: Testing.

In computing this week we learnt about the testing stage of the software development process.  The testing stage is generally the most expensive or the equivalent to the analysis and design stage. If problems aren’t fixed earlier on it becomes a lot more costly to fix the bugs at the testing stage.

Testing does not begin after the implementation stage, it actually begins at the analysis and design stage, as this is where a prototype is usually created. A prototype is a rough model of the program which shows the basic outline of the programs functions. This is more cost effective to the project.

There are many testing errors but a few of the most common are :

-Incomplete Logic.

-Incorrect Interpretation of specification.

-Poor Error Handling.

-Bad Time Planning.

To test a program there needs to be characters the tester can test it with and he/she will know the specific outcome (to see if it works correctly). They usually use three types of test data sets. these are:

-Normal

-Extreme (Boundary Data)

-Exceptional (Out of Range Data)

Normal Data

This type of data shows that the program should work as expected.

Extreme Data

This type of data is also known as Boundary Data. This data tests the program to its limit. To show that it has boundaries.

Exceptional Data

Also know as out of range data. this set show that the program should be able to handle unexpected inputs.

There are five main stages to the testing phase these are

  1. Procedure/Module testing
  2. Integration testing
  3. System testing
  4. Acceptance testing
  5. Alpha and Beta testing

1. This is when Individual modules and code is tested.

2. At this stage the tester checks that all the modules work together.

3. This is when the overall system is tested.

4. The client tests the program against the specification at this point.

5. This is when the program is released to users for it to be tested by possible consumers. 

 
1 Comment

Posted by on September 12, 2011 in Computing, software development process

 

Debugging in REALbasic.

As a program has to be tested for bugs, debugging is a useful tool. In REALbasic. This tool is simple. As you run a program, you can create a breakpoint. This tells the program to ‘break’ and then in REALbasic it lets you view the code where its taken the break (the specific line of code is highlighted).

 

                                                

After the breakpoint is created, there is a function which allows the tester to step through each line of code whilst monitoring the variables. This is so the tester can see if the program is doing exactly what has been asked of it.