erk wrote:
> It's #3 I object to. I've created mapping layers (not my
> idea) which allow swapping an XML "data source" for a SQL
> (JDBC) one. A colossal pain in the ass which is
> complicated by the fact that the underlying "data models"
> are incompatible; the XML was much more restrictive,
> forcing dumbing-down. I don't believe its hierarchy adds
> much meaningful information to flat files (having create
> mapping utilities from flat files to object hierarchies, I
> have to say that's it's not rocket science and has fewer
> pains in the ass than XML does, despite the availability
> of parsers).
I don't know why but for a few years I was seduced by XML
hype and did my best to embrace it. I used XML/XSLT to
generate webpages, XML for simulation parameter files, XML
to write significant documents with XSLT to transform them
to LaTeX or HTML/CSS or PostScript, etc. Anything and
everything I could think of.
In the end just as you found (if I understood you correctly)
XML sucked for serialization of program parameters/data for
my applications as you said /DESPITE/ the availability of
parsers. I kept falling back to flat files. Refinements on
those ultimately led to my interest in the relational
model. As for the XML/XSLT apps I mentioned, well it did
work and I didn't even really mind the verbosity. However, I
did mind that I had to learn so many /different/ languages
to do useful work (XML/XSL/DTD/HTML/CSS/XPath/MathML/SVG,
XML attribute syntax, etc). I kept wondering why the hell
all these were not simply Lisp and wishing that this were
so, ie that HTML had been Lisp from it's inception like
(html( (body( ... )body) )html)
or similar. Then it seemed that all the other alphabet soup
would have been superfluous and never "invented". And I
could of done much more by learning a single syntax along
with the usual programming knowledge.
Now I feel the XGurus cheated us, and wasted the valuable
time of many (or all) of us.
> Relational is more powerful than other data models, and
> models the business better. SQL continues to be better
> than XML and the others, despite its weak adherence to
> relational ideas; even watered-down, perverted relational
> is better than the alternatives. I wish my languages had
> relations (and its necessary components, constraints and
> user-defined types - aka objects) as first-class citizens
> - it would eliminiate a lot of unnecessary code, catch
> errors in my thinking, and eliminate the "impedence
> mismatch."
Same here. How do you like Tutorial D?
-- Keith --
Keith H Duggar wrote:
> erk wrote:
> > It's #3 I object to. I've created mapping layers (not my
> > idea) which allow swapping an XML "data source" for a SQL
> > (JDBC) one. A colossal pain in the ass which is
> > complicated by the fact that the underlying "data models"
> > are incompatible; the XML was much more restrictive,
> > forcing dumbing-down. I don't believe its hierarchy adds
> > much meaningful information to flat files (having create
> > mapping utilities from flat files to object hierarchies, I
> > have to say that's it's not rocket science and has fewer
> > pains in the ass than XML does, despite the availability
> > of parsers).
>
> I don't know why but for a few years I was seduced by XML
> hype and did my best to embrace it. I used XML/XSLT to
> generate webpages, XML for simulation parameter files, XML
> to write significant documents with XSLT to transform them
> to LaTeX or HTML/CSS or PostScript, etc. Anything and
> everything I could think of.
>
> In the end just as you found (if I understood you correctly)
> XML sucked for serialization of program parameters/data for
> my applications as you said /DESPITE/ the availability of
> parsers. I kept falling back to flat files. Refinements on
> those ultimately led to my interest in the relational
> model. As for the XML/XSLT apps I mentioned, well it did
> work and I didn't even really mind the verbosity. However, I
> did mind that I had to learn so many /different/ languages
> to do useful work (XML/XSL/DTD/HTML/CSS/XPath/MathML/SVG,
> XML attribute syntax, etc). I kept wondering why the hell
> all these were not simply Lisp and wishing that this were
> so, ie that HTML had been Lisp from it's inception like
>
> (html( (body( ... )body) )html)
>
> or similar. Then it seemed that all the other alphabet soup
> would have been superfluous and never "invented". And I
> could of done much more by learning a single syntax along
> with the usual programming knowledge.
>
> Now I feel the XGurus cheated us, and wasted the valuable
> time of many (or all) of us.
>
> > Relational is more powerful than other data models, and
> > models the business better. SQL continues to be better
> > than XML and the others, despite its weak adherence to
> > relational ideas; even watered-down, perverted relational
> > is better than the alternatives. I wish my languages had
> > relations (and its necessary components, constraints and
> > user-defined types - aka objects) as first-class citizens
> > - it would eliminiate a lot of unnecessary code, catch
> > errors in my thinking, and eliminate the "impedence
> > mismatch."
>
> Same here. How do you like Tutorial D?
>
> -- Keith --
I am the same way. I spent so much time reading about all of the hot
new technologies, but I always ended up using plain text files without
markup for most of the configuration on my personal applications. XML
would be great if it wasn't so damn complicated.
I spent years drinking the cool-aid, thinking that my Java/C#/C++ apps
would be so much better if I added that extra level of flexability that
XML had to offer - and I added a whole lot of extraneous XML code to
projects to make myself and my peers happy.
Now, I am taking gulps of all that is interpreted languages, and
defining all of my configuration information in Ruby, Python, and Lisp.
The web is still a mess, but at least the backends of my applications
are not.
···········@gmail.com" schrieb:
> Keith H Duggar wrote:
> > I don't know why but for a few years I was seduced by XML
> > hype and did my best to embrace it.
[...]
> I spent years drinking the cool-aid, thinking that my Java/C#/C++ apps
> would be so much better if I added that extra level of flexability that
> XML had to offer - and I added a whole lot of extraneous XML code to
> projects to make myself and my peers happy.
...
be prepared: next hype will come!!!
And what did you hear
-times ago-
about deniers of "new-hype"?
Same position as before here.
The world was made by sellers, but there is often no need for.
Or: why do you think, Lisp is so old?
(consequent working: remove all the rest and
:)
stefan
···········@gmail.com" <··········@gmail.com> writes:
> Keith H Duggar wrote:
>> erk wrote:
>> > It's #3 I object to. I've created mapping layers (not my
>> > idea) which allow swapping an XML "data source" for a SQL
>> > (JDBC) one. A colossal pain in the ass which is
>> > complicated by the fact that the underlying "data models"
>> > are incompatible; the XML was much more restrictive,
>> > forcing dumbing-down. I don't believe its hierarchy adds
>> > much meaningful information to flat files (having create
>> > mapping utilities from flat files to object hierarchies, I
>> > have to say that's it's not rocket science and has fewer
>> > pains in the ass than XML does, despite the availability
>> > of parsers).
>>
>> I don't know why but for a few years I was seduced by XML
>> hype and did my best to embrace it. I used XML/XSLT to
>> generate webpages, XML for simulation parameter files, XML
>> to write significant documents with XSLT to transform them
>> to LaTeX or HTML/CSS or PostScript, etc. Anything and
>> everything I could think of.
>>
>> In the end just as you found (if I understood you correctly)
>> XML sucked for serialization of program parameters/data for
>> my applications as you said /DESPITE/ the availability of
>> parsers. I kept falling back to flat files. Refinements on
>> those ultimately led to my interest in the relational
>> model. As for the XML/XSLT apps I mentioned, well it did
>> work and I didn't even really mind the verbosity. However, I
>> did mind that I had to learn so many /different/ languages
>> to do useful work (XML/XSL/DTD/HTML/CSS/XPath/MathML/SVG,
>> XML attribute syntax, etc). I kept wondering why the hell
>> all these were not simply Lisp and wishing that this were
>> so, ie that HTML had been Lisp from it's inception like
>>
>> (html( (body( ... )body) )html)
>>
>> or similar. Then it seemed that all the other alphabet soup
>> would have been superfluous and never "invented". And I
>> could of done much more by learning a single syntax along
>> with the usual programming knowledge.
>>
>> Now I feel the XGurus cheated us, and wasted the valuable
>> time of many (or all) of us.
>>
>> > Relational is more powerful than other data models, and
>> > models the business better. SQL continues to be better
>> > than XML and the others, despite its weak adherence to
>> > relational ideas; even watered-down, perverted relational
>> > is better than the alternatives. I wish my languages had
>> > relations (and its necessary components, constraints and
>> > user-defined types - aka objects) as first-class citizens
>> > - it would eliminiate a lot of unnecessary code, catch
>> > errors in my thinking, and eliminate the "impedence
>> > mismatch."
>>
>> Same here. How do you like Tutorial D?
>>
>> -- Keith --
>
> I am the same way. I spent so much time reading about all of the hot
> new technologies, but I always ended up using plain text files without
> markup for most of the configuration on my personal applications. XML
> would be great if it wasn't so damn complicated.
>
> I spent years drinking the cool-aid, thinking that my Java/C#/C++ apps
> would be so much better if I added that extra level of flexability that
> XML had to offer - and I added a whole lot of extraneous XML code to
> projects to make myself and my peers happy.
>
> Now, I am taking gulps of all that is interpreted languages, and
> defining all of my configuration information in Ruby, Python, and Lisp.
> The web is still a mess, but at least the backends of my applications
> are not.
>
I tend to agree. Though, I do think XML has a role - the problem seems
to be that somehow it got a "magic silver bullet" type of reputation
and suddenly, all the pointy haired bosses wouldn't even consider a
project unless it had the magic three letters XML.
I've been looking through my archives for a paper I wrote almost 10
years ago during the time the XML hype was just beginning to gain
momentum in which I raised the concern there appeared to be a growing
attitude that XML was going to solve all our problems and my (at the
time) concern that all the B2B XML based stuff was never going to be
successful unless there were agreements on DTDs. It seemed everyone
was developing XML based systems, but at the same time, too many were
defining their own DTDs and multiple different ones were emerging in
the same problem domains. I felt there was going to be a growing
maintenance and compatibility problem as you started having to manage
more and more DTDs and keep their compatibility/versions correct. I
was also concerned about how difficult it would make it to select the
particular XML schema to use when the same domains had multiple
solutions which on the surface all appeared to have equal stremgths
and weaknesses.
In the specifics, I was more wrong than right - but unfortunately the
general concerns seem to have been reasonably accurate. The good news
was the paper convinced the decision makers to hold off for a while
and stick with what we had been doing using SQL and familiar config
solutions. My battle now is to get *some* use of XML in clearly
defined roles where it will be of benefit - its still a bit tricky to
get the balance right.
It still strikes me as funny that so many were ready to run with the
very verbose XML, but will fight me all the way on Lisp because of all
those nasty ()'s.
Tim
--
tcross (at) rapttech dot com dot au
On 2006-06-13 10:34:13 -0500, "Keith H Duggar" <······@alum.mit.edu> said:
> erk wrote:
[...]
>> Relational is more powerful than other data models, and
>> models the business better. SQL continues to be better
>> than XML and the others, despite its weak adherence to
>> relational ideas; even watered-down, perverted relational
>> is better than the alternatives. I wish my languages had
>> relations (and its necessary components, constraints and
>> user-defined types - aka objects) as first-class citizens
>> - it would eliminiate a lot of unnecessary code, catch
>> errors in my thinking, and eliminate the "impedence
>> mismatch."
>
> Same here. How do you like Tutorial D?
>
> -- Keith --
Just in case you haven't seen it, an old friend and colleague of mine
has a working implementation of Tutorial D [1]. I suggested, somewhat
facetiously, that he should start over and use Lisp instead of Java, to
which he responded -- IIRC -- that Darwen had stated at one point that
he (Darwen) wished they had defined Tutorial D with a more functional
syntax.
-Mike
[1] http://dbappbuilder.sourceforge.net/Rel.html
--
Michael J. Forster <····@sharedlogic.ca>