Q1) How complex is the model, concerning the number of actors and elements?
Symptom	The size of the model is unusually lower, or higher, than in most models.
Potential problem	The model may be over-simplistic, or unnecessarily complex, leading to problems in the understandability of the system.
Suggested action	Consider revising the model. If necessary, add more detail, or remove accidental complexity.
Metric	NAct – Number of Actors
Informal definition	Total number of actors in the SD/SR model
Formal definition	context ISTAR def:NAct():Integer = self.hasNode -> select (n:Node | n.oclIsKindOf(Actor)) -> size ()
Metric	NElem – Number of Elements
Informal definition	Total number of elements in the SD/SR model
Formal definition	context ISTAR def:NElem():Integer = self.NEOAB() + self.NEIAB()
Requires	NEOAB – Number of Elements Outside Actors' Boundaries NEIAB – Number of Elements Inside Actors' Boundaries

Q2) Does an actor have too much responsibility in the model?
Symptom	The actor has an unusually high number of internal model elements.
Potential problem	The actor may have too many responsibilities in the model.
Suggested action	This actor may be a good candidate for further scrutiny. Consider decomposing this actor into several sub-actors and distributing his responsibilities among them. If the system has no outliers, the assignment of responsibilities is probably well balanced.
Metric	NEA – Number of Elements of an Actor
Informal definition	Number of elements inside an actor's boundary in the SR model
Formal definition	context Actor def:NEA(): Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Element)) -> size()
Metric	MinNEA – Minimum Number of Elements of an Actor
Informal definition	Minimum number of elements inside an actor’s boundary
Formal definition	context ISTAR def:MinNEA(): Integer = self.hasNode -> select(n:Node | n.oclIsKindOf(Actor)) -> iterate(n:Node; min:Integer = -1 | let nea:Integer = n.oclAsType(Actor).NEA() in if min = -1 then nea else min.min(nea) endif)
Metric	MaxNEA – Maximum Number of Elements of an Actor
Informal definition	Maximum number of elements inside an actor's boundary
Formal definition	context ISTAR def:MaxNEA(): Integer = self.hasNode -> select (n:Node | n.oclIsKindOf(Actor)) -> iterate (n:Node; max:Integer = -1 | let nea:Integer = n.oclAsType(Actor).NEA() in if max = -1 then aux else max.max(nea) endif)
Metric	AvgNEA – Average Number of Elements of an Actor
Informal definition	Average number of elements inside an actor's boundary
Formal definition	context ISTAR::AvgNEA() pre:self.NAct() > 0 context ISTAR def:AvgNEA(): Double = self.NEA() / self.NAct()
Requires	NEA – Number of Elements of an Actor NAct – Number of Actors

Q3) How complex is an actor's goal, with respect to its decompositions?
Symptom	An actor's goal has an unusually high number of decompositions.
Potential problem	The goal may be over-decomposed.
Suggested action	This goal may be a good candidate for further scrutiny. Consider abstracting out this goal, if it is over-decomposed. If the actor has no outlier goals, their decomposition is probably well balanced.
Metric	NDG – Number of Decompositions of a Goal
Informal definition	Number of decompositions associated with a goal in the SR model
Formal definition	context Goal def:NDG():Integer = self.goalMeansEnds -> select(me:MeansEnds | me.oclIsKindOf(MeansEnds)) -> size ()
Metric	MinNDG – Minimum Number of Decompositions of a Goal
Informal definition	Minimum number of decompositions associated with a goal
Formal definition	context Actor def:MinNDG(): Integer = self.hasElement -> select (e:Element | e.oclIsKindOf(Goal) and e.oclAsType(Goal).NDG() > 0) -> iterate (e:Element; min:Integer = -1 | let ndg:Integer = e.oclAsType(Goal).NDG() in if min = -1 then ndg else min.min(ndg) endif)
Metric	MaxNDG – Maximum Number of Decompositions of a Goal
Informal definition	Maximum number of decompositions associated with a goal
Formal definition	context Actor def:MaxNDG():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Goal) and e.oclAsType(Goal).NDG () > 0) -> iterate (e:Element; max:Integer = -1 | let ndg:Integer = e.oclAsType(Goal).NDG() in if max = -1 then ndg else max.max(ndg) endif)
Metric	AvgNDG – Average Number of Decompositions of a Goal
Informal definition	Average number of decompositions associated with a goal
Formal definition	context Actor::AvgNDG() pre:self.NGWDI() > 0 context Actor def:AvgNDG(): Double = self.NDG() / self.NGWDI()
Requires	NDG – Number of Decompositions of a Goal NGWDI – Number of Goals With Decompositions Inside

