Currently we're using XHR for fetching EDEN code when include() is called. This works well in a hosted environment but when you're JsEden locally it forces you to have a webserver installed. If instead, the mechanism worked by injecting a script tag pointing to the file to be included, and a callback given on finishing loading this, it could work without requiring a webserver.

I think jQuery.getScript achieves this trivially: http://api.jquery.com/jQuery.getScript/

The rb and rhtml files have ruby set in a dcs specific location that does not work on a standard non-dcs setup without modification.

E.g. right now

x = y = [1, 2, 3];
x[1] = 4;

In JS-Eden x and y refer to the same array, but in tkeden the modification to x isn't seen in y, they are totally separate values. The latter is the ideal behaviour when using dependency and agency, e.g.

x = [1, 2, 3];
y is x;
proc p : y { writeln("y changed"); }

Modifying x will silently cause changes to y, but p will not see the change because it was due to aliasing, not dependency or agency.

E.g.

x = @ + 1;

Value of x should be @, but currently it is NaN.

It is possible to go backwards through commands with the "previous" button, but not forwards through them with the "next" button.

chromium (linux amd64)
Version 28.0.1500.52 Ubuntu 13.04 (28.0.1500.52-0ubuntu1.13.04.2)
js-eden v0.4.1-8-g74ab

Example 1:

include("https://raw.githubusercontent.com/mudcube/MIDI.js/master/js/MIDI/AudioDetect.js");

JavaScript console response:

XMLHttpRequest cannot load https://raw.githubusercontent.com/mudcube/MIDI.js/master/js/MIDI/AudioDetect.js. The 'Access-Control-Allow-Origin' header has a value 'https://render.githubusercontent.com' that is not equal to the supplied origin. Origin 'http://emgroup.github.io' is therefore not allowed access.

Example 2:

include("http://mrcoles.com/piano/audio.js");

Response:

XMLHttpRequest cannot load http://mrcoles.com/piano/audio.js. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://emgroup.github.io' is therefore not allowed access.

JS-EDEN version: http://emgroup.github.io/js-eden/
Browser: Chrome 38.0.2125.111 m
OS: WIndows 7

Test case:

b = 3;
writeln(5%b);

Result in github.io version: A parsing error message appears and afterwards the "Submit" button no longer functions to submit any further scripts. If a space is inserted after the % operator then the error does not occur. If the observable name b is replaced with a number then the error does not occur.

Result in construit version: The number 2 is written in the status bar, as expected.

If we want to support further TkEden notations then some work needs to be done to support notation switching, e.g:

%eden
x = 2;

%donald
line l

This could be done by generating some kind of "higher order" parser that looks for tokens like %eden and hand off everything else to other parsers stored in an associative array:

parsers[notationName](code);

String literals terminating in a backslash escape sequence are not parsing correctly.

Example:

s = "";
writeln(s);

Result: parsing error message
Expected result: s should be the string containing a single backslash character.

I don't know if this problem can be easily fixed but I'm going to log it's existence here anyway.

Example:

func f {
return 1;
}

g = f;

The symbol list displays:

g = function () { var args = new Symbol().assign(Array.prototype.slice.call(arguments)); return 1;}

Expected result:

The EDEN definition should be preserved, as if the following code had been executed.

func g {
return 1;
}

Taking care to relabel any recursive function calls appropriately.

There is a R/R conflict in the Eden translator that causes sadness when trying to load the jugs model.

Good start to tackling this would be to update Jison so that we can get better output about the problem, and see if we can get rid of it.

The following code:

func f {
  auto x;
  x = 2;
  x is z;
}

In tkeden this is a parse error, in jseden the x is z the x is a global observable. This is confusing, in that the x inside the function can refer to two different things. It should be an error to try to use is with an auto.

Despite updating the functions.json file the functions list window doesn't update.

E.g.

func f {
  auto x;
  auto y;
  y = 1;
  return y;
}

Valid in tkeden but won't parse in JS-Eden.

