bcos in manier cases things will change in later phases.

You cant plan only for the current phase of the project as 
your future activities are still coarse granular. To have 
good plannig you need to have fine granularity w.r.t the 
tasks to get clear WBS

To mitigate the risks asap and it will also help them in
sizing and other things.

SRD contains the details about the system where the 
appliation is deployed.(i.e) software and harware 
specification 

FRD contains the details about the application which has to 
be developed. 

RDS contains the details about what actually need to be 
done/modified(if existing system) in the application that 
has to be developed.

The arguments distinguish functions with the same name 
(functional polymorphism). The name alone does not 
necessarily identify a unique function.  However, the name 
and its arguments (signatures) will uniquely identify a 
function.
In real life we see suppose, in class there are two guys 
with same name, but they can be     easily identified by 
their signatures. The same concept is applied here.
ex:
class person
{
public:
char getsex();
void setsex(char);
void setsex(int);
};
In the above example we see that there is a function setsex
() with same name but with different signature.

Usecase diagram.

From the use cases, designers will incure class diagrams 
and Dynamic modelings like sequence diagrm,Activity diagram 
and Collaboration diagrams.And from the use case diagram, 
we will identify control classes, boundary classes and 
Interface classes.Every Inerface classes will have 
realisation classes(implementation of the abstract classes).
This is the way of conveying the implementation details to 
programmers

In Unified Modeling Language (UML) sequence diagrams, a 
guard condition, also called as an interaction constraint, 
is a Boolean conditional expression that guards an 
interaction operand in a combined fragment. A guard 
condition contains two expressions that designate the 
minimum and maximum number of times that a loop combined 
fragment executes.

One who plays different roles
One who is interacting with the system

An Actor is something or someone who intract with the 
system under development. An actor can be a Human, device 
or an external system. An actor can be a giver / reciever 
of information or both.

An actor specified the role played by an external entity( 
may be human ,process or other system ) on the system.

An Actor is an entity which interacts with the System 
(either human(Developers & End-User) or hardware(Hardware 
Accessories) or system(Software System)).

It is useful to represent the complete and specific 
funtionality that an actor(USER) is desirous of.
This functionality is shown by the USECASE model with the 
help of Diagrams, i.e. Sequence Diagram and Colloboration 
Diagram. It shows the various states of a work flow(Project 
or Program).

Diagram which represents the requiremnets(usecase) of the 
user(actor). its needed to represent the dynamic model at 
the analysis stage to represent the graphical view of the 
requiremnetal behaviour.

an usecase is a sequence of actions which can be done by a 
actor.

use case is a interaction between actor(USER) and System
(application), for single system there many use cases 
depends on Requirements.

use case represents diagrams. there are two types of use 
cases BUC-> business use case and SUC-> system use case
In BUC we represent pictures related to Domain and SUC we 
represents shapes like elipse,arrows etc. this is the very 
first stage of design where we find out actors and related 
activity. actor performs happy activity

When OOAD was in the birth phase, There were different 
different ways to define the OOAD consepts.
Before 1994 there were different methodologies like 
Rumbaugh, Booch, Jacobson, Meyer etc who followed their own 
notations to model the systems. The developers were in a 
dilemma to choose the method which best accomplishes their 
needs.     This particular span was called as ?method-wars?.

Selvan Pongy

No, you cannot apply the link and Association 
interchangeably. Since
* link is used represent the relationship between the two   
objects.

* But Association is used represent the relationship 
between the two classes.

link ::          student:Abhilash         course:MCA

Association::    student                  course

Aggregation is the relationship between the whole and a 
part. We can add/subtract some     properties in the part 
(slave) side. It won?t affect the whole part.
Best example is Car, which contains the wheels and some 
extra parts. Even though the parts are not there we can 
call it as car.
But, in the case of containment the whole part is affected 
when the part within that got affected. The human body is 
an apt example for this relationship. When the whole body 
dies the parts (heart etc) are died.

Static modeling is used to specify structure of the 
objects that exist in the problem domain. These are 
expressed using class, object and USECASE diagrams. 

 Dynamic modeling refers representing the object 
interactions during runtime. It is represented by sequence, 
activity, collaboration and statechart diagrams

Static Model - Time Independent view of the system.
e.g. Class has same number of students in an year.
Static model includes :
CLASS DIAGRAM
OBJECT DIAGRAM
COMPONENT DIAGRAM
DEPLOYMENT DIAGRAM

Dynamic Model - Time dependent view of the system
E.g. ATM can accept card only when it is in ready state. 
ATM cannot read card card when it is in ERROR state. Thus 
state of ATM is a dynamic aspect.
Dynamic Modelling includes
USE-CASE DIAGRAM
INTERACTION DIAGRAM
STATE DIAGRAM
ACTIVITY DIAGRAM

Funtional Model-What happens
Static Model- To whom it happens
Dynamic Model - When it Happens

Static Model refers to the model of system not during 
runtime. This is more structural than behavioral. This 
includes classes and it relationships(Class Diagram), 
Packages etc. For example, the concept of class itself 
static. At runtime there is no concept of Class, Sub class 
etc.

Dynamic model refers to runtime model of the system. This 
includes the concept of Objects, interactions, 
Collaborations, sequences of operations, Activities, state 
changes, memory model etc.

SBI stands for State, Behavior and Identity. Since every 
object has the above three.
* State:         
It is just a value to the attribute of an object at a 
particular time.

* Behaviour:

It describes the actions and their reactions of that object.

* Identity:

An object has an identity that characterizes its own 
existence. The identity makes it possible to distinguish 
any object in an unambiguous way, and independently from 
its state.

Object has
State:Described by attribute values 
Bahaviour:Described by methods 
identity: Object id for reference assigned by system(hex) 
or by address of memory location

Mainly there are four concepts for OOAD.
1.Abstraction -grouping of data and behaviour(operations) 
into a conceptual object.
2.Encapsulation -Its the implementation mode of data 
abstraction.With encapsulation, we can accomplish data 
hiding
3.Polymorphism -Polymorphism refers to the process whereby 
an object invokes a method of another object in a common 
manner (with the same name) without understanding or caring 
how it is accomplished. 

4.Inheritance-When an object is derived from another 
object. It inherits all the properties etc

Abstraction - Interfaces are the best examples of 
abstraction .
Encapsulation - Classes are best examples of encapsulation.

Generally we encapsulate what varies & 
we abstract commonalities...

One more thing, You should always subclass for behabiours..
you should never subclass for properties / attributes. If 
only properties vary, then you have got to encapsulate them 
in somewhere else e.g. in a class or in some collection 
object like - Properties in Java / Map 

Hope this helps..