Q4) How complex is an actor's softgoal, with respect to its decomposition?
Symptom	An actor's softgoal has an unusually high number of decompositions.
Potential problem	The softgoal may be over-decomposed.
Suggested action	This softgoal may be a good candidate for further scrutiny. Consider abstracting out this softgoal, if it is overdecomposed. If the actor has no outlier softgoals, their decomposition is probably well balanced.
Metric	NDS – Number of Decompositions of a Softgoal
Informal definition	Number of decompositions associated with a softgoal in the SR model
Formal definition	context Softgoal def:NDS(): Integer = self.softgoalContribution -> select(cl:ContributionLink | cl.oclIsKindOf(ContributionLink)) -> size ()
Metric	MinNDS – Minimum Number of Decompositions of a Softgoal
Informal definition	Minimum number of decompositions associated with a softgoal
Formal definition	context Actor def:MinNDS():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Softgoal) and e.oclAsType(Softgoal).NDS() > 0) -> iterate(e:Element; min:Integer = -1 | let nds:Integer = e.oclAsType(Softgoal).NDS() in if min = -1 then nds else min.min(nds) endif)
Metric	MaxNDS – Maximum Number of Decompositions of a Softgoal
Informal definition	Maximum number of decompositions associated with a softgoal
Formal definition	context Actor def:MaxNDS(): Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Softgoal) and e.oclAsType(Softgoal).NDS () > 0) -> iterate(e:Element; max:Integer = -1 | let nds:Integer = e.oclAsType(Softgoal).NDS() in if max = -1 then nds else max.max(nds) endif)
Metric	AvgNDS – Average Number of Decompositions of a Softgoal
Informal definition	Average number of decompositions associated with a softgoal
Formal definition	context Actor::AvgNDS () pre:self.NSWDI () > 0 context Actor def:AvgNDS():Double = self.NDS() / self.NSWDI()
Requires	NDS – Number of Decompositions of a Softgoal NSWDI – Number of Softgoals With Decompositions Inside

Q5) How complex is an actor's task, with respect to its decompositions?
Symptom	An actor's task has an unusually high number of decompositions.
Potential problem	The task may be over-decomposed.
Suggested action	This task may be a good candidate for further scrutiny. Consider abstracting out this task, if it is over-decomposed. If the actor has no outlier tasks, their decomposition is probably well balanced.
Metric	NDT – Number of Decompositions of a Task
Informal definition	Number of decompositions associated with a task in the SR model
Formal definition	context Task def:NDT():Integer = self.taskDecompositionLink -> select(dl:DecompositionLink | dl.oclIsKindOf(DecompositionLink)) -> size ()
Metric	MinNDT – Minimum Number of Decompositions of a Task
Informal definition	Minimum number of decompositions associated with a task
Formal definition	context Actor def:MinNDT():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Task) and e.oclAsType(Task).NDT() > 0) -> iterate(e:Element; min:Integer = -1 | let ndt:Integer = e.oclAsType(Task).NDT() in if min = -1 then ndt else min.min(ndt) endif)
Metric	MaxNDT – Maximum Number of Decompositions of a Task
Informal definition	Maximum number of decompositions associated with a task
Formal definition	context Actor def:MaxNDT():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Task) and e.oclAsType(Task).NDT() > 0) -> iterate(e:Element; max:Integer = -1 | let ndt:Integer = e.oclAsType(Task).NDT() in if max = -1 then ndt else max.max(ndt) endif)
Metric	AvgNDT – Average Number of Decompositions of a Task
Informal definition	Average number of decompositions associated with a task
Formal definition	context Actor::AvgNDTI() pre:self.NTWDI() > 0 context Actor def:AvgNDTI():Double = self.NDT() / self.NTWDI()
Requires	NDT – Number of Decompositions of a Task NTWDI – Number of Tasks With Decompositions Inside

