UCOSPSongBaeChoi

Kevin Brightwell edited this page Aug 26, 2015 · 1 revision
Clone this wiki locally

Each UCOSP participant is asked to log all the difficulties they have getting set up to understand Umple. This includes understanding how to model in Umple, using UmpleOnline, code that is difficult to figure out, and development tools that are hard to figure out, or don't seem to work properly. The more log entries added the more we can better get a grip on the usability issues with Umple, and the more we can help future new contributors come up to speed.

Log entries

Post 20

Apr 6

Have been continuing my work with both issues. It seems that using regular expressions might be a good idea to handle the issues. Have been concentrating more on handling associations and studying the manual for different types of associations.

Post 19

March 30

As mentioned in previous post, decided to insert a function to synchronize data between the Text Editor and the Layout Editor in the Action.processTyping function, before the Action.updateLayoutEditorAndDiagram function is called.

Have written a basic function for the case when all the information in the Text Editor is deleted.

If the solution is designed efficiently and correctly, it can possibly resolve issues related to both the class and association, which is issue 280 (on Google Code) and issue 125 (on Google Code), respectively.

My current design seems to have some flaws. My plan was to find the difference between the old and new Text Editor, and use that information to update the Layout Editor information. It currently fails when the deleting the 2nd class from 3 classes.

Old code:

class NewClass {} class NewClass2 {} class NewClass3{}

New code:

class NewClass {} class NewClass3 {}

It currently produces the difference as being 2 {} class NewClass.

Post 18

March 29

Currently looking into issue 125 (on Google Code): when something is deleted from the Text Editor, the change is not correctly reflected in the Layout Editor and the Model Editor. One solution recommended by Tim, was to parse the data in the Text Editor and the Layout Editor (to ensure that changes made in the Text Editor appear in the Layout Editor) before sending the code to the compiler.

Inspecting umpleonline/scripts/umple_action.js, it appears that the best location to process the data would be in Action.processTyping, right before Action.updateLayoutEditorAndDiagram is called. umple_system.js seems to provide possible useful functions.

Post 17

March 26

Upon closer inspection, it seems some of my assumptions have been wrong.

  • If class is created from Text Editor and deleted from Text Editor, it will be deleted from the Text Editor and Canvas Editor.
  • If class is created from Canvas Editor and deleted from Text Editor, it will still exist in the Canvas Editor.

It seems that when a class is created from the Text Editor, position is assumed to be default if not specified. However, if a class is created from the Canvas Editor, it will almost always have position information. Therefore, even if the Layout Editor is not used, a class created in the Canvas Editor and deleted from the Text Editor will not disappear in the Canvas Editor since it has position information associated with it.

Issue 280 (on Google Code) consists of two parts: a race condition and a second art which currently has a simple fix. Decided to look into Issue 125 (on Google Code) as it seems more of a priority.

I have also created a wiki document for setting up a local UmpleOnline web server for Windows 7.

Post 16

March 18

Think I will possibly look into issue 280 (on Google Code) next. There definitely seems to some issues when deleting information in UmpleOnline.

Assume a class has been drawn using the Canvas Editor. Class should now be present in the Canvas Editor, UmpleCode Editor, and Layout Editor.

  • Delete class from Canvas Editor. Class is deleted from UmpleCode Editor and Layout Editor.
  • Delete class from Layout Editor. Class still exists in UmpleCode Editor and class has moved to default position in Canvas Editor.
  • Delete class from UmpleCode Editor. Class still exists in Layout Editor and Canvas Editor.

Canvas Editor seems to have highest priority. If class does not exist in Canvas Editor, it does not exist anywhere else. Layout Editor seems to lowest priority. If class does not exist in Layout Editor, default position is assumed. Should UmpleCode Editor have equal priority as Canvas Editor? If the class does not exist in the UmpleEditor, should it not exist anywhere else?

Assume a class is created using the UmpleCode Editor. Class should now be present in the Canvas Editor and the UmpleCode Editor.

  • Delete class from Canvas Editor. Class is deleted from both editors.
  • Delete class from UmpleCode Editor. Class is deleted from both editors.

Both editors seem to have equal importance in this scenario. If a class does not exist in one editor, it does not exist in the other.

Post 15

March 16

Issue 129 (on Google Code) has been resolved. Generated jar files to test on local UmpleOnline and it worked. Would like to clean up code to make it prettier and more efficient (take advantage of methods provided in Umple if they exist).

Post 14

March 15

Realized that two test cases might be necessary for issue 129 (on Google Code).

class NewClass { position 119 106 109 41; position.association NewClass__NewClass1 110,11 0,7; } class NewClass1 { position 344 107 109 41; }

One case for when NewClass name is changed and one for when NewClass1 is changed. position.association NewClass_NewClass1 has to change correctly according to the name being changed. For example:

