Business Analyst UML Relationships Tutorial | Generalization | Use Case | Include | Extend Tutorial

so broadly you know use cases are also similar to that so we can come up with different type of use cases and still everybody could be right so there's nothing one of my top armed officers hey know it you know the fact that you know they have so many applications which are similar nature but which are designed differently like you take up an email application right so there's so many email applications and each one of them is different like you have yahoo alligator of G domain and there were completely different so the basic behavior is

the same you still have to you know check your emails and and you know respond to emails and all but you know the way they are designed or the way they look and all is different right so similarly use cases also could be you know different so that doesn't mean that you know only one is right and the rest of them are all wrong so having said that let's see how these relationships would improve the use case diagrams the first one is the generalization relationship okay we tend to use the generalization where you know you

have two or more use cases which has a significant common behavior right so there are two let's say use cases which are talking about functionalities to different functionalities but a lot of them is similar right so for example let's look at the example you have a registration process right now there are some variations of registration a local student can registration registered in office in University a foreign student has to register in the university and out-of-state student also has to register in the university right but broadly what are they doing they're restricting the use so now

if there are some ten or six steps in the registration process a lot of them are common across these three new spaces in those in that situation you know it doesn't make sense to repeat all six steps in three separate use cases okay we can what we can do is we can create a common version of it and creative parent useless okay it has all the common steps and then in the look in the in the child use cases you'll only specify the differences so you're not specifying all the details so you would say now

the primary flow for the parent use case would have these six steps but for local registration in primary flow you would say step one to five refer to ministration and step six units are right similarly for foreign registration you would say now step one to three in the for registration and four to eight you can list down out of state registration first step one to four refer to the registration use case step 506 you can this down here okay so that is how you know it will help you now the advantage of this is let's

say step two changes so of this requirement let's say the customer comes back and say you know I want this step to change you don't have to go and make the change at three places so you don't have to make it here so if you have used the generalization relationship you will make the change only at one place at this point okay so managing the changes would become much easier and and logically it makes sense you know all the registration related steps are in one single use case and then only the you know the the

deviations of the differences are powered in the child use cases right so it looks much more you know well organized and it would also increase the maintainability because any changes which comes in it's it's easier to identify and make a change at one single place rather than multiple places right so simple so that that would result in your reduction in effort as well so if you have made change to this only one single one it's a similarly the design and development and testing the effort will also be restricted to only this one single useless you

don't have to retest all these redesign we develop and we test all three use cases okay that's the net wonderful generalization so you've used the symbol a triangle and then finally the head and so this is a symbol which which you find a simple equation so what this generalization means is whatever is defined in the parent is by default applicable here for childishness over and above that you can add some some you know steps to this off or delete some steps from this or modify some steps over here all right so you can do all

that so basically you can override the behavior okay so that's what we are doing here we define anything six steps here and and six step number six I'm changing in the local administration and four five six I'm changing and I'm adding two additional step seven and eight then out of recession recession and just changing steps y-axis okay so that way you know the at least of common steps are referred from the from the salient use gates the second one is an include useless now there would be some functionality which could repeat across different use cases

now one way is like let's say there are there are four different use cases and let's say each one of them has ten steps one to ten steps get something each four of them has as ten steps okay and some piece of functionality let's say let's call like steps four to six are common and they're repeating one two three four cases this you know steps of four to six are repeating so you know right rather than write those four five six here four five six here four five six here and four five six here four

different places you could pull it out and then create a suffix use case for steps four to six right so some some common behavior if you have across unrelated use cases you would put that out and then include bullet you're just saying that you know what this is a common behavior it was for different use kisser so rather than explain it in all these fourth you are pulling it out and then for trading as a producer and then you'll just include it now the advantage is that you have one single source a year right so

this steps four to six you don't have to repeat it four different places so if this change one of these steps changes either four five or six changes you don't have to go and then make any changes at these four places you just come and make change only at this place increase your maintainability right so your impacts up at much lesser okay let's look at an example it becomes much easier in so we all use our online banking options right so our online banking system we have bank accounts we are meaning to there and if

you see some of those transactions would have a secondary authentication which means you'll have to authenticate yourself so maybe no the first time you login you when you login into the application you would have to enter your user ID password but sometimes you'd also be asked to either enter a security code which is sent to your mobile number or maybe you have a secondary password or maybe you ask to you know enter the you know some numbers of the get it values at the back of your car so some secondary authentication mechanism is in place

