cs297proposal.pdf
297 Report.pdf
src[TemperatureConverter v2].zip
- Loading...
- No images or files uploaded yet.
To do:
Report (1st draft):
Week 12: (04/10 – 04/16)
To do:
1. Report Outline *Updated*Introduction 1. Domain Specific Languages 2. JavaFX 2.1. List of Important Features 2.1.1. Incremental dependency-based Evaluation 2.1.2. Triggers (Insert, delete and update) 2.1.4. dur operator 2.1.5. do and do later 2.1.6. Sample JavaFX application 3. Host Languages 3.1. Scala 3.1.1. Operators as valid Identifiers 3.1.2. Single Parameter methods as infix operator 3.1.3. Parameterless methods 3.1.4. Properties 3.1.5. Functions 3.1.6. Mixin Class Composition 3.1.7. Views 3.2. Groovy 3.2.1. Parenthesis less methods & named parameters 3.2.2. Closure 3.2.3. Categories 3.2.4. DelegatingMetaClass 3.2.5. ExpandoMetaClass 3.2.6. Dynamic method invocation? 4. Rich Graphical User Interface DSL 4.1. DSL in Scala 4.1.1. Incremental dependency-based Evaluation (Bind) 4.1.1.1. Bound Property 4.1.1.2. Bound Swing Components 4.1.1.3. Bound Bean Property 4.1.1.4. Bind with Expressions 4.1.2. dur operator 4.1.3. do and do later 4.1.4. Assessment of Scala as a DSL Host 4.2. DSL in Groovy 4.2.1. Incremental dependency-based Evaluation (Bind) 4.2.1.1. Bound Property 4.2.1.2. Bound Swing Components 4.2.1.3. Bind with Expressions 4.2.2. dur operator 4.2.3. do and do later 4.2.4. Assessment of Groovy as a DSL Host 4.3. Sample Application 5. Evaluation of Scala and Groovy as DSL Host 6. Conclusion References Appendix A: Code 1. Scala Code 2. Groovy Code
2. Three Achievements *Updated*1. Evaluation of Scala / Groovy as DSL hosts. 2. Working with developing languages, fluid feature sets and nascent IDEs. 3. Innovatively utilizing dynamic features of Scala / Groovy.
3. Writeup on BindI started with the explanation of bind in JavaFX, I am stuck at trying to create a sample that shows bind to function. The examples from net don't work directly on the version of JavaFX in my Netbeans, I have converted one to the old syntax but on converting to the bare bone function bind between model and view it has stopped working. But after wasting a few hours on the code I moved on to the wrtite up for Scala bind. Will look into creating a simple example after writeup on bind for Scala and Groovy is done. The first draft of JavaFX bind:
The first draft of Scala Bind writeup: Contains sections on Bound Property and Bound Swing Components
Also fixed the code for "Bind with expressions" example from last week. Created a BoundJFormattedTextField to allow binding with Double type BoundProp as Dr. Horstmann suggested. Code: val field1 = new JFormattedTextField; val field2 = new JFormattedTextField;
var Celsius = new BoundPropDouble; var Fahrenheit = new BoundPropDouble; Fahrenheit bind (Celsius * 1.8) + 32.0;
Celsius := 45;
field1.value bind Celsius; field2.value bind Fahrenheit;
Source Code:
Week 11: (04/03 – 04/09)
To do:
1. Report OutlineIntroduction 1. Domain Specific Languages 2. JavaFX 2.1. List of Important Features 2.1.1. Incremental dependency-based Evaluation 2.1.2. Triggers (Insert, delete and update) 2.1.4. dur operator 2.1.5. do and do later 2.1.6. Sample JavaFX application 3. Scala 3.1. List of Features 3.1.1. Operators as valid Identifiers 3.1.2. Single Parameter methods as infix operator 3.1.3. Parameterless methods 3.1.4. Properties 3.1.5. Functions 3.1.6. Mixin Class Composition 3.1.7. Views 4. Groovy 4.1. List of Features 4.1.1. Parenthesis less methods & named parameters 4.1.2. Closure 4.1.3. Categories 4.1.4. DelegatingMetaClass 4.1.5. ExpandoMetaClass 4.1.6. Dynamic method invocation? 5. Prototype DSLs 5.1. Scala Prototype 5.1.1. Incremental dependency-based Evaluation (Bind) 5.1.1.1. Bound Property 5.1.1.2. Bound Bean Property 5.1.1.3. Bound Swing Components 5.1.1.4. Bind with Expressions 5.1.2. dur operator 5.1.3. do and do later 5.1.4. Assessment of Scala as a DSL Host 5.2. Groovy Prototype 5.2.1. Incremental dependency-based Evaluation (Bind) 5.2.1.1. Bound Property 5.2.1.2. Bound Swing Components 5.2.1.3. Bind with Expressions 5.2.2. dur operator 5.2.3. do and do later 5.2.4. Assessment of Groovy as a DSL Host 5.3. Sample Application 6. Evaluation/Comparison of Scala and Groovy as DSL Host 7. Conclusion References Appendix A: Code 1. Scala Code 2. Groovy Code
2. Three Achievements1. Evaluation and comparison of the dynamic features of Scala / Groovy and assessment of the ability of these languages to be DSL hosts. 2. Creation of sample JavaFX like DSL for rich internet application development with features providing easier and more readable syntax, and requiring less boiler plate code. 3. Creation of powerful features like bind, useful in user interface development and many other domains.
3. Writeup on Bind with ExpressionsI was trying to create a basic example to include in the report to explain bind (bind with swing components and bind with expressions). It is a basic application where you enter the temperature in Celsius and it converts it to Fahrenheit.
I am stuck at the following issue:
Code: var Celsius = new BoundPropDouble; var Fahrenheit = new BoundPropDouble; Fahrenheit bind (Celsius * 1.8) + 32.0; //show off bind with expressions
Celsius := 45; //updates Fahrenheit's value
//Issue: Celsius is a BoundProp of type Double and field.text is a BoundProp of type String.. How can I allow binding between two different types? field1.text bind Celsius; //show off bind with swing components field2.text bind Fahrenheit; Source Code: Right now it is hacked so that TextField text is a BoundProp of type Double.. just to see the flow of work.
Week 10: (03/27 – 04/02)Hours: 10
To do:
4. Property LiteralsSeems like this is something we tried last semester and stopped when we ended up having to create new classes (e.g TextField) and manually write fire property change events for each property (e.g Text) since the property change events were not getting fired when the components were changed through GUI so we had to create our own Document Listeners.
1. Scala - dur operatorChanged the syntax of the dur operator to remove the clunkier bind part.
JavaFX syntax: loadingScreenOpacity = [1.0,0.99..0.0] dur 1000;
Old Scala syntax for dur: var loadingScreenOpacity = new BoundProp[Int]; var arr = new Array[Int](10); loadingScreenOpacity bind (arr dur 1000);
New Scala syntax for dur: var loadingScreenOpacity = new BoundProp[Int]; loadingScreenOpacity dur (1 to 5, 1000); //Can say 1 to 5 because Scala implicitly converts the Int to Range which has a function "to" for generating a range of numbers (only //works on integers)
dur Code in BoundProp class: def dur(arr: Seq[T], millisecs: Long) = { //Seq is the parent class of all collections in Scala, T is the type of BoundProp val internal = this; //Had to store "this"(reference to BoundProp) to a local variable since inside the Runnable "this" refers to something else. var t = new Thread(new Runnable() { def run = { for (i <- 0 to arr.length-1) { internal := arr(i); Thread.sleep(millisecs); } } }); t.start(); }
2. Groovy - dur operatorChanged the dur operator syntax in Groovy as well to get rid of bind. Also instead of ArrayList the due now accepts the java.utils.Collections class.
Old Groovy syntax: BoundProp<Integer> loadingScreenOpacity = new BoundProp<Integer>(this); loadingScreenOpacity.bind([1,2,3,4,5].dur(1000));
New Groovy syntax: BoundProp<Integer> loadingScreenOpacity = new BoundProp<Integer>(this); loadingScreenOpacity.dur([1,2,3,4,5], 1000);
dur Code in BoundProp class: def dur(Collection<T> coll, Long milliSecs){ Closure func = { for (i in 0..coll.size-1) { set(coll[i]); Thread.sleep(milliSecs); } }; new Thread(func).start(); }
3. Groovy - do/doLaterLast time we created the do/doLater functions and this week I was trying to port them into Object (or ThreadUtil) so that they were accessible everywhere.
Using Categories: First attempt was using Groovy's categories, create something like a ThreadUtil (as suggested by Prof. Horstmann for the Scala code.. to create do/doLater as static methods in a ThreadUtil class rather than Object class to make it more Scalable)
Code for Usage of doLater and do: use(ThreadUtilCategory){ doLater { println("This will run in the EDT thread"); }
doOutside { println("This will run in a New Thread"); } } Code for ThreadUtilCategory class: class ThreadUtilCategory { static def doLater(Object obj, Closure func) { SwingUtilities.invokeLater(func); } static void doOutside(Object obj, Closure func){ new Thread(func).start(); //closure implements runnable } }
Using DelegatingMetaClass: But Groovy says we can create new control structures with it so there has to be a way to add do/doLater to Object class and seamlessly say:
doLater{ //.... }
So I tried the DelegatingMetaClass feature which we used to add bind to Groovy.
Code to for ObjectMetaClass: package groovy.runtime.metaclass.java.lang;
class ObjectMetaClass extends DelegatingMetaClass{ ObjectMetaClass(MetaClass metaclass){ super(metaclass); }
public Object invokeStaticMethod(Object a_object, String a_methodName, Object[] a_arguments){ if(a_methodName == "doLater"){ SwingUtilities.invokeLater((Closure)a_arguments[0]); } else{ super.invokeStaticMethod(a_object, a_methodName, a_arguments); } }
Code for Usage: Problem is the method does not get inherited by other classes. So it is only callable on Object class. Object.doLater{
println("This will run in the EDT thread");
}
Using ExpandoMetaClass: I found out that the ExpandoMetaClass provides the ability for added functionality to be inherited so I tried adding do/do Later with it.
Object.metaClass.'static'.doLater << {{SwingUtilities.invokeLater(it);}} ExpandoMetaClass.enableGlobally(); doLater { //does not work.. only works for Object.doLater, Surprisingly works for "some string".doLater but not for String.doLater.. WEIRD!
println("This will run in the EDT thread"); }
Anyways I have posted about this on the Groovy-user mailing list: How to create your own control structure. Will wait to see if I get a better way of doing this.
Week 9: (03/20 – 03/26)Spring Break - Wasted on Recovery:(
Week 7 & 8: (03/06 – 03/19)
To do:
Incorporate bind into Scala sample applicationSince the background Image drawing and the current temperature printing etc. were done differently in Scala as compared to JavaFX, I can't figure out how to add bind to these. Sample codes are given below.
JavaFX code: Group{ .... content: bind getConditionImageForCode(todayConditionImages, weatherModel.todayConditionCode) //No need to call repaint.. It gets taken care of by bind } Text{ .... content: bind weatherModel.temperature.toString() }
Scala code: g2D.drawImage(getConditionImageForCode(todayConditionImages, weatherModel.todayConditionCode), 10, 2, null); //The image returned from getConditionImageForCode is not assigned // to an object but directly drawn g2D.drawString(weatherModel.temperature.toString(), 105, 64); In Scala code, method getConditionImageForCode returns an AnimatedImage and the image changes are handled by its animate method which calls repaint for each new image.
//code from animate method of AnimatedImage for (val i <-0 to imgs; animate) { dolater{ currentImage = images(i); weather.repaint(); } Thread.sleep(frameDelay); } JavaFX classes like CompositeNode and Group etc. are specifically designed to work with bind. So apparently just emulating bind will not give us all the power of JavaFX in this area. But on the other hand all these classes could probably be created in Scala or existing classes rigged to work with bind, just like we did for JTextField and other components to get them to play nice with bind. Groovy seems to be doing just that as we will see in the SwingBuilder section coming up:) But I need to figure out what to add in the sample app to show off bind.
Groovy -- do, do later, dur operatorThe Groovy world, it turns out, has been going in the same direction as our research with their SwingBuilder project. They seem to have implemented animate(something like the dur operator in JavaFX), bind, doOutside (do in JavaFX), doLater and an edt (execute in Event Dispatch Thread) and the code has the same declarative syntax flavor like JavaFX.
Links: Danno Ferrin's Blog: New Swing Features in Groovy 1.5 Danno Ferrin's Blog: bind() and animate(), new and exciting features in SwingBuilder
Code snippets taken from above blog: SwingBuilder's bind import groovy.swing.SwingBuilder SwingBuilder's animate swing = new SwingBuilder() Compared to this my attempt at dur in Groovy seems just plain sad! JavaFX syntax: loadingScreenOpacity = [1.0,0.99..0.0] dur 1000; Groovy syntax: loadingScreenOpacity.bind([1,2,3,4,5].dur(1000)); Groovy Code for dur operator:
The metaclass and some of the other features that were not working in the stable release last semester have now been incorporated in the stable release and also work in the updated eclipse plugin, So I no longer had to download and build groovy source in order to run these features:)
ArrayList.metaClass.dur << {Long milliSecs -> BoundProp<Integer> internalBP = new BoundProp<Integer>(this);
Closure func = { for (i in 0..delegate.size-1) { internalBP.set(delegate[i]); Thread.sleep(milliSecs); } }; func.setDelegate(delegate); new Thread(func).start(); return internalBP; }
Issues: 1. Had to use bind instead of = (cannot overload = operator in Groovy), could not figure out any other way of updating loadingScreenOpacity. The new values in our case are not actually returned but set into a BoundProperty which is bound to loadingScreenOpacity. It is not possible to return a value from the closure and still keep generating new values in the closure (as far as I could figure out).
2. The .. operator in Groovy seems to be working differently than what I expected [1.0,0.99..0.0].dur 1000; //output = [1.0, 0.99], Where does the rest of the expression go? What we wanted [1.0,0.99,0.98,0.97,....,0.0] [0,1..5].dur 1000; //output = [0, [1,2,3,4,5]], What we wanted:[0,1,2,3,4,5]
3. Generics have been updated in Groovy but I am still getting issues in it:
class BoundProp<T> extends PropertyChangeSupport implements PropertyChangeListener { T value;
def BoundProp(Object source){ super(source); value = new T();
} ........... ...........
BoundProp<T> set(T newValue){ T oldValue = value; //value and oldValue are both of type Object even though the BoundProp was created with type Integer value = (T)newValue; //newValue is Integer.. so I had to put in a hack firePropertyChange("value", oldValue, newValue); this; } } "Java's generics implementation incorporates a feature known as "type erasure" which "throws away" generic type information after completing static type checking. This allows Java to easily integrate with legacy "non-generics" libraries. Groovy currently does a little further and throws away generics information "at the source level". Generics information is kept within signatures where appropriate" From Groovy Generics
4. The dur method right now works for ArrayList only and not all types of collection.
5. Methods accepting single parameters can be written without parenthesis in Groovy (working below for bind) but is not working for dur implementation. Seems to be an issue when the method has another method as its parameter. Cant say loadingScreenOpacity.bind [1,2,3,4,5].dur 1000, have to say loadingScreenOpacity.bind([1,2,3,4,5].dur(1000)) Groovy do/do laterReference: Getting Stated Guide - Groovy Beans Though Groovy doesn't support anonymous inner classes, it is possible to define action listeners inline through the means of closures. So instead of writing in Java:
Processor deviceProc = ... deviceProc.addControllerListener(new ControllerListener() { public void controllerUpdate(ControllerEvent ce) { ... } }
//You can do that in Groovy with a closure:
//Add a closure for a particular method on the listener interface deviceProc.controllerUpdate = { ce -> println "I was just called with event $ce" }
For do later I need to call EventQueue.invokeLater and run the closure passed to it, in the run method. Something like:
EventQueue.invokeLater(new Runnable() { public void run (){ System.out.println("In run method of EDT thread"); func } });
So according to the above logic this would translate into something like EventQueue.run = {....}, but this does not work obviously since we need invokeLater. I finally used SwingUtilities for this instead.
void dolater(Closure func){ SwingUtilities.invokeLater(func); }
void doInNewThread(Closure func){ new Thread(func).start(); //closure implements runnable }
*TO DO* Do, do later now need to be added to Object class (Right now they are just methods in a Tester class). I also have to move dur operator to the ArrayList class.
Scala dur operator:To implement dur operator in Scala I followed the same approach as Groovy. So the results of the dur method are set to an internal BoundProp which is bound to loadingScreenOpacity variable. The syntax was just as bad if not worse than Groovy's. It does not have a .. operator and you cannot do [1,2,3].dur as it doesn't recognize [1,2,3] syntax. Also we had to use one set of parenthesis.
Scala syntax for dur: var loadingScreenOpacity = new BoundProp[Int]; var arr = new Array[Int](10); loadingScreenOpacity bind (arr dur 1000); Compare to JavaFX syntax: loadingScreenOpacity = [1.0,0.99..0.0] dur 1000; Week 6: (02/28 – 03/05)Hours: 11
To do:
PropertyChangeSupport Issue:We got rid of the issue by simply re-evaluating the terms. But following is the replies I have gotten from the mailing list:
Link to mailing list query: Another super class constructor query
Also, I got this reply from Martin Odersky:
========================Email=============================== From: martin odersky <martin.odersky@epfl.ch> Date: Tue, Mar 4, 2008 at 6:30 AM Subject: Re: [scala-user] Another super class constructor query
1) Parameterless classes consistently get empty parameter lists. That is
new IOException
is really the same as new IOException(). Or:
extends Bar
is the same as
extends Bar().
2) A parameter list gets converted to a single tuple parameter when this is required. So
extends Bar()
would be treated as
extends Bar(())
... and that explains the behavior you are seeing. I also think this goes too far. I'm not quite clear what to disallow, though. I think 1) needs to stay as it is. As to 2), I suspect code would break if we did change it.
Cheers
-- Martin ========================Email===============================
Bind with Expressions:The following code now works
========================CODE=============================== var a = new BoundPropInt; var b = new BoundPropInt; var c = new BoundPropInt;
//3 is implicitly converted to a term a bind (3+b) +(c+2); //a bind 3+(2+1) also works .. should we dis-allow it?
System.out.println("a: " + a); //prints 5
b := 5; System.out.println("a: " + a); //prints 10
c := 10; System.out.println("a: " + a); //prints 20 ========================CODE===============================
The following are examples of expressions that can be binded currently
a bind b a bind b + 3 a bind 3 + b a bind b + c a bind b + (c + d) a bind 2 + (3 + b) a bind (b + c) + (d + e) a bind (3 + b) + (c+2) etc.
Source Code:
Implicit conversionsWhile we are doing implicit conversions from Int to Term to facilitate binding of the form.. Term bind Int + Term (e.g. a bind 3 + b) but we cannot declare variables of type Int and handle everything with implicit conversions from Int to Term for the following reason: Implicit conversion code: implicit def Int2Term(i : Int) = new Num(i);
var a = 1; var b = 2; var c = 3;
a bind b + c; //works, calls bind of term but 'a' gets converted to Term on the spot but not forever. System.out.println("a: " + a); //calls print of Int and not Term, so prints 1 and not 5..implicit conversion is only called when required e.g. method or field not found
Refer to mailing List: Overriding methods and Views
So for the time being to use bind, a variable needs to be declared as a BoundPropInt.
Scope of Implicit conversionI have not found a reference on how to limit scope of implicit conversion. This is just something I tried. Not sure if this was what Dr. Horstmann was looking for. The idea was derived from Categories in Groovy.
We can limit the scope of an implicit conversion by importing only in that scope e.g:
========================CODE=============================== a bind (3+b) //does not have implicit conversion from Int to Term so + operation that takes a BoundPropInt and returns a Term (to be used by bind) not defined. //Compiler complains! { import utils.Term._;
a bind (3+b) //works }
a bind (3+b) //does not work ========================CODE===============================
Week 5: (02/21 – 02/27)
To do:
JavaFX Bind Details:
From JavaFX Mailing Lists: question about bind-ing a function
Issues faced in bin with expressions: 1. For a bind b + c if b or c changed we get a propertyChangeEvent. How do we extract which object (b or c) fired the propertyChangeEvent when both belong to the same Class so the propertyName is the same. I tried to getSource on the propertyChangeEvent but that returns (). So the above is currently hard coded to always update value of b with the new value and then calculate the sum to update a.
Week 4: (02/14 – 02/20)Hours: 10
To do:
Note for report: Consider adding dolater and do to a ThreadUtil class as statics rather than directly into Object (to make it more Scalable)
1 & 2: Animate background & do later:Right now the animation works without bind. But the application uses the dolater & do control syntax created.
Code: The Scala Version of the Weather Application: Contains a Java Project YWS and the Scala project WeatherApplication. To use the Java code (YWS) in the Scala project I import both projects in Eclipse. Then right click on the Scala project (WeatherApplication) to select Build Path -> Configure Build Path in the projects tab and then add the Java project YWS to required projects on build path. And run.
The JavaFX version: available from within NetBeans: WeatherFX 3. Understanding bind:Link to "question about bind-ing a function" posted on mailing list From JavaFX mailing list functions and operations: "Functions are designed to be used to factor bindings into reusable subroutines. Functions automatically track all their dependencies (inputs), not just their formal parameters but any variable or attribute that's referenced in the body. So there's no difference between this:
var a = 2; var y = 3; var z = bind a + y + 10 println(z); // prints 15 y = 10; println(z); // prints 22
and this:
var a = 2; var y = 3; function f(x) = a + y + x; var z = bind f(10); println(z); // prints 15 y = 10; println(z); // prints 22
In both cases when I modify "y", the expression that is bound to "z" is incrementally reevaluated and then the new result is implicitly assigned to "z". It's almost as if the body of the function was lifted into the binding that called it. By contrast, Operations and Java methods are sequential processes which are "triggered" by changes to their inputs. When an input changes the whole process is carried out from the beginning. This means that they only depend on their formal parameters. Changes to variables or attributes referenced later in the body will not trigger the Operation to run again. Instead such references are to the "current" value of the variable or attribute at the point that the operation executed (which is the familiar behavior you're used to in Java). As a result if I use an operation instead of a function for the above I get different behavior (namely the behavior you'd expect in Java):
var a = 2; var y = 3; operation f(x) { return a + y + x; } var z = bind f(10); println(z); // prints 15 y = 10; println(z); // prints 15 Other Links: Planet JFX: "Operation" vs "Function"
Week 3: (02/07 – 02/13)Hours: 8
To do:
Still working on creating the sample application in Scala, since we need that for creating the animation (using bind).
do / do later keywords in Scala:Attempt to add the do later keyword to Scala has resulted in the following syntax:
this.dolater { //... }
I used Views and Companion Objects in Scala to add the dolater command. Basically the dolater is a method in an Extended Object class. It will be available to any class by adding the following import statement: import packageName.ExtendedObject._;
Issues: Cannot call dolater without "this." prefix. Looking into this to see if it is possible to do away with the prefix. Also added a "do" like functionality using the same technique as above. Problem: do is already a keyword in Scala so will need to come up with a different keyword. Right now I am using a place holder called "dont" stands for "DO in New Thread":)
Posted question about the prefix on Scala-User group: Link to query
Update: Changed a few things I learnt from the response I got on the mailing list and now I can call dolater without the "this" prefix:)
dolater { //... }
Source Code for do later & do:
Week 2: (01/31 – 02/06)Hours: 7
This is what the application looks like currently in Java. No where as good as the original even for the text that is drawn. I wonder why the lines are not as smooth as the original (antialiasing? how to do that?) no animations in here either:(
do later:As for the first do later in the code below:
do later { // why??? var yws:YWS; //imported yahooWeatherService as YWS do { yws = new YWS(weatherCode, false); // second param is for isCelcius flag do later { var wm = WeatherModel{}; wm.loadFromYWS(yws); weather.weatherModel = wm; } } }
removing it did not seem to have any effect. If the purpose was to push the whole block of code into the thread for execution later why not move the "do" outside. Why does the variable declaration part need to be in the event dispatch thread?
Update:Figured out how to do antialiasing.. from http://java.sun.com/mailers/techtips/corejava/2006/tt0923.html
Now the application looks slightly better:)
Useful Links:Affine Transform Tutorial: http://www.glyphic.com/transform/
Week 1: (01/24 – 01/30)
I was trying to implement the JavaFX's WeatherFX in Java. It uses do later and dur for animation.
Stuck right now in Graphics purgatory. The outer Frame was easily translated in Java but for each of the 3 weather blocks, they use a CompositeNode object. As expected no documentation exists on this and being new to Swing / Graphics2D I am not sure what would be a good Java alternative for this.
List of JavaFX classes for which I need to find a Java alterego:
Link to JavaFX API: https://openjfx.dev.java.net/nonav/api/index.html
Other than that tried to read anything I could find on the do/do later pair.
References for do & do later:
Some other readings:
Misc Links:Groovy SwingBuilder and Bindings, a Hole to be Filled. Chaotic Java: So, why not Groovy, really? Scala Actors: A Short Tutorial
Background Work: (01/02 – 01/21)
1. Worked on CS298 Proposal:
2. Read up on Threads in Java:
Some changed have been made in JavaFX Syntax (to support compilation): Converting to the New Syntax
Sample JavaFX application: WeatherFXThe above JavaFX application uses bind, dur and do later etc. so it would be a good sample application to implement in our DSLs.
References from CS298 report:1. Odersky, M. And Zenger, M. 2005. Scalable component abstractions. 2. Henry, K. A crash overview of groovy. 3. Mernik, M., Heering, J., and Sloane, A. M. 2005. When and how to develop domain-specific languages. 4. van Deursen, A., Klint, P., and Visser, J. 2000. Domain-specific languages: an annotated bibliography. 5. Odersky et al. A Tour of the Scala Programming Language. Available from 6. Writing domain specific languages. http://groovy.codehaus.org. 7. JavaFX Community. https://openjfx.dev.java.net/index.html
|
|
Comments (0)
You don't have permission to comment on this page.