position.association Student_NewClass1

or

position.association NewClass_Mentor

Post 13

March 14

Source of the problem for issue 129 (on Google Code) definitely lies in the EditAction method in UmpleSync_Code.ump. Tokens are generated by looping through umpleParser:

[classDefinition][name:NewClass][inlineAssociation][inlineAssociationEnd][bound:*][arrow:--][associationEnd][bound:*][type:NewClass1][elementPosition][x:68][y:52][width:109][height:42][associationPosition][name:NewClass_NewClass1][coordinate][x:1][y:2][coordinate][x:3][y:4][classDefinition][name:NewClass1][elementPosition][x:176][y:199][width:109][height:42]

All the old names, NewClass1, are successfully replaced with the new name, Mentor, except in the associationPosition area. It seems that in the current code, this area is entirely skipped for some reason. I have begun to add an additional else if case for associationPosition problem. I was able to reach the correct token with the value NewClass_NewClass1. Now I just need to write the code to replace NewClass1 with Mentor, or the new class name.

It seems that TextParser_Code.ump provides various method for manipulating the tokens. There is a method replace(token,string), which given the token, it will replace the entire value with the new string. I wonder if there is a method where given two strings, it will replace the first string with the second string.

Currently, I have been performing a full build ant command. However, I am only making changes in cruise.umple/src and cruise.umple/test. I will have to see if there is a better way to build.

Post 12

March 13

While working on issue 129 (on Google Code), noticed something new. One can define the position attribute in the UmpleCode Editor as such:

class NewClass { position 132 196 109 45; }

When defining the position in the UmpleCode editor, it seems that it will not show up in the Layout Editor. Even after moving the class in the Canvas Editor, it will not show up.

I have created a test case called EditClassWithAssociation for issue 129 (on Google Code). It fails the JUnit test as expected.

The provided UmpleCode is:

class NewClass { * -- * NewClass1; position 68 52 109 42; position.association NewClass_NewClass1 1,2 3,4; } class NewClass1 { position 176 199 109 42; }

The NewClass1 name will be changed to Mentor as indicated in the deltacode in json:

{\"position\" : {\"x\" : \"176\",\"y\" : \"199\",\"width\" : \"109\",\"height\" : \"42\"},\"attributes\" : [],\"id\" : \"umpleClass_1\",\"name\" : \"Mentor\", \"oldname\" : \"NewClass1\"}

The expected result is:

class NewClass { * -- * Mentor; position 68 52 109 42; position.association NewClass_Mentor 1,2 3,4; } class Mentor { position 176 199 109 42; }

And the actual result is:

class NewClass { * -- * Mentor; position 68 52 109 42; position.association NewClass_NewClass1 1,2 3,4; } class Mentor { position 176 199 109 42; }

Post 11

March 5

As noted in Tim's email, issue 129 (on Google Code), issue 280 (on Google Code), issue 125 (on Google Code), and issue 268 (on Google Code) are all related. I will continue to work on issue 129 (on Google Code) then tackle the next related issue. Hopefully, resolving issue 129 (on Google Code) will aid in the other issues as well.

Below outlines the behavior I noticed for issue 129 (on Google Code). Actions: Using the canvas tool, draw two classes, draw an association between them, and rename one as 'mentor'. Using Firebug in Firefox, I was able to view the umpleCode in the post data of the Ajax.sendRequest function in Action.ajax:

class NewClass { * -- * NewClass1; } class NewClass1 { }

//$?[End_of_model]$?

class NewClass { position 119 106 109 41; position.association NewClass__NewClass1 110,11 0,7; } class NewClass1 { position 344 107 109 41; }

Additional parameters include:

action=editClass

actionCode={"position" : {"x" : "344","y" : "107","width" : "109","height" : "47"},"attributes" : [],"id" : "mentor","name" : "mentor","oldname" : "NewClass1"}

It is clearly visibly in actionCode that a class name change is occurring and the new name is 'mentor'.

The response is as follows:

class NewClass { * -- * mentor; }

class mentor { }

//$?[End_of_model]$?

class NewClass { position 119 106 109 41; position.association NewClass__NewClass1 110,11 0,7; }

class mentor { position 344 107 109 47; }

Following the code from the PlaygroundMain class, the change seems to occur in the EditAction class in UmpleSync_Code.ump.

Post 10

February 29

With Andrew's assistance, I have verified my suspicions that resolving issue 129 (on Google Code) may not lie in the actual .js but in the umplesync.jar. Some time was wasted extracting this jar and attempting to figure out how I might be able to view and edit the .class files. I have found that the actual source of the umplesync.jar contents are located in cruise.umple/src-gen-umple/cruise/umple/sync/.

Additional time was spent looking into the test version of UmpleOnline. Adam noticed a problem similar to issue 280 (on Google Code). Upon further inspection and from my experience of looking into issue 129 (on Google Code), I noticed an issue quite similar to issue 280 (on Google Code). After resolving issue 129 (on Google Code), I will look into issue 280 (on Google Code) as well.

Due to two midterms coming up tomorrow, I have been unable to invest as much time as I should into issue 129 (on Google Code) this week.

Post 9

February 21

Have been investigating issue 129 (on Google Code). I have definitely gained a good understanding of the various Javascript files working behind the scenes. For issue 129 (on Google Code), I have looked heavily into the umple_action.js, umple_page.js, and umple_system.js files. It appears that the association name is updated correctly in the text editor but fails to update in the layout editor. As suspected, the association names do seem to update probably but for some reason, only the layout editor does not display the correct association name. I will spend further time investigating ajax.js and compiler.php.

Post 8

February 6

Turns out that my local UmpleOnline setup was incomplete. As Tim mentioned, clicking umple.php only displayed the actual code in the file. Although PHP was already installed, I realized that it was not configured properly to run with Apache. Once I finished reconfiguring everything, umple.php correctly displayed the UmpleOnline page.

I will write up a proper installation guide for a local UmpleOnline on Windows 7 and update the SettingUpLocalUmpleOnlineWebServer page.

Post 7

February 3

It seemed that I was making progress on Issue 21. As I was creating test cases, I continued to build and run JUnit to verify that it was behaving as I expected.

However, things took a turn and I seem to be going in circles. The build fails now complaining about the Program.java, Mentor.java, and Student.java files that are created in the cruise.umple/test/cruise.umple.implementation directory. The build will succeed only if I delete these newly created files and rebuild.

Currently, I am a little confused as to exactly which file is responsible for selecting the correct template when constructing constructors.

Furthermore, it appears that the test I entered in cruise.umple/test/cruise.umple.implementation/ClassTemplateTest.java is causing problems as well.

On a side note, I have been working on an Umple demo and found have found a couple other issues that I would like to look into in the near future. I have also setup a local version of UmpleOnline.

Post 6

January 29

It has been an extremely busy week since last week. Once I have written my midterm this coming Tuesday, I hope to be able to commit a larger block of time working on a fix for the bug I have decided to tackle.

During last week, the time I had was spent creating test cases for Issue 21 and beginning to look into a fix for the issue. Additional time was spent testing the new Umple Online on various browsers on my Windows machine. I came across many of the same issues that other students have found in Internet Explorer 9.

Post 5

January 22

Upon further investigation, Issue 21 creates uncompilable Java code. It appears that inside the second ModelRelationship constructor, parameters are wrongfully pluralized.

Post 4

January 21

Experienced issues with JUnit tests. Ran the proper 'ant' command found here to fix version issues. However, there was still 1 failed JUnit test due to conflict with the version. Problem was resolved with a fix by Andrew.

Would eventually like to work on Issue 184. Until I am more familiar with the system and the processes, I will be looking into Issue 21 and also work on creating a larger complex example of Umple.

Post 3

January 20

Although previously I was able to successfully build everything and pass the JUnit tests, was unable to reproduce a successful build again. Various issues were causing a build failure: had to install PHP and Ruby. Ruby's rake was still causing issues and from Andrew's recommendations, was able to build with the following command:

ant -Dmyenv=wlocal

Post 2

January 15

Following instructions in the email from the Google+ conference.

  • Downloaded Eclipse Indigo Modeling Tools from here only to run into this error:

Failed to load the JNI shared library "C:\Program Files (x86)\Java\jre6\bin\client\jvm.dll".

Found out that the Java on my machine was 32-bit, not 64-bit, and had to download the 32-bit version of Eclipse.

  • Due to unsuccessful setup following Step 2 Method 1 from http://code.google.com/p/umple/wiki/Install_Eclipse_Plugin, followed Jordan's advice and attempted to try Step 2 Method 2 instead.

  • Was confused at Step 4 of http://code.google.com/p/umple/wiki/DevelopmentSetUp Importing libraries.. After poking around, figured out what had to be done.

    1. Right-click on the cruise.umple project and select properties.
    2. Select Java Build Path then the Libraries tab.
    3. Click 'Add JARs...', expand lib, and select JARs to import.
  • Build was finally successful and all JUnit tests passed!

Post 1

January 12

Started reading most of the wiki pages found on https://code.google.com/p/umple/wiki/UmpleHome to become familiar with the project. Gained more understanding of Umple after experimenting with Umple Online. Following suggestion, attempted to compile the program from command line rather than setting up the Eclipse environment. The build failed with numerous errors but I am sure I have overlooked something. Will attempt to rebuild later in the evening. Will also need to decide if I should run a VM Linux or probably install Linux.