UCOSPLogChristopherHogan

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

Each UCOSP participant is asked to log all their accomplishments as well as the difficulties they have getting set up to understand Umple and other experiences they have. Difficulties might include 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

NOTE: Entries are listed in reverse chronological order.

November 28 2012

I've finally have tightened up my grammar and my implementation for doing the most minor constraints and am ready to move on from it to determine which route to go from here.

Like suggested earlier I can begin to make umple constraints their own part of the umple meta model. However another solution has come up, issue 365 (on Google Code). I have do some research into the matter now of adding language specific options for umple to choose from. This would change my one target language into enhancing the code injection at the meta model where the work of separating it up into different languages again.

I haven't quite chose which route to go yet, perhaps more research on what is obtainable, no in the whole but I if the steps to 356 could be reached that it would be far more of great contribution to umple, in my mind at least.

November 23 2012

Over the last 3 weeks or so I've been doing research into creating Constraints through the code injection feature that Umple contains. I've tightened up the grammar below to reduce the number of tags that come through however some pointers remain to help guide the Parser to what is looking at. This will be helpful for when I get around to implementing Compound Expressions verses Boolean expressions. Thus the parser will be able to recognize structures such as these ((a>5)&&(a<7)).

I had success at creating a constraint within Java using the Code injection feature. However since the Code Injection use simply [before||after] Name [code] it is not at all language specific. Any implementation done this way will be constructed such that it will work for at least 1 language but not all. This draw back I should have seen early when doing the research but I've been to eager to get results.

I will have to put in more work in the last few weeks to Modify the Jet Templates, MetaModel and lastly the generators, I'm fairly confident the parsing step can easily be modified from what I have to fit the needs if we need to go this route. I'll be sure to put more time and keep a much more detailed log from her on out.

November 2 2012

Unfortunately this week has been busy with midterms such that progress on Umple was slow. I'm I've managed to create my grammar such that it can read the simple lines of boolen constraints. The recursive grammar is still a problem and I'm unsure what differences mine has versus the grammar for State machines (Already implemented recursive grammar).

Below is my code,

invariant : [ ([name] :)? ([[constraint]]) ]
// A constraint is an expression optionally be surrounded in round brackets or negated
constraint- :  [[negativeConstraint]] | OPEN_ROUND_BRACKET ([[constraintBody]]) CLOSE_ROUND_BRACKET |  [[constraintBody]]

negativeConstraint : ! OPEN_ROUND_BRACKET ([[constraintBody]]) CLOSE_ROUND_BRACKET | ! [[constraintBody]]

// A constraint body is a Boolean constraint value or a constraint expression.  
constraintBody : [[constraintExpr]]
constraintExpr : [[boolExp]] | [[compoundExpr]]

compoundExpr : [[constraint]] [=||] [[constraint]] | [[constraint]] [=&&] [[constraint]]
boolExp : [[constraintVal]] [[boolOp]] [[constraintVal]]
boolOp : >= | > | == | != | <= | < 

constraintVal : [name]

While the state machine recursive grammar looks like,

state : [stateName] { ( [[stateInternal]]  )* } | [=final] [stateName] { ( [[stateInternal]]  )* } 
stateInternal- : [[comment]] | [=changeType:+|-|*]? [[stateEntity]]
stateEntity- : [=-||] | [[entryOrExitAction]] | [[autoTransition]] | [[transition]] | [[activity]] | [[state]] | [[trace]]

In addition to looking at this problem. I've also begun to figure out where to start putting code within the Generating ump files. Hopefully I have an update on this later today.

October 19 to 26 2012

I started my Analysis of Issue 187 (on Google Code) which looks to have some complexity to it. I've been trying to Manipulate the Grammar to create the current error message of 9999:

 Feature under development. '{0}' found and ignored. processed as: '{1}'

located in the UmpleInternalParser_CodeClass. So far it's been helpful to see how Umple is interpreting my Testcases of constraints. Reading the GrammarNotation.Txt document and going through some of the other Grammar usages was helpful. However it wasn't until I found the previous work done on Issue 187 (on Google Code) that really kick started what I was doing, Revision 1700 (on Google Code) in umple_constraints,grammar.