while because you know you want to add that extra layer of security okay so let's say you know we the process of secondary authentication is you will be send a security code to your mobile right and then you have to enter that into your online banking to confirm the products so you do so a security code is sent the customer would enter and then the system would validate and then proceed with the father's make so there are three steps right now the secondary authentication is used at multiple places so let's say when you want to

transfer any funds you have to enter that security for maybe you know whenever you are changing your password then you'll have to you know in terms of security for which is sent to your mobile whenever you want to add a new beneficiary you want to implement that the secondary authentication maybe you know if you are logging in from a new system also right so maybe if your IP address is new so you might also still want to have that secondary authentication also right so there could be multiple places where you could do a second vehicle

division so broadly that is a deposit okay now if I have to explain these steps at each and every part you might have to again do it multiple times let's have to do it three times three steps here three steps here three steps here restructure and there are if there are two more use cases which are using this I love to do that key right let's say you know this step two changes or step three changes let's say one of these steps change right after go and make changes one two three four five six requirement

six use cases are impacted okay so it it means a lot of changes so rather than do that if I if I pull out these three steps and create a separate use case I mean gas authentication of customer then say a security code would be sent as step primary step one step two you the user has to enter that foot and step three you validate the foot and confirm and then proceed further and so that's so authentication customer for useless now I can just tag it along with all those features which are which need secondary

authentication so if I want to change password I'll explain the we know the steps to change password so go to that page with password change option is there enter your old password new password and then confirm your new password then you click on the submit button and submit button you know you'd have to secondly Authenticator so you sent a security code you have to enter that value and then only if it's validated then you say that ok not password changed successfully ok so effectively you know in your primary flow you're removing these three steps and

saying you know refer to this authenticate customer use case for details about it all right so you have made your job a little more easier so every time you you you know you want to use this feature you just have to refer it in your wire use case they like you know these this authenticate customer like whatever it has like three requirements like three steps and like the change password uses these three steps but the transfer phones uses only two steps and how we will mention like you know what has to be included in this

and what has to be excluded only where the functionality which includes all these three steps then we can pull it up so I didn't pull up some functionality parent-child relationship will only work like if it works for everything so this should this should not be a parent child this is a include relationship parents Island is only for work generalization okay and include is very used where there is a common set of functionality and that you want to use it at multiple use cases you would pull that out and create a subject this this this use

case doesn't have the common behavior you cannot create an include really useless so this whole steps the three steps should be you know created in the same flow right so if you cannot say that only two steps would be used in transfer funds I would still infer that was I so logically look at it let's say if some common behavior is there so let's say only two steps are there then you know you should bring out only two steps and then put it as so look from a functional point of view only when you say

that okay no this behavior I think you know authentication of customer with a common process which is a cross so rather than repeat all steps at at each and every use yes I will pull it out and define it as a separate and include it with a can we say this like the first world they can you say it's like a one-to-many relation and this one is like many to one relation so you talking about generalization is something about like one-to-many include is like 181 could be yes so you're saying that there is a common

one and then that is leading to many use cases and here many use cases are linking to one right or or a different way you have to put it in a different way I would say you know generalization let's say you know there is a use case and let's say there are two use cases and a significant part of that is common right let's say 80% is gamma so this 80% you will define it as a parent useless right and and usually if you look at the child they're all related right so then you say

it's you know one is localisation for in this session out of specificity but the end of it it's all registration right so they're there they have something a lot of the functionality common among themselves right so broadly there are all the registration process right but in an include it's all unrelated features right changing a password or funds transfer has nothing in common except some minor thing which could be 10% of the functionality which is authenticating the customer it so there is nothing common between these you know these use cases which are including the common personality

but in case of generalization all the child use cases are related so you tend to have a more or less common name like you know registration in this case you have this tration for all these three processes right so so I would say you know a common behavior if it's if it's a significant part of it is common behavior like 7080 percent you will define a generalization let's say only a small part of the behavior is common so you have multiple use cases one let's say only this is common right which is like 10% right