Q6) Is an actor too dependent in the model?
Symptom	An actor has an unusually high number of outgoing dependencies.
Potential problem	The actor may be too dependent on other actors to achieve its goals.
Suggested action	This actor may be a good candidate for further scrutiny. Consider balancing the number of outgoing and incoming dependencies among actors. If there are no outliers, the dependencies are probably well balanced.
Metric	POD – Percentage of Outgoing Dependencies
Informal definition	Percentage of outgoing dependencies of an actor in the SD/SR model
Formal definition	context Actor::POD() pre:self.ND() > 0 context Actor def:POD():Double = self.NOD() / self.ND()
Requires	NOD – Number of Outgoing Dependencies ND – Number of Dependencies

Q7) Does an actor have too many dependencies in the model?
Symptom	An actor has an unusually high number of incoming dependencies.
Potential problem	If too many actors depend on a particular actor, changes in this actor may have ripple effects through the other actors. This potentially reduces the maintainability of a system.
Suggested action	This actor may be a good candidate for further scrutiny. Consider balancing the number of outgoing and incoming dependencies among actors. If there are no outliers, the dependencies are probably well balanced.
Metric	PID – Percentage of Incoming Dependencies
Informal definition	Percentage of incoming dependencies of an actor in the SD/SR model
Formal definition	context Actor::PID() pre:self.ND() > 0 context Actor def:PID():Double = self.NID() / self.ND()
Requires	NID – Number of Incoming Dependencies ND – Number of Dependencies

Q8) Is there a variation in the average complexity of the different types of actors?
Symptom	The actors from different types have a significantly different complexity. This is observable by statistically comparing the distributions of complexity by actor type.
Potential problem	It might be the case that a particular type of actor is frequently over- or under-specified, which would reflect on the typical complexity of actors of that type. On the other hand there might be a good reason for making a particular actor type more (or less) complex than the other ones.
Suggested action	Consider comparing the average complexity of the different actor types with the one found in other systems. If it is significantly different, further investigate whether this results from the essential complexity of the system, or from some accidental factor (such as over-, or under-specification of the actors).
Metric	NEIAct – Number of Elements Inside an Actor
Informal definition	Number of elements inside an actor’s boundary in the SR model
Formal definition	context ISTAR def:NEIAct():Integer = self.NEIAB() - (self.NEIAgB() + self.NEIPB() + self.NEIRB())
Requires	NEIAB – Number of Elements Inside Actors' Boundaries NEIAgB – Number of Elements Inside Agents' Boundaries NEIPB – Number of Elements Inside Positions' Boundaries NEIRB – Number of Elements Inside Roles' Boundaries
Metric	NEIAg – Number of Elements Inside an Agent
Informal definition	Number of elements inside an agent’s boundary in the SR model
Formal definition	context Agent def:NEIAg():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Element)) -> size()
Metric	NEIP – Number of Elements Inside a Position
Informal definition	Number of elements inside a position’s boundary in the SR model
Formal definition	context Position def:NEIP():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Element)) -> size()
Metric	NEIR – Number of Elements Inside a Role
Informal definition	Number of elements inside a role’s boundary in the SR model
Formal definition	context Role def:NEIR():Integer = self.hasElement -> select(e:Element | e.oclIsKindOf(Element)) -> size ()

Q9) How specific are the actors?
Symptom	This model uses a significantly different percentage of specific actors, when compared to other models.
Potential problem	This may be a symptom of an insufficiently detailed system specification, or, conversely, an over-specified one which may be difficult to understand.
Suggested action	Consider scrutinising the types of actors used in the model and re-considering whether an actor should, or should not be defined using a specific type.
Metric	PSAct – Percentage of Specific Actors
Informal definition	Percentage of actors with a specific type (agent, position or role).
Formal definition	context ISTAR::PSAct() pre:self.NAct() > 0 context ISTAR def:PSAct():Double = (self.NAgents() + self.NRoles() + self.NPos()) / self.NAct ()
Requires	NAgents – Number of Agents NRoles – Number of Roles NPos – Number of Positions NAct – Number of Actors

