First, let’s discuss XML. XML (Extensible Markup Language) was endorsed by WC3 in early 1998, giving it the leg up on age. That age has given it the advantage of being widely utilized and accessible. Another plus for XML is it’s readability. A person with little to no understanding of data structures can look at an XML object and make safe assumptions as to it’s meaning. Finally, XML has multiple frameworks associated with it as well as being used by nearly 80% of the online APIs available.

Now onto JSON. JSON (JavaScript Object Notation) began being used around 2001 by State Software. While JSON is harder to read for some, programmers have no issues as the format is similar to most language’s arrays. JSON also takes up considerably less space when considering larger amounts of data because it does not require the closing tags that XML does. JSON is also far easier to process in a program. XML requires nested each loops for a complex structure while JSON can accomplish the same with a simple for loop.

Perhaps, however, I am not the owl with the answer in this case but the crotchety old turtle telling you to look somewhere else. Like maybe the current trends in web development. As of mid 2011, 20% of the API’s were using strictly JSON. This may not seem that high but when you consider this is up from less than 5% only 3 years prior it’s impressive. The fact is that JSON is preferred by web developers and those who offer APIs want to cater to those web developers. But then again, we could be wrong. After all, we all know that owl was just a sugar crazed scammer.

Wolfram Alpha (also written WolframAlpha and Wolfram|Alpha) is an answer-engine developed by Wolfram Research. It is an on-line service that answers factual queries directly by computing the answer from structured data, rather than providing a list of documents or web pages that might contain the answer as a search engine might. It was announced in March 2009 by British scientist Stephen Wolfram, and was released to the public on 15 May 2009.

At present, Alpha draws all its answers only from Wolfram-curated data sets.

The professional edition will be able to draw answers from user data sets (submitted as XML or other formats) also.

The other paper sways to the financial side of development, focusing on issues of cost surrounding the use of translation memory in language translations. In the end (spoiler alert) it explains why the user can save significant costs by utilizing their Vasont Content Management System’s Translation Savings Feature within technical communications groups as well as buyers of localization services.
Both papers are available to subscribers of Vasont’s website. If you’re not a subscriber you can register here for access.

<person>
  <name>Bob</name>
  <race>Caucasian</race>
  <race>Boston Marathon</race>

</person>

Utilizing namespaces, we can make each race have more meaning.

<person
xmlns:p="http://www.xmlpronews.com/person"
xmlns:r="http://www.xmlpronews.com/race">

  <p:name>Bob</name>
  <p:race>Caucasian</race>
  <r:race>Boston Marathon</race>
</person>

With XML Namespaces declared, a p: element represents something in the namespace described at http://www.xmlpronews.com/person. This file does not actually exist, but, if it did, would simply describe the available elements for the namespace. The W3C XML namespace for HTML4 can be found at http://www.w3.org/TR/html4. There is no required format for these namespace pages.

According the the Corisecio website, the software “provides e.g. protection methods against SQL injection and XXE attacks and enables realization of scheme validation like WS-security standards.” Most people out there know about SQL injections, simply because there have been so many attacks of various types around the business sector lately. However, not many people know what an XXE attack actually is, and I am here to enlighten. According to SecuriTeam.com

“(An) XXE (Xml eXternal Entity) attack is an attack on an application that parses XML input from untrusted sources using incorrectly configured XML parser. The application may be coerced to open arbitrary files and/or TCP connections.”

Anybody that works in network administration or security can see how this could be extremely problematic. This offering is supposed to help protect against such attacks, and considering the fact that it is free, it may be worth a try. Some to the the listed features are:

• Easy to use, install, and administer
• An XML Firewall
• A Web Service Security Suite
• can be implement in a variety of infrastructures, including a virtual platform

If you are looking for something to cover another possible security hole that you may not have thought of, then go and check this out at http://secrt.corisecio.com/.

The researchers who found the problem, Juraj Somorovsky and Tibor Jager from Ruhr-University Bochum in Germany, reported in their paper that “they were able to decrypt data by sending modified ciphertexts to the server, by gathering information from the received error messages.” They also see it a such an important issue because “It is employed in a large number of major web-based applications, ranging from business communications, e-commerce, and financial solutions.”

According to statements from Amazon.com officials, they were notified by the researchers through the W3C email list and they have already taken care of the problem in their systems. They are doing their best to ensure their customers that all of their data is still safe and is no longer in any danger from this threat. This would mostly be an issue for those using Amazons cloud computing services under their EC2 platform.

If you are directly affected by this, do your best to either fix the problem yourself or at least keep your eye out for updates on revisions of the XML standard. As more problems will most likely arise from this situation, there will likely be a great deal of effort to get the fix out there to the public.

Oxygen XML Editor – this is definitely one of the most popular and feature heavy of the XML editors out there. It is supported on all three of the major platforms, has an XSLT debugger, and also can be run as a plugin for Eclipse (which is hugely popular itself). It also has the ability to edit files other than XML and XSL files such as CSS and HTML files, which would be very handy, given the typical usage for XML files in web environments.

Liquid XML Editor – This editor is very similar to Oxygen featurewise, but this editor is only available for the Windows platform, which clearly limits a lot of its customer base. Regardless of that, if for some reason you are running Windows, then this may be the editor for you.