so this 10% you will define as a use case and then include it as required right so here if 80% of 90% is common right so you define that as a pendant use case right which is common and then you would define the generalizations so if a small piece of functionality is repeating across unrelated use cases use an intruder small piece of functionality like authentication of customer small behavior is repeating across and related features like changing password here's the authentic in customer transferring the function of any customer adding a beneficiary year of indicated customer login

from a new system you are authenticated customer all unrelated features but you are using some common functionality so pull that out and define it as an improved and they're a significant part of that is coming like a local registration foreign registration and out of six state registration let's say there are six steps or six screams and out of that more or less most of them are common it's all close to four or five of them are common it's a three four five round four steps up are common among among this right so why do you

want to you know create rewrite all those steps all you can do is you can define a parent one which is a common behavior and then the child can have them the specifics the changes of modifications or new steps are they going to the same places so the third type of relationship is extends okay now when you're talking about some use case or some functionality right now there would be a lot of those what if conditions right so what if you know under special certain ditions some additional functionality could be related right like you have

a common set of behavior but under certain condition you have some additional features coming up right so that additional behavior which is relevant only in a particular scenario we will capture that using extend relationship okay so we will clearly specify the reason under this condition this additional steps would be would be defined event subtype useless and I'll explain this using a small example let's say I tell you to write the use case for receiving a phone call okay so what you will generally right you would say now okay now when a phone the phone should

ring first and then you should give a notification of who is calling first then you will accept the call in sick on the taxi button or swipe and then you will talk and then once the call is over in the car or disconnect okay those are the steps involving a friend car right but sometimes maybe when you are already talking you might receive a second puff so what options do you have you can either place this call on fold and then take that call or you can end this call and then take the additional car

or you can continue with the call and then ignore the other follows all right so you know when I talk and when I ask you about you know capturing the requirement about receiving a phone call you will just capture the basic steps you'll not say no in case an additional call comes in then you have to do these things in this useless right so because you know it will create a lot of confusion and a lot of unnecessary details in the for useless right my core requirement for receiving a phone call is you know show

the name of the person Colleen we were in notification accept the call talk and disconnect right so this four five steps are there but in some special cases under certain conditions like when somebody else cause you can take in a distant went all right so you can you can put it on hold and then taken a distant phone call or you could you know end a call and then continue with on the right but all that extended behavior is coming only in that some specific scenario where your current call has been where you are getting

a second call when you are talking on the on the first cop you get it you understand what extents mean so rather than put everything into the for base use case into the base use case you are creating those special conditions and special scenarios and then saying that this is an extended behavior should be relevant only when you get a second otherwise in the normal behavior for receiving a phone call Israelis captured in the base useless so just to avoid that confusion and given more clarity what you're saying that any additional special scenarios any resistance

step that needs to be done after body that primarily talks about the extents relationship right again now you know trying to figure out if you can identify any relationships and even if it's okay you don't even I will define relationship don't forcefully try to create relationships or purposefully no no try to create out of it for now but most restricted advantage only if they're you know coming out clearly saying that okay know what some behavior is repeating create an include if there is a lot of common behavior over a generalization right and then if some

special conditions are there and use and extents so that's how I would summarize use V so the way you would work is you would first the first step is define the use case diagram then okay I think I will talk about it later then once I introduce them to the rest of the human diagram support but broadly when you are creating your use cases the first step is you'll create a use case diagram tried not to identify the relationships at that point in time because you know you don't actually understand the details about the each

use case individually if you don't know how what are the steps involved in local registration of correlation so generally no first create the first draft of a use case diagram and then start you know capturing the details about each of those use cases in your discussions as and when you get more clarity then you can figure out I know what this is there is common behavior which can authenticate customer which I can put it and users in truth are all these registration process are actually the same which is the registration but with some minor tweaks

or have a generalization relationship right are of this particular use case has some special scenarios special conditions and and then it would have some additional extended steps which is called as extended behavior so in use an extent so here your relationships will be updated as and when the requirement detail you know you will start writing that use case now rate you and it becomes clear you know I can pull this out and that is produced so that's where you'll go and out of update your use case like so it's not like once you create a

use case diagram that's fine so most of the time you won't get the person final question of the use case diagram in the first first attempt it usually goes to some two or three iterations to arrive at that final use case time okay as I'm when your clarity emerges on each of those functionalities each of the use cases you tend to identify the relationships also and make it more meaningful okay now a lot of times what happens is you'll not get into your project which is starting right from the day one it won't be a

