various requests for modification/enhancement

Hello. i've noticed a number of issues and deficencies in alice2. i know that yo u have said that development has stopped on alice2, but i'd like to voice these in the hope that they don't make it into version 3, or that maybe you'll wind up fixing them

0. This one isn't so much a flaw as a harmful practice that i suspect alice might be teaching users. Basically, all variables in alice are "public", even if the editor usually prevents us from referencing them in "another scope". The real problem here though, is that although alice supports the rudiments of object oriented proramming (minus polymorphism), i worry that my peers might be learning some bad habits (such as prefering to reference a property, not an accessor/mutator for that property. I believe that there should be a qualifier that tells alice not to let values be accessed from other objects

1. users should be isolated from the complexities underlying equality comparisons with floatingpoint numbers (ie - equality should internally do a |(a-b)| < EPSILON test; i've encountered situations where a whole number- number didn't equal its self, and i suspect that is due to something like this (esp. since "(abs (a-b) ) < 0.01) worked just fine)
(example:
world.my first method ( )
num = 3.14 , num2 = 3.14
// entered num as 3.141, num2 as 3.14
If ( num == num2 )
print good
Else
print bad
//^ output is "bad".

2. despite native java support for unicode, Alice seems unable to display unicode, even when set to a japanese system locale, and when using fonts containing east asian characters. this is a great disapointment to me as i would like to make alice worlds to practive my chinese with, but sadly alice seems to not work well with that.

3. strings - need more than equal/not equal - something like "substring", and "str2char" would be nice

4. PLEASE FIX THE DUPLICATE LINE and DROP FROM CLIPBOARD problems that occur with statements using local variables or parameters

5. is there anywhere i can find an alice api documentation? (for most things this is simple enough, but for stuff like what does "right forward up" do? it can be more confusing

6. i think there is a scoping issue regarding a local variable of type object-list defined in methods: when i pass that local list to another method, and when i've called the method declaring the local list, multiple times (via a do-together), i find weird things start to happen (it seems that all calls are using the same local variable). i'm guessing this is due to the fact that unlike stuff such as Doubles, Strings and the like in java, Lists (or whatever you implment them with), are mutable (not just re-assignable to). (this also happens with objects, but since they have to refer to a world-object anyways, its clear that mutations should not be hidden in a local scope)

7. i've noticed that undo sometimes doesn't revert to the correct state

8. is there a place to find documentation for the alice source code?
i've looked at it a little bit, mostly interested in trying to fix a few of the glitches i've observed, but i was overwhelmed by both the sheer number of files (~1500), and the utter lack of documentation, combinded with problems such as compile errors (enum is now a java keyword)

9. using number arrays, i have found the following causes an error:
array[] = { 2, 3, 4};
number mynumber =1;
set array[1] = mynumber;
something along those lines tends to fail, with a java arraystore exception

A. alice's type-checking prevents the creation of a list of lists, and also prevents returning arrays/lists from functions(it seems to silently discard the list/array qualifier and just return whatever the element type was,is what i've observed, based on putting stuff into the return statements.

B. alice errors should also show a trace of the user's program at that point(so that they can code a work around)

C. lack of support for something like the "new" operator. this, combinded with lists of lists, and arrays of lists, would allow people to examine abstract data structures more clearly

D. a means to add a limb to an object (so that saved objects can aquire new limbs)

E. I've noticed that Begin-During-End events seem to terminate the During event if the end condition is true before the during event handler finishes (loop while a flag is true in the during handler, then add a print statment after that, and in the end handler, clear the flag): the print statement doesn't execute

F. The various save dialogs don't remember their last path a lot, and alice defaults to the user directory, not the desktop(or other directory) when saving a world.

10. although they won't throw errors when you do so, if you try to specify a array/list return type for a function, they seem to instead just lose the array/list qualifier and be whatever base type was specified

11. some form of polymorphism, even if its as primitive as the "object x's limb"


12. scoping fixes:
index = 1
if (true)
{}
else
{
loop for index =0 up to but not including 10 step = 1
{
}
}
print index;
//the above prints 1,even though index is only defined in the loop
//also, a similiar problem occurs with for -eaches if you drag an element to a different for-each loop(its worse when iterating over a list with the same name)

14. i've noticed a troublesome "bug":
//put into a function:
while (true)
{
//end less loop, course
}
//now that isn't a bug per se, but what happens is - alice becomes totally unresponsive, and can only be closed by killing the process (via something such as taskmanager). many programming languages deal with this by unsing something like ctrl+break to force an end to execution.

15. a side effect of crashses, is that alice clears the recent history list(this also occurs if the computer shuts down without closing alice (overheat)). is there a way to tell alice to keep it recent history list?

16. if the speedmultiplier is set to zero or negative, the world doesn't run at all.

17. "ask user for a number" crashes the interpreter (err.. alice has encountered an error), if the input isn't a valid integer (apparently due either to an empty string or to a "number format exception". isn't there a way to allow users to write slightly more robust alice programs?


18. no support for a hud - ie - elements that are never clipped by objects in the scene

19. transparency problems -when opacity is set to 0, an object still obscures stuff like a tree's shadow (which used a translucent texture or something)

1A. support for debuggers - or some other way of tracing the problem in alice (even making the runtime window non-modal, and allowing the user to pause and then inspect their world) would be useful

1B. a way to query the rotation of an object, and to measure an object (without its parts) in different dimensions, as well as a less confusing "a distance in front of b" (is that something like a distance to b - a.depth/2 , or b distance to a - b.depth/2?, and which is in front of which?)

1C. textures don't work well on shape objects, and i can't seen to find a template for making a custom texture for a model, which results in much trial and error(i still haven't figured that out), when trying to make custom textures

1D.a way to painlessly convert a number to an integer-precision string (not "3.0", but instead "3"

1E. the submit bug feature(on the error dialog) seems to its self throw an error

sorry about having so many complaints! anyways, kudos on making alice2. If nothing else its given me some ideas for a summer research project. anyways, good luck on version 3!

i've found the source if this the bug in issue 1, and have a solution to fix it:
(at least for equality):
//original
package edu.cmu.cs.stage3.alice.core.question;

/** @deprecated */
public class NumberIsEqualTo extends BinaryNumberResultingInBooleanQuestion {
private static Class[] s_supportedCoercionClasses = { NumberIsNotEqualTo.class, NumberIsGreaterThan.class, NumberIsGreaterThanOrEqualTo.class, NumberIsLessThan.class, NumberIsLessThanOrEqualTo.class };
public Class[] getSupportedCoercionClasses() {
return s_supportedCoercionClasses;
}
protected boolean getValue( double aValue, double bValue ) {
return aValue == bValue;//NO! don't compare double's this way!!!
}
}

//solution:
1. add the following declaration to the file:
private static final double EPSILON = 0.01d; //limit precision to the amount visible to users
2. change the line i've marked "//NO! ...", from
"return aValue == bValue;//NO! don't compare double's this way!!!"
to the following snippet:
"{
double absoluteDifference =
(aValue < bValue)?(bValue-aValue):(aValue-bValue);
absoluteDifference =
return (absoluteDifference < EPSILON);
}"

of course i can't get the alice2 source code to compile without way too much work, so i won't bother testing this right now, but i believe this would solve the problem.

................Wow... That's quite a mouthful. (No offense intended)

I do have something that will support this point, although it's probably gonna sound really stupid. Why not allow some sort of feature in Alice 3.0 where a user can update and/or patch their program if a flaw were to arise (or any of the ones our friend has posted above! /\ ). It would be a nifty little feature, and admin could put an archive of updates and patches (probably best used in .ZIP format for space reasons ) on the home page or on the forums!

Just like that beer commercial, I say "BRILLIANT!"

I've been reading stuff and it seems alice2 used to support jython scripting, and while this still seems supported, it seems to be impossile to edit/create scripts in alice. i was wondering, why was this done?