What are functions,variables and prototyping in C?

Variables or identifiers are the fundamental basic building blocks of a program. They are general terminology for objects, classes, functions, arrays etc. It can be defined as an arbitrarily long sequence of letters and digits and the first character must always be a letter. Upper and lower case letters are treated differently and all the characters are significant. C is implementation dependent. C is case sensitive as it treats lower and upper case letters differently. These are basically named storage, whose values can be manipulated during the execution of the program. There are 2 values associated with every variable namely r value and l value. The value of the variable is called r value whereas l value is the address in memory where the variable is located. Generally a variable is declared as :

type name;

A simple definition consists of a type specifier followed by a variable name. There are 2 types of variables: local variables and global variables. Local variables are declared inside a function and are available to that function only whereas global variable are declared outside main() and are available to all the functions.

A large program is difficult to manage and understand. Thus, it is broken down into different modules called functions which can be put together to form the complete program. So we can define a function as a sub program that acts on data and often returns a value. A good function contains a number of functions since it is easier to maintain update and debug. Each function has its own name. On the encounter of the function’s name in any part of the program the function is called. There are basically 2 types of functions namely built-in functions and user-defined functions. Built in functions are parts of the compiler package and are made available to the program by header files. For example: exit(), sqrt(), strlen(), size() etc. user defined functions are created by the programmer as per the requirements of the program. A function has 3 parts: function definition, function call and function prototype. In C a function must be defined before it is used anywhere. Generally a function is defined as:

type function-name(parameter list)
{
Body of the function
}

Here the type specifies the type of return value. The parameter list is the list of arguments passed to the function separated by commas. A function may be defined without any arguments or it can also have an open parameter. A function definition must have a return statement.

One of the most important features of C is function prototyping as it describes the function interface to the compiler. It can be defined as the declaration of the function that tells the program about the type of the value returned by the function and the number and type of arguments. Therefore, we can say that a prototype has following parts:
- Return type
- Name of the function
- Argument list

Function prototyping is essential as it allows a compiler to compare each use of the function with the prototype to determine whether the function has been invoked properly or not. This makes it easy for compiler to correct the errors. The function prototype and function definition must exactly agree on the function name, return type, and argument list. The prototype looks just like a function definition except that the code is missing. A prototype introduces a function to the program whereas a definition being a declaration also tells the program what the function is doing and how it is doing. C makes prototyping essential. We can skip the arguments in a prototype but not in the definition.

Sometimes requirements change very quickly, what can be done in those cases?

There is an expectation that the requirements should be determined early and should remain stable. Some approaches can be followed if these expectations are reasonable:

- Understanding how the requirements might change early in the stage can be done by working with project stakeholders early.
- The application should allow some adaptability to the changes that can occur in the requirments later.
- The code should be well documented and wriiten and commented. It makes notification of changes much easier.
- Rapid prototyping can be used to minimize changes.
- Some extra time should be taken into consideration in the case of changes.
- The new requirements should be moved to different phase while the original requirements should be in the original phase.
- The requiremnts that can be implemented more easily should be incorporated in the project first keeping the difficult requirements for future versions.
- The management and customer should keep in mind the effects that the changes in the requirements can incorporate.
- Automated test scripts should be made flexible.
- Test cases should be designed to be flexible.
- Ad hoc testing should be in focus more instead of detailed test plans and test cases.
- Minimize regression testing methods.

If the application has the functionality that was not in the requirements and if the functionality is not necessary, then it should be removed because it can have some unknown impacts and dependencies in the application which were not taken into account
by designer or customer. The management should be aware of the added risks as a result of unexpected functionality.

What is Software Process? What do you mean by software quality factors? What are different process models?

The factors that affect the quality of the software are called quality factors. The software product quality has three dimensions and each of the dimension deals with a set of quality factors.

PRODUCT OPERATION
- Correctness
- Reliability
- Efficiency
- Integrity
- Usability
PRODUCT TRANSITION
- Portability
- Re usability
- Interoperability
PRODUCT REVISION
- Maintainability
- Flexibility
- Testability

