The project life cycle has four phases within it:
Initiation, Planning, Execution and Closure.
The initiation phase is the 1st phase in the
Project life cycle as it is where a project is started up. A project is started
up by knowing its objectives, scope, purpose and deliverables that need to be
produced. The project team will then need to be chosen and hired, an office for
the project is setup and then a review of the project to ensure all is correct
and gain approval to continue to the next stage. It is needed in software development to set out a plan of what is being done.
The planning phase is the second of the four phases in the
Project life cycle. In this stage, a set of plans are created to help guide the
team with instructions and resources through the last two phases of the
project.It is important for a software development team to plan their project efficiently and see what is the best route of doing something
During this phase, plans are created to help manage time in
the project, cost, quality, change, risk and issues. There are there also to
help to manage staff, ensuring suppliers deliver on time and also within the
set budget.
In the execution phase the physical project deliverables are
built and are presented to the customer to sign off. This phase usually takes
the longest time out of the four and also consumes a lot of energy and the most
resources. This is where the software development team will test to see that all is working well.
To monitor control in this phase, management processes will
need to be implemented. These processes are used to help manage time, cost,
quality, change, risks and any issues.
The final phase in the Project life cycle is the closure
phase. This is where a project is formally closed and a report is created to
analyse the success of a project and report that to the sponsor. The software development team will look here at whether the project was a success and what can be changed for next time
In this stage it is all about handing over deliverables to
the customer, passing over the documents to the business, cancelling any
supplier contracts, releasing the staff and equipment that are no longer needed
and masking the stakeholders aware that the project is complete.
When the project is complete and has been closed off, a Post
Implementation Review is undertaken and completed to identify the success and
any pointers to take into the next project.
Discuss the
use of various software structures and how they fit into the life cycle,
consider:
Functions: These fit into the life cycle mainly in the execution stage as the developers will look to see were the functions may be necessary to have a purpose.
Procedures: The procedures may be thought about in the planning stage to plan to code what they will do or what needs to be done.
Classes/Objects: Classes and objects fit into the life cycle in the execution phase as they are implemented here to have a purpose and to act within a program.
Data abstractions: This is the hiding of data so would fit into the life cycle in the project execution as well as it will need to be executed and do its job to ensure that it is hidden away and the access to the particular data is forbidden.
Pre-defined code: This will fit into both the initiation and execution phase as it is already pre-defined so this will already be known in the initiation phase but then it is actually implemented in the execution phase.
Readability: This will fit into the planning and execution phase. The planning phase will show what needs to be done and read so will show that the code needs to be understandable not only now but also in the future. This will then be implemented into the code at the execution phase.
Readability: This will fit into the planning and execution phase. The planning phase will show what needs to be done and read so will show that the code needs to be understandable not only now but also in the future. This will then be implemented into the code at the execution phase.
Task 2:
Use these phrases: Annotation, Logical methods, Program
structures, Sequencing Selection Iteration, Eliminating repeating or redundant
code.
·
Readability – When writing code, it is important
to ensure that it is readable for people to go back and look at adapting or
fixing that code. If it is all cramped up and not written in a presentable
manner then it won’t be able to be fixed without being time-consuming.
·
Comments – It is useful to annotate code whilst
writing it so that users can make sense of what the code is and does at a later
date. It will also be easier to navigate through it if there was a problem with
it. Annotations are used to clearly label a part of a piece of code.
·
Appropriate names for variables – This is used
to avoids any confusion whilst coding. An example is if a game had a red ball
alongside a number of other coloured balls, it would be very confusing and hard
to monitor if the ball was simply called either “ball” or “ball1” for example.
·
Indentation – This is used to show that a piece
of code belongs to that above it; so for a loop when a “:” is used, it
automatically indents to show that it belongs within the loop. Indentation also
makes code look presentable and shows sub sections to code rather than just a long
section of primary base code. This is a logical method of coding as it saves
time and is easy to look back at how it works.
·
Quality of code e.g. efficiency – Having a good
quality of code is useful for making the code make sense in as less code as
possible. This is efficiency and it is key to be efficient while coding because
it is a long drawn-out process.
·
Reliability – Making code reliable is important because
it will work correctly. This also counts for adapting code, if code is taken
form previous examples or is taken from elsewhere, it is important that it is
from a reliable source so that it will work.
·
Robustness - Having robust code allows a system
or a computer to handle any errors in code and still execute it like there were
no errors. This is useful for large amounts of code because it could take a
long time to identify any errors within a piece of code.
·
Usability – It is useful to have code that is
easy to use because it ensures that it can be looked backed upon if it needs to
be edited as it may have a function to it. This code may also be used for other
things so it may be copied and inserted somewhere else. This means that is
should be able to be used by someone else even if they have not coded it.
·
Portability – The portability of code is how
well it can be transferred from a computer environment to another. The code may
well be transferred with no problems but when it is opens or put into practice
t may fail. It is important to always ensure that it can be supported on
another operating system or to wherever it is being transferred to.
·
Maintainability – The reason to maintain
important code is to avoid any updates to it or the programmes that they are
run on deleting them or changing what the code does. If the code is changed and
not maintained it would be useless.
Explain in detail why the following terms are important when programming:
Debugging: A program needs to be debugged when it doesn't work properly. Finding any mistakes in the code can be hard at times so it is time-consuming to try to find what the problem is. Once this problem has been found then the program will work properly. It is important to be able to debug code because it allows any form of program to be able to work whether it be a game, a webpage or anything that requires code.
Team working: Working as a team whilst programming is important as it allows a program do be finished and worked on quickly and efficiently. This also helps generate more and creative ideas which could ultimately build a better program than what would have been created. Teamwork also brings a group together as friends and individuals can work better as a team.
Updating: Updating code regularly is important while programming because the current code may become out-dated and the function of the code may have changed and cause a bug in the program. Also updating may introduce new code which could bring in brand new code that could be more useful than what is currently available