Serna-free – This is an open-source editor available on the Syntex website. This editor is also available for all of the major platforms, but unlike the other editors does not have the ability to edit not XML files. They also have an enterprise version available for download.

Go out and take a look at some of these editors and see which one works for you (all of them have free trial versions for download).

http://www.oxygenxml.com/

http://www.liquid-technologies.com/xml-editor.aspx

http://www.syntext.com/products/serna-free/

The key to text formatting is the run. As previously discussed, a run is a particular block of text with the particular purpose of applying formatting. If you are familiar with HTML, consider the run akin to the <span> tag.

<w:document>
	<w:body>
		<w:p>
			<w:r>
				<w:t>Hello, world!</w:t>
			</w:r>
		</w:p>
	</w:body>
</w:document>

The above is an unformatted run. To format a run, we need to supply properties for the particular run via the rPr element.

. . .
	<w:p>
		<w:rPr>
			<w:b/>
		</w:rPr>
		<w:t>I am bold!</w:t>
	</w:p>
. . .

By simply specifying a run properties entity and putting in other run property elements, we are able to format our text. However, we can also order a particular run to not use a particular format:

. . .
   <w:rPr>
      <w:b w:val="false" />
   </w:rPr>
. . .

This would be useful for ignoring higher level formatting from being applied to a particular run of text. Other than explicitly stating whether or not to apply a format option, we also have formatting elements that need attribute values to work. For example, the color entity:

. . .
   <w:rPr>
      <w:color w:val="FF0000" />
   </w:rPr>
. . .

This example will make the run of text red, and follows the HTML color attribute style. You can also define “auto” as a value, which will automatically apply the appropriate color based on other parts defined in the document, i.e. a background part may specify an appropriate default font color.

Furthermore, there are theme level attributes available, i.e. the themeColor attribute. Often, you may have a document that specifies a Default, Heading, Sub-Heading, etc. formats, and this attribute can tap into those defined formats. Since these defined formats are stored within the document, we can generate these along with our document. Doing so will make it easier for anyone potentially modifying our generated document to maintain the various heading and text formatting across any modifications or additions they make. For our next article, we’ll examine how to add these predefined formats to our generated document.

For a more in depth list of text formatting options and entities, check out: http://openxmldeveloper.org

A WordprocessingML package contains a main part that strongly resembles an HTML document structure. A body contains one to many paragraphs, which contain one to many runs. A run is akin to an HTML span, which encapsulates a segment of text that formatting can be applied to. In fact, a style is used to repeat formatting across various runs and/or paragraphs, much like CSS does in HTML.

As mentioned in our introduction, a final OOXML document is actually a collection of files that make up the document. Here is the structure we’ll be creating today:

/[Content_Types].xml
  /_rels/.rels
  /document.xml

This structure is actually the minimum required by OOXML, and when we begin to do more advanced layouts, we’ll need a much more complex structure. The [Content_Types].xml file defines what types of files this package contains. For our example:

<Types  xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
  <Default Extension="rels"  ContentType="application/vnd
  .openxmlformats-package.relationships+xml"/>
  <Override PartName="/document.xml"  ContentType="application/vnd
  .openxmlformats-officedocument.wordpressingml.document.main+xml"/>
  </Types>

The Default Extension element will tell the package to use the specified ContentType for any file with the specified extension. Override PartName will explicitly define what ContentType should be used for a given file (part). In our example, we have defined that every file with the .rels extension is a relationship, and the document.xml file is a WordprocessingML main part.

Next, we’ll define our single relationship in our "Hello, world" document:

<Relationships
xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/
  officeDocument/2006/relationships/officeDocument"  Target="document.xml"/>
  </Relationships>

Finally, we’ll build our document.xml:

<w:document>
  <w:body>
  <w:p>
  <w:r><w:t>Hello,  world</w:t></w:r>
  </w:p>
  </w:body>
  </w:document>

Now, we zip up our files as a .docx file, and we can open it up any OOXML compliant word processor! Next article, we’ll look at more advanced uses to format our document.

The standard office formats, documents, spreadsheets, and presentations, have particular sub-languages of the Open Office XML structure: WordrocessingML, SpreadsheetML, and PresentationML, respectively. Each of these sub-languages go into more depth on how to build the appropriate parts, relationships, and characteristics of that particular filetype. There also existing supporting sub-languages, such as DrawingML, that are more directly tuned and related to typical parts found in these documents.

Generating parts is pretty straightforward:

<w:document>
  <w:body>
    <w:p/>
  </w:body>
</w:document>

In this example, we have a document part, a body to that document, and a paragraph. Each XML entity, in this example, is considered to be a part of an OOXML package.

Where OOXML becomes powerful, however, is not the simple creation and customization of parts. Relationships, i.e. how parts relate to one another and the package itself, is where you can truly begin to build more advanced documents. A common relationship is for an image:

<w:pict>
  <v:imagedata r:id="rId4"/>
</w:pict>

<Relationships ...>
   <Relationship Id="rId4" Type="../relationships/image"
      Target="image.jpg" />
</Relationships>

With this example, we have an image referenced to the external file of image.jpg via a relationship. Relationships are referenced via the Id attribute.

In our next article, we’ll build a “Hello, world!” document with Open Office XML and WordprocessingML.

For more information, check out: http://openxmldeveloper.org/