Test case:
y = 2;
x = 1;
proc p: x {
y = y + 1;
}

Result in tkeden: y has the final value 3.
Result in JS-EDEN: y has the final value 4.

Support for sessions as a means of saving models and for collaborative development. Sessions need to be listed with projects and can become projects once saved and made static. New sessions can be blank or based upon an existing session/project. Sessions can also be deleted.

Consider the result of the expression:

n = 2;
nmod3 = (n%3>=0) ? n%3 : 3+n%3;

In tkeden and http://jseden.dcs.warwick.ac.uk/construit/# nmod3 is assigned the value 2. In GitHub master it is assigned the value 4. This is equivalent to interpreting the right-hand side as:

((n%3>=0) ? n%3 : 3)+n%3

2 is the preferred result, intuitively, for compatibility with tkeden and older versions of JS-Eden and in line with other languages such as C (I think).

Leaving a note to remind myself.

A rendering bug appears when opacity, fill, outline and increased line width are all used simultaneously.

Example:
item is Rectangle(75,75,300,150,"blue", "black", {lineWidth: 10, opacity: 0.5});
picture is [item];

The problem and a possible solution are described in the context of a different software product at https://konvajs.github.io/docs/performance/Disable_Perfect_Draw.html

Requires #29 first.

This should have no output (which is currently true for JS-Eden):