Like the previous student I want to keep a very general case of how to interpret constraints. Here's a couple of the variations of examples I'm testing my Grammar against

(((a>5)))
((a>5)&&(a<4))

This is to ensure that the Parser can read correct code when given (worry about the error checking after I get a working solution).

However the current roadblock, possible caused my the implementation of grammar, seems to be the recursion within the grammar is failing the test since the rule defining does not encounter a base case. Which might to limiting what can be done but requires more investigation.

The other issue is getting umple to recognize the boolen operations instead of putting the enter Expressions as the value of a Constraint Variable. But I believe I can solve this if I tighten up my grammar.

I still haven't made massive success in Issue 187 (on Google Code) as much as I would've for the first post on the problem.

October 12 2012

I've fixed the details for my setFailedPosition, the 3rd argument and on are used by the en.error as parameters. Following that I then attempted ensure that my code was working on the command. This process took me took much time as I and I could have saved most of it if I had sooner searched the wiki pages, where I found my solution at umplerun.

September 29 2012

This is the second day of the Code Sprint. The first day we spent getting everyone's environment set up. The two keys problems related to myself. Where that we needed a the newer version of ant for a successful build of umple in eclipse. Following that when building on the command line for windows you can use the following,

ant -Dmyenv=local -f build.umple.xml

This will only build umple will skip around php and ruby since I did not have them installed correctly. PHP works fine but the version of ruby I have has an executable not recognized by windows (I will fix this later). We also covered alot of the details and started looking at some minor issues to work and I looked further into issue 272.

Created a successful failing test for the problem, seen as 025_multipleAttributesWithTheSameName. I currently have made some successful changes in UmpleInternalParser.ump, however I'm stuck on the last step of successfully passing my own test with the method setFailedPosition. Ctrl+Shift+R and Crtl+Shift+T have been very useful in familiarizing with the Classes and Methods in the multiple Java Files.

September 26 2012

Following up with my difficulties with Ant. I missed a step in the instruction video in the tutorials, which I've corrected. I've added PHP to the system PATH, however before I can move on to Ruby tests my build still fails in PHP. Appears to occur in umple\build\build.testbed.xml:118: PHP tests failed ('Fail' found).

In the meantime with Eclipse I've been investigating Issue 272 (on Google Code), I'm still going the process of understanding the suggested Metamodel and Code Generation Umple files in the Architecture.

I'll attempt to make further progress later today.

September 21 2012

Last week I successfully installed the Umple plugin as well as got Umple to run the command. I played around with Umple a little enough to know I did not know what I was doing, after reading through Umple User Manuel, very helpful with the definitions and examples. I did not notice anything to big wrong with Umple although most of my test were building off of the given umple files. An interest of mine at this point would be implementing a more graphical interface for State machines for Umple Online but I realize that's not anything of high priority.

Following that, the steps at Development Set Up page were easy to follow and updated Video 1 on the tutorials page sums it up. However I'm still receiving 120 warnings. Most of the them come from the Local Value Attr isn't used by some generator but I have few that mention some Umple rules may be consumed without object instantiation. It would be interesting to whether or not these warnings are common.

It wasn't till I ran the JUnit 4 tests that I hit a roadblock. First test run through I received some 2000 errors, I had missed some step in the instructions. After redoing the setup I received 456 Errors 1036 Failures. Began trying to run ANT to compile Umple.

Unfortunately I'm still struggling with ANT in my Windows CMD prompt. I receive an identical error as Sonya. The first error line being.

[junit] WARNING: multiple versions of ant detected in path for junit

And Multiple errors after. Although I already have my ant-contrib in my ant directory. I will see what I can do for getting a Ubuntu 11.10 (VM) to follow up these errors (I believe my unfamiliarity with ANT has caused Path problems.)

However after ANT failed to compile the project I believe it fixed the version errors within eclipse. After trying it again the JUnit tests pass with No Errors or Failures (Hopefully that does not change as suggested in some of the previous logs).

With Umple on eclipse working, I'm looking to start work on an Issue but don't know where to begin.