Software process is a set of activities, together with ordering constraints among them, such that if the activities are performed properly and in accordance with the ordering constraints, the desired result is produced.
Software process deals with the technical and management issues of software development.
The different process models are:
- Waterfall Model
The phases of the model are organized in a linear order.
- Prototyping
A throw away prototype is built instead of freezing the requirements before design or coding to help understand the requirements.
- Iterative
The software should be developed in increments with each functionality added to each increment.
- Spiral
Software development activities are organized like a spiral that has many cycles. The radial dimension represents the cumulative cost and the angular dimension represents the progress.

Rapid Application Development (RAD) - Advantages and Disadvantages

The main objective of Rapid Application Development is to avoid extensive pre-planning, generally allowing software to be written much faster and making it easier to change requirements.
Rapid Application Development Model (RAD Model) is a linear sequence of the software development process model where we focus a very short development cycle by using a component based construction approach.

When organizations adopt rapid development methodologies, care must be taken to avoid role and responsibility confusion and communication breakdown within the development team, and between the team and the client.

To facilitate rapid development, strong emphasis was placed on the idea of software re-use. The notion of software components began to be nurtured.

ADVANTAGES OF RAPID APPLICATION DEVELOPMENT(RAD)

- It increases speed of developing software. It can be achieved using methods like rapid prototyping, virtualization of system related routines, the use of CASE tools and other techniques.
- Re-usability of components help to speed up development.
- It increases the quality.
- Some systems also deliver advantages of interoperability, extensibility, and portability.
- It incorporates short development cycles.
- Promotes strong collaborative atmosphere and dynamic gathering of requirements.

DISADVANTAGES OF RAPID APPLICATION DEVELOPMENT(RAD)

- Unknown cost of product.
- Difficult to commit the time required for success of the RAD process.
- Short iteration may not add enough functionality, leading to significant delays in final iterations.
- Early RAD systems faces reduced scalability occurs because a RAD developed application starts as a prototype and evolves into a finished application.
- Early RAD systems have reduced features that occur due to time boxing, where features are pushed to later versions in order to finish a release in a short amount of time.
- Dependency on strong cohesive teams and individual commitment to the project.

Rapid Application Development (RAD) - Characteristics and Phases

Rapid Application Development is a software development methodology that focuses to decrease the time that is needed to design the software through gathering requirements using workshops or focus groups, prototyping and early, reiterative user testing of designs, the re-use of software components, a rigidly paced schedule that defers design improvements to the next product version, less formality in reviews and other team communication.

Characteristics of Rapid Application Development(RAD)

- It involves techniques like iterative development and software prototyping.
- Focused scope where the business objectives are well defined and narrow is well suited for RAD.
- Project data suitable for RAD is the data for the project already exists (completely or in part). The project largely comprises analysis or reporting of the data.
- Decisions can be made by a small number of people who are available and preferably co-located are suitable for RAD.
- A small project team (preferably six people or less) is suitable for RAD.
- In RAD, the technical architecture is defined and clear and the key technology components are in place and tested.

Phases of Rapid Application Development

RAD has a step by step process.
- Planning of Requirements: Developers meet with the project coordinator or manager to create specific objectives from the desired program. Strategies for development and tools for development are also laid out in a specific project.
- RAD Design Workshop: Using the agreed tools and interfaces, developers will start to create different programs based on the business need.
- Implementation Phase: Even though it has gone through hundreds or even thousands of testing and critique, the stage wherein the software is implemented in a larger scale is different hence new suggestions and bugs should be expected from different users.

Prototyping process

How to go about prototyping:

1. Identify the base set of requirements

2. Develop the initial prototype

3. Get the prototype reviewed by end-users and customers

4. Based on this review and other work, revise the prototype until it has broad agreement with the customers and end-users



2 main types of prototypes:

1. Evolutionary prototypes: The objective of evolutionary prototyping is to deliver a working system to end-users. Used for systems where the specification cannot be developed in advance such as user interface systems and where verification is impossible because there is no specification.

2. Throw-away prototypes: The objective of throw-away prototyping is to validate or derive the system requirements. Throwaway or Rapid Prototyping refers to the creation of a model that will eventually be discarded rather than becoming part of the finally delivered software. After preliminary requirements gathering is accomplished, a simple working model of the system is constructed to visually show the users what their requirements may look like when they are implemented into a finished system.