proc p : a { writeln("a = " // str(a)); }

This should output "a = @" (not yet true for JS-Eden):

a = @;
proc p : a { writeln("a = " // str(a)); }

In JS-Eden, triggered actions currently don't fire until the first change to the observables they observe.

The blue is currently wasted space, especially on laptop/tablet screens. (Eden input box button could be moved elsewhere.)

When running on the localhost using jseden-dev-server.js I get the following text displayed in an alert() popup in the browser, "SecurityError: failed to read the 'localStorage' property from 'Window': Access is denied for this document", and the JS-EDEN environment fails to initialize itself into a workable state (no input window).

Example:

s = "##foo";

Result in JS-EDEN:

JS-EDEN produces a parsing error regarding a supposed missing semicolon. The semicolon that's present has been mistakenly perceived as being commented out.

Result in tkeden:

The code parses and when executed s is assigned the string containing two hash characters followed by the word foo.

E.g.

include("doesnotexist.jse");

Currently just puts "Loading doesnotexist.jse" into the top status bar. We should report an error using Eden.prototype.error that there was a problem fetching the included file.

Need to save regex searches as different views, ideally these would be saved on the server and work with session sharing.

Test case:

y = 1;
proc p : x {
y = y + 1;
}
x = 1;

After execution y = 2 and x = 1. Generating a script using the script generator produces a script that contains definitions for x and p but not y. Executing that script in a fresh instance of the environment yields a state with x = 1 and y = @;

In tkeden you can query to see all observables including "observables not yet defined". So e.g. you can do:

x = y;

At this point, x and y both have the value @, the difference is that y is "yet to be defined". This is different to completely unreferenced observables, e.g. z doesn't show up as an observable, and if you forget(&y); then y will show up in the list of observables either.

I think we can use the last modified by which tracks the last agent to modify, already existing on Symbol, but it will require some tests to make sure it works.

I notice that when a view is closed using the new style X button (either on the window title bar or the Windows menu) it's _view_xxx observables still show up in Symbol List windows afterwards. I'm curious as to why that should be the case, since without the view existing anymore these observables don't have any active functionality anymore.

At first I wondered what would happen if I were to somehow create another view with the same name as the no longer existing one using createView. Would the new view be initialized to appear in the same position the old one was in when it was destroyed? Could that be a good reason for keeping the _view_xxx observables around?

I tried it out.

(1) I created a Symbol List view.
(2) I destroyed it using the X button on the view's title bar.
(3) I executed createView("view_0", "PlainHTML");

The following strange things happened.
(1) The Symbol List view reappeared, despite having previously been removed from both the "desktop" and the Windows menu.
(2) Additionally a new HTML view also appeared, though in the default position, not the position specified by the _view_view_0_xxx observables.
(3) A new entry appeared in the Windows menu that read "view_0 [PlainHTML]".
(4) Hovering over that new entry in the Windows menu highlighted the Symbol List view and not the HTML view.
(5) A subsequent assignment to the _view_view_0_width altered the size of the Symbol List view, not the HTML view.

Given:
func f {
return writeln;
}

Example where a parse error occurs:
(f())("Hello World!");

Example where "Hello World!" is correctly written:
f()("Hello World!");

In tkeden it is possible to prevent notification of dependencies and triggered actions of changes. E.g.

x is y;
y = "hello";
autocalc = 0;
y = "goodbye";
writeln(x);

prints out "goodbye".

Currently this isn't possible in JsEden. The solution is to have a single place for notifications to be buffered and fired depending on a setting (which could be made accessible via autocalc).

Example:
func f {
para list;
if (list == @) {
return 0;
} else {
return 1;
}
}

writeln(f([]));

Expected output: 1
Actual output: error message, "Cannot read property 'length' of undefined"

This is a regression from http://jseden.dcs.warwick.ac.uk/construit/

Pressing the tab key while the input window has focus no longer inserts a tab character into the edited code as it did in previous versions (e.g. http://jseden.dcs.warwick.ac.uk/construit/). This makes editing and debugging code (particularly funcs and procs) more difficult.

Every canvas redraw regenerates the options list causing the currently selected option to be reset.

I've noticed that the result of using list concatenation doesn't seem to work as described as in the eden handbook: http://www2.warwick.ac.uk/fac/sci/dcs/research/em/software/eden/langref/data/#list

a = [1,2,3]#;
b = [4,5,6]#;
c = a + b;
d = ([1,2,3] // [4,5,6])#;

This results in:

a = 3
b = 3
c = 6
d = 10

I have tested this using tkeden 1.73 in dcs and get these results:

a = 3
b = 3
c = 6
d = 6

Suspicious test case:

proc p : x {
y = x + 1;
}

x = 1;

At this point the system state contains:
x = 1;
y = 2;
and the definition of p.

Now proceed with:

forget("p");

The state now contains x = 1, y = 2 but no longer contains p. Now use the script generator plug-in to generate a script. The generated script only contains a definition for x and is not sufficient to restore the current value of y.

Remove database sessions from master into a separate branch for future work (not v1)

Example steps to reproduce:

• Cover the input window with the projects window http://pbrd.co/1jlt9Ti
• Go to views -> click on the existing input window http://pbrd.co/1jlt2qT

Expect:
input window to be sent to top

Observe:
input window is not sent to top

e.g. enter these individually into the input window

x is b+c; ## (Successful)
x=23; ## (Successful)
x is b+c+1; ## (Successful)
x = 23; ## (Successful)

If you inspect the observable x in the SLT during this sequence of definitions, you will see that the original definition of x is still displayed after the explicit assignment to x has been made, so that the fact that x is no longer defined implicitly isn't registered. As far as the SLT is concerned, it appears that you can happily change the definition of x, but you can't change it to an explicity defined value.

This page: http://trmonks.me.uk/projects/js-eden/timer.html has several things that http://trmonks.me.uk/projects/js-eden/eden.html could do with using. E.g. a sensibly implemented symbol table that only gets updates to the parts that have changed (instead of recreating the whole table), and a code editor with basic syntax highlighting and automatic indentation.

It might be easier to go the other way round and add more stuff to something like timer.html, e.g. a window for drawing donald, error reporting...

Even if the error window has been closed, it can be refocused by pressing Ctrl+m.

showObservables should be showSymbols - make it a parameter to decide which type of window to open?

e.g.

[1, 2, 3] == [1, 2, 3]

Is currently false and should be true.

From Peter Tomcsanyi

I wrote this code to allow the user to draw freehand:

old = 0;
picture = [];
proc pt:mouseX,mouseY {
  auto p;
  if (mousePressed) {
    p = Point(mouseX,mouseY);
    if (old != 0) {
      picture = picture // [Line(old.x,old.y,p.x,p.y)];
    }
    old = p;
  }
}

It is quite simple (but still needs some understanding of if statement and curly brackets) and I would suggest to use it as an introduction to handling mouse events (well, after the problem mentioned below will be corrected).
But the problem is that the lines are "steppy" (you can see better what I mean if you try out the code).
During the C1 meeting I have shown it to Elizabeth.
The point seems to be that whenever both the mouseX and mouseY coordinates change the proc pt is called twice - in the first call only mouseX has the new value and then in the second call also the mouseY has the new value. The result is a "step" (e.g. to west and then to the north) instead of a "diagonal" (to northwest).
I made a workaround that uses only each other event but it is then not so easy to explain:

old = 0;
picture = [];
n = 0;
proc pt:mouseX,mouseY {
  auto p;
  if (mousePressed && (n % 2 == 1)) {
    p = Point(mouseX,mouseY);
    if (old != 0) {
      picture = picture // [Line(old.x,old.y,p.x,p.y)];
    }
    old = p;
  }
  n = n+1;
}

So maybe mouseX and mouseY should be treated as a special "atomic" couple that is never being updated partly (or maybe it should be a Point value called MousePos to be compatible with mouseDown and mouseUp?).

Steps to reproduce:

1. Open a Plugin Listing view
2. Click on ADM

The ADM views are accessible from the New menu but the ADM still shows as "not loaded" in the Plugin Listing view. If you subsequently close the Plugin Listing view and open another Plugin Listing view then the ADM then shows as "loaded". The loaded status of other plugins (e.g. the State Listener plug-in) updates immediately when you click to load those plug-ins.

Every search bar should accept a regex, there should be no implicit ^.

I've just loaded the Jugs model, and tried the forgetAll functionality:
forgetAll("");
None of the canvas observables were deleted, and so the picture didn't change.

Given,

func f {
para l;
shift l;
return l;
}

then attempt to evaluate:

writeln(f([1, 2]));

In tkeden this prints [2]. In JS-EDEN it produces the error message "undefined is not a function".

Unusually,

x is f([1,2]);
writeln(x);

prints the undefined value without the producing the error message

There is another example of the same problem given at: https://groups.google.com/forum/#!topic/jseden/640XlZg-mxA

L = [1, 2, 3];
delete L, 2;
writeln(L);

tkeden result: [1, 3]
JS-EDEN result: [1, 2]

L = [1, 3];
insert L, 2, 2;
writeln(L);

tkeden result: [1, 2, 3]
JS-EDEN result: [1, 3, 2]

List pointers are being compared in javascript, not the contents. Similarly a list copy will copy the pointer and so shift modifications will affect both. Solution would be to iteratively compare and full copy.

In tkeden if we define an observable in terms of something that doesn't yet exist, e.g.

a is f(2);
b = 10;

Then a takes the value @, and the next line causes b to take the value 10.

In JsEden the first line causes an type error when trying to call the value "undefined" as a function, so b remains undefined after attempting to execute these statements.

This can be fixed by changing the translator to use a higher order function for function calls so the following eden code:

f(2);

is translated to JavaScript like so:

call(f, 2);

call would then return undefined in cases where f were undefined.

Dealing with a chain of potentially failing operations might be more generalisable (basically Maybe monad!) but for now this would be cool.

Steps to reproduce:

Declare, say for example:

x = 2;

Then bring up either a symbol list view or an observable list view and find x in the list.

Then issue the statement:

forget("x");

Notice that after executing the above statement x remains listed in the symbol list (or observable list) even though x no longer exists in the symbol table.

If you then subsequently refresh the symbol list by altering the regular expression specifying the symbols to search for then x disappears from view and will not appear again (unless x is subsequently redefined).