I am happy to announce the first release (v0.1.0) of XML Boiler (Automatic transformation of XML namespaces) software.
This release is alpha. But it seems to be already useful. For example, the documentation of XML Boiler is built using XML Boiler itself.
Here is the list of advantages of this new kind of XML software:
- freely intermix tag sets of different sets of tag semantics (using XML namespaces), without disturbing each other (such as by name clash) in the global world
- add your new tags to HTML (and other XML-based formats)
- get rid of using HTML in future Web, switch it to proper semantic XML formats
- make XSL-format based browsers with automatic generation of XSL from other XML formats
- make automatic coloring of source listings (for example)
- add macroses and include (such as by XInclude) other files in XML
- intermix different XML formats, with intelligent automatic processing of the mix
- embed one XML format in another one
- automatically choose the order of different XML converters applied to your mixed XML file
- make browsers to show your XML in arbitrary format
- make processing XML intelligent (with your custom scripts)
- integrating together XML conversion and validation scripts written in multiple programming languages
- associating semantics (such as relations with other namespaces and validation rules) to a namespace
- semantics can be described as an RDF resource at a namespace URL (or a related URL)
- many more opportunities
- integrate all of the above in single command
XML Boiler project reached an important milestone: To make the first release it remains to debug it. (Also need to create particular XML processing scripts to make it useful.)
XML Boiler is the implementation of my Automatic transformation of XML namespaces specification, which is going to revolutionarize processing of XML documents both locally and on the Web.
Please donate to email@example.com at PayPal.
This is a letter to Martin Fowler, which I also publish in my blog.
I am rather wondered why you don’t do any mention in your article
about the following problem:
Real classes which use dependency injection very often may need to pass some of their dependencies to implementation classes which they depend on.
This may lead to increase of the number of dependencies and make code somehow hard to write and read. Another problem is that while implementation of a class changes (say to make it more advanced), new dependencies may appear leading to such inconveniences as changing constructors’ signatures.
I feel that one of the best solutions is to group related dependencies into a record (if to use Pascal term) or a structure (if to use C/C++ term), like as this fragment of my ongoing open source project written in Python:
def __init__(self, logger, translations):
:param logger: logger
:param translations: usually should be gettext.GNUTranslations
self.logger = logger
self.translations = translations
This way I can pass one object ExecutionContext instead of two objects (the logger and the translations) into constructors. These objects are to be then grouped into even greater objects, etc.
Do you think it is a good idea?
I originally started to write my XML Boiler software in Ada. Ada compiler has too many bugs.
I switched to Java. I discovered for myself that Java byte arrays are limited to about 4GB of bytes, this makes problematic processing of big XML files. I switched to Python.
Now I have finished translating it from Java to Python. Now I can continue to implement features. Yet much work remains.
I have created a C library to span a process with given input and receive its output.
One cannot just write to stdin of a process and then read its stdout through pipes, because this way it may lead to a deadlock.
Instead use my library:
It is an alpha release, tested on Linux.
During its development I managed to crash Linux: https://bugzilla.kernel.org/show_bug.cgi?id=198549
This is about Automatic transformation of XML namespaces.
Previously I divided all transformations into two groups:
- with a given source and target namespace (as converting DocBook into HTML);
- with only source given but not the target (as for XInclude).
Today I’ve realized that it is a wrong division. Instead we need to split into:
- transformations for transforming from a specified source to a specified target;
- transformations for which transformation should happen if we have correct source namespaces, not depending on which is the target namespace.
The second kind is some kind of “reducing” as XInclude reduces one XML file to another (and this usually are transformation in “right” direction even if the destination namespace is not in our list of destination namespaces). The “reduce” is defined as an operation which should always happen over an XML file even if the target namespace is not in our set of expected target namespaces.
But “reducing” is not absolute. Sometimes we may want to reduce from a given source namespace and sometimes not. Reduce is some relative property: The same namespace may be considered as a source of reduce and sometimes not. For example one may want to convert XInclude tags and attributes into another XML namespace which describes inclusion (instead of reduce).
We are yet to understand relative of what is the reduce. How we specify when a reduce is in our set of reduces and when no.
Sorry if I explained not quite clearly, this is a work in progress.
This is a new hard (fundamental) problem appeared before me while developing Automatic transformation of XML namespaces. I have solved some other fundamental problems after some despair and hope to solve this problem too.
I sought in Internet how to determine from Google response whether an access token is expired. I found no definitive answer.
So, finally I created an access token and waited for a hour to see the Google response when I try to use this token.
The Google response (with a partial list of HTTP headers) is below:
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer realm="https://accounts.google.com/", error=invalid_token
Content-Type: application/json; charset=UTF-8
Username/Password Authentication Failed.
A weird thing is that Google says that it is application/json but the response body is not a JSON.
So the only way is to check whether the response HTTP status is 401.