Jorge Phillips

Does anybody know if there is a JDE equivalent package for Emacs for Groovy/Grails?

Gabriel is correct. A lambda expression by itself is not a closure. A closure is a construct that binds a lambda expression to an evaluation context (lexical or dynamic)used to lookup any free variables (functional or not) in the lambda body. Passing around closures thus allows evaluation of a lambda expression to be done in the environment where the closure was created as opposed to the environment where the closure is evaluated.

As an example: if you have two separate evaluation stacks A and B and you create a closure in one of the stacks (say A) and pass it as an object to a function that is executing in the other stack (say B), then evaluation in stack B of the lambda expression in the closure that was created in stack A will be done in the environment context in stack A where the closure was created. Therefore the name closure. It closes the evaluation environment of the associated lambda to be the environment where the closure is created, regardless of where the closure is evaluated.

As you see, this mechanism is very powerful for creating complex control structures and evaluation regimes.

Paul, thanks for your thoughtful comments and pointers. Andy and Shiang, thanks for the comments on tools. I'll check all these out.

Welcome Paul and Andy, it is great to have you in this forum.

I would like to hear your views on using continuous integration for ORM systems where as code evolves so does the schema in the underlying database. I understand well the concept of code evolution, integration and testing.

The issues I am interested in are those that arise from the need to both seed base data into the database as well as second-order data (data that requires complex constraint maintenance and interactions with multiple tables to ensure initial business logic correctness) in order to test system behavior to verify an integration is correct.

Do you have any suggestions on tools, methodologies, etc. to use? Or are we basically thrown into using ad-hoc test and associated seeding protocols?

Think of a data structure as a tree. A shallow clone clones the root of the tree and shares the subtrees of the original tree's root. A deep clone is a recursive copy, i.e. all data structure components in the clone are copies of those in the original. In this case every non-leaf node in the tree would be a copy of the corresponding node in the original. Thus the name shallow vs deep.

Btw this terminology comes from LISP where you could do shallow and deep copies of lists. In this case the shallow copy copied only the top-level of the original list and the deep copy all levels of same.

Originally posted by Rob Warner:
...snip... As an SWT kind of guy, I now find myself in the curious position of defending Swing, but Swing is far from dead IMHO. ...snip...

Rob, in one of our projects we debated whether to use SWT or Swing. We ended up using a combination of SWT/JFace and JWS to build a native-look client in a distributed system. It was the right choice for our requirement set. Yet, your comment above made me ponder on what might be so good about Swing compared to SWT/JFace beyond the uniform look-and-feel across platforms.

Can you comment on what in Swing is so superior to SWT/JFace that you think will maintain Swing around? Or viceversa, what is inferior in SWT/JFace to the way it is handled in Swing?

Thanks.

I guess remote debugging, pattern-directed development and powerful refactoring features are the main drivers for me. I have converged on Eclipse after having tried a number of IDEs, mainly because it has the right extensible architecture, UI and level of intrusiveness (or non-intrusiveness for that matter).

Inheritance semantically is analogous to "a kind of" relationship. There are classes where you want thread functionality but where the inheritance relationship doesn't make much sense. It is better in those cases to implement Runnable. Also if your class needs to extend another class, and yet access thread functionality, the only way to achieve this (since Java has no multiple inheritance) is to implement Runnable in addition to extending the parent class.

Eclipse is a good approximation. Not only does it handle Java and C/C++ but there is some work in progress to implement a C# plugin which you can run if you download the .Net framework. I personally enjoy very much Eclipse's modular extensible nature. Within Eclipse you also have access to a wealth of SD tools (pattern interfaces, GUI generators, metric calculators, etc).

Ramnivas,
Welcome to JavaRanch! Thanks for contributing.
I am curious re. level of complexity of software development projects you have been involved in where AspectJ is used heavily (say in terms of # of classes, kind of projects, etc.). Could you comment on what penalty (if any) do you pay for using aspects in your projects? I can see clearly the benefit of separation of concerns, especially for orthogonal horizontal concerns that span a number of separate modules, yet we all know there is no such thing as a free lunch!
-Jorge

If I may add my 2c, the fact is that rule based languages are declarative in nature, while Java is an imperative language. Declarative languages are concise and expressive when used to represent logical expressions. The semantics of a rule is implemented by a logic interpreter. Converting into an imperative form such as a Java API would require explicating the procedural semantics of the rule in terms of a set of base classes and expressions, plus somewhere in your system implementing a Java version of the interpreter to thread the rules into the desired set of behaviors, such as Ernest showed in his message.
Ernest, I am just beginning to learn about JESS. Can you do forward and backwards based reasoning with JESS rules?

How about just writing out a text file (possibly with a .txt extension) and reading it into Word. Word should convert the file automatically. You can then save the file as a .doc file and then apply any formatting you need using macros, etc. to expedite the process.
If this is a one shot deal, I would favor this approach.

I assume your output is an HTML stream. You can pipe this stream into a number of converters freely available on the Web (into PDF, DOC, RTF, not sure about XLS nor why would you want it anyway) to create the format you need.
Do some googling to find out how to download them. Once you have the converters use Java to sequence the appropriate system calls. This seems to me the most expeditious approach.

You don't mention if your parse class returns structured exceptions (like a rooted tree with an unknown operator that you could parse yourself) or allows callbacks to handle exception conditions.
If you just have a vanilla black box, it seems to me that it is easier for you to write your own algebraic expression parser on the formula arg. Parsing algebraic expressions is rather simple. Any compiler book (say Ullman's) shows you how to do it using a trivial tokenizer.
[ March 31, 2002: Message edited by: Jorge Phillips ]

Have you tried debugging your DLL in isolation? E.g. calling it from a driver in some other programming language just to make sure that your DLL code is not the culprit. Sometimes the cause for this kind of behaviour is either an ill-formed DLL file, or a buggy DLL, which is normally the case. If a trivial driver does not work and call linkage is correct chances are you have a bug inside your library.