下载文档原格式
UML建模分析与设计_洛阳师范学院中国大学mooc课后章节答案期末考试题库2023年1.一个正确的状态机图中的选择节点不同分支上的监护条件应该覆盖所有情况。
答案:正确2.下列选项中不属于通信图与顺序图的共同点的是（）。
答案:对象表示相同，都可以显式地体现出对象的生命周期3.节点就是一台计算机答案:错误4.组件是系统工作产品的一部分，因此exe文件是一个组件，而程序的源文件不能作为一个组件。
答案:错误5.下列选项中，不属于组件图的元素的是（）。
答案:用例6.假设在某个状态的内部的一行内容表示为“ eventA/ defer”，则这行内容所表示的是( )答案:可推迟事件7.组件与其提供的接口之间构成依赖关系。
答案:错误8.下列建模需求中，适合使用活动图来完成的是（）。
答案:对业务流程建模9.（）技术是将一个活动图的活动状态进行分组，每一组表示一个特定的类、人或部门，它们负责完成组内的活动。
答案:泳道10.活动图可以像流程图一样表达出顺序、分支及循环控制结构，但语义要比流程图丰富得多。
答案:正确11.包中可见性修饰为 public的元素表示这些元素可以被项目中的所有包无条件地访问。
答案:错误12.参与者位于系统边界外，并不是系统的一部分。
答案:正确13.用例描述中的前置条件与后置条件分别指的是用例执行前和执行后系统与参与者所处的状态。
答案:正确14.节点就是一台计算机。
答案:错误15.迭代过程指的是在某一个工作流中重复执行工作。
答案:错误16.“4+1”架构中的开发视图将四个视图结合为一个整体。
答案:错误17.在状态机图中，转换就是对象在两种状态之间的时空下发生的有意义的事情。
答案:正确18.在组件图中，将系统中可重用的模块封装成可替换的物理单元的是（）。
答案:组件19.组件图主要描述的问题是（）。
答案:系统中组件与组件之间、定义的类或接口与组件之间的关系20.对于组件图中的接口，下列说法正确的是（）。
论证与测试+⽤EA画uml论证与测试，谁才是真正的不⼆法门第⼗三次作业的时候，我们开始使⽤Junit对代码进⾏测试，主要是测试代码的覆盖率，以及分⽀的覆盖率。
（主要是检查JSF写的是否是符合规范，……）。
这⾥我给出我测试的结果，可以看出测试的结果还不是很理想的，是因为在Override中，测试代码的覆盖率没有达到100%。
这是为什么呢？在我的测试运⾏之后，我的代码显⽰的是全部都允许了。
问题是，在我们看来确实是每⼀步都执⾏了，但是实际上是这样吗？当然不是，否则我的覆盖率为什么回事99%，⽽不是100%呢？这说明有些部分代码看起来执⾏了，但是实际上并没有。
那么测试代码给我带来了什么呢？对于我的代码来说，当我尽可能的考虑所有情况的时候，还是有⼀段代码没有执⾏，这是说明我那⼀段代码本⾝就是多余的。
可能有设计上的问题，这种问题常会出现在这种情况下，那就是在之前我们以及限制了变量的范围，但是在接下来的代码中，还是习惯性的多写⼀个else，所以根本不可能出现的情况在else⾥⾯出现了，这就导致了代码的多余。
测试的功能远不⽌这些，对于程序来说，虽然⽤户是最好的测试，但是不可能将还没有完全完善的程序给⽤户拿去测试，所以⼤规模的⾃测是对程序的保证。
那么论证⼜有什么⽤呢？个⼈感觉其实没多⼤⽤，但是结合测试的时候我发现，只有测试的话，我们往往能过发现问题在哪？测试者怎样去发现问题呢？感觉这就与论证有关了，如果⼀个程序怎么都测不出来bug，那么问题可能有两种，⼀是程序本⾝就没有bug，但是也有可能是测试的不完备，导致没有发现bug。
如何快速的读懂代码，然后发现问题，最后进⾏测试呢？论证⽂档不是写给⾃⼰看的，是写给别⼈看的。
所以通过论证⽂档理解程序的框架，以及发现问题的所在是最快の⽅法。
论证⽂档给出了编程者⾃⼰的思想以及每⼀个⽅法的实现，但是⼜与代码有多区别，代码难以直观的反应出程序的构架以及实现⽅法。
所以论证与测试都不是不⼆法门，只有将其结合起来才是王道。
电子科技大学uml期末考试题B卷答案电子科技大学考卷（B卷）11（执行者（Actor）与用例之间的关系是（）（A）包含关系（B）泛化关系（C）关联关系（D）扩展关系考试时间年月日（120分钟）课程UML12（在类图中，下面哪个符号表示继承关系（）⑷（B）（0 （D）教师签名_请将答案填写在答题纸上〜不要在考卷上作答〜13（在类图中，“ 表示的可见性是（）(A)Public (B)Protected (C)Private (D)Package 一、单选题(每小题只有一个正确选项，每小题2分，共30分）14（下面那个类图的表示是正确的（）1（下面哪个符号代表包图（）⑷(B) (0 (D)⑷(0 (D)⑻Student Student Student Studentname : String Name : String getName ()age : Age: intinteger getAge （） 2（在UML协作图中，有多少种关联角色的构造型（）Integer (A) 1 (B) 3 (C) 5 (D) 7 getName ()getAge 0 3（在类图中，哪种关系表达总体与局部的关系（）（A）泛化⑻实现（C）依赖（D）聚合15（下面哪个符号代表部署图的节点（）4（在类图中，“表示的可见性是(A) (B) (C) (D) (A)Public (B)Protected (C)Private (D)Package5（下面哪个符号表示注释（）⑷(B) (C) (D)二.多选题（每小题有一个或多个选项，每小题2分，共10分）1（下面哪些图形可以清楚地表达并发行为（）（A）类图（B）状态体（C）活动图（D）顺序图6（生命线是UML视图中哪个图形的组成部分（）2（下面哪些元素构成了组件图形（）（A）类图（B）状态图（C）活动图（D）顺序（A）组件（B）转换（C）关系（D）接口 7（在类图中，那种关系表达总体与局部的关系（）3（部署图中的节点具有以下哪些方面的内容（）（A）泛化⑻实现（C）依赖（D）聚合（A）计算能力（B）基本内存（C）位置（D）接口 8（下面哪个图形代表活动（） 4（顺序图的用途包括（）（A）（B）（0 （D）（A）显示并发进程和激活（B）当不同的类之间存在多个简短的方法时，描述控制流的整体序列（0显示在协作图中难于描述的事件序列9（下面哪个UML视图是描述一个对象的生命周期的（）（D）显示涉及类交互而与对象无关的一般形式⑷类图（B）状态图（C）协作图（D）顺序图5（常见的UML工具有哪些，（）(A), ational Rose (B)Power Designer (C)Visio (D)Visual UML 10(下面哪个视图属于UML 语言的交互图（）（A）行为图（B）状态图（C）实现图（D）顺序图姓名姓名专业名称, 专业名称, 班号, >>>>>> 学号八 > > 班号»>>>>>>学号八八，，教学中心，，教学中心.密密封 线三.填空题(每空2分，共30分)题号1 2 3 4 51. UML 中有多种关系，请标出图示是哪种关系：CD ACD ABC ABCD 答案ABCD 0. . 1 0. • *三.填空题(每空 2 分，共 30 分)(，)(,)employer employee 1.答 案:依赖关联聚合组合泛化实现(,)C) 2. (5) (6)答案：(1)F (2)B (3)C (4)E (5)C (6)E 3( 2. UML 提供了一系列的图支持面向对象的分析与设计，其中(1)—给出系统的静态设计视图；答案：(1)B ⑵A (3)D _(2)—对系统的 行为进行组织和建模是非常®要的;—(3)—和—(4)—都是描述系统动态视 图的交互图，其中—(5)—描述了以时间顺序组织的对象之间的交互活动,(6)—强调收发消息的对象的组织结构。
uml相关的名词解释UML（统一建模语言）相关名词解释简介：在软件工程中，统一建模语言（UML）是一种标准化的、通用的建模语言，用于描述和构建软件系统。
被广泛应用于软件开发过程中的需求分析、系统设计、代码生成等环节，UML具备描述问题领域、定义软件结构和行为的能力，以及促进开发者之间的交流和沟通。
本文将对与UML相关的一些关键名词进行解释与阐述。
1. 用例图（Use Case Diagram）用例图是UML中最常用的图形之一，用于描述系统与用户之间的交互。
用例图通过显示系统的功能和角色之间的关系，来帮助开发者理解和定义系统的需求。
用例图中的参与者代表系统的用户、外部组织或其他系统，而用例则代表系统的功能或交互场景。
用例图可以帮助团队更好地理解系统的需求，从而指导系统的设计和开发过程。
2. 类图（Class Diagram）类图是用于描述系统中的类、接口、关系和结构的图形化工具。
在类图中，类被表示为矩形框，类之间的关系以及类的属性和方法则通过箭头连接来表示。
类图可以帮助开发者理解、设计和组织系统中的类与对象之间的结构关系，从而更好地进行系统设计和编码。
3. 时序图（Sequence Diagram）时序图用于描述对象之间的交互，尤其是强调交互的顺序和时序逻辑。
时序图中的对象以及它们之间的消息传递被表示为垂直的时间轴和消息顺序。
时序图可以帮助开发者理解和描述系统中对象之间的交互过程，以及时间上的先后关系。
4. 活动图（Activity Diagram）活动图用于描述系统中的行为和流程，强调系统中的活动和动作。
活动图以节点和边的形式描述活动的流程和顺序，用于展示系统中各个活动之间的流转和控制。
活动图可以帮助开发者分析和设计系统中的流程，以及理解系统的行为逻辑。
5. 组件图（Component Diagram）组件图用于描述系统的组件和它们之间的关系，关注系统的组织结构和组件之间的依赖关系。
在组件图中，组件被表示为矩形框，组件之间的关系以及组件的接口则使用箭头表示。
UML用例图中包含(include)、扩展(extend)和泛化(generalization个性：都是从现有的用例中抽取出公共的那部分信息，作为一个单独的用例，然后通后过不同的办法来重用这个公共的用例，以削减模型维护的工作量。
1、包含(ilude) 包含关系：用法包含（Inclusion）用例来封装一组跨越多个用例的相像动作（行为片断），以便多个基（Base）用例复用。
基用例控制与包含用例的关系，以及被包含用例的大事流是否会插入到基用例的大事流中。
基用例可以依靠包含用例执行的结果，但是双方都不能拜访对方的属性。
包含关系对典型的应用就是复用，也就是定义中说的情景。
但是有时当某用例的大事流过于复杂时，为了简化用例的描述，我们也可以把某一段大事流抽象成为一个被包含的用例；相反，用例划分太细时，也可以抽象出一个基用例，来包含这些细颗粒的用例。
这种状况类似于在过程设计语言中，将程序的某一段算法封装成一个子过程，然后再从主程序中调用这一子过程。
例如：业务中，总是存在着维护某某信息的功能，假如将它作为一个用例，那新建、编辑以及修改都要在用例详述中描述，过于复杂；假如分成新建用例、编辑用例和删除用例，则划分太细。
这时包含关系可以用来理清关系。
对于一个扩展用例，可以在基用例上有几个扩展点。
例如，系统中允许用户对查询的结果举行导出、打印。
对于查询而言，能不能导出、打印查询都是一样的，导出、打印是不行见的。
导入、打印和查询相对自立，而且为查询添加了新行为。
因此可以采纳扩展关系来描述： 4、泛化(generalization) 泛化关系：子用例和父用例相像，但表现出更特殊的行为；子用例将继承父用例的全部结构、行为和关系。
子用例可以用法父用例的一段行为，也可以重载它。
父用例通常是抽象的。
在实际应用中很少用法泛化关系，子用例中的特别行为都可以作为父用例中的备选流存在。
例如，业务中可能存在许多需要部门领导审批的事情，但是领导审批的流程是很相像的，这时可以做成泛化关系表示：上面是我参考的一篇文章，觉得将三种第1页共2页。
VP-UML Quick StartLast update: June 18, 2012Table of ContentsTable of Contents (2)Getting Started (3)Installing Visual Paradigm for UML (VP-UML) (3)Starting VP-UML (3)Selecting Workspace (4)Importing License Key (4)Environment (5)Saving and Opening Projects (5)Diagramming (7)Creating Diagram (7)Creating and Connecting Shapes (7)Documenting Model Elements (8)Setting Color, Line and Font Styles for Shapes (9)UML Modeling (10)Drawing Use Case Diagrams (10)Documenting Use Case Flow of Events (10)Building Glossary (11)Drawing Sequence Diagram (12)Drawing Activity Diagram (13)Drawing Class Diagram (14)SysML Modeling (16)Drawing Block Definition Diagram (16)Drawing Internal Block Diagram (17)Code Generation (18)Java Round-Trip (18)C++ Round-Trip (18)Instant Generator (18)Instant Reverse (19)Instant Reverse Java Code to Sequence Diagram (19)Reporting (20)Using Report Composer (20)Project Publisher (21)Modeling Collaboratively and Concurrently (23)Share Design with Visual Paradigm Teamwork Server (23)Checkout and Open Project (24)Commit (24)Update (25)File Referencing with Teamwork Support (26)Advanced Modeling (28)Using Nicknamer (28)Project Referencing (29)Impact Analysis with Matrix (31)Getting StartedInstalling Visual Paradigm for UML (VP-UML)1.Run the VP-UML installer after your download it.2.Click Next on the welcome page. This will bring you to the License Agreement page.3.Read through the license agreement. Choose I accept the agreement after you finish reading theagreement and fully understand and accept the terms. Click Next.4.Specify the directory for installing VP-UML. Click Next to continue.5.Select the location for the start menu folder, under which you will find the program’s shortcut. Click Next.6.Decide on whether to enable your system to recognize .vpp project files and .zvpl key files. If enabled, youwill be able to open the file in the appropriate application directly by double clicking it. Keep both .vpp and .zvpl associations checked and click Next.7.Select the edition of VP-UML you want to install. Click Next to start the file copying.8.Once the file copying is finished, you can choose to start VP-UML immediately, or just finish theinstallation without starting VP-UML. Choose the option Don't Start and click Finish. This will end theinstallation of VP-UML.Starting VP-UMLStart VP-UML from the shortcut in the Start menu. If you selected not to create an entry in the Start menu (during the installation), you can look under the installation folder of VP-UML (the same path specified in step 4 in the section above) and start VP-UML by running the launcher in the launcher folder.Selecting WorkspaceWhen you start VP-UML, you need to specify a folder for workspace. A workspace is a folder in which application preferences, like the look-and-feel settings, are stored.You need to select a workspace every time you start VP-UML but the workspace selected need not always be the same. If you want to keep applying the same set of preferences, always start VP-UML with the same workspace folder. If you are moving to a new machine and want to keep the application preferences, simply copy the workspace folder over and choose it as workspace when starting VP-UML on the new machine. If you want a fresh working environment, select a new folder and proceed. Now, select any folder you like and click OK to continue. In this guide, we will choose C:\Visual Paradigm\vpworkspace as the workspace folder.Importing License KeyAfter you select a workspace, the Key Manager will open, asking you for a valid key to 'unlock' VP-UML. Depending on whether you own a purchased copy or an evaluation copy of VP-UML, you can get the key by following the steps below:For CustomersIf you purchased a copy of VP-UML, you should receive our notification (Email) with an activation code. The same activation code can also be found from the license key listed in your customer account. Copy the activation code.Click on Input activation code and paste the copied activation code in the dialog box.For EvaluatorsFor evaluation copy of VP-UML, you can click either Try without key or Request key. Choosing Try without key enables you to evaluate VP-UML for 10 days. To evaluate for 30 days instead, choose Request key and sign in. If you are not our member yet, fill the Registration form to register. After you sign in and make a request, you will receive the key file via email.EnvironmentNo. Name DescriptionSaving and Opening ProjectsTo save your work, select either File > Save Project or File > Save Project as…. When you are saving a project for the first time, you will be asked to specify the location. You can save the new project either in your currentworkspace or a directory of your choice.To open an existing project, select File > Open Project… from the main menu and select the project to open.DiagrammingThis section will go through the steps of creating diagrams, creating entities and connecting them. In addition, you will learn how to document entities and make diagrams more readable by using different colors in entities. Creating DiagramLet’s c reate your first diagram in VP-UML. To create a diagram (e.g. a use case diagram):1.Right-click on the Use Case Diagram node in the Diagram Navigator.2.Select New Use Case Diagram from the popup menu.3. A blank use case diagram is created. You can give the diagram a name in the text box at the top left cornerof the diagram. Name the diagram Sales Order System.Creating and Connecting ShapesYou can create shapes either through the Diagram Toolbar (which appears to the left of the diagram) or the Resource-centric Interface. Let’s create an actor from the Diagram Toolbar for now.1.Select Actor from the Diagram Toolbar.2.Click on the diagram to create an actor. Name the actor Customer and press Enter to confirm editing.If you move your mouse pointer over a shape, you will see a number of resource icons surrounding the shape. From that shape, those icons help you create the next new shape (with connector) or create a connector to an existing shape. Let’s create a use case from the actor above.1.Place your mouse pointer over the actor shape we’ve just created.2.Press on the resource icon Association -> Use Case and drag to the right.3.Release the mouse button. Name the use case Place Order. This will create a use case that associates withthe Customer actor.Documenting Model ElementsGenerally speaking, naming model elements alone would not suffice to describe their details. To elaborate, you can enter additional details in the Documentation Pane. Simply go to the diagram and select the shape you want to document. At the bottom left of the application, open the Documentation Pane and fill in the details.In addition to textual description, voice recording is also available. If your machine supports microphone usage, click the Record button at the bottom of the Documentation Pane. In the Record Voice window, click the red circle button to start recording. To stop, click the button with a square inside. To save your recording, click OK.Setting Color, Line and Font Styles for ShapesYou can make your design more readable by formatting shapes differently, based on their natures. Let’s change the color for the use case shape.1.Right click on the use case shape and select Styles and Formatting > Formats… from the popup menu.2.Open the Background tab in the Formats window. Select Green for color. Click OK to confirm thechange.The use case turns green.UML ModelingDrawing Use Case DiagramsA use case diagram is used to model and identify the functional requirements of a software system. In a use case diagram, all stakeholders and system goals are identified to elaborate how the system is formed. The main elements of a use case diagram include actor, use case and association (communication link).An actor is any person or external system that interacts with the system to achieve a user goal (i.e. use case). The following simple use case diagram illustrates the use cases of a sales order system. Customer , an actor, interacts with the system to accomplish the goal of order placement, as modeled by the use case Place Order . There are other goals that the customer wants to accomplish, such as Request Refund and Cancel Order .Now, apply the diagramming techniques described in the previous section to draw the diagram. You can drag the resize handler surrounding a shape to resize it. To reshape a connector, press on it and drag around to produce and move a pivot point (which appears as a bubble).Documenting Use Case Flow of Events [Professional Edition or above]A use case’s name tells us the 'what' aspect of a use case – what the users need. Meanwhile, the flow of eventsshows the 'how' aspect of a use case by explaining how a user ’s goal can be achieved. It is a technique for analyzing interaction between the actor and the system in accomplishing a use case. To work with the flow of events editor:1. Right-click on a use case (e.g. Place Order ) and select Open Use Case Details… from the popup menu.2. Open the Flow of Events tab.3. Enter the steps involved in accomplishing the Place Order use case.Tips:- Create a new step by pressing Enter .- Set a step as sub-step by pressing Tab .- Add and declare a step responded by the systemby clicking and selecting System Responsefrom the popup menu.- Make use of the formatting functions (e.g. bold,italic, etc) to format text. 4. At the bottom of the editor you can find the Extension section. An extension represents a variation of theuse case being extended. The variation may be triggered when walking through the main flow, undercertain conditions. L et’s assume the place order use case is capable in handling rush order. Right click on step 5 where a user proceeds with buying. Select Add Extension from the popup menu.5.Fill in the steps required for handling rush order.Building Glossary [Modeler Edition or above] A glossary is a place where domain-specific vocabularies are stored and managed. And you can build a glossary by identifying terms in a flow of events.1.Suppose rush order is a key phrase that requires definition. Highlight it in the flow of events, right-click toselect Add “rush order” to Glossary from the pop-up menu to make it a term.2.This opens a glossary with the term online system homepage added. Right-click on the term to select OpenTerm Editor from the pop-up menu.3.Specify its alias. In the Term Editor, click Add and enter urgent order. Add also quick order as alias.Enter the term’s definition in the Definition section below.A sequence diagram is used primarily to show interactions between objects that are represented as lifelines in a sequential order. More importantly, lifelines show all of their interaction points with other objects in events. A sequence diagram can be created by right-clicking Sequence Diagram in the Diagram Navigator and then selecting New Sequence Diagram from the pop-up menu. Alternatively, you can create a sequence diagram as a sub-diagram of a use case to model the interaction of that use case. Let’s s ee how that works.1.Move the mouse pointer over the use case Cancel Order.2.Click on the tiny resource icon (Sub Diagrams) at bottom right and select Add > UML Diagrams >Sequence Diagram from the popup menu.3.The actor Customer is created automatically. Le t’s model the interaction of how customer can cancel anorder. Move the mouse pointer over the actor. Press on the Message -> LifeLine resource and drag it out.4.Release the mouse button. Name the lifeline System, and the message login.plete the interaction by adding other messages and the Order lifeline.An activity diagram is essentially a flowchart, showing flow of control from one activity to another. Unlike a traditional flowchart, it can model the dynamic aspects of a system because it involves modeling the sequential steps in a computational process. Let’s make use of activity diagram to model the registration process.1.Create an activity diagram via the Diagram Navigator. Name the diagram Register.2.Select Initial Node from the Diagram Toolbar. Click on the diagram to create an initial node, whichrepresents the beginning of a flow.3.Press on the initial node’s resource icon Control Flow -> Action and drag it. Release the mouse button tocreate an action and name it Click [Register]. This is the first action of the flow.plete the rest of the flow as shown below. The diamond shape is a decision node which leads to twopossible subsequent flows.5.You can use a swimlane to group actions by participant. Select Horizontal Swimlane from the DiagramToolbar and click on the diagram to create one. Double-click on the header of the partitions to name them.Drag the actions and other flow elements into the partitions appropriately.A class diagram models the blueprints of objects required by a system and the relationships between them. Let’s make use of class diagram to model the domain classes of the order processing system.1.Create a class diagram via the Diagram Navigator. When the diagram is created, you are prompted toenter the package header. A package will be created with the entered string as name. The class diagram and the classes in the diagram will all be contained by the package. Enter myapp. the diagram Domain Model.3.Select Class from the Diagram Toolbar and click on the diagram to create a class. Name the classPayment.4.Add attributes to the class. Right click on the class and select Add > Attribute from the popup menu.Name it date : Date (The text after colon stands for attribute type).You can create as many attributes as you need by pressing Enter after inputting a new entry. Add two more attributes: total : double and remarks : String.5.Add an operation by right clicking on the class and selecting Add > Operation from the popup menu.Name it printPaymentDetails() : void.6.Generalization is a kind of relationship that models the “a-kind-of” relationship among two classes. Movethe mouse over the Payment class, press on its resource icon Generalization -> Class and then drag it out.7.Release the mouse button to create the sub-class. Name it CreditCardPayment. Create another sub-classChequePayment from Payment class.8.Add attributes to the sub-classes.9. A class can be associated with another class. Create a class Customer. Move the mouse pointer over it anddrag out the resource icon Association -> Class. Release the mouse button and name the new class Order.10.To edit an association, double-click on it to open the Association Editor. Enter a name for the role of theassociation in the middle text box and adjust properties like multiplicity and navigability as needed.plete the diagram by creating other classes and relating them.SysML ModelingSysML, short for Systems Modeling Language, is a visual modeling language. SysML extends a subset of UML, making the language more software centric, catering the modeling needs for specifying, analyzing, designing, verifying and validating systems.Drawing Block Definition DiagramBlock is one of the main notations in SysML. A block describes a composition of a system. Block definition diagram, composed of blocks, describes the system hierarchy, component classification, specification and inter-connections.1.Let’s model the parts of a cool mist humidifier in this section. We will go back to QuickStart.vpp in thenext section. Create a new project. You can create a new project by selecting File > New Project from the main menu.2.Create a block definition diagram via the Diagram Navigator. Name the diagram Cool Mist Humidifier.3.Select Block in the Diagram Toolbar and click on the diagram to create a block. Name it Cool MistHumidifier.4. A cool humidifier consists of two main parts. The upper part is the water tank and the lower part is thebase. To model this, move the mouse pointer over Cool Mist Humidifier and drag out the resource iconPart Association -> Block. Release the mouse button and name the new block Water Tank. Create another part and name it Base.5.Water tank composes of a handle and a spring valve, while the base composes of a fan and a switch knobcontrolling the fan speed. Add the blocks and connect them with part association.Drawing Internal Block DiagramInternal Block Diagram describes the internal structure of a block in terms of properties and connectors between properties. We are going to draw an internal block diagram to describe the internal structure of a cool mist humidifier. Instead of including every little parts of a humidifier, we will just model a partial view that focuses on the parts that control the state and fan speed. The other parts will be omitted.1.To describe the internal structure of the cool mist humidifier, right click on the Cool Mist Humidifier blockin block diagram and select Sub Diagrams > SysML > Internal Block Diagram > Create Internal Block Diagram from the popup menu.2.We want to focus on the base of the cool mist humidifier, which controls the state of humidifier as well asthe amount of mist produced. Create a part for base. Select Part Property in diagram toolbar and click on the diagram. When you do this, you are prompted to select the type of block. Check Base and click OK. the part base.4.Fan and switch knob are both parts of a base. Move the mouse pointer over the base property and click onthe resource New Part Property to create a part property that is contained by base.5.When you are asked to select a block as property type, select Fan and confirm. Name the property fan.6.Create another property named sk, with Switch Knob as type.7.Switch knob controls the fan speed. To represent this, move the mouse pointer over sk : Switch Knob. Dragout the resource icon Connector > Part Property and release the mouse button on fan : Fan.8.Select Item Flow in diagram toolbar. Click at the connector between sk : Switch Knob and fan : Fan. Namethe item flow signal.Code GenerationJava Round-Trip [Standard Edition or above]Round-trip engineering enables you to keep class model and source code in-sync. With Java round-trip, you can reverse a code-base to VP-UML as class model, analyze, and make changes such as adding missing classes, and then updating the changes to code, or vice versa.To generate Java source code from class model, select Tools > Code Engineering > Java Round-trip > Generate Code… from the main menu. Enter the output path in the Generate code window and click OK to generate.To reverse engineer a class from code, select Tools > Code Engineering > Java Round-trip > Reverse Code…from the main menu. The Reverse Code window will pop up asking you to select a source file path. Click OK to reverse.C++ Round-Trip [Standard Edition or above]To generate C++ for the whole project, click Tools > Code Engineering > C++ Round-trip > Generate Code…from the main menu. The Generate Code window will pop up asking you to select a path, click the + button to add a path. After selecting one, click OK to generate.To reverse class model from code, select Tools > Code Engineering > C++ Round-trip > Reverse Code… from the main menu. Select a source file path in the Reverse Code window and click OK to reverse.Instant Generator [Standard Edition or above] Instant generator produces source code from your model at a particular instant. Unlike the code generation support in round-trip engineering, instant generator is a one-off. To generate code, select Tools > Code Engineering > Instant Generator from the main menu, then select the programming language in which to generate.Instant Reverse [Standard Edition or above]Instant Reverse allows you to reverse different types of source into UML class models, such as Java source, Java classes, C++ source etc. To reverse, select Tools > Code Engineering > Instant Reverse from the main menu, then select the appropriate programming language. Select the source files and proceed.Instant Reverse Java Code to Sequence Diagram [Standard Edition or above] Sequence diagram can help represent interactions between objects in runtime. VP-UML enables you to reverse your Java source code to sequence diagram. You can gain a better understanding of a piece of Java source code by reading its corresponding diagram, instead of looking at possibly a thousand lines of code. To reverse Java code to sequence diagram, select Tools > Code Engineering > Instant Reverse > Java to Sequence Diagram… from the main menu. Add the folder that contains the source code, continue and select the source file. Finally, visualize the code in a new diagram.ReportingUsing Report Composer [Standard Edition or above] You can develop professionally designed documentation using the Report Composer. Apart from the diagram-based report generation function, you can customize a report by adding elements to your report manually.1.Let’s continue with the QuickStart.vpp. Open the use case diagram Sales Order System. Create one if youdo not have one already.2.Right-click on the diagram and select Utilities > Generate Use Case Report from the popup menu. Thiscreates a new report in report composer.3.Scroll to the end of the report.4.In the Diagram Navigator, press on the class diagram node Domain Model. Drag to the end of the report.The result should look something like this.5.Click on the Export button at the top right and select Word Report….6.In the Export Word Report window, fill in the output path and click Export to produce a Word. Project Publisher [Standard Edition or above] You can publish your project to Web format through the Project Publisher.1.Select Tools > Project Publisher… from the main menu.2.In the Project Publisher window, specify the output directory, which is the folder for storing the files topublish.3.Click OK. When finished, you can read the published content in a web browser.4.Open the use case diagram Sales Order System in published page.5.Click on the use case Place Order on diagram.This brings you to its specification page.Modeling Collaboratively and ConcurrentlyIf you work as a team and need to share your design with your teammates, or work together on the same design, you need to make use of the team collaboration support. VP-UML supports version controlling systems like Teamwork Server, SVN, Perforce, ClearCase and CVS. In this guide, we will cover the import of project into Teamwork Server, and common operations like checkout, commit and update of project.In this section, you need to simulate two persons in the same team - Peter and Stephen. They are both involved in the Sales Order System project. Before we continue, make sure you have Teamwork Server installed. You can download the Teamwork Server here. Installation of Teamwork Server is described in the user’s guide page here. Share Design with Visual Paradigm Teamwork ServerTeamwork Server is a product developed by Visual Paradigm for supporting collaborative and concurrent modeling. To share your design with others:1.In VP-UML, select Teamwork > Open Teamwork Client… from the main menu.2.In the Login window, keep selecting Standalone VP Teamwork Server as Server and fill in theconnection information. Click OK to proceed. You should consult your system administrator about thelogin detail.3.When the Manage Project window appears, skip it by clicking OK at the bottom of the window.4.In the Teamwork Client window, select Project > Import Project to Repository from the main menu.5.In the Import Project window, keep QuickStart to be the project name. Assign other teammates to thisproject and grant them with read and/or write permissions. Click OK to confirm importing.You have now imported the project into the server, and checked it out. Stephen, your colleague, can start working on the project you have imported.Checkout and Open ProjectNo matter you are using Teamwork Server, SVN, Perforce, ClearCase or CVS, you need to checkout a project from server and open it in order to work on it. If you are the one who imported the project into server, you do not need to perform checkout as this was done for you right after the import. However, you still need to open the project.Now, play the role of another team member. Take the following steps to checkout and open project.1.Start VP-UML in a new workspace.2.Select Teamwork > Open Teamwork Client… from the main menu.3.In the Login window, fill in the connection information of the other member and click OK.4.In the Manage Project window, double click on the QuickStart project. Click OK to continue.5.At the bottom right corner of the Teamwork Client window, click Checkout, and then click OpenProject. Now, you have opened the project, and can start working on it.CommitCommit is the process of uploading changes done in the working copy back to server. As you, the team member, make changes in a project, you can share your works by committing those changes to the server, and let others to update the changes from server. (Update will be discussed in next section)Play the role of the team member who imported the project into server. Take the following steps to try out the commit process.1.In Teamwork Client window, open the project you just imported to server.2.Open the use case diagram Sales Order System.3.Rename the use case Place Order to Buy Goods.4.Select Teamwork > Commit… from the main menu.5.The Commit window appears. It lets you review the changes to be committed, solve conflicts (if any), andadd comments to describe the commit action. Click Commit to continue and complete the commit process.UpdateUpdate is the process of refreshing the working copy by merging changes that others have made and committed to server. Let's say you are now Stephen. And you need to update the changes made by John.1.Select Teamwork > Update… from the main menu.2.The Update window appears. It lets you review the changes to be merged into your working copy. Openthe Model Elements tab to see the changes.3.Click Update to continue and complete updating.File Referencing with Teamwork SupportWhen modeling, there may be external resources you want to attach to a model which help describe it in detail or include data that cannot be modeled, like a text document. You can do this by adding file references to models. If you are working in a team-based environment with Teamwork Server, you do not need to copy any referenced files for other team members to open. Instead, you could commit your model along with the referenced files to the server.1.Open the Teamwork Files pane in the panes group at the bottom left of the user interface.2.Drag a file to the Teamwork Files pane.3.Click OK when you are asked to confirm putting the file to workspace. You must click OK here. If not, thefile won't be added as a teamwork file nor committed to server.4.Select Tools > Application Options from the main menu.5.In the Application Options window, select User Path on the left hand side.6.On the right hand side, click Add... and select Project Files Path from the popup menu. Click OK at thebottom of the Options window to close it.7.Move the mouse pointer over the use case Buy Goods to show the resource icons.8.Click on the References resource icon at the bottom left of the requirement shape and select Add File...from the popup menu.9.In the Use Case Specification window, click on the button ... next to the Path field.。
Evaluation of UML Extensions for Aspect OrientedDesignFernando Asteasuain,Bernardo Contreras,Elsa Est´e vez,Pablo R.Fillottrani∗Departamento de Ciencias e Ingenier´ıa de la Computaci´o nUniversidad Nacional del SurAv.Alem1253–(8000)Bah´ıa BlancaArgentina{fa,bec,ece,prf}@.arAbstractThere are some concepts,such as synchronization,error checking,distribution, security,and others,that are dissimilar from the basic functionality of a system,andthey are not correct encapsulated when using traditional programming methodolo-gies.Thus,the code corresponding to these concepts result disseminated throughthe complete system,and therefore the overall software quality decreased.AspectOriented Programming(AOP)provides solutions for code scattering promoting theseparation of these concepts through mechanisms that allow an adequate abstractionand composition of them,tofinally integrate the complete system.The unit thataggregates the entire semantic of each of these concepts is defined as aspect.Theexplicit disunion of these concepts enables a more reliable management of softwarecomplexity,and afinal product of better quality.The key principles applied aremodularity,and separation of concerns.During thefist stages,the research relatedwith AOP was focused at the implementation or codification level.In this paper,we present different approaches to include aspects during the design phase.Theseapproaches propose different extensions to UML.We include examples to illustratethem,and we define evaluation criterias to compare them.Keywords:Aspect Oriented Programming,extensions to UML,aspect oriented design,design evaluation criteria.1IntroductionAspects[11],basic programming unit of AOP[1,10],can be identified during the design and implementation phases,although they will effective manifest during the implementation ∗Grupo de Ingenier´ıa de Software-Miembro del IICyTI1or codification activities[6].When aspects appeared during the implementation,software engineers add or remove them easily due to the plug-in plug-out nature of the elements of this paradigm.In contrast,for those aspects identifiable during the design phase it is not possible to take action,and we should only wait until the codification phase.Thus,this fact promotes the need to develop mechanisms and tools that enable aspect manipulation and specification during the design phase.Including a special aspect specification during the design,simplifies the development of aspect oriented software facilitating different concerns.First,documentation and learning are facilitated.Considering aspects as design constructors,software engineers can recognize them in a higher level of abstraction and during an early stage of the development process. Aspect designers and software engineers initially involved in AOP can learn and document models in a more intuitive fashion.Second,it promotes aspect reuse.The way in which aspects are documented and further studied,the considerations about how aspects are designed,and how they depend on the abstractions associated to them,is crucial for aspect reuse.Finally,it promotes evolutionary development.If aspects are considered during the design phase,it is possible to produce incremental aspect oriented software.Briefly, the considerations and motivations for considering aspects during the design phase are semantically equivalent to those that justify to include the design phase during traditional software development.Kande et al.[5]define two main topics needed to evaluate an aspect oriented design model.First,the model needs to define clearly which are the elements that crosscut the basic functionality.Without this information,the representation and reasoning about aspects structure and its behavior in the system is difficulty.Second,it needs to provide mechanisms and means to separate the elements that crosscut functionality from basic system components,and also must encapsulate these elements in a special artifact.The most direct and natural approach is to investigate UML adaptability[7],as a specification language for aspect modeling.UML is the design language most accepted in software engineering,and is considered as a standard.It provides a powerful set of modeling tools for system analysis and design,for the definition of the system architecture,and also for specifying the system behavior.It also provides,a set of mechanisms to extend or adapt UML to a specific domain.This extensibility characteristic make it more suitable.In this paper,we analyze UML for specifying aspect oriented design.In the next section,we discuss if UML,as it is defined,is able to express aspects,and if it is able to satisfy the two topics mentioned by Kande et al.These concepts are shown by an example. In section3we evaluate two approaches to manipulate aspects during the design phase, based on different UML extensions.In section4,we present different design evaluation criteria to compare these approaches.Finally,we present our conclusions and future work. 2UML for Aspect Oriented DesignSuppose we need to model a system for the following requirements.We consider two classes Client,and Supplier.The Supplier class includes a method invoice(q:int)that is used to store the different invoices that the supplier receives from the clients.One of the system requirements stipulates that is needed to save all the information related to the requests2Figure1:Log Aspect:saves the requests to a Supplierthat the supplier receives from his clients.This requirement is a concept that crosscut different parts of the system,and its code will be diseminated among several classes.The implementation of this requirement is naturally supported by an aspect oriented develop-ment.The Log aspect will be responsible for the implementation of this requirement and is shown in Figure1.The aspect introduces the method initLog in the Supplier class.This method creates thefile where all the information about invoices will be saved.Thefile is managed through thefile attribute,which is also introduced by the aspect in the Supplier class.The semantic for the Connection Point and for the Notice defined in the aspect is quite simple:after each request to the method invoice of the Supplier class,the relevant information is saved on thefile.Figure2shows the class diagram for the example.Figure2:Static structure of the aspect semantic.The collaboration diagram may be used to model the dynamic structure of the system. The diagram shown in Figure3shows a behavioral view based on the interactions between an object c from Client class and an object s from Supplier class.The object c invokes3the method invoice defined in s,shown by the arrow labeled with invoice().One approach to show the aspect semantic,is to apply the technique used to model interceptions to method invocations[5]:it consists of adding a new class whose instances are interposed between the interacting objects.The application of this technique is shown in Figure3.An interceptor objetc i is placed between the client and the supplier.The object i implements the logging aspect,and also has an interface that supports all the methods of the Supplier class that can be invoked by the Client class,plus a mechanism to resend the invocations intercepted to the Supplier class.Figure3:Dynamic structure of the aspect semantic.UML,as it has been shown,admits the structure and the interactions modeling of the aspect oriented system.Although,the resultant models suffer important disadvantages[5]. First,the crosscutting concepts are not modeled correctly.The design of the logging aspect results disseminated all over the system because it is partially modeled with the Logging interface and the association bewtween File and Supplier classes.The dymanic of the system is represented by an object of the Intercept class,that interchanges messages with objects of other classes.Second,the diagrams do not show differences in class modulariza-tion and aspect modularization.The specific concepts of Aspect Oriented Programming, such as Connection Points,or Notices are not explicitly modeled.Third,the model does not reveal the fact that the interception to the method invocation is done transparently. Finally,the model does not show the property“plug-in plug-out”of the Logging aspect.In the following section we evaluate different UML extensions.3UML Extensions for Aspects ManagingThere are two alternatives to extend UML in order to manage aspects.One of them is the General Extension to UML(GEU).It modifies the meta model of UML to include at this level the concepts related to the paradigm.Thus,UML will be able to model all type of aspects in any situation and in any context.Hence,aspects will befirst level objects because they will be predefined mechanisms of the language,such as classes.Consequently, it will be possible to construct correct and simple models with enough level of abstraction. The disadvantage of this approach is that in order to be so general,perhaps some concepts related to the aspects may be lost during modeling.To solve this problem,a different4approach was proposed.It consists on a Specific Extension to UML(SEU)that prioritizes the understandability of the problem and aims to reduce complexity.In this approach, design is not done for any aspect,just only for the aspects in the current system.There-fore,a model that reflects more closely the problem is obtained,and this model presents higher level of abstraction.The disadvantage is that when changing to another problem, it will not be possible to reuse anything of the previous products,and we must start from the beginning again.In being so specific,if we change the environment,the extensions constructed to one system will not serve to the other,making difficult the reuse.This discussion is the same that raises when developing an aspect oriented language [2].Should the development consider aspects in general,or only those specific to the problem?These alternatives are well known in literature as General Purpose Aspect Oriented Languages,and Specific Aspect Oriented Languages.The decision of which one should be selected during the design phase is the same:both alternatives are valid,but depending on the application domain,one of them will be the most convenient.In the next subsections we present both alternatives.3.1General Extension to UMLSuzuki y Yamamoto[4]propose a general approach to express aspects during design.They suggest an extension to UML to support aspects appropriately without violation to the meta model specification.For this purpose,they add to the meta model new elements for the aspect and the weaver[1,2],and an existing element is reused to model the relation-ship class-aspect.3.1.1AspectsIdeally,the aspect should be a constructor derived from the Classifier element,describ-ing its structure and behavioral properties.The Class,Node,Interface,and Component elements are Classifier types,such as Aspect should be.An aspect can have attributes, operations and relationships.The aspect operations are used to express its behavior.The aspect relationships include generalization,dependence,and associations.Figure4shows the proposed extension for the aspect constructor.Figure4:An aspect as a metamodel element.53.1.2Class-Aspect RelationshipThe UML Metamodel defines three primary relatrionships derived from the metamodel element Relation.These are the associations,the generalizations and the dependencies. Considering that the dependency relationship stipulates that the implementation of one element requires the presence of other element or elements,we consider this type of relation the most adequately to model the class-aspect relationship.The properties derived from the dependency element are:abstraction,bound,permis-sion,and use.The class-aspect relationship is a type of abstraction.An abstraction dependency relates two elements that corresponds to the same concept in two different levels of abstraction,or from two different points of view.The UML Metamodel defines four stereotypes for the abstraction dependency:derivation,realization,refinement and trace.The most appropriate is the<<realization>>stereotype.A realization is a relationship between an element of the specification model,and the element of the model that implements it.3.1.3WeaverUsing a weaver,the aspect code and the class code are combined,generating a weaver class.The structure of this class depends on the weaver and on the base language used. To express it in the metamodel,an stereotype<<W eaver Class>>is introduced to the Class element.It is advisable to use a labeled value to specify the aspect,and the class or classes asociated to it.3.2Specific Extension to UMLIn[3],UML is extended to support the synchronization aspect.Each object is designed in two levels:a functional level where the basic functionality of the object is defined,and the synchronization level,where the synchronization properties are described.Without UML extensions,the synchronization policies are not explicitly modeled,consequently they result simply in code written in the body of the methods.The mechanisms that UML provides for posible extensions are used to extend UML [7].These are stereotypes,constraints,and labeled values.The stereotypes provide a mean for elements classification,adding new attributes,relationships,and operations.The constraints enable the specification of new semantic for the model elements.The labeled values permit to associate information to any model element.A new stereotype<<Synchronization>>is defined to represent the synchronization policies.All the synchronization semantic is represented by its atributes and methods.Also,a new type of state diagram is described to model the dynamic structure,such as synchronization conditions,state changes,and each of the event constraints.This new diagram is known as state diagram for synchronization.The construction rules are:•A synchronization state represents a set of methods that can be invoked at any time.6•A transition represents a relationship between two states.It indicates that an object in a state can change to other state when an event occurs.A transition between two synchronization states will happen only when a method is invoked.•The transition condition evaluates the possibility to execute the transition.Thus,it evaluates the possibility to execute the method.Finally,the synchronization actions are defined.They are classified in two categories: pre-actions,and post-actions.The pre-actions are the set of actions that must be executed before the method invocation,and the post-actions are the set of actions that must be executed after the method invocation.All this information is added to the transition. Figure5shows the transition scheme.Figure5:Transition scheme for an UML extensionAs an example,we consider a chat server.The server provides several methods,two of them are the connection and the disconnection methods.The synchronization policy stipulates that it will be possible to establish a connection if the server is not overloaded. This means that the number of connections already established are less than the maximum bound.First,we define the Server Sync class with the<<Synchronization>>stereotype. It implements the synchronization policies for the server methods invocation.In this case, it only involves an attribute counter,for the registration of the number of connections,and two methods increase and decrease,to manipulate the counter.In Figure6we show the static structure of the system.Figure6:UML Extension:Synchronization stereotype As it was mentioned,a state diagram for synchronization is required to show the dy-namic behavior.This diagram is related with the Server Sync class and defines the syn-chronization policies required.Figure7shows such diagram.We have presented in this section two approaches based on extensions to UML for aspect oriented design.In the next section we define evaluation criteria to compare them.7Figure7:State Diagram for syncronization of Server class4Evaluation of Both ApproachesTo compare both alternatives we follow the criterias defined in[9].These criterias are used to evaluate how each approach satisfies the considerations mentioned in Section2.The criterias are:•Traceability:how easy is to follow the requirements in the design models.This criteria is defined to ensure that the design approach has provided the adequate constructors.•Propagation of Change:how the model facilitates the incorporation of future changes in the design.•Reuse:how it promotes design reuse for other systems.•Understandability:how the design facilitates the understanding of the system func-tionality.•User Friendliness:how the design techniques are easy to learn and use.•Separate Development:how the design techniques enables parallel development of different modules of the system.This criteria promotes a better productivity of the development team.In the next subsections we eavluate the two approaches presented,based on these criterias.84.1TraceabilityThe SEU approach provides a good traceability as a result of the separation of the static and dynamic behavior.Within the static models,stereotypes and relationships are used, objects,aspects,and also how they are related are clearly specified.Within the dynamic models,new state diagrams are defined,where the actions related to aspects are captured by pre-and postactions related to a transition.These actions enable the modeling of those requirements that crosscut the design.In the GEU approach,each paradigm concept has its associated constructor.This is a main characteristic because in this way the connection point notion is explicit.This one-to-one relationship between the paradigm concepts and the language constructors is very importat because it produces a perfect traceability.This situation is not present in the SEU approach where several concepts,such as the connection points are modeled in an implicit way.4.2Propagation of ChangeThe SEU approach shows a weak point in the dynamic behavior modeling.As all the actions related to aspects are specified within the transitions,a change or modification implies a review to all the state diagrams to check the modification.In the GEU approach,this problem is not present because of the one-to-one relationship between concepts and constructors.Although,the disadvantage is that aspects have an excesive view and control of the internal structure of the objetcs related to them.Thus, the effects of a change can be rapidly propagated.The fact of controlling and restrict this strong influence of the aspect over the object is a responsability concern of a good designer.4.3ReuseIn the SEU approach,while the aspect results correctly encapsulated,such encapsulation is mainly based on the current system,presenting all its constraints and characteristics. Mostly,the decissions are taken considering the current context.Thus,to move the aspect to other system,with other properties,is a complex task.In the GEU approach,as the aspects and their objects elements arefirst classes in the model,richer and more expressive models can be produced.Therefore,promoting the alternative to model aspects inheritance,abstract aspects,and other characteristics.As a result,a good reusability of aspect designs is obtained.4.4UnderstandabilityIn the SEU approach,the understandability is vey good working with models with few aspects,because it is based on well known and familiar constructors.As more aspects appear it results more difficult to identify the relationships between aspects,and between aspects and their objects.The GEU approach does not provide clear composition rules,and also exists a strong9influence of aspects over objects.These two characteristics reduce the design understand-ability.4.5User FriendlinessIn the SEU approach,the extensions to manage aspects are realised with the own mecha-nisms provided by UML for extension.Thus,extended models preserve simplicity.With solid knowledge of UML and its extension mechanisms,it is simply to apply those mecha-nisms to aspect handling and learning.This approach is quite easy to use,and also is easy to understand the system behavior.In the GEU approach,as new elements are added to provide a general solution,they require more attention about their behavior,and also the way in which they can be used and composed.Thus,it is necessary a previous learning stage,not trivial,before using them.Therefore,the learning and user friendliness is considerably reduced.4.6Separate DevelopmentIn the SEU approach,as simplicity is prioritized,the aspects interaction is essentially reduced,enabling a separate development of all the aspects involved in the system.In the GEU approach,because of a greater interaction between aspects and objects,and also because of the aspect design references to the objects related,separate development is seriously affected.In the next section we present ourfinal conclusions and future work.5Conclusions and Future WorkIn this work we have presented the need for expressing aspects in thefirst stages of the development process,particularly during design.It represents thefirst main step for the consolidation and definitly maturity of AOP.First,we have anlyzed if UML,the most popular and accepted specification language in software community,as it is defined is able to express aspects.The conclusion is that it is possible to represent aspect semantics,but the way to express them is not so satisfactory. Thus,the next step was to study different approaches to extend UML.A general and formal alternative is to include the paradigm concepts in the language metamodel.The other alternative,not so rigorous,but also effective,is to extend UML for the currrent problem,using the mechanisms that UML provides to extend its semantic.In thefirst approach,aspects are treated during the design phase in a more formal and general fashion.With this extension,it is possible to express in UML any aspect that appears in the system at any moment.Also,when changing to another system,and having to manage different aspects,the same extensions will serve to model the new system. Although granularity is not so good,there are good benefits with respect to documentation, learning,reusability,and formality.In the second approach,a specific extension to UML was defined to manage the syn-chronization policy for the functional behavior of the objects of the system.To model10Criteria GEU SEUTraceability Excellent SuficientPropagation of Change Sufucient BadUnderstandability Suficient RegularUser Friendliness Regular ExcellentReuse Good BadSeparate Development Good Very GoodTable1:GEU and SEU Evaluationthe static structure,we create a new stereotype<<Synchronization>>,and for the dy-namic structure a new state transition diagram was added.Thanks to these extensions,the synchronization policies can be designed separatly and independently,enabling a greater reuse.The abstraction level was correct,and the concepts related with synchroniuzation resulted clearly encapsulated.As it was mentioned,this extension is usable only for the synchronization aspect.For other aspects,new stereotypes and new state diagrams should be considered.We compared both extensions based on particular criterias.In table5we resume the result of each approach for each of the criterias,based on our analysis.We have used to following scale:Excelent,Very Good,Good,Suficient,Regular,and Bad.In a little system,with a controlable number of aspects,namely no more thanfive plus or minus two,the SEU approach is a direct way,simple and effective.Although,when the system complexity increases,and the number of aspects is important,the simplicity of SEU is a disadvantage for the developer.In this situations is when it reveals that this approach is an ad-hoc solution,an approach to solve a particular situation.As it was also mentioned in[8],SEU is a compromise solution,a solution not conceptually robust.We believe that the main issue behind aspect oriented design is to consolidate the GEU approach,in such a way that it can satisfy all the criterias mentioned.The future work is to study its weakness and to look forward to improve them,specially facilitating its use, making it more adaptable to changes,and more understandable.As far as we know,the research made about including aspects during the design phase, as those presented in this paper,try to solve a particular problem,in an isolated way. The different appraches are quite different,they do not respect standards,they include different stereotypes,and there is no consensus.The main contribution of this work is an attempt to unify different approaches,and to guide the developer in decidig the aspect oriented design strategy.Our future work is to study automated tools able to generate code from models con-taining aspects.Thus,tools that take as input an UML model,then ask all the information required for the elements,andfinally generate an application skeleton.Those tools should consider the aspect language,but also the language where the basic functionality will be expressed.11References[1]Aspect-Oriented Programming.In Proceedings of the European Conference on Object-Oriented Programming(ECOOP),Finland.Springer-Verlag LNCS1241.June,1997.Gregor Kickzales,John Lamping,Anurag Mendhekar,Chris Maeda,Cristina Videira Lopes,Jean-Marc Loingtier,John Irwin.[2]Programaci´o n Orientada a Aspectos:An´a lisis del Paradigma.Final Thesis for theBachellor Degree in Computer Science.Universidad Nacional del Sur.November,2002.Fernando Asteasuain,Bernardo Ezequiel Contreras.[3]Introducing Separation of Aspects at Design Time.In Proceedings of AOP Workshopat ECOOP’00,Cannes,France.June,2000.Jos´e Luis Herrero,Fernando S´a nchez, Fabiola Lucio,Miguel Toro.[4]Extending UML with Aspects:Aspect Support in the Design Phase.3er Aspect-Oriented Programming(AOP)Workshop at ECOOP´99.Junichi Suzuki,Yoshikazu Yamamoto.[5]From AOP to UML-A Bottom-Up Approach.Software Engineering Laboratory,Switzerland.June,2001.Mohamed M.Kand´e.Jorg Kienzle,Alfred Strohmeir. [6]Generative Programming:Principles and Techniques of Software Engineering Basedon Automated Configuration and Fragment-Based Component Models.Ph.D.Thesis, Technische Universitat Ilmenau,Germany,1998.K.Czarnecki.[7]UML:The Unified Modeling Language.Addison Wesley,2000.Grady Booch,JamesRumbaugh,Ivar Jacobson,Rational Software Corporation..[8]A Metamodel for Aspect-Oriented Modeling.Workshop on Aspect-oriented Modelingwith the UML.First Conference of Aspect-oriented Software Development(AOSD 2002),Holland.April,2002.Christina Chavez,Carlos Lucena.[9]An Analysis of Design Approaches for Crosscutting Concerns.Workshop on Identi-fying,Separating and Verifying Concerns in the Design(AOSD2002),Holland.April, 2002.R.Chitchyan,I.Sommerville,A.Rashid.[10]Programaci´o n Orientada a Aspectos:Metodolog´ıa y Evaluaci´o n.IX Congreso Ar-gentino de Ciencias de la Computaci´o n CACIC,Octubre2003Fernando Asteasuain, Bernardo Contreras,Elsa Est´e vez,Pablo R.Fillottrani.[11]Getting Started with munications of the ACM(CACM)Vol.44Nro.10,Octubre2001.Gregor Kickzales,Erik Hilsdale,Jim Hugunin,Mik Kersten,Je.rey Palm,William G.Grisnold.12。
