Simplifying the DBAL annotations; removing the specific annotation type and moving towards just @simpl_field and other additonal annotation needs?

So, currently, if I have some class, I go about applying specific annotations in a source language to create my describable class.

If I have myClass...

public class myClass{
    public int myField; 
    public List<Something> myCollection; 
    public Composite someComposite; 
} 

I have to know some stuff about annotating DBAL... and additionally, some of those annotations can be determined simply from the type of the field:

public class myClass{
    @simpl_scalar
    public int myField;

    @simpl_collection("someTagName")
    public List<Something> myCollection; 

    @simpl_composite
    public Composite someComposite; 
} 

The current model also allows a user to incorrectly annotate a field... this decreases usability in general, and effectively our description api becomes more problematic for a user..

public class myWrongClass{ 
    @simpl_composite
    public int thisIsDramaticallyWrong;
}

There are a lot of different annotations in the "DBAL". In java, there's:
*bibtex_key.java
*bibtex_tag.java
*bibtex_type.java
*DbHint.java
*Hint.java
*simpl_classes.java
*simpl_collection.java
*simpl_composite_as_scalar.java
*simpl_composite.java
*simpl_db.java
*simpl_descriptor_classes.java
*simpl_exclude_usage.java
*simpl_filter.java
*simpl_format.java
*simpl_hints.java
*simpl_inherit_parent_tag.java
*simpl_inherit.java
*simpl_map_key_field.java
*simpl_map.java
*simpl_nowrap.java
*simpl_other_tags.java
*simpl_scalar.java
*simpl_scope.java
*simpl_tag.java
*simpl_use_equals_equals.java
*simpl_wrap.java

This is a lot of complexity that could be washed away / simpl-ified.
I propose the following:

1. We carefully look at all of the annotations presently in the system and eliminate all of them which can be determined from type information; replacing those with a @simpl_field annotation.
2. We find a way to add format-specific information in a different way (I'll elaborate more on a proposal to this later; I have a solution but I think 1. is more important)
3. Ultimately: We should make simpl annotations as simpl as possible. Where can complexity be cut / simplified / made more general and usable?

Thoughts? @amwebb @andruidk @rhema @quyin

Something more in line with what I'd like to move towards:

public class myClass{
    @simpl_field
    public int myField;

    @simpl_field(tag="something") 
    public List<Something> myCollection; // will be <my_collection> <something ...> ...

    @simpl_field 
    public Composite someComposite; 
} 

[andru1d]

can we support new & old syntaxes concurrently?

On Sun, Feb 3, 2013 at 3:24 AM, Tom White notifications@github.com wrote:

So, currently, if I have some class, I go about applying specific
annotations in a source language to create my describable class.

If I have myClass...

public class myClass{
public int myField;
public List myCollection;
public Composite someComposite;
}

I have to know some stuff about annotating DBAL... and additionally, some
of those annotations can be determined simply from the type of the field:

public class myClass{
@simpl_scalar
public int myField;

@simpl_collection("someTagName")
public List<Something> myCollection;

@simpl_composite
public Composite someComposite;

}

The current model also allows a user to incorrectly annotate a field...
this decreases usability in general, and effectively our description api
becomes more problematic for a user..

public class myWrongClass{
@simpl_composite
public int thisIsDramaticallyWrong;
}

There are a lot of different annotations in the "DBAL". In java,
there's:
*bibtex_key.java
*bibtex_tag.java
*bibtex_type.java
*DbHint.java
*Hint.java
*simpl_classes.java
*simpl_collection.java
*simpl_composite_as_scalar.java
*simpl_composite.java
*simpl_db.java
*simpl_descriptor_classes.java
*simpl_exclude_usage.java
*simpl_filter.java
*simpl_format.java
*simpl_hints.java
*simpl_inherit_parent_tag.java
*simpl_inherit.java
*simpl_map_key_field.java
*simpl_map.java
*simpl_nowrap.java
*simpl_other_tags.java
*simpl_scalar.java
*simpl_scope.java
*simpl_tag.java
*simpl_use_equals_equals.java
*simpl_wrap.java

This is a lot of complexity that could be washed away / simpl-ified.
I propose the following:

1. We carefully look at all of the annotations presently in the system
   and eliminate all of them which can be determined from type information;
   replacing those with a @simpl_field annotation.
2. We find a way to add format-specific information in a different way
   (I'll elaborate more on a proposal to this later; I have a solution but I
   think 1. is more important)
3. Ultimately: We should make simpl annotations as simpl as possible.
   Where can complexity be cut / simplified / made more general and usable?

Thoughts? @amwebb https://github.com/amwebb @andruidkhttps://github.com/andruidk
@rhema https://github.com/rhema @quyin https://github.com/quyin

Something more in line with what I'd like to move towards:

public class myClass{
@simpl_field
public int myField;

@simpl_field(tag="something")
public List<Something> myCollection; // will be <my_collection> <something ...> ...

@simpl_field
public Composite someComposite;

}

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/60.

andruid kerne, ph.d.
director, interface ecology lab
associate professor, department of computer science and engineering
texas a&m university 979.862.3684 fax
college station, tx 77843-3112 http://ecologylab.net

http://facebook.com/ecologylab

Interfaces are the multidimensional border zones through which the
interdependent relationships of people, activities, codes, components,
and systems are constituted. Interface ecology investigates the
dynamic interactions of media, cultures, and disciplines that
flow through interfaces.

Most def, it'd make sense to deprecate the old syntaxes over time, but the way that I am thinking of modularizing the interpretation of annotations / types for simpl would easily accomodate the old syntax.

(+ I think I can achieve 90% of that compatibility by inheriting the current syntax from a simpl_field annotation. I need to test that to be sure though.)

Oops..... I can't get the compatibility for mostly free from subclassing annotations... was thinking in C# mode and not Java mode.

I can still get it through modularizing the interpretation of the annotations though, so that's still acceptable.

Delegating this to Someday. For now, it's a lot of work.