UCOSPLogEricTelmer

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 in reverse chronological order

April 24

Added the switch statement that switches over the deep history placeholder. Also added the cases for the states with sub-states.

April 22

Looked into how to generate the if statement to switch into substate's deep history state. Will need to add entry action to deep history state.

April 18

Found where to add the case statement

April 17

Planned out how to implement deep history states So this is what I was thinking, take this section of a state machine as an example.

  sm {
    s1{
      ss1{
        sss1{
          e1 -> ss2;
        }
        sss2{
          e1 -> s2.ss3;
        }
      }
      ss2{
        e2 -> s2.ss1;
      }
      dH{
      }

If there were a transition to s1.dH then there would be a call to setSmS1(smS1.dH)
I would add the code below the arrow

private void setSmS1(SmS1 aSmS1)
  {
    smS1 = aSmS1;
    if (sm != Sm.s1 && aSmS1 != SmS1.Null) { setSm(Sm.s1); }

    // entry actions and do activities
    switch(smS1)
    {
      case ss1:
        if (smS1Ss1 == SmS1Ss1.Null) { setSmS1Ss1(SmS1Ss1.subsubb1); }
        break;
-->  case HStar:
        switch(smS1HStar)
        {
          case ss1:
            if (smS1Ss1 == SmS1Ss1.Null) {setSmS1Ss1(SmS1Ss1.HStar);}
            break;
          setSmS1(smS1HStar);
        }
    }
  }

April 14

Got generated code to transition to the placeholder. This was the last step in implementing history states. I will begin working on deep history states.

April 8

Got generated to set the history state placeholder

April 7

Realized that I was editing the wrong file for generation. I was editing JavaInterfaceGenerator.java file when I should have been editing the template files

April 4

Added code to place history states in the correct place. Also inserted code in the java generator to add a placeHolderStateMachine definition.

April 3

Began fixing dot notation bug where if the transition is to a state that doesn't exist, a state with it's name in dot notation will be made at the top level. This post analysis phase is where I will put the code that detects history states.

April 1

Started to learn how the code generation works

Mar 29

Did some planning for the implementation of history states

Mar 28

Fixed errors below and pushed patch

Mar 27

Fixed code to generate code correctly. I am currently failing a few tests though. UmpleConsoleMainTest Version

UmpleParserStateMachineTest testOfNotTwoOrMoreTypesOFStateMachineInSameClass

UmpleParserStateMachineTest pooledStateMachine_UnspecifiedReception

StateMachineTest pooledStateMachine_UnspecifiedReception

JavaStateMachineTemplateTest pooledStateMachine_UnspecifiedReception

Mar 25

Fixed code so that dot notation to undeclared states would work

Mar 21

The root of my issue: When the state isn't found because it hasn't been created yet, it will be saved in placeHolderStateMachine, but with name still in dot notation (ex: s1.ss2.sss3). Then when the correct state is created it searches placeHolderStateMachine for the state (ex: sss3) but won't find it because the name is in dot notation. My plan: When a state is created look in placeHolderStateMachine for names in dot notation. If the last part of the notation matches new state name, look upwards to make sure the rest of dot notation matches.

Mar 20

The error I got below was because my code wasn't working correctly. But I think it is now!...just kidding. Ran into an issue because if a dot notation pointed to a state below it textually, then that state wouldn't exist yet. will have to edit the code that creates states that don't exist yet. My rule will be search for the first state at transition level, if not found go up until found. If never found, create first state at transition level then next state in that and so on.

Mar 19

Began running tests. Ran into issue where X.java was created at /cruise.umple/test/cruise/umple/compiler/X.java and in that there was a compile error at a line which contained: enum Sm { s1, s2, s1.ss1} so I think I may have to look at code generation?

Mar 18

Fixed a few compile errors

Mar 16

Finished my implementation of findStateDotNotation. Began writing tests.

Mar 12

Began implementing findStateDotNotation. Realized that the user should not have to specify the outer state if that state is the only one containing the next state name. See transition in s2 for more clarification. ex:

sm{
  s1{
    ss1{
      A{}
      B{}
    }
    ss2{
      A{}
      B{}
    }
  }
  s2{
    event -> ss1.A; //Right now this would not work, would have to be s1.ss1.A
  }
}

Adding this functionality would require a lot more work, including fixing issue 531 (on Google Code). I will continue with my original plan for now and add that later if I have time. Was on spring break this week so didn't do as much work as usual.

Mar 11

Planned out how to do findStateDotNotation. Will first start by looking in the state mcahine containing the transition for the first state name in the dot notation (s1 in s1.s2.s3). If not found I will traverse up to the parent state machine until the first state name in the dot notation is found. Then I will find each subsequent by going into each state machine with the same name as in the dot notation until the final state is found.

Mar 3-4 2014

Planned out possible way's to create a historyState, how to have the state machine keep a history, and how the historyState would automatically transition to the most most recent state. My initial plan tried to only use the meta model constructs available now. Because a transition can't be to a variable containing a state, the only way I could think of was to have a guarded transition to every possible sub state. The guard would check to see if the mostRecentState variable corresponded to where the transition was going to. The only way I could think to constantly change the most recent state variable was to add an action to every transition that modified the variable. Both of the methods don't scale and would produce a lot of code. Had midterms this week so I didn't do as much as planned.

Feb 27-28 2014

Began exploring how transitions found the correct state to transition to, to see how I could implement dot notation. Gained a deeper understanding of the meta-model worked with nested state machines, and found states in them.

Feb 25 2014

Continued to investigate how to allow transitions to use dot notation and the special name H, for deep history. I edited the grammar file to change stateName (in the transition definition) to [~stateName] because before the stateNames were only supposed to be alphanumeric. This caused the parser to ignore anything that wasn't alpha numeric and consider it extra code. Dealt with some broken builds here, not sure exactly what caused them. I noticed then that the stateName errors were being generated later during the parsing, so I changed this code to allow dot notation and H.

Feb 22 2014

Checked out issue 519 (on Google Code), 238 and 239 began looking into how to edit grammar to allow for deep history states

Feb 20 2014

Finished and pushed patch for issue 485 (on Google Code) based on what was decided on the umple-dev group

Feb 17 2014

Continued discussion on the desired behavior with regards to the order of transition handling in the presence of sub-states

Feb 11 2014

Finished code to detect duplicate events in substates, however I am waiting to push a patch until we decide on what the behavior should be

Feb 7-9 2014

Facebook Code Sprint! Got eclipse set up. Fixed build environment, pushed a patch that fixed issue 485 (on Google Code) without sub-states. Began work on detecting duplicate events in sub-states

Feb 4 2014

Created necessary test files and added code to UmpleParserStateMachineTest.java

Feb 3 2014

Wrote code to address part of issue 485 (on Google Code). Right now it doesn't test any guards, it only raises a warning if an event without a guard comes before the same event, with or without a guard. Must allow later events to exist without guards to act as default cases, as required by the test: MultipleGuardsSameEventWithDefaultNoGuard.ump. I haven't written my own test yet.

Jan 30 2014

Began writing code to fix issue 485 (on Google Code). Will try and get umple to build with my changes and test them.

Jan 28 2014

Continued to try and understand how the parser and grammar works.

Jan 23 2014

Began inspecting issue 485 (on Google Code): Duplicate Events (without guards or mutual exclusion) results in non determinisms.

Jan 20 2014

Got a local copy of umpleOnline working. Edited the troubleshooting section of the wiki page: https://code.google.com/p/umple/wiki/SettingUpLocalUmpleOnlineWebServer to reflect the problems I encountered.

Jan 17 2014

Set up the environment and ran a successful full build. Will setup a local copy of umpleOnline next.

Jan 14 2014

I did preliminary research on Umple and played around with Umple Online a bit. I also refreshed on some Object Oriented programming concepts and on the UML language.