brand new project so it'll be you know taken as a business analyst support in some applications so there would be some fear for existing applications then you know what the client would do is they would assign a huge that you would hire one business understand and say you know any changes coming into the system you will have to maintain that so that would be your responsibility as a business so you are not actually having those you know VR the sorry the RFP and then we are creating a VR geography do you think it's only when

a new project you're working on a new project then a BRD would be stupid otherwise most of your requirements are captured you should change the first okay so you know you in that kind of situations you don't really create a you know use case diagrams it's a useless diagram we can't be relevant because no you're not having all the detail departments from scratch all you'll have to do is there is an existing system and you are expected to make changes to that existing okay so first you have to understand how the current feature of functionality

is and what is the change that the business user is this thing right so all that you capture as part of the description of change now this can be very elaborate it will not be like one two lines right so you could even know actually you add in those screenshots and they say you know this is how your initial screen was a lot of times what you do is you know we have we have a system in place right so let's say there are some multiple screens in it so let's keep it simple there are

only four states of some four features and for screen six now the customer would come and then say you know what this requirement to it currently has only these three for details right now I want to capture some additional details add in this three additional details so it would be as simple as that right so you know you you have to capture all these details as part of the change request so the customer would give you that these are the details and then you know you'll have to elaborate it further so you would say now

this my current screen looks like this there are four details captured here right now you have to add this additional three fields here and so you exactly call that out right so say this is the screen current screen current state then another future state has to be so there would involve so be these four things then you're adding three additional pins into this right and make this as mandatory right and perform some checks like you know this should be a valid date format and this should be a number so all those you know details you've

captured as part of the requirement okay so effectively yep yep your requirement the changes which are coming in is are very simple all you have to do is understand the current system say that this is how the current state is now the current screen looks like this and this is the change that we need to make and after change this is how the screens of the trick very simple thing you don't even need news cases or anything it's just that you have to be very clear about the requirement you have to ask all those eyes

questions it in their education process and convert that screen to this thing right typically if you're you know hired into a support kind of projects you will be working on change requests and this is the only thing that we'll be doing right so you won't be creating those use case diagrams and getting into the complex things it's quite simple that way okay so that description of change would be captured here then you have to give a justification usually this and you tell you why these changes require what is the benefit you get okay and what

all functionality is is related to right so if you have to figure out you know does this have any impact on existing functionality you'd have to clearly mention that and what is the estimated time and cost complete okay is there any process change and is standard operating procedures have to be changed any documentation or process changes have to be mentioned all that you know you have to miss down there or here okay then you know you'll also give an estimation so this would again you might provide the analysis apart and then reporting and development if

what would be given by the architect right you will basically take the number of our shouldn't take the billing rate and then finally get the dollar amount okay so then finally you send it to the approval manager right so for is a the SME or the project sponsor or the solution owner they would take the decisions of whether it's approved or rejected and they will specify the reasons and finally it would be approved by the ITT and implemented right so that is a process of a change request change requests are much simpler and your overall

PRD okay so all you have to do is you know you'll you'll have to explain the change what this is a current way it's working and this is the future change that will up in it or adding this additional feature into this particular screen that is exactly what we love to do in a change clear about this so this is much simpler compared to the BRD process where you are doing in to end project okay so a lot of times you'll just be managing this change of course there won't be any project planning phase and

so there won't be any detailed project plan prepared a lot right you just feel you know getting some spine of it and change requests which will typically be in like one week or two weeks or you know at the maximum time is right now the challenge is we love in your work case you have to understand the current state how the application works you have to understand the requirement and then suggest how it would be looking in the future state you have to identify the dependencies if they're in any other functionality depend on that you

love to mr. down and all the tunnel analysis has to be done by you and then finally updated into the change request so more or less you know broadly the change request would be of the same format right so you would have some additional details in in most of the cases you'll capture the project name the sponsor right who has completed the change request is a semi when was it coming in and what is a number project manager ID okay then what type of change it is whether it's business change you know this is because

of some this defect that you are trying to correct we sit another girl to the department which is coming in right what is a priority of it right so it says if they will define it also if it's critical means this is definitely required if this is not there then you cannot use the system right so you if it ties means you definitely need it but I can work with the company normal means I would want it maybe in the new release next series right and low is like it's not impacting my work anyway but

