ActiveXML 1.0: XML as a 4th generation language

Discussions

News: ActiveXML 1.0: XML as a 4th generation language

  1. The ActiveXML Project has released version 1.0.

    ActiveXML is a component-oriented development framework that allows you to define Java-based components as XML elements, manage interaction between such components, provide common logging, and design execution patterns.

    The ActiveXML development environment is completely XML based and offers an easy to read and process-driven way to define applications. ActiveXML incorporates interpreter-based and runtime compiled language – XSSL – eXtensible Server Side Language, which is the core of the framework and the main component that allows for definition and inter-operation of various active components.

    ActiveXML is built with extensibility in mind and therefore does not enforce strict component definition rules via XSSL but rather enforces such through the actual API, so to offer developer freedom to determine their own rules and restrictions. There are however a limited set of rules that is recommended to be followed, unless extensibility scope of a given projects interferes with the predefined rules.

    One may learn more by looking at the provided documentation and the source code, as well as posting questions and suggestions to the forum offered with the project.

    ActiveXML projected is located here.

    Threaded Messages (59)

  2. NOOOOOOOOOOOOOOOOOOOOO!!!!!!!

    You would have hoped that people stopped seeing XML as the way to go for _everything_ and just use it for what's it meant for: data in human readable format.
    provides a capability for any developer to define their own language with its specific syntax, naming and compilation rules
    Don't you just love those uniform, non proprietary standards?
    After converting every data file to XML, databases to XML, writing a zillion protocols based on XML and doing graphics with XML, we now have: an XML programming language! GREAT, that's what I'm waiting for, more properietary XML tags to learn and even better, you can make up your own, more runtime checking, more morrons who think that being able to do an <myTag>someData</myTag> gives them enough knowledge to write mission critical enterprise applications.

    Don't people have anything better to do then to polute the world with frameworks (not implying that all frameworks are bad, but _everyone_ has one now adays) and other projects nobody is waiting for.

    Anyway, why can't just someone take that rabid dog called XML out the back and let it die a silent though violent death?

    Just to make something clear: XML has it's use, but this is not it :-)

    This post is also not meant as a flame towards the creator of the project, but I'm sick and tired of getting beaten to death by XML and people forcing it down your troath, for there are too many people still falling for the hype.
  3. Hmmmz, sorry for the incoherent rambling, but I just had to get that off my chest, next time I'll write a more coherent reply. ;-)

    And I must note that I just scanned the documentation and the project site and didn't spent much time on it, so before burning me down that I haven't read every bloody detail, you're true and it's possible that I completely missed the ciritical point of the project.

    TSS needs a preview option for posts ;-)
  4. I liked Barry's first take better than his recantation.

    XML is over-hyped and over-used, and using it for a programming language syntax defies everything we know about good language design.
  5. XML is over-hyped and over-used, and using it for a programming language syntax defies everything we know about good language design.
    Can you expand on this? What do we know about good language design?

    If by good design you mean full and useful functionality, then xml will not affect this in anyway. It determines /how/ the language is represented, not /what/ gets represented. Since all languages end up being analysed as some kind of abstract syntax tree, then using a representation geared towards trees seems to make alot of sense.

    If by good design you mean being easy to write by hand, then I agree that something like Java is easier to write than an xml equivalent. But with an xml version, at least you have something that is easier to manipulate using generators and graphical tools. With xml, we have a much better chance of at last getting away from having to code everything by hand.

    What we're after is a way of expressing the structure and functionality of a required system. Traditional source code is one way of doing that. But it doesn't have to be the only way. Why don't we use tools and technologies to make other, more natural ways possible too?

    Regards
    Kit
  6. But with an xml version, at least you have something that is easier to manipulate using generators and graphical tools.
    Code generation, graphical representations, sure.
    But I don't think creating a whole new "programming language" in XML will do the trick to facilitate in that.
    With xml, we have a much better chance of at last getting away from having to code everything by hand.What we're after is a way of expressing the structure and functionality of a required system. Traditional source code is one way of doing that. But it doesn't have to be the only way. Why don't we use tools and technologies to make other, more natural ways possible
    Sounds a bit like the presentation I had on the OMG days when they first came out with MDA, enough said on that :-)
  7. Code generation, graphical representations, sure.But I don't think creating a whole new "programming language" in XML will do the trick to facilitate in that.
    A programming language is only a means to an end, to represent the structure and behaviour of a system. This is why UML and other graphical notations are also described as "languages". When UML gets exported to XMI, it doesn't make UML less valid. It's the terms and concepts included in the language that decide how good it is at solving problems, not its representation.

    I agree that you don't need to create a new language, just represent an existing language like Java in XML. But to me the important issue is not that it is in XML, but that the terms and concepts are well thought out.

    I think XML is a very useful and enabling format for representing programming languages, /unless/ one of the requirements of the language is that it must be easy to write by hand. But then I like the idea of MDA (you guessed, didn't you! ;o) so I am trying to avoid that if I can.

    Regards
    Kit
  8. Not all that bad an idea ...[ Go to top ]

    Since all languages end up being analysed as some kind of abstract syntax tree, then using a representation geared towards trees seems to make alot of sense.
    Anybody heard of "CodeDOM" (from the other side of the world)? Works pretty well. If you can represent the lexical structure of a program in a tree-form in memory, then why not store it on disk as well !

    Been working on a J2EE product that interoperates with .NET

    aXe!
  9. XML is over-hyped and over-used, and using it for a programming language syntax defies everything we know about good language design.
    Is that why we have not streamlined any of the development techniques? Is that why projects take as much time as they do, where most of such time is wasted on coding, rather than on the architecture and design, because we all are trying to abide to the good language design of a free-form low-level language stack?
    Is that why we cannot take business requirements and directly translate them into executable business "rules"? Why does the business have to suffer cost and time wise, because of a developer's need to be sophisticated and always provide solutions in most "complicated" fashion? Is that because we all are so proud of the complexity we have to deal with as far as the ALMIGHTY syntax and lexicon driven programming language spec? Is it because of developers who do not want to be "dummied down" by the easiness of using prebuilt components and so they write everything themselves, again and again. Such people are good for pioneering new heights and designing and implementing new ideas, but for the immediate business need and requirement, reusability, standardization and clarity is a must, so there we all fail, with our love to be the "scientists" of the computer world and craving to constantly do our research and extend our knowledge, but unfortunately at expense of others and with no immediate benefit to others (business)...

    What do you mean by XML being over-hyped? It is being successfully used in a bulk of Web enterprise applications, in B2B applications as metadata and as transformation language. If you do not like XML being a programming language, than you have to admit not liking XSL as it is an XML document with logic bound to its XML components and to make it short - it is a language, transformation or whatever, but it is a programming language with specific area of application, and XSL is taking a broader acceptance every day.

    You do not like XML to be a programming language because you are used to free-form logic definition and doing whatever you want in the code, because any low-level language would allow you for it, where XML is strict towards the exact representation of itself. But the strictness is the only way to make sure standards and specifications are followed and that developer's community finally has an idea without spending too much time on it, about the standard.

    Tell me what is a difference between the following:

    <condition>
     <some condition/>
     <some associated action>
     .
     .
     .
     <some condition/>
     <some associated action>
    </condition>

    and

    if (some condition) {
     some action
    }
    else (some condition) {
     some action
    }
    .
    .
    .

    What is not being preserved as far as the
    good language design.
    Tell me, as I would like to know, to make sure I do preserve the “good language design” in XML-like programming language.

    Sincerely,

    Artem D. Yegorov
  10. What do you mean by XML being over-hyped? It is being successfully used in a bulk of Web enterprise applications (...)
    I somehow don't think you should look at success stories when confronted with criticism.

    XML has been used in a host of applications that have not been successful. I claim that this represent most of the uses of XML. Using XML is not a panacea.

    Some uses have flourished, and these are all without exception uses where the XML format has added something in some way.

    yours
    Geir Hedemark
  11. XML is not a panacea, as XML by itself is nothing but a data represented in a structure and without a set of tools one cannot even access it programmatically.

    The tools is what matters and I agree that there has been a whole lot of fiascos in the example area that I have cited, but there were still plenty of successes, but again such were attributed to the tools written on top of the XML spec but not to XML itself.

    And I am not saying ActiveXML is a panacea (I am surprised it has caused such a violent surge of ... "hate" I guess), it is just another way to approach programming and things revolving around such.

    Sincerely,

    Artem D. Yegorov
  12. Tell me, as I would like to know, to make sure I do preserve the “good language design” in XML-like programming language.Sincerely,Artem D. Yegorov
    I suggest the following article:
    http://www2.inf.ethz.ch/~meyer/publications/oxford-hoare/evolution.pdf

    Regards,
    Henrique Steckelberg
  13. I suggest the following article:http://www2.inf.ethz.ch/~meyer/publications/oxford-hoare/evolution.pdf
    How does your suggestion answer the original question?
    Tell me what is a difference between the following:

    <condition>
     <some condition/>
     <some associated action>
     .
     .
     .
     <some condition/>
     <some associated action>
    </condition>

    and

    if (some condition) {
     some action
    }
    else (some condition) {
     some action
    }
    .
    .
    .

    What is not being preserved as far as the
    good language design.
    Tell me, as I would like to know, to make sure I do preserve the “good language design” in XML-like programming language.
    As the article describes the concepts and paradigms of the essential non-XML-like programming languages (Java, C++ and etc) and which I am well aware of and the questions was on what exactly is missing, if two scriplets above are compared, from the XML-like notation as far the good design principle.

    Sincerely,

    Artem D. Yegorov
  14. As far as I know, there are sintax issues regarding XML languages: they are much more verbose (given all the ">", "<", "/"), for one. I agree that tools could help here, or even what has already been proposed: translate from an existing language (Java, etc.) to XML before processing it. There is a topic on the article specifically about syntax.

    Regards,
    Henrique Steckelberg
  15. You are right, XML is verbose, but we still stick to the XML metadata for readability and for easiness of writing GUI management tools to work around the verboseness issue. I am not able to do everything at once. ActiveXML was me from the begining to the end. So today it is the framework and the language and tomorrow it is the IDE. Give me time or help me.

    Sincerely,

    Artem D. Yegorov
  16. I did not want to reply to your previous message, as again I did not see anything but judgmental rumble. I appreciate critics, as this is the best way to get things in one's project improved and enhanced.
    As far as clarification though, on what the project is and if you haven't read the documentation, please allow me to explain in more detail:

    ActiveXML is indeed a language with a VM and a compiler and yes you are right - human readable format like Java or C/C++ syntax if much easier to use if you are being as wordy as it is required by an application written in such language, but with ActiveXML the main goal was to cut on the amount of code one has to put out where most of the code, being Java or C++ is encapsulate within components (call them beans if you want to) and such components are bound to the XML-names. ActiveXML indeed has components that implement low-level elements like conditions and loops, but that to accommodate the convenience and need for complicated processing within a particular "rule". Most of the times one would not use such low level components, but would instead encapsulate reusable business logic within a component and bind it so it becomes an ActiveXML component.

    Tell me what is easier to read in this particular example:

    <jdbc-result datasource-id="some datasource">
      select some_columns from some_table where ...
    </jdbc-result>

    or

    Class.forName("some driver");
    Connection con = DriverManager.getConnection(url, username, password);
    Statement st = con.createStatement("select some_columns from some_table where ...");
    ResultSet rs = st.executeQuery();

    Why not reuse the latter Java code once and for all and let other developers enjoy the architecture and implementation of the actual application, not thinking about specifics on how to instantiate a particular connection, how to handle the exceptions, the closing and etc. Would you rather worry about the business requirements and technical specifications of the application at hand, or every time you would worry about hundred other things, which will potentially, damage the timeline of you project and the quality of the project.

    As far as proprietary comment is concerned, than you are right again - this framework and its syntax is proprietary and there is nothing to be ashamed of, as this is a new project, this is another way to look at things, this could become a standard, with useful input from the developer's community on what might be good to add, change or redo, this could be a useful thing and unfortunately judgmental bashing of other's idea's does not help and drags other people, otherwise ready to benefit the project with their commentary and possibly work, in to this bashing and mindless arguing of how the world is unfair and how XML has annoyed everybody...I am sorry that it did for you, but there are other people who use it and enjoy its predictability in representation and flow. Once again, do read the document, check the source and have the sample app done, and then you can criticize ActiveXML any way you want to, but with the facts and quotes from the sources I mentioned, so I can use it to make the project better.

    I understand comments on XML being over-used and all, but what is the difference what each developer or a project uses XML for, as long as the result of such use is a functional application? I see XML's strength being in the fact that it can be whatever one perceives it to be and it is understood cross platform as well.

    Sincerely,

    Artem D. Yegorov
  17. 4GL versus YAS[ Go to top ]

    Tell me what is easier to read in this particular example:

    <jdbc-result datasource-id="some datasource">
    select some_columns from some_table where ...
    </jdbc-result>orClass.forName("some driver");

    Connection con = DriverManager.getConnection(url, username, password);
    Statement st = con.createStatement("select some_columns from some_table where ...");
    ResultSet rs = st.executeQuery();

    Why not reuse the latter Java code once and for all and let other developers
    This is not anything like a 4GL, IMHO.

    What you are writing here is a repackaging of the old statement paradigm using XML (and you also leave out the configuration bits in the XML case while including them in the Java case).

    We already have tools that provide this functionality using other encapsulations. Hibernate and JDO come to mind. JSTL has a similar functionality which is XML-ish in nature, but which people don't seem to use very much because it does not provide enough benefits.

    I haven't looked at ActiveXML. From what you have said here, there doesn't seem to be any new, compelling reasons to invest time in looking at it - it is just the same, old boring way of going about my business, repackaged in XML, with a toolchain that is, by necessity, new and buggy. I can't see where the return on my invested time would appear.

    "It is more general" is not something I can translate to a something that benefits me, most of the time. Usually, gratuitious generalizations are not cost effective. The "swiss army knife" and "golden hammer" antipatterns spring to mind.

    You seem to think ActiveXML is a good idea. I feel kind of dense not being able to see your point of view. Could you please elaborate on why ActiveXML is a step forward? What can it actually do that I can't do now? Does it ease testing? Design? Maintainability? Implementation?

    yours
    Geir Hedemark
  18. 4GL versus YAS[ Go to top ]

    I would gladly ellaborate, as you do indeed have a point.

    I did leave out the configuration, examples of which you can see in the documentation, where such is a not that complicated.

    I wish one would read the draft documentation offered on site, to alleviate the unclarities and I would suggest that, but I would also try and explain here:
    The example I have provided is indeed something that you have all over the place with Hibernate, JDO and etc.
    But keep in mind - it was just an example, consider this as another example:

    <imap-folder datasource-id="some imap server" folder-name="Inbox"/>

    This is another example of the resource component feature of activeXML, but though has nothing to do with Hibernate and JDO...Yes, you can extend both to support the functionality, but it is going to be new and buggy.

    Consider this:

    <trasform>
     <some xml as Text, Document or Element/>
     <xsl inline or returned/>
    </transform>

    and this:

    <iterate>
     <xml over xpath iteration, collections, enumerations, tokenized strings, io streams by character and by line, result sets/>
     <some action/>
    </iterate>

    And also consider scope drive variable definition and by reference and by value access, self-assessment and run-time compilation, definable compilation-time validation, integrated logging (log4j) with run-time per component tracing and level manipulation as well as logging control based on the class inheritance hierarchy and logging output evaluation with regular expression, dynamic initialization of the VM and compiler via extensible filtering mechanism, extensible XML document compilation routines and type bindings, auto-discovery and bindings of non-ActiveXML API classes and class methods. Binding of ActiveXML documents to the XML names for reuse and etc. (more covered in the documentation and I do not want to rewrite all of it here, please do look at it).

    Sincerely,

    Artem D. Yegorov
  19. Just to make something clear: XML has it's use, but this is not it :-)
    In software, everything is ultimately data, even programs.

    The best thing about XML for me is that it can be processed by XSLT. What the XML represents is immaterial. It could be anything, including source code.

    For which other programming language could you write a simple script to analyse a piece of code and transform it for what ever purpose you want. Eg: bytecode for execution, documentation (a la Javadoc), graphical round-trip code builder.

    All made alot easier by using XML.

    Regards
    Kit
  20. The wheel, reinvented[ Go to top ]

    In software, everything is ultimately data, even programs.
    <br>right, so why not code in Lisp directly then?
  21. The wheel, reinvented[ Go to top ]

    You are right, but besides the wheel being reinvented it could also be enhanced and made better and more functional. Take it from that perspective. ActiveXML might strike a similarity with various different frameworks, languages and engines, and such has been a design thought - To reuse existing widely accepted ideas and upon such create a more concise and functional task-oriented programming language.

    Sincerely,

    Artem D. Yegorov
  22. The wheel, reinvented[ Go to top ]

    In software, everything is ultimately data, even programs.
    <br>right, so why not code in Lisp directly then?
    Sorry, I'm not familiar with Lisp so I don't understand your point. I am happy to be enlightened!

    But I imagine that if you want to use Lisp, you need a Lisp compiler (or interpreter) which must include a Lisp lexer. For maintenance of large Lisp projects you might also want Lisp generators, debuggers, documenters, diagrammers, profilers, code analysers, pretty printers, etc.

    The software industry is awash with tools that maintain and manipulate source code. A every language has to have a different set of tools. And writing such tools is not insignificant. How much easier it would be if it was all in XML!

    Regards
    Kit
  23. You jest surely?[ Go to top ]

    XML syntax is unredeemingly ugly, it only makes sense for embedding
    occasional markup directives, and really doesn't at all for
    a programming language. Anyone who's used Lisp knows programs
    are data, but given a choice between XML and Lisp, I know which
    one I'd choose.

    Of course there's no deep reason not to define a mapping from
    XML to/from Common Lisp should you really want the hassle of
    typing all those < and > and doing comparison operators like >=

    As far as I can see to only features of XML useful for programming
    languages are the nested syntax and namespaces, everything else
    about it makes things worse than early Fortran... I mean you can't
    even comment to end-of-line...
  24. Re: You jest surely?[ Go to top ]

    XML syntax is unredeemingly ugly, it only makes sense for embeddingoccasional markup directives, and really doesn't at all fora programming language. Anyone who's used Lisp knows programsare data, but given a choice between XML and Lisp, I know whichone I'd choose.
    I would entirely agree, *unless* there is actually no requirement for the code to be written *by hand*. This might seem strange in the traditional 3gl world, but when the language is aimed at the 4gl/BPM market, having a graphical builder is definitely the way to go. And, having built such a tool myself, I know this is made much easier by using an xml representation rather than a non-xml one. Hand-coding source code isn't required in all situations and with some current trends (eg. MDA, BPM), those situations are likely to increase in number.

    Rereading these posts, I appear to have come across as more of an xml zealot than I actually am. I certainly don't advocate it for everything but as a language for high-level process description, it seems fairly appropriate to me.

    Regards
    Kit
  25. Remake of Jelly?
  26. It does strike similarity, but the approach and the goal is different, although Jelly would be a good example of Java-to-XML bindings and ActiveXML could resemble somewhat of Jelly, but having a more strict API and more flexibility as far as compiling/processing of the actual XML document via dynamic Types and Instructions. To be more familiar, please chek out the doucmentation.

    Sincerely,

    Artem D. Yegorov
  27. xml based algorithm description is a BIG step forward to easy AI implementation:
    in this way it is easy to create systems with dynamic algorithms - changing xml representation algorithm is much more easy then changing java representation.


    denik.
  28. ActiveXML 1.0: XML as a 4th generation language[ Go to top ]

    -> Artem D. Yegorov

    ne nadrivaites - im trudno poniat' novie veschi - oni ne chuvstvuut dvizheniya tehnologiy, oni sposobny myslit' tol'ko na osnovanii kakogoto fundamenta, im slabo sozdat' noviy

    denik.
  29. Denik,

    Ogromnoye spasibo za podderzhku. Ya nachinayu priderzhivat'sya toy zhe samoy tochki zreniya. Priyatno kogda vstrechayesh' lyudey umeyuzhih mislit' vne "fundamenta" kakoy-libo bazi. Ezhe raz ogromnoye spasibo!

    Artem
  30. Artem's description of ActiveXML sounds like a good project to provide an efficient way to link components together in an SOA environment. Why should the ActiveX developers of the world have all the fun? :-)

    I'm not sure why the project needs a scripting language? ActiveXML includes the XSSL - eXtensible Server Side Language - to define runtime rules of how components interact in a workflow. It seems to me that Java, Jython, or Groovy would be better at writing scripts. These are already first class languages. XSSL would need conditionals, expression evaluation, string/number formatting, lists/tuples/collections, flow control, interfaces to the system devices (files, network, etc.), exception handling, and classes. For an open source project that seems like a big effort.

    By the way, TestMaker 2 implemented an XML scripting language back in 1999. Eventually I replaced it for Jython when I realized how much effort it would be to make the TestMaker XML language a first class language.

    -Frank
  31. I apreciate the support and ActiveXML really does not have a scripting language, instead all of the
    conditionals, expression evaluation, string/number formatting, lists/tuples/collections, flow control, interfaces to the system devices (files, network, etc.), exception handling, and classes
    can be implemented (many already are) as ActiveXML components, thus everything is 100% component-oriented.

    Consider an example:

    <append>

       <define>
          <http-parameter name="productCode" object-id="product-code"/>
       </define>

       <jdbc-xml table="inventory" row="item">
         <jdbc-result datasource-id="inventory">
            <append>
               select * from
               <condition>
                <starts-with:product-code>
                  book
                </start-with:product-code>
                <text>book_inventory</text>
                <starts-with:product-code>
                  compact
                </start-with:product-code>
                <text>cd_inventory</text>
              </condition>
               where product_cd = <object:product-code/>
            </append>
         </jdbc-result>
      </jdbc-xml>
    </append>

    This will retrieve a request parameter productCode, evaluate it to figure out which product category the product code relates to, to define which table to query and return the results based on the productCode as xml. This is not a extremely well defined example, but it shows some conditional logic and use of variables.

    Sincerely,

    Artem D. Yegorov
  32. An update (cannot do an inline bind paramter inthis case as the query is being built dynamically within the <append/> component and therefore the <object:product-code/> will be executed by the <append/> rather than by <jdbc-result/>):

    <append>

       <define>
          <http-parameter name="productCode" object-id="product-code"/>
       </define>

       <jdbc-xml table="inventory" row="item">
         <jdbc-result datasource-id="inventory">
            <append>
               select * from
               
               <condition>
                <starts-with:product-code>
                  book
                </start-with:product-code>
                <text>book_inventory</text>
                
                <starts-with:product-code>
                  compact
                </start-with:product-code>
                <text>cd_inventory</text>
              </condition>

               where product_cd = ?
            </append>

            <object:product-code bind-index="1"/>
         </jdbc-result>
      </jdbc-xml>
    </append>
  33. God help us. I can't wait to hear all of the supporters claiming how great this will be because of what you can do with XSL now that everything is XML. Sorry to sound cynical, but XSL is pretty much garbage for anything beyond page layout, and even then, if I had options, I'd use them. As others here, I fail to see the significance of this or any advantages it grants over existing languages and tools. If you want to simplify things, design for simplicity. Don't introduce a whole new layer that adds more syntactical garbage to the process of solving the problem at hand. There are a lot of really nice examples here of the coding that an XML language will somehow save you, but none of them are based on any connection to the real world that I've seen. The JDBC connection example is my favorite. You know what I do when I need to handle data access in my apps? I use hibernate, and then I can do this:

    Company c = new Company("Company name");
    Session session = this.getSession();
    session.save(c);
    session.close();

    Not very difficult at all. I fail to see how XML will simplify that. I also fail to see how an xml representation of something for the express purpose of letting it be manipulated by XSL helps on the display side, either, when I can use any combination of Jsps, Velocity, sitemesh, tiles, etc. that I want, and usually explain it to another programmer in 5 minutes.
  34. What do you do when you need access to your LDAP, IMAP, POP and other non-JDBC data sources??? I do not think you use Hibernate for that...

    And by the way, please do include the Hibernate configuration file that allows you to do
    Company c = new Company("Company name");
    Session session = this.getSession();
    session.save(c);
    session.close();
    By the way, XSL is used for data-to-data mappings and FO transformation, the page layout is just one of the things, sorry you did not know that and ActiveXML has no direct relationship with XSL, you might have confused it with XSSL (eXtensible Server Side Language) that it has.

    Yeah and consider you example in ActiveXML:
    <company name="Company name"/>
    I bet this is easier...just by line count :-)...and believe, if you read the documentation, by the implementation to.

    Sincerely,

    Artem D. Yegorov
  35. Look, this is kind of a silly reply. Yes, I didn't show the hibernate file. But that's a whole other argument. The reason I use hibernate is because I keep my ORM configuration separate from my code. Otherwise, I get SQL statements embedded in my code, as your example shows. That's a bad idea, whether you're programming in Java or XML.

    The point is that there are ways to design your access to data (or LDAP, or IMAP, or POP) that reduce the complexity of the code and can make it easy to handle in a few lines. That's what things like IoC and a layered architecture can do for you. You're attempting to solve the complexity issue in a different way, using a language that is overly verbose for most programming constructs along with proprietary handling of access to common resources. What if I don't want to embed SQL in my code? I don't know from the examples I've seen how ActiveXML will let me use another data architecture, or how it will let me access LDAP or IMAP in any way other than the default mechanisms you've built in. I'd rather solve those problems myself because the solutions usually differ from project to project. I can still use best practices so I don't reinvent the wheel.
  36. I won't get involved in the argument that does not have any point, especially that you have not had time to read the documentation and therefore have all those questions and assumptions. Read the very first post! It talks about DOCUMENTATION being available. I will just clarify couple of things.

    As far as your ORM mappings and configuration file being another matter - it is not, it is the exact matter, at tell me what do you use as the configuration preferred format...hmm...let me guess...XML...

    And as far as assuming that one can easily write stuff for LDAP, IMAP and etc. Try using JavaMail API and working with the multipart message, than tell me how easy that is and how clear that is.

    The problem is that you haven't grasped the concept, as again, you have not read the documentation. ActiveXML is an attempt to generalize best practices and bind such to XML names, so you or anybody else would not have to worry about best practices and spend days on Google figuring out how exactly to extract INLINE attachments from a message via JavaMail API, or how to cross reference objects in the LDAP directory and the Relational Database and etc.
    You want to do it yourself...well I hope the business you are working for is ready to fund your research and extra time you will spend on it every time you embark on delivering another solution.

    I might sound judgemental and harsh, but I am sick and tired for reading all the posts based on nothing but hot air and emotion. I will reiterate again - READ THE ActiveXML DOCUMENTATION and then present me with the valid arguments. Because lot's of unclarities are clarified there. I've spent some time on it for that reason alone and I thing it covers quite a bit of stuff. Check it out.

    To answer you question about embedding SQL in your code (it is covered in the documentation by the way), here is another example:

    <jdbc-result datasource-id="so and so">
       ${/sql-metadata/some-category/some-query-id}
       .
       .
       .
    </jdbc-result>

    or

    <jdbc-result datasource-id="so and so">
      <parameter:sql-metadata path="/some-category/some-query-id"/>
      .
      .
      .
    </jdbc-result>

    or

    <jdbc-result datasource-id="so and so">
      <parameter datasource-id="sql-metadata" path="/some-category/some-query-id"/>
      .
      .
      .
    </jdbc-result>

    This is an example on how to pull values out of XML metadata (defined as an XML datasource) using XPath via ActiveXML. In this example sql-metadata is the id for the one of the registered XML Datasources (read documentation) and /some-category/some-query-id is the XPath for the SQL query.

    So, to answer your question again - ActiveXML allows for configuration files and not having to embed configuration data in the code.

    Sincerely,

    Artem D. Yegorov
  37. I can use any combination of Jsps, Velocity, sitemesh, tiles, etc. that I want
    This is the principal things that scares me - doing whatever you want with a whole bunch of different technologies will create an unsupportable, unreadable mess that will be some complex and hard to understand, I do not even want to compare it with clear to read and follow XML document. Stick to a standard or otherwise you will fail on the long run.
    explain it to another programmer in 5 minutes
    I would like to see this explanation, might quote an example of such? How about it a 5 minute explanation of mixing Velocity, JSPs, Tiles and so on compared to an XSL template explanation and the XML data structure behind? Come on, be realistic!

    Sincerely,

    Artem D. Yegorov
  38. My point is not "hey, I can do everything I want, so I'll just mix it all together!". My point is that there are many ways to approach the layout of page elements, and some are more suited to certain projects than others. The Java toolset doesn't force one way of doing things. Even within frameworks like Struts and Webwork, there are options. An unsupportable, unreadable mess is the result of choosing a mish mash of technologies, but the intelligent assembly of a set of complementary technologies can result in quite the opposite.

    Your standard is a set of proprietary mechanisms for dealing with important things like data access, resource access, etc. The "language", xml, is not proprietary, but your use of it is. If I wanted to stick to one monolithic approach to all of these important issues, I'd be working with .NET.

    As for a 5 minute explanation, the velocity syntax guide is half a page long. JSPs aren't much more difficult for anyone with any experience with web pages. XSL, on the other hand, is an unmitigated nightmare. XSL is something that a lot of people have a hard time getting their heads around, because it's a completely different way of thinking of things. Unfortunately, once you've come around, you realize that the different way of thinking of things isn't really that useful compared to the effort it took to get there. There are other, more natural ways to represent data transformations, at least for most of the things that XSL gets used for. An XML data structure isn't hard to read, but the combination of understanding the true meaning of a set of proprietary tags can be.
  39. And again, who claimed that ActiveXML is based on the proprietory standards?
    ActiveXML has been written towards open standards.
    It is based on, uses and supports XML, XSL, Xalan, JDOM, Sturts (access module), JDBC, JNDI, JavaMail, RegEx, etc. and one can easily integrate Velocity or any other APIs and have a native non-proprietory support for such including configuration files. That is what ActiveXML does. And if you tell me that binding a A.class to <a-class/> name creates a proprietory language...well I am sorry to hear that, because any other dynamic framework including Hibernate, forces you to create proprietory metadata...

    And another thing...ActiveXML does support Hibernate...and if you do not like how it supports Hibernate...well, write yout own ActiveXML component...do everything yourself, but do it once and reuse it via metadata, what is so wrong about that?

    Sincerely,

    Artem D. Yegorov
  40. For those interested in JDBC, JavaMail, HTTP and Struts components of ActiveXML, I will be releasing the documentation by 7/09/2004 and will make it available on the web site.

    I will also try to get the ActiveXML Core Documentation to Draft 2, including examples, best practices, road map and etc. by 7/16/2004.

    I will post the release schedule on the web site ASAP.

    Sincerely,

    Artem D. Yegorov
  41. Bullshit[ Go to top ]

    ActiveXML makes the baby jesus cry!

    Nobody needs another bullshit XML language!! Enough already!
  42. Bullshit[ Go to top ]

    Looks like you got into a wrong place, buddy. Bullshit is only what you are saying. I guess you are one of those "IT" people who have never achieved anything in their life and always cry how they are mistunderstood and unapreciated. Probably you have been supporting the same client/server application for last 15 years, huh, buddy? Still fighting for COBOL? or maybe FORTRAN?
    Get a life, dude!

    And just remember, any opinion is respected, as long as it is voiced intelligently and politely, your's though, well you just made an ass of yourself, my friend.

    And I certainly hope the baby jesus keeps on crying as those are the tears of joy! Ponder on that, friend! :-)
  43. Unbeleivable bullshit[ Go to top ]

    Actually, I'd like to direct that one to you! You're one of those people not getting out much, because he's inventing some NewAndRevolutionary thing that'll blow everybody away. Do you see anyone using that 1060 NetKernel bullshit? Do you see anyone using Jelly? And here you are with yet another piece of shit to add to that list.

    Seriously, why do you want to code in XML? What value does that add? It's not 1999 anymore, people use XML for storing documents in an easily convertable format, and XML for configuration. XML isn't new anymore. The NewAndShinyToysWankers use Ruby and/or the other new scripting languages, play aroud with an IoC container, talk/wave arms at SOA, etc.
  44. Unbeleivable bullshit[ Go to top ]

    It looks like you've gotten to know a whole bunch of buzz words, but truly do not understand what they mean. Look at your own post - it consists of as much intelligence as 1 year old baby's mumbling does, if not less. Where are the facts? Where are the examples? All you know is words “bullshit” and “unbelievable”, which persists in your mindless posts all over TSS.

    Hey, there is a crazy idea - you are probably still a kid, and than I can understand your vocabulary lacking intelligence as you lack experience.

    Why another XML language, you ask? Well, do indeed take a look at SOA and tell me that XML as metadata and as flow and task oriented language is not present in its implementations...:-) Take a look at workflow definition languages...Take a look at what defines UML? A whole bunch of XML metadata and language varieties. There is no going away from XML, but one can come up with an integration language or intelligent metadata to be able to standardize all of those different tasks and efforts.

    You just do not know what you are talking about...Again, stop supporting that application of yours and open your eyes to the world, my friend. It helps to read too and get some education to straighten that brain of yours. Do not post anything; until you have some knowledge to back it up, you look stupid otherwise.

    Sincerely,

    Artem D. Yegorov
  45. Even more bullshit[ Go to top ]

    I just find ActiveXML hugely offending. Makes me want to rip my eyes right out of my face!

    To facts:
    I did compare activexml to jelly and 1060 netkernel.

    And sure, XML works well as a storage/carrier of meta- and configuration data. I said so in a previous post.

    XML defines UML? Really? No, there's a format that you can use to persist a UML diagram. There's nothing XML with UML. And from looking at what you're doing with XML, I can see that it is possible to use XML for whatever you claim. The POINT is, however, that it's a bad idea. XML as such doesn't lend itself to be as easily readable as a language such as C and Java. And to cut to the chase, I know you can present unreadable C code, that doesn't make C unreadable.

    Just answer my question from my previous post: what makes XML a better choice than a custom script language using civilised tokens and expressions?

    It's so typical for people like you to bring examples like you do too. That datasource vs. jdbc code example is SILLY! That example, as peopel have already pointed out, hides LOTS of setup and configuration code. You yourself used that argument against people here wanting to use frameworks instead of pure JDBC. Then why, mr Yegorov, do you hide such pieces of cludge yourself?

    XML is data. It always was and it'll always be. Stray away from that fact and you end up with abominations like what you have created here and a bunch of other tools that people hate. Do the developer community a favour and crawl back under the rock from under which you emerged and take ActiveXML with you.
  46. Even more bullshit[ Go to top ]

    Just answer my question from my previous post: what makes XML a better choice than a custom script language using civilised tokens and expressions?
    It is not, as it is not used for what any script language will be used for. It uses are described in the doucmentation and in the previous posts. Period. This is not Java or C replacement, I did not say that, you did. ActiveXML is not as lowel-level as C or Java and it heavily employs Java in defining its components, but for the reuse sake and for delivering business logic straight out of the business requirements, for those things ActiveXML has been created and is being successfuly used. Wanna do buisness logic coupled JSPs, go ahead. I don't, but I am not making anybody follow along. It is a free choice.
    XML defines UML? Really? No, there's a format that you can use to persist a UML diagram. There's nothing XML with UML
    To the UML point, I did not say that UML derives from XML, but in many cases and, you rephrased me at that, UML diagrams are indeed persisted as XML or DEFINED by XML or whichever other word you may use.

    XML is the metadata of choice for a lot of applications, frameworks and etc. ActiveXML is a metadata language, configuration or whatever makes you sleep better, for the business logic. That is it. Your business components, as high level or low level as you wanna get, are defined in Java and used via bindings to configure a particular business rule. Happy? I used the word CONFIGURE, not CODE.
    It's so typical for people like you to bring examples like you do too. That datasource vs. jdbc code example is SILLY! That example, as peopel have already pointed out, hides LOTS of setup and configuration code. You yourself used that argument against people here wanting to use frameworks instead of pure JDBC. Then why, mr Yegorov, do you hide such pieces of cludge yourself?
    Tell what exactly you find cludgy based on the documentation provied examples? Have you even looked at it? I never hid the fact of such examples and additional configuration being present, I initally pointed everybody to have a look at the DOCUMENT.
    XML is data. It always was and it'll always be. Stray away from that fact and you end up with abominations like what you have created here and a bunch of other tools that people hate. Do the developer community a favour and crawl back under the rock from under which you emerged and take ActiveXML with you.

    Everything is data. If you have not realized that by now, well to bad. So why don't YOU do the developer's community a favour and free us from your incoherent mumbling and offensive content. Go back into your "I SAY BULLSHIT A LOT" hole and never show your face again.
  47. Even more bullshit[ Go to top ]

    And to reiterate:

    ActiveXML has never been intended as a panacea for everything. It is not. It is good for what it does: business requirements to business rule translation. It was never intended for ActiveXML to replace any other language.

    Those who want to check it out and use it, you are more than welcome. But if you don't mind, please spare me the agressive comments, if the idea goes against your principles and your ideas.

    I did what I did and I will stand by it. It has been a lot of work for me and I am proud of it. If you feel offended by ActiveXML, my apologies.

    Sincerely,

    Artem D. Yegorov
  48. Aleph 1 BS ;-)[ Go to top ]

    Here be trolls; but, on to a more serious note:

    The only justification you've made that actually holds water is that the language is a configuration/integration language only, fair enough, horses for courses.

    Hovever, you agressive defense of XML was really completely over the top, and I think that was what caused most of the hostility. People like to vent about things as overhyped as XML, you made youself look like an XML zealot and that is asking for a flaming.

    XML zealots are like kids that have just found out about masturbation, they want to XML all day every day - XML for everything. Sometimes they mature, maybe it's XML a few times a week, a web service here, and configuration file there, maybe some XSL occasionally; sometimes they don't.


    XML has structure, big woop. We have this mutant tree type with a serialisation standard. So we can jam any syntax tree into XML; it doesn't mean that we should all snort freebased XML 24/7.

    If you haven't head of LISP then I can assume that you are very inexperienced in the area of program language development & structure representation. I'm going to let you in on a secret - in those dark days before XML when we wanted to get a structure we used something called a parser. In fact the horrible truth is that XML structures can only be revealed through one these mystical devices.

    A well formed XML document (even a schema vaildated one) is not much closer to to an executable program than a text file, and without attached logic pretty near useless for transformation as well. Sure a human can read it and try and out guess the crazy bastard that defined the tags, but for a machine it's no more than a checksum.

    Java could easily be expressed in XML, and yes transforming it would be useful (XSL has its problems, but XDoclet XDT is no better). However it is just a question of different ways of serialising the tree: we don't have to write java in XML, and get unreadable files 3x the size - all I would need to do to use XSLT on java is wite a serialiser/deserialiser (SAX, DOM, whatever)to interface Java to the XSLT engine.

    I'm not saying you language is useless, but being in XML confers no special virtue at all; maybe for this application an XML encoded syntax is just what is needed, but never forget that configurability must be part of a carefully designed framework - a framework that XML does not provide in itself.
  49. Re: Aleph 1 BS ;-)[ Go to top ]

    Hi Clive,

    Not sure who you're replying to here. Some seems to be aimed at Artem Yegorov and some me. I am not involved at all in the ActiveXML project and I know nothing about it.

    However, some of the criticism that was aimed at the project was made purely because it used XML for the processing language. I have tried to point out that in many cases, using XML as such is a reasonable choice and can bring many positive benefits. You obviously disagree :) though your argument seems to be just that XML is "mutant", period.

    Anyway, it's bad practice to reply to trolls, so I'll leave it. I've put all the points I wanted to make in other posts so reread to get the full picture.

    Regards
    Kit
  50. Aleph 1 BS ;-)[ Go to top ]

    Hovever, you agressive defense of XML was really completely over the top, and I think that was what caused most of the hostility. People like to vent about things as overhyped as XML, you made youself look like an XML zealot and that is asking for a flaming.
    I am not defending XML, I am defending ActiveXML which is my project, raw XML is nothing but the structured data representation, why defend that? The fact that people started being agressive with the first post, does not make me an XML zealot. All I did is announced the release of version one and provided some detail in the first post. Ever since it has been this stupid bashing. Sorry, dude, I am no XML zealot and I apreciate other languages like Java and C and Perl and so on and on; and I tend to realize the uses of one over the other. So, please, spare the patronizng.
    XML zealots are like kids that have just found out about masturbation, they want to XML all day every day - XML for everything. Sometimes they mature, maybe it's XML a few times a week, a web service here, and configuration file there, maybe some XSL occasionally; sometimes they don't.
    Web Services? XSL? You telling me those are not based on XML? Come on, dude, XSL is a well-formed XML, just a parser is able to parse all the "XSL" namespaced components as "active" logic bound components. Majority of Web Services specification, at least those offered by SUN, are based on XML and the implementation includes things like JAXB, JAXR, JAXP and etc. You do know what "X" there stands for, right? XML, dude! So those XML zealots never take a break as it is all XML from your examples. So what is your point? It looks like you are as much into XML as anybody else? Possibly you haven't realized that yet,as lots of XML-based frameworks hide the XML behind the API as such is unreadable and which is perfectly fine. ActiveXML does the same thing too. Just never had a time to hide it completely by a fancy GUI. :-)
    If you haven't head of LISP then I can assume that you are very inexperienced in the area of program language development & structure representation. I'm going to let you in on a secret - in those dark days before XML when we wanted to get a structure we used something called a parser. In fact the horrible truth is that XML structures can only be revealed through one these mystical devices.
    When did I say that? You just like to jump to conclusions, my friend. Can you quote me saying that I have never heard of LISP? You are kidding me right, dude?
    So keep your secrets and your tone with you as your assumption is wrong. Interesting thing is though that I still do not understand what LISP has to do with ActiveXML which does not posess a syntax driven language anyway? Why would you even bring it up in relationship to ActiveXML???
    A well formed XML document (even a schema vaildated one) is not much closer to to an executable program than a text file, and without attached logic pretty near useless for transformation as well. Sure a human can read it and try and out guess the crazy bastard that defined the tags, but for a machine it's no more than a checksum.
    And any other Java or C or some other script or syntax language program is nothing without an interpreter and/or a compiler and a ton of other "mystical devices", so what is your point?
    Java could easily be expressed in XML, and yes transforming it would be useful (XSL has its problems, but XDoclet XDT is no better). However it is just a question of different ways of serialising the tree: we don't have to write java in XML, and get unreadable files 3x the size - all I would need to do to use XSLT on java is wite a serialiser/deserialiser (SAX, DOM, whatever)to interface Java to the XSLT engine.
    Did ActiveXML say anything about reprsenting Java as XML? Why all of you are trying to pin this on ActiveXML? I will say this again - There was and will be no direction in ActiveXML to replace a syntax oriented language, just for the sake of XML not being good for it!!! That is no fucking secret. ActiveXML is not even an object-oriented language, it is a CONFIGURATION and INTEGRATION langauge based on components,so it is component-oriented. Stop comparing it to C and Java!!!

    And why would you do this transformation anyway? And how is this related to ActiveXML? I mean you are right at your assumptions and how you can port raw Java syntax to be translated by XSL, but how is it relatd to ActiveXML??? It is neither a representation of Java in XML or a way to transform code by XSL. My apologies for not getting the point here.
    I'm not saying you language is useless, but being in XML confers no special virtue at all; maybe for this application an XML encoded syntax is just what is needed, but never forget that configurability must be part of a carefully designed framework - a framework that XML does not provide in itself
    ActiveXML is not a language, XSSL is, ActiveXML is a framework around such language. That is discussed in the doucmentation by the way. I keep repeating this as it does not register with anybody. So, in other words, ActiveXML is that "carefuly designed" framework to keep XML syntax at bay.

    Please exucse me my temper, but my own inability to explain drives me nuts. It is my ESL I guess...But regardless, it seems that a lot of anger is around ActiveXML being mistaken for the syntax driven language replacement, Java in XML language and etc. and etc. It is not that, it has never been intended to be that and I will personally strangle such whomever says that XML is able to replace any syntax driven language and be less complicated. ActiveXML is all about components and their interaction within the business rules and ability to define such components so they can be used as close to the translation of business requirements to business logic as possible, simply that, some flexibility in such component definition, abstraction of data sources and configuration extensions.

    Sincerely,

    Artem D. Yegorov
  51. Never on a Monday[ Go to top ]

    I should never participate in arguments on a Monday.

    First up an apology on the LISP thing I speed read the posts an mixed up one of Kit's replies with Atem's.
    In my rant about XML hype I purposefully avoided directly refering to ActiveXML, quite simply because I wasn't talking about it. I was (apparently unsucessfully) trying to show why some people have a phobic reaction to XML as a result of the huge oversell, and that you had walked straight into it with an over agressive defence (and yes, I made that exact same mistake myself).

    I think you are right, on the whole people did not read the docs, just the name ActiveXML was a red rag to a net full of bulls (or Trolls?).
    <snip/>Web Services? XSL? You telling me those are not based on XML?
    <snip/>
    I know they are, I'm only a few style sheets from being an XML zealot myself. What I was saying is XML has it's place it is a good generic structure representation, great for data transport and templates, but its not the best for everything, all the time. Jelly is cool for some things, and I use Ant all day; XML has strengths; the primary ones are unambiguous nesting & namespaces. What I meant is, for instance, nobody in their right mind would build an enterprise application completely in XSL (yes, thank you, I know ActiveXML is not XSL).

    I have now looked at you documentation (briefly) You have two components framework for the VM & compiler config, and somewhat seperately, XSSL. I expect we can agree on this much. While the idea has much functionality in commmon with Jelly you've done the binding in a different way, interesting.
    And any other Java or C or some other script or syntax language program is nothing without an interpreter and/or a compiler and a ton of other "mystical devices", so what is your point?
    That an XML language is also nothing without a similar framework, above and beyond the XML parser which is something frequently glossed over when people get excited about all tht wonderful structure (not by you!).
    Did ActiveXML say anything about reprsenting Java as XML? Why all of you are trying to pin this on ActiveXML? I will say this again - There was and will be no direction in ActiveXML to replace a syntax oriented language, just for the sake of XML not being good for it!!! That is no fucking secret. ActiveXML is not even an object-oriented language, it is a CONFIGURATION and INTEGRATION langauge based on components,so it is component-oriented.
    Configuration and integration, fine, as I said in the start of my post before I went off topic. Yet YOU where the one who repeatedly posted highly slanted examples of XSSL vs Java.
    My thoughts on transformation, and actually I am a big fan on the code transformation paradigm (but not only for XML), were directed at one of Kit's comments, and some of the follow on ones... debates like this tend to get off topic if something doesn't appear to relate to the original topic it probably doesn't. I should have put it in a seperate post (if at all); there are actually very valid reasons for wanting transformable code (javadoc, anyone?) but this is not the place.

    So much for apology, now I'm going to get into it

    It is better to explain my suspicion of XML mania with an example:
    condider:

    if (test1) {
     if-code;
    } else if (test2) {
     else-if-code;
    } else {
     else-code;
    }
    roughly speaking in XSSL:
    <condition>
     <test1/>
     <if-code/>
     <test2/>
     <else-if-code/>
     <else-code/>
    </condition>

    Classic example of how XML does nothing to improve person to person communication because to me that looks more like (blatant pseudo code):
    switch (test) {
     case: test1
      if-code;
     case: test2
      if-else-code;
     default:
      else-code;
    }

    In to original code the enclosure by conditions is more explicit, in the XSSL the cotrol binding only to the folowing emement is implicit. I would write (if I had to allow follow on if-else):
    <exclusive-condition>
     <test1>
       <if-code/>
     </test>
     <test2>
       <if-else-code/>
     </test2>
     <else-code/>
    <exclusive-condition>

    Or something similar (yes I know I could probably use ActiveXML to define my own XSSL, this is an example)

    Now this looks even more like a switch, but the nested if-else is a switch, with an exclusivity rule, and the condition/conditional-code association is now explicit - to me. Clearly, My XML is not your XML, which it different again to Bill Gates' XML, say.

    (Don't even get me started on proper usage of namspaces)

    In summary XML as we all know is not a universal language, that is the gist of what I was saying - which I admit has little to do with ActiveXML and only a little to do with XSSL.

    ActiveXML uses XML a configuration files, which is good - custom config formats are a pain. ActiveXML/XSSL uses XML for coding, which is not in itself a problem. In view of you repeated statements about XSSL being seperate it seems to be part of the "core library"; I'd like to know how easy it is to use ActiveXML without it (or to change the bindings of the core classes to XML).

    On the examples efficient datasource access, all I'm gong to say is: ColdFusion anyone?
  52. Never on a Monday[ Go to top ]

    I apreciate the elaborative explanation.

    Nothing to argue with, but just one point and that is the switch statement which is defined by the core XSSL components and is exactly the following:

    <log message="Evaluation of test is:">
      <switch>
        <object:test/>
        <text choice="1">one</text>
        <text choice="2">two</text>
        <text choice="3">three</text>
      </switch>
    </log>

    Let's say test reference point to an object that has a value of "1".

    The output will be:

    Evaluation of test is: one.

    No nested if...else conditions required.

    And I do apologize again if I have overreacted in the previous post to you.
    I'd like to know how easy it is to use ActiveXML without it (or to change the bindings of the core classes to XML)
    Simply do not load it at the VM initialization. It is not required. Some classes are, but not through bindings and therefore they are accessed by the JVM through teh classpath anyway, as they are a part of the common jar, but the bindings can be easily overloaded or created anew without a use of the core library. ActiveXML gives the developer a freedom to either reuse what's already been done, or write it themselves if they do not agree with the concept or do not like the characteristics of the code. Documentation talks about it in the AVM chapter.

    Sincerely,

    Artem D. Yegorov
  53. Never on a Monday[ Go to top ]

    Interesting thing too, that the next release (1.1) coming out soon will allow you to define your own compiler/lexer so you can stray away from the plai XML definitions and provide any token/syntax based parsing logic for the ActiveXML rules. You would ask, why ActiveXML than? Well, that is because the internal structure of the framework is bsed on XML and such is abstracted from the way the rules are defined, whether it is XML or plain text.

    For example:

    <log message="Evaluation of test is:">
      <switch>
        <object:test/>
        <text choice="1">one</text>
        <text choice="2">two</text>
        <text choice="3">three</text>
      </switch>
    </log>

    could be defined as

    println(message="Evaluation of test is:"):
     switch->test:
      case 1: text("one");
      case 2: text("two");
      case 3: text("three");
     ;
    ;

    or

    println:
    message="Evaluation of test is:" (switch(case: choice="1" (text("one")))->test)
  54. Never on a Monday[ Go to top ]

    Accidently pressed the wrong key and unfinished post went through, I will continue:

    .
    .
    .
    or

    println(
       message="Evaluation of test is:"
       (
         switch->test(
                 case: choice="1" (
                                    text("one")
                                   )
                  .
                  .
                  .
                )
        )
    )

    or any other syntax Java or C or anything else like, still bound, by lexical patterns now to the defined components.

    So you can bind regex pattern like "switch([a-zA-Z0-9]+)({([case [a-zA-Z0-9]+:[a-zA-Z0-9]+;]+)}))" to a component "switch" and have that parsed accordingly. This is just an example. Since this feature has not been released yet, there could be modifications and chnages, but that is the jist of it.

    Sincerely,

    Artem D. Yegorov
  55. Artem - Ignore the dunces[ Go to top ]

    When a true genius appears in the world, you may know him by this sign, that the dunces are all in confederacy against him. ~Jonathan Swift

    Artem,

    I'm not sure if you're a genius, but you sure have the dunces against you.

    For example, you've stressed over and over that ActiveXML is *not* a programming language... but then the previous poster (Mark Tillotson) tries to bash you for using XML as a programming language! (Sorry to single you out, Mr. Tillotson: you had the last post at the time I read this. There are plenty of other posters who share your confusion.)

    I really can't believe how many people are protesting so loudly against your research. I say ignore the dunces and concentrate on your vision.

    best,
    assmund
  56. Artem - Ignore the dunces[ Go to top ]

    Thank you so much for the support.

    I think they are using this project and myself to get rid of stress and frustration.

    Sincerely,

    Artem D. Yegorov.
  57. After the earlier flame, I thought I'd provide an example of how such a technology could be used in real situations and why you'd want to use it.

    XML is already widely used in MDA tools that allow you to provide a high level description of your data model. This data model is then process by the MDA that applies design patterns to produce low level code such as Java. The resulting code is then compiled and deployed. This is quite nice and means that a good part of the boring but error prone code is generated for you. And the resulting code can follow very strict design standards. However, this code is static. Once you've built it and deployed it, you need to re-build and re-deploy to change it.

    Here's where I can see a use for ActiveXML. Let's imagine I am building an application where I need some of the business logic to be under the control of my customer's business people. And they want to change it at run time without re-compiling or re-deploying the application. What I can do is build the application using my language of choice (Java of course) and delegate some of the logic to an externaln engine. This external engine could be a rules engine such as Jess or an ActiveXML engine. So, in ActiveXML, I could have this sort of logic:

    <choice>
      <case>
        <condition>
          <not-equals>
            <get:property name="account.country.code" />
            <get:property name="beneficiary.country.code" />
          </not-equals>
        </condition>
        <action>
          <set:property name="payment.type">SWIFT MT100</set:property>
        </action>
      </case>
      <case>
        <condition>
          <and>
            <and>
              <equals>
                <get:property name="account.country.code" />
                <string>GB</string>
              </equals>
              <equals>
                <get:property name="beneficiary.country.code" />
                <string>GB</string>
              </equals>
            </and>
            <and>
              <greater>
                <get:property name="payment.amount" />
                <money>GBP 100000</money>
              </greater>
          </and>
        </condition>
        <action>
          <set:property name="payment.type">CHAPS</set:property>
        </action>
      </case>
      <default>
        <action>
          <set:property name="payment.type">BACS</set:property>
        </action>
      </default>
    </choice>

    Then I can let my customer's business people modify this logic the way they want and update it live in the application.

    So why would I use ActiveXML to do that sort of things rather than a real rules engine?
    • XML is verbose and therefore easier to understand by non-technical people
    • XML is easy to parse and there are lots of tools out there to do just this so I don't have to write a funky parser just to verify that the syntax is correct (if I have non-techies update it, this is essential)
    • If my customer's business people want some funky functionality in those rules that I don't support out of the box, I can easily add to the schema
    • Using XSL, I could produce the code above very easily from an XMI representation of a sequence diagram, and vice-versa
    So, my point of view is it's a nice concept. It will not replace the code I produce now anytime soon but it can definitely be used efficiently to define high level logic that I need to abstract out of my core product.
  58. Exactly my point. You've got the main point about ActiveXML. Thank you for clarifying it too.

    Sincerely,

    Artem D. Yegorov
  59. So what is the ultimate point? Runtime-configured object binding? Scripting? Rule engine? I fail to grasp the main benefit of this project.

    If it is about runtime modifications to the code? I remember the good old days of Clipper 5 for DOS. It had the notion of code blocks. One could write a code block which was pretty much a Clipper expression, and store it in a file or a database. Then during runtime one would just load it in string variable and call eval() on it, and voila! the internal Clipper compiler would compile it and execute. One could pass parameters to code blocks and retrieve result. This was one of the most wonderful features of Clipper.

    If Java would allow to do such things with the same ease, would we need ActiveXML? And if yes, what would be the reason?
  60. So what is the ultimate point?
    The ultimate point is to provide a mechanism for a requirements-defined business language that is used to implement business rules. I have pointed this out several times in the earlier posts.

    The idea of ActiveXML is that you can make it as simple or as difficult as you want to and it would still follow a set of predefined standards, so it will be understood by others.

    ActiveXML also let's you reuse components as well as the rules themselves via bindings, such that a given business rule developer can benefit from an ultimate reuse and therefore a more streamline dapproach to the development process.
    If Java would allow to do such things with the same ease, would we need ActiveXML? And if yes, what would be the reason?
    Again, I do not want to compare ActiveXML and Java, as both are good for what they have been created for. ActiveXML is not as low-level as Java by any means, as I was designed to be as high level as possible, so it can easily plugin into a future graphical framework, where the possible complexity of its XML syntax will be hidden by an ActiveXML GUI frontend.

    The reason for ActiveXML is an ability to streamline unnecessary complex development processes like business rules development, Web application development, BPM flow definitions and etc. that can benefit from a more lightweight framework that strives to understand and integrate any XML-driven environment.

    I hope this sheds some light, but my ESL can fail me once more. :-)

    Sincerely,

    Artem D. Yegorov