Q10) How detailed are the goals?
Symptom	An actor's goal has an unusually low number of decompositions.
Potential problem	The goal may be under-decomposed.
Suggested action	This goal may be a good candidate for further scrutiny. Consider detailing this goal, if it is under-decomposed. If the actor has no outlier goals, their detail is probably well balanced.
Metric	PGWME – Percentage of Goals With Means-End
Informal definition	Percentage of goals with means-end link
Formal definition	context ISTAR::PGWME() pre:self.NGIAB () > 0 context ISTAR def:PGWME(): Double = self.NGWD() / self.NGIAB()
Requires	NGWD – Number of Goals With Decompositions NGIAB – Number of Goals Inside Actors' Boundaries

Q11) How detailed are the softgoals?
Symptom	An actor's softgoal has an unusually low number of decompositions.
Potential problem	The softgoal may be under-decomposed.
Suggested action	This softgoal may be a good candidate for further scrutiny. Consider detailing this softgoal, if it is under-decomposed. If the actor has no outlier softgoals, their detail is probably well balanced.
Metric	PSWC – Percentage of Softgoals With Contributions
Informal definition	Percentage of softgoals with contribution links
Formal definition	context ISTAR::PSWC() pre:self.NSIAB() > 0 context ISTAR def:PSWC():Double = self.NSWD() / self.NSIAB()
Requires	NSWD – Number of Softgoals With Decompositions NSIAB – Number of Softgoals Inside Actors' Boundaries

Q12) How detailed is the SR model with respect to its actors?
Symptom	The SR model has an unusually low percentage of actors with elements inside its boundary.
Potential problem	The actors specification may be over-simplistic.
Suggested action	Those actors may be good candidates for further scrutiny. Consider adding and/or detailing elements inside their boundaries. If the system has no outliers, the SR model is probably defined with the typical amount of details, with respect to the elements inside actors boundaries.
Metric	PAWEI – Percentage of Actors With Elements Inside
Informal definition	Percentage of actors with elements inside its boundary
Formal definition	context ISTAR::PAWEI() pre:self.NAct() > 0 context ISTAR def:PAWEI():Double = self.NAWEI() / self.NAct()
Requires	NAWEI – Number of Actors With Elements Inside NAct – Number of Actors

Q13) How close are we to end the assignment of responsibilities to an actor?
Symptom	The percentage of actors with unconnected elements inside their boundaries represents the percentage of actors with an incomplete specification.
Potential problem	The system specification will not be complete, which can lead to problems in its understandability. This may hamper the developers ability to faithfully implement the system according to the intention of the requirements engineer, because this intention is not documented with enough detail in the requirements model.
Suggested action	Consider completing the specification.
Metric	PAWOUEI – Percentage of Actors WithOut Unconnected Elements Inside
Informal definition	Percentage of actors without unconnected elements inside its boundary
Formal definition	context ISTAR def:PAWOUEI():Double = 1 - self.PAWUEI()
Requires	PAWUEI – Percentage of Actors With Unconnected Elements Inside

Q14) How close are we to end the assignment of links to the actors?
Symptom	The percentage of actors which are not connected to other elements in the system.
Potential problem	The system specification will not be complete, which can lead to problems in its understandability. In particular, the role of the actor in the system may become unclear. This may hamper the developers ability to faithfully implement the system according to the intention of the requirements engineer, because this intention is not documented with enough detail in the requirements model.
Suggested action	Consider completing the specification by creating the necessary associations between the actor and other model elements.
Metric	PAWDOA – Percentage of Actors With Dependencies Or Associations
Informal definition	Percentage of actors with dependency or association links
Formal definition	context ISTAR::PAWDOA() pre:NAct() > 0 context ISTAR def:PAWDOA():Double = self.NAWDOA() / self.NAct()
Requires	NAWDOA – Number of Actors With Dependencies Or Associations NAct – Number of Actors