I would want that future right so the the assembly would give this classification then they will identify what are the benefits along with a semi right and are there any alternatives or different ways in which you can now you know which you can meet this requirement right so sometimes there could be some two three so these two three ways of implementing the solution make sure missed on all those all alternatives right and then you look at the impact of the change on to the overall system right and then what are all the other impact rate

constant is deliver it is okay you'll identify the cost the schedule you need additional days will be acquired right for the people who would require for this change overall you dis down the summary and then finally the the you know the change Advisory Board of change Control Board would take the decisions and so you will have to get that authorization clearly right and then you'll track the change request so I didn't leave it when you start capturing the details it will be in change they first opened and once it has been approved by the authorized

or authorized board will be change it to approve or if they rejected you change it to rejected and once it's implemented you close it right or if you have put it on hold and you wanted to review at a later date you right so you know Bradley you know the the template would be more or less similar except for some additional details which was coming if you look at it more or less that will be the format of the change request your description then any additional documentation you know screenshots benefits what is the solution that

they're providing what is the impact of that change okay and then you also identify the posit a stand time lines and then what is your recommendation okay and then what is the dish then taken all that would be captured as father you have seen very first something yeah are you cleared now about how your your requirements would be captured and how would generally be documented so we still have to cover the BRD what generally goes into a VAD and what are the details about that so I cover about BRD in the next session and we'll

also spend some time on these the rest of the UML diagrams right so class diagrams diagram and the rest of them but it's not important you can comfortably ignore those that session it's not important what is important is you know how do you document your requirement primarily into a BRD using use case diagrams or change request which I've just explained you it's much simpler than you change the first to capture the current state and then what are the changes suggested and how does your future screen switch right okay then you capture the business then it's

the cost the timelines and then memorization taken all that would be captured as part of it see our changes it's a tomorrow whole session will learn about non-functional requirements what else goes into a be added right so if you are in your you're involved in a full-fledged project you tend to create a PID you're just supporting an application existing application and you know taking up my the question though those would come in as change requests right so the change management process for kicking and then you'll capture the requirements in that change request forms so which

would generally not be using the use case models it the mostly would use those screenshots of how your screen would look like and then maybe you know a process flow or flow chart diagrams all that could be used to explain the change request calculator for change requests so see analysis side I mean let's say you know you love to analyze the requirement understanding system so that part you might you might provide right so you say no I would require some to three days to understand the requirement and then you know create this case right so

a lot of it you'll gain into experience you couldn't feel that estimate by looking at the department level Department and understand based on your understanding of the existing application and then the request family you could decide that okay and the development and you know design development and testing effort would be given by the technical level so you're not expected to identify that out of there so generally you know or most of the times what happens is the way that efforts are calculated is this way right so broadly first the development and coding and unit testing

effort is calculation okay so so there are some methods estimation methodologies like you know function point analysis simple medium complex there are multiple methodologies which are used to calculate their foot right so so usually this using these methods will calculate the development and unit testing effort design development engineer we call that as a diecut effort design od testing so that's a term which isn't really wish and once you have that negative word so typically that would be around 40% of your effort let's say this this effort first around 40 days right so they would extrapolate

it parted for you know 40 days is 40 percent of the effort 100% of it would be hundred days so the overall time when 300 days and requirement would be around 25% of 20 to 25% depending on the complexity of the department similarly testing also would be around 30 to 35% and find me all your the implementation and funding and all that would take around five percent days so this is how the broadly the efforts are distributed so sometimes you'll not be able you you're not expected to do the requirement related effort also right so

they would extrapolate it from the big data for each other in a way by using some of these methodologies okay so if we given that okay now since the development takes 40 days you put the caps of the requirement in front you can try this but that is the logic which is used meet again tomorrow and tomorrow's session will discuss about the business requirements top of the ID how do we how is the typical be a distraction okay so yeah so let me recap we learned about use key relationships today we learnt about the change

requests and how do we capture the request changes coming right so be clear with these two topics I just want to make sure that you understand the topics for this hour daily and and up when to pay for those whatever is important than 28 hours so be clear about those are on use case overview and and I'll ask questions about what is the use case and then you know explain use case diagram use case description and even to an extend relation chips okay and then you also have to be very clear about the changes how

would you handle the change requests what are details of our new