Altova Blog

Introducing MetaTeam!

2012-05-15T09:07:00.000-04:00

Cloud-based Team Collaboration and Project Management

Today we are very excited to announce a brand new addition to the Altova product portfolio! MetaTeam® is an elegant, cloud-based collection of collaboration tools that is unlike any project management solution you’ve seen before.

MetaTeam is Different.

MetaTeam is designed with teams in mind, because people – not spreadsheets or file servers or charts – are the most important factor in any successful project. Unlike other collaboration and project management tools, MetaTeam provides a framework that encourages team work and creates a sense of ownership among all project stakeholders, not just project managers.
The reason MetaTeam is different is because today’s teams are different. They’re increasingly virtual, distributed across departments and often across continents and time zones. This presents complex challenges from different working hours, to different hardware platforms, to different levels of project-related knowledge and terminology.
MetaTeam removes these barriers, empowering teams to communicate, collaborate, and deliver results – together, in an organized way.
Because MetaTeam is cloud-based, it’s accessible to you and your teammates 24x7, no matter where you're located. There’s nothing to download, and no infrastructure costs.
The clean, intuitive MetaTeam interface offers integrated apps for managing to-dos, team member roles and responsibilities, project-specific terms and documentation, structured decision making, team member information, and more. Threaded discussions and customizable email alerts foster communication and clarity.

Try MetaTeam

MetaTeam is currently in public beta, and access is free to all. And though our existing customers will find MetaTeam extremely useful, MetaTeam is not just for technical users! Teams in any capacity can access its powerful tools to enhance efficiency in managing projects of any kind.
Check out our short intro video, and then sign up (it’s free!) to try MetaTeam for yourself!

MetaTeam Introduction

Resist Data Integration Redundancy

2012-04-30T12:05:00.001-04:00

The Internet makes massive amounts of data available for lots of interesting applications. But whenever you design a unique analysis and presentation of information you don’t privately control, you risk that the owner will offer the same view at some point in the future, instantly making your application redundant.

That’s exactly what happened to the Groupon API data-mining project we originally wrote about in August, 2011. Fortunately, the core of our project is a MapForce graphical data mapping. We can quickly and easily tweak the mapping and repurpose it to present an entirely different data set that provides new value.

Our project initially began when we noticed Groupon deals only offered in a few individual locations that could actually be redeemed over the Web for physical merchandise to be shipped almost anywhere.

We used MapForce to query the Groupon API for all offers from every Groupon location, we filtered out the offers classified as online deals, and we presented them in an HTML page elegantly formatted by Altova StyleVision for desktop and mobile devices.

The new Goods tab recently added to the top of the Groupon Web page makes our original data mapping completely redundant, since it offers immediate access to items for sale online from many locations.

Even worse, since most of the same goods are offered in nearly every Groupon location, our mapping output now generates dozens of duplicates.

Repurpose the Application

Thinking at a more meta level, the justification for our original project is still valid: Groupon organizes and displays deals based on a geographical query, but there are instances where a deal is more attractive than the location. For example, a trip to Allentown, Pennsylvania might not be on your bucket list, but what if you knew about a Groupon deal to drive a Ferrari, Lamborghini, or Aston Martin five or ten laps around the Pocono Racetrack for half the usual price?

The Ferrari offer isn’t an Online Deal, so it’s not listed under the Goods tab, nor is it selected by our MapForce data mapping. As a new target for our mapping design, let’s collect all Groupon offers from all locations that are NOT classified as Online Deals. There are probably lots of interesting things to do in places that might not immediately spring to mind.

Here’s the section of our original data mapping that filtered the data response from the API to select Online Deals:

The contains function in the center of the screenshot checks to see if an element called <redemptionLocation> in the deal description contains the word Online, indicating an online deal. The deal is passed along for further processing only if the result is true.

The logical-and function at the top right combines online deals with a test of the element called <isSoldOut> to select only the offers that are still available ( <isSoldOut> = false).

We can very easily reverse the set of collected data by inserting a logical-not function after the contains function. The new mapping selects all deals that do NOT contain Online in the <redemptionLocation> element.

Since the structure of the data does not change, only the content, we don’t have to do anything else before executing the new version of the mapping. Here is a portion of the XML output showing the Ferrari deal:

We could take this output file and immediately process it through StyleVision using our original stylesheet to create an HTML document, but while we’re in MapForce, let’s add two more enhancements.

Remove Duplicate Data

We are still getting some duplicates in the new results because the same deals are frequently offered in multiple neighborhoods of large cities. One of the samples installed with MapForce is a mapping called DistinctArticles.mfd that demonstrates how to remove duplicates from an input stream where XML nodes contain repeated data.

We can easily copy the design from the example to our Groupon mapping:

The <title> element functions as a unique key to identify duplicate deals, and the compute-when variable sends only the first copy for further processing.

Of course we can also apply this de-duplication strategy to the original mapping of Online deals, to find out if the Goods tab for one location really offers all the Online deals out there. (It doesn’t.)

Data Sorting

A new feature added to MapForce 2012 Release 2 allows us to sort the data before it reaches the output file. Here is the section of the mapping that sorts first by division names, which are the Groupon locations for deals, then by the deal title within each location.

Now we can process the completed mapping and generate an HTML document by transforming the XML output file with our original StyleVision stylesheet:

Maybe we can even get a deal on a tasty Italian snack after driving a fast Italian car!

MapForce, and StyleVision are all available together in the specially priced Altova MissionKit. See for yourself how easy it is to use the MissionKit to integrate data from a Web API -- download a free 30-day trial!

XPath Enhances XML Reports

2012-04-17T09:25:00.001-04:00

In our previous post on Creating Elegant Reports for GPS XML Data we used an XPath expression to select nodes from an XML document for an elevation line chart. You can also use XPath to compute values. Altova StyleVision includes strong support for XPath, and we can write XPath expressions to add interesting information to our GPS XML reports. For instance, we can process the elevation data stored by the GPS device in meters to plot a chart showing the elevation in feet above sea level instead.

The conversion formula for meters to feet is (meters x 3.2808399) = feet. We can apply this calculation in the Chart Configuration dialog:

Now the chart will be drawn using the results of the calculation performed on data retrieved from the source file.

XPath Time Functions

You may have noticed our chart does not include a definition of the X-axis scale. We deliberately eliminated tick marks and values from the X-axis because GPS devices store trackpoint information every few seconds. The file for the ice-climbing hike has more than 1,800 elevation data points and the sheer volume of data points created a series of tick marks that merged into a solid line! There wasn’t enough room for the values text either.

But wouldn’t it be interesting to know how long the hike took? We can insert that fact into our report by taking advantage of StyleVision Auto-Calculation. The portion of the design below shows three Auto-Calculation elements added to the report via the Insert / Auto-Calculation / Value menu option and enhanced with descriptive text.

Right-clicking any Auto-Calculation element opens a menu that provides access to the Edit XPath dialog illustrated below in reduced size. You can type an XPath expression directly into the window, or construct one by choosing from the Element, Operator, and Functions lists.

To calculate the elapsed time for the trip we can use the XPath functions max(anyAtomicType) and min(anyAtomicType) with XPath expressions for the <time> elements for each trackpoint to find the earliest and latest times recorded in the track. We can subtract the earliest time from the latest time to calculate the elapsed time.

Another selection in the Auto-Calculation right-click menu opens the Value Formatting dialog for instant access to a variety of formats appropriate for the data type of the calculation result.

We could also use the min( ) and max( ) functions to select the Departure and arrival Times, but the data stored by the GPS device is in GMT time and this hike took place in Eastern Standard Time in the United States, where the local setting is five hours earlier.

Fortunately, XPath includes a special function adjust-dateTime-to-timezone( ) to adjust a dateTime value to a different time zone. Here is the expression we used to adjust the departure time:

adjust-dateTime-to-timezone( min( $XML/n1:gpx/n1:trk/n1:trkseg/n1:trkpt/n1:time ), xs:dayTimeDuration('-PT5H') )

Note that we must enter the adjustment duration as a string and explicitly declare it as a dayTimeDuration data type.

We can use the Value Formatting dialog to present the departure and arrival times in a familiar style:

We have one more XPath enhancement for our GPS XML report. In our earlier post, we described a technique to use a StyleVision Project and standardized file names to generate reports for multiple data files without modifying the SPS file. You can also use the StyleVisionBatch utility, or even the StyleVision API to automate processing through SPS stylesheets to create reports in a variety of formats.

Chart File Names

When we generate and save HTML output, the main report is an HTML document and charts are separate image files. We can specify the chart file name in the Chart Settings dialog, but if we want to save multiple HTML reports in the same folder on a server, we will need different file names for each chart. Otherwise, each new chart will use the default name, overwriting the previous version.

The Custom file name option lets us use an XPath expression to specify a different image file name. One simple solution might be to generate a random number, convert it to a string, and insert the string into the file name.

But we can’t do that because XPath does not include a random( ) function.

Instead, we can generate a pseudo-random string by combining two additional XPath time functions. The function seconds-from-time( ) returns seconds and milliseconds from any value, and current-time( ) returns the current system time in hours, minutes, seconds, and milliseconds.

We can seed seconds-from-time(current-time( )) into an XPath expression in the Image file settings dialog to plant a file name based on the exact second and millisecond the HTML result is generated. The complete XPath expression to generate the file name string looks like this:

When we save the generated HTML output, StyleVision reports all additional files created with the main document:

Route Map Image File Names

When we create multiple HTML pages for trip reports, we will also need to reference a different route map image for each trip. XPath can help with this task too. We initially inserted the map using a specific filename URL, but instead we can define an image filename as a parameter to be supplied when the stylesheet is processed.

The Edit / Stylesheet Parameters menu option opens the Edit Parameters dialog, providing centralized access all parameters for the stylesheet. In the screenshot below, we added one parameter named routeMapFile and defined its default value.

Now we can use the parameter to assign the route map file. The Edit Image dialog includes four options to define the location of an image. In the screenshot below, we chose the Static and Dynamic tab for a specific folder path and a dynamic file name.

We can supply a new value for the routeMapFile parameter when we generate a report in any output format. If we don’t supply a new value, the default defined in the Edit Parameters dialog is used.

Now we can write a command line to execute StyleVision in batch mode with a different route map image:

We could also use a parameter to assign the chart background. Another command line option can even select a new input XML file to replace the working XML defined in the stylesheet. Parameters and command line options make StyleVisionBatch a great way to use the same stylesheet to generate reports for many different data sets.

Here is the HTML preview of the ice climbing trip data with all our XPath enhancements applied:

To design your own reports based on GPS XML files, or to elegantly achieve any other XML reporting, e-forms, or multi-channel publishing requirement, click here for a free trial of Altova StyleVision.

Creating Elegant Reports for GPS XML Data

2012-04-10T08:00:00.005-04:00

In our earlier post on XML for Global Positioning Systems, we mentioned that adventurers and athletes might want to use XML data from their devices to keep a record of their trips, or even training sessions leading up a marathon or other special event. Several colleagues responded by offering example files!

Looking through all this data, we realized that plotting elevation changes over time would show interesting results for many activities. We used XMLSpy to create this customized line graph directly from the XML data to show elevation vs. time for an afternoon of bicycling through California wine country. We even applied the vineyard photo as a background image right from the XMLSpy chart settings dialog.

Whenever you want to elegantly present data from multiple XML data files based on the same XML Schema, Altova StyleVision is the tool that lets you design a richly featured stylesheet for repeatable output in HTML, RTF, PDF, or Microsoft Word formats.

Here’s how we did It for our GPS XML data:

;

First we opened the GPS data file for each trip in XMLSpy to replace the generic title inserted by the GPS device in the <name> element at the top of the file, shown on line 11 in the screen shot below. The gpx.xsd schema defines an optional <desc> element for a description that can appear after <name>, so we added that element and wrote some commentary about the trip.

Next we used StyleVision to create a new SPS stylesheet based on the gpx.xsd schema, using our edited .gpx file as the working XML. We created a simple headline for the document and dragged the <name> and <desc> elements into the design window.

We wanted to insert the elevation chart next. All the chart settings were already saved in XMLSpy, so we could easily load the design into our stylesheet using the All Settings button in the StyleVision Chart Settings Dialog. We also wrote XPath expressions to select the time and elevation data from the working XML file.

We thought it would interesting to compare the chart of elevation changes to the map route, so we plotted the route using the GPS Visualizer Web site, took a screen shot of the map, and added it to the our design using the StyleVision Insert / Insert Image menu option.

As we built the design, the Preview buttons along the bottom of the StyleVision Design window let us preview the document in any supported output format. Here is the Russian River Valley GPS data rendered by StyleVision in HTML, using the final version of the stylesheet:

We needed an easy way to apply the same stylesheet to other GPS XML files. A StyleVision Project collects related files so they can be easily accessed by an SPS stylesheet, so we defined a project that includes the external folder containing all the files we used to create our design.

We carefully chose file names for the three files used in the stylesheet to describe their purpose instead of their contents. To create a new report, we can simply replace chartBackground.jpg, (the background photo for the chart), Log file.gpx (the working XML file), and routeMap.PNG (the map from GPS Visualizer) in the working files folder with copies corresponding to a different trip, then generate new output. We don’t need to make any changes or revisions to the SPS file!

Simply swapping all three files and generating new HTML gave us this result for a ski trip in the Alps, not far from the Altova office in Vienna:

Swapping again created this result for a winter hike in the New Hampshire woods to reach an ice-climbing wall:

The same stylesheet can generate other formats too. Our design fits neatly as a one-page Microsoft Word document we can print and store in a binder.

If you’d like to produce reports based on your own GPS XML files, or if you need to accomplish any other reporting, e-forms, or multi-channel publishing requirement, click here to download a StyleVision free trial. StyleVision includes extensive online Help, including a tutorial and sample files. Altova even offers self-paced Beginner and Intermediate Online Training for StyleVision.

Editor’s Note: A follow-up to this post titled XPath Enhances XML Reports describes how to use XPath expressions to localize and add more data to reports on GPX data.

Transforming a Plain Layout in StyleVision

2012-04-03T09:00:00.002-04:00

Altova Online Training’s newest course, XSLT Technology, leads the student though several transformations of XML data into new formats. Even with all the transformations performed in the class, there are some transformations that did not make it into the final edit.

In Chapter 4 of the XSLT Technology training, I walk students through the process of creating a flyer for the play “Hamlet” using StyleVision. The source content is in XML, and StyleVision autogenerates the XSL stylesheets required to render it into HTML, PDF, and Word, based on our design.

I asked the Altova Art Department to spruce up my design, and, while I did not end up using the nicer design in the training, I wanted to show how to turn my plain flyer into the Art Department’s vision.

Let’s explore the transformation.

The Art Department sent me a PDF of their final version of the flyer with a this set of instructions: background color: #fffde9 and #f7f0cb headline: Künstlerscript size: 58pt, color: #7a1315 subheadline: Minion pro size 14pt, color: #92793b text: Minion pro size 10pt, color: black line: 2pt, color: white

Let’s add these design elements to the flyer. Most of these changes are set using the Style window in StyleVision. You can get a copy of all the files here.

Open the flyer_plain.sps file in StyleVision. The end result will match the flyer_fancy.sps file.

Click on the background of the design, and in the Style window, change the layout container, color, background to #F7F0CB. This changes the background color of the page.

Click on the Play/Title at the top of the page. Change the layout box, color, background to #FFFDE9.

Change the content, color, color to #7A1315 and the content, font, font to 58pt Kunstler Script.

We want to set the default font for the entire page. Click on Edit Properties at the top of the Design. On the Document Setting tab, set the font, font to 10pt Minion Pro.

Select the text “A Play in Five Acts”. Click the Bold toolbar button to un-bold the text. In the Style window, set the text, color, color to #92793B.

In the second column, click the TITLE tag to select the (content). Click the Bold toolbar button. Set the text, color, color to #92793B.

Click on the vertical line between the columns. In the Properties box, set its color to white and its width to 2pt.

Click on the PDF tab to generate the PDF file. It is very close to the finished product, but we still need a little work.

It is a subtle difference, but if you look at the Scene titles, in the Before, we have “SCENE I. Elsinore. A platform before the castle” and in the After, we have “SCENE I. Elsinore. A platform before the castle”.

We need to italicize the text after the scene numbers. This is complicated by the fact that this field in our layout is a single string element in the XML data. We will need to programmatically split the string into substrings and assign the formatting to each substring separately in our layout. We will use the period that appears after each scene number to split the string.

For the Dramatis Personae list, we want the names in all upper case to be left as is, and the rest of the words to be Italic.

We want to use the comma after the all capital name as the splitter, but not all the lines in the list have an all capital name. We will test the string to see if it has a comma. If it does, then the text before the comma will appear Normal, and the text after the comma will be Italic. If there is no all caps name, then we make the entire line Italic.

Go back to the StyleVision Design view.

Delete the (contents) from between the Scene/Title tags, leaving the tags. Right click, and Insert an Auto Calculation/Value in its place. Enter the following XPath Expression:

substring-before( ., “.”)

This will extract the text before the first period in the string. This will be “SCENE X” where X will be the scene number. Remember that the period refers to the current node in XPath. The period inside the quotes is the string fragment consisting of a single period.Copy the Auto Calculation and paste it right after the existing Auto Calculation. Double-click to edit, and change the substring-before function to the substring-after function. This will insert the text after the period.

Select the second Auto Calculation, and click the Italic toolbar button to apply the Italic format to the text.

Because we split the string before and after the period, we need to add the period back to the layout. Type a period between the Auto Calculations.

Scene List after formatting. Note the period between the Auto Calculations.

The Dramatis Personae needs a similar procedure. Delete the (contents) between the Persona tags. Insert an Auto Calculation/Value, and type the following XPath Expression:

if ( contains( ., “,”)) then concat( substring-before(. , “,”), “,”) else “”

If the Persona string starts with an all-caps name, it will have a comma between the name and the description. This is what we use to split the Persona string. If the string does not start with a name, we want to output nothing.

Add another Auto Calculation/Value, and make its XPath Expression be:

if ( contains (. , “,”)) then substring-after(. , “,”) else .

If the Persona string started with a name, then we want this to be the string after the name. If the Persona does not start with a name, just return the entire Persona string.

Select this second Auto Calculation and click the Italic toolbar button.

Click on the PDF tab to generate the output file. This is now identical to what the Altova Art Department specified.

Save your work.

Because we created the flyer transformation in StyleVision, we can apply it to any play in the same format. Try it out with the Macbeth.xml file in the zip file.

To learn more about transforming XML data, take our free, on-line, self-paced XSLT Technology training.

FlowForce Server Beta 2 is Now Available

2012-03-28T09:30:00.002-04:00

FlowForce Server, the new server product from Altova that automates execution of MapForce data transformations, has gained hundreds of enthusiastic followers since the release of FlowForce Server Beta 1 last December. Now we are pleased to announce the release of FlowForce Server Beta 2, offered as a free public beta test to all licensed users of Altova MapForce 2012 Enterprise Edition and MapForce 2012 Professional Edition.

The beta test period for FlowForce Server Beta 2 is extended until September 1, 2012.

FlowForce Server Beta 2 adds robust access control to segregate jobs and related data files, so departments can work independently without seeing or overwriting each other’s data. Access control functionality includes defined Users and Roles, Privileges, and Credentials, all managed by FlowForce Server Administrators.

FlowForce Server Beta 2 also includes Web interface enhancements to provide more status information about job schedules, active triggers, and more.

FlowForce Server Beta 2 is available in a 32-bit version and a 64-bit version. The new 64-bit version allows the MapForce Beta 2 module to process very large data files and provides compatibility with 64-bit database drivers.

Click here to read more about FlowForce Server Beta 2 at the Altova Web site, or visit the FlowForce Server Beta 2 download page to get a copy of the installers for yourself!

Come Visit Altova this Spring at FOSE!

2012-03-26T09:00:00.001-04:00

Stop and smell the cherry blossoms, then come visit Altova while we are in Washington D.C.! We will be at FOSE April 3-5 in booth #719 at the Walter E. Washington Convention Center showcasing the tools in the Altova MissionKit.

If you are attending FOSE, stop by our booth to see the latest features in the Altova MissionKit 2012r2, which include EPUB editing and validation in XMLSpy, sorting of data mapping results in MapForce, generation of code from UML sequence diagrams in UModel, RichEdit functionality in StyleVision and Authentic and much more.

When you stop by our booth, don’t forget to enter our drawing to win a free Altova MapForce Basic Edition license.

Visit Altova at DevConnections!

2012-03-20T09:00:00.000-04:00

Join us in Las Vegas as we kick off the 2012 tradeshow season! The Altova team will be in booth # 215 in Las Vegas on March 26-29 at the MGM Grand for the Spring Microsoft DevConnections event.

We would love to see you there, where we will be showcasing the entire suite of tools found in the Altova MissionKit. Altova MissionKit 2012r2 products provide specialized functionality for Microsoft developers and IT pros, including seamless integration with Visual Studio®, C# and C++ code generation, powerful functionality for SQL Server® database management and reporting, integration with SharePoint® Server, functionality for working with Open XML (OOXML), diff/merge for Word documents, and much more.

Feeling lucky? If you are planning on attending the show, don’t forget to stop by our booth and enter our drawing for a chance to win a free Altova MapForce Basic Edition license.

Building Web Pages – HTML Design with StyleVision

2012-03-13T10:08:00.000-04:00

The rapid pace of today’s business environment means that information – along with the format in which it is required – changes often. Although some Web pages contain content that doesn’t often change (e.g., About Us and directions pages), the majority of today’s corporate Websites are continually updated with new data.

For this reason, many organizations choose to store Web content in XML. This allows organizations to develop content in a highly efficient manner because information in the XML file can be used for multiple purposes and in multiple output formats – the XML Schema associated with the XML file describes the content model.

StyleVision is a powerful stylesheet and report designer that can help you leverage XML. StyleVision will allow you to build Web pages with sophisticated formatting in a template-based, drag and drop design window. StyleVision auto-generates XSLT stylesheets so that you can integrate your design into a new or existing site – you can even generate ASPX Web applications right from the File menu.

In this post we’ll design a Web page that will show off some of StyleVision’s HTML formatting capabilities. Although StyleVision’s built in formatting capabilities allow you to create sophisticated designs via simple drag-and-drop, for this example we’ll use CSS3, images, and other standard design elements to create a Web page that doesn’t need to be reformatted when content changes.

Our initial StyleVision design couldn’t be more basic.

As you can see in the Schema Tree window below, the source XML Schema was designed so that the XML can be published in book format and includes an overview, chapter headings, chapter subheadings, and content. We’ve simply dragged the elements corresponding to these sections into the design window.

As you can see below, the XML content is rendered appropriately – and we didn’t have to write any XSLT or HTML by hand to achieve it. However, it needs a style makeover before we can publish it as a Web page.

Although virtually all design elements can be formatted in the Styles and Properties panes in the StyleVision interface, in this instance we’ll use a CSS file to apply formatting. That way, if we want to change the formatting we can simply point to a new CSS file in the XSLT rather than making changes in the design itself.

We’ll use XMLSpy, Altova’s XML editor with integrated CSS2 and CSS3 editing and authoring capabilities, to create our CSS.

The screenshot below captures a portion of the CSS file we’ve created in XMLSpy and includes the properties for the h1, h2, and h3 headers. We’ll define these elements here in the CSS file. Then we’ll assign them to elements from our XML file in StyleVision.

Notice that we’ve included the CSS3 properties box-shadow in h1 and box-sizing in h3 – both XMLSpy and StyleVision support HTML5 and CSS3.

Once we’ve created our CSS file we’ll return to StyleVision and assign it to the design we’ve created.

To assign a CSS file to a StyleVision design, we simply click the add new CSS File link in the Design Overview and navigate to the file.

Please note that a StyleVision design can support multiple CSS files. We recently blogged about how to dynamically assign CSS files to a StyleVision design.

Now we can start assigning the selectors we created in our CSS file to the elements in our design.

We’ll start with the chapter heading. We’ll highlight the contents placeholder for the chapter heading element and select h1 from the drop down box on the menu bar.

In our CSS file we defined font, font size, color, and alignment for h1. We also used the CSS3 box-shadow property.

Below is the HTML view of our design with the h1 selector assigned to the chapter heading element.

Likewise, we’ll assign the h2 and h3 selectors to the overview and chapter subheading elements. Our design now looks like this.

The HTML view appears below – notice that we’ve used the CSS3 box-sizing property to position the subheadings (Create Striking Output and Visual Stylesheet Design) and wrap the text around them.

Finally, we’ll add an image to the bottom of the page using an attribute called coverimage from the source XML file (pictured below).

To add the image to our design we’ll simply drag the coverimage element from the Schema Tree into the Design Window and select Create Image. This will invoke the Insert Image dialog box. We’ll move to the Dynamic tab, click the Edit XPath button and select the cover image element from the Schema Tree.

The Insert Image dialog box appears below.

We’ve also added some formatting for images in our CSS file using the CSS3 property border-radius, which adds rounded corners to an element.

The section of our CSS file that defines image formatting appears below – this view is from XMLSpy.

In addition to the formatting techniques we’ve used here, we could also add advanced functionality using JavaScript functions, conditional templates, auto-calculations, and more – but for the purposes of this example we’ll keep things simple.

Our design is now ready for prime time – the HTML view is pictured below.

Now that we’re happy with the design we can save the auto-generated XSLT stylesheet using the File menu.

We can likewise generate an ASPX Web application for this design by selecting the Web Design option immediately below Save Generated Files. We can choose to generate HTML 4 or HTML 5 output and even select Internet Explorer compatibility from the Properties dialog box (also accessed via the File menu).

Better yet, if the source data changes, it will automatically be reflected in the HTML output.

If we add to our XML file, for example, the new content is formatted like the original and all design elements appear in proper relation to each other – no re-coding of the HTML is necessary.

Here we’ve added a new chapter subheading and associated content to the underlying XML file and previewed it in HTML.

As you can see StyleVision offers the best of both worlds – you can create a single one-size-fits-all HTML template with dynamic formatting capabilities. With the total formatting control afforded by StyleVision you can design Web pages and ASPX applications that reflect your vision.

The Global Positioning of XML

2012-03-06T08:00:00.002-05:00

XML is everywhere. If you don’t believe it, get a USB cable and connect a GPS device to a computer, then browse for any file with the extension .gpx. We quickly found a 2 MB file named Current.gpx on a Garmin GPS. Opening it in XMLSpy reveals XML data and an XML Schema assignment at the top.

Scrolling through the body of the file displays numerous <trkpt> tags that record latitude and longitude along with <ele> and <time> tags reporting the elevation, date and time at that location.

Any place you may go in the world, XML is there to tell you where you are.

Back at the top of the .gpx file, we can copy the URL for the XML Schema and open it in XMLSpy directly from the Web.

The GPX Schema opens in XMLSpy Schema view, where we can see it is well-documented with explanatory text. Double-clicking the root element opens the XMLSpy Content Model view.

This XML Schema describes a specialized data architecture using tags that are accessible for a casual user. Expanding the <trk> element drills down to definitions of the <trkseg> and <trkpt> elements we saw in Current.gpx. These are also documented in the XML Schema with clear explanations of their purpose.

The X in XML stands for eXtensible. The extensions element in the gpx XML Schema signals the developers knew their design would not suit all possible requirements. Back at the top of the Current.gpx file, we can see the assignment of extension schemas on line 2, and the metadata starting on line 3 indicates that Garmin International created extensions for this file.

The body of Current.gpx includes Garmin extensions to record speed in <gpxtpx:speed> and directional heading in <gpxtpx:course>.

Web sites like GPS Visualizer let you upload .gpx files and plot their data on Google maps, but when we uploaded the Current.gpx file, the map showed a confusing jumble of many overlapping and intersecting colored lines. A legend on the Web page listed nearly two dozen individual trip logs, identified by the words ACTIVE LOG and a date.

The legend entries all look suspiciously like line 83731 in the screenshot of partial contents of the .gpx file. Using XMLSpy to search for “ACTIVE LOG” verifies our file actually does include records for numerous road trips. Like many other car navigation and handheld devices, the Garmin GPS accumulates data over time in a single large file, with each individual trip encapsulated between <trk> and </trk>.

Altova MapForce is a convenient tool to split these large .gpx files into smaller files for each trip. We can assign the gpx.xsd XML schema for both the input and output side of a mapping and use the group-by function to split the Current.gpx file based on each new occurrence of the <trk> element, highlighted below by the red connector. We used the <name> element just below <trk> as the key to mark each break, and to construct each output filename, after stripping the “:” character that is illegal in filenames.

When we click the MapForce Output button to execute the mapping, MapForce generates a new output file each time <trk> is encountered in the input stream. The screenshot below shows file 14 of 20 total files created. Notice the schema assignment and metadata (lines 2-8) are included in each output file.

Now we can map any individual file at the GPS Visualizer Web site to see a single trip:

An application like this is handy for athletes like hikers, mountain climbers, bicyclists, or runners, as well as road trip adventurers who like to keep records of their journeys. More information about the GPS Exchange Format, the GPX schema, and a list of supporting resources is available at http://www.topografix.com/gpx.asp. If you’d like to try out XMLSpy, MapForce, or any other Altova tool, you can click here to download a free 30-day trial.

Editor’s Note: On April 10, 2012 we published an associated post titled Creating Elegant Reports for GPS XML Data that describes a StyleVision stylesheet to draw a graph of elevation changes recorded in the GPS XML trip log and render a report in HTML, RTF, PDF, and Microsoft Word formats.

New! XSLT Technology Training

2012-02-27T06:00:00.000-05:00

We’re excited to introduce our new XSLT Technology training as the latest Altova Online Training offering. As with all our trainings, XSLT Technology is released as a free, self-paced course, available online, so students can fit it into their busy schedules.

XSLT transforms XML data into other formats, and this course will transform a beginner XML student into an advanced user. Intermediate and advanced students will gain valuable techniques to add to their XML toolkits.

Chapter 1 starts the course with an overview of XPath, XSL, XSLT, and XSL-FO to introduce the concepts and vocabulary.

In chapter 2, we move on to taking XML data and reforming it into new XML files. This is programmed in XMLSpy using XSLT code. We then transfer data from XML source files into new XML destination files using the graphical mapping tools of MapForce.

Chapter 3 transforms XML data into HTML web pages. XMLSpy is used to program the transformations. StyleVision is used to graphically represent the transformation and perform it. StyleVision is also used to generate XSLT code files.

Chapter 4 explores XSL-FO transformations. We use an XSL transformation to generate an FO file that is then transformed into a PDF file. XMLSpy is used to show the two step transformation. StyleVision is then used to simplify the process.

In chapter 5, we explore XSLT programming techniques. We use XSL functions to lookup, group, number, and alter XML data. We also modularize our XSLT code using functions.

After completing the course, the student will be able to transform XML data into XML files, into HTML web pages, and PDF documents, using both the programming tools of XMLSpy, and the graphical tools of MapForce and StyleVision.

You can access XSLT Technology, and all of our free, web based, self-paced trainings on the Altova Online Training page.

Release 2 of the Altova MissionKit 2012

2012-02-22T09:59:00.002-05:00

It’s an exciting week here at Altova! We have several new offerings to tell you about, including Release 2 of the Version 2012 Altova MissionKit and entire product line, a new Altova Online Training course on XSLT Technology, and a new service called Altova Product Consulting.

Let’s start with what’s included in the latest product release. Version 2012 Release 2 delivers a host of the new features that have been most frequently requested by our customers, including support for EPUB 2.x, sorting of data mapping results, RichEdit functionality for Authentic eForms, code generation from UML sequence diagrams, and much more.

Version 2012 Release 2 Highlights

EPUB

As the demand for e-books and other digital publications has exploded, so have the number of requests we’ve received from developers who need an easy way to create and edit these documents in XMLSpy 2012. In Release 2 we’ve added support for EPUB® (electronic publication), the open standard for e-books from the International Digital Publishing Forum (IDPF). It’s easy to view and work with the various files that make up an EPUB document in XMLSpy’s Archive View, which supports creating, editing, validating, and previewing EPUB digital publications.

XMLSpy already provides validation and support for editing XML, XHTML, CSS, and other standards-based files that comprise EPUB documents, making it a natural choice for creating and working with EPUB content.

Check out all the new features in XMLSpy.

Sorting for Data Mapping Projects

Another frequently requested feature is the ability to sort data in mapping projects where the final output format needs to be ordered differently than it was in the input. MapForce 2012r2 includes two powerful new sorting features that you can apply in a variety of ways.

The screenshot below shows a new function that performs a multi-level sort on the source data before writing the output file:

Another option is available for sorting relational input. MapForce users have long been able to sort database data through ORDER BY statements in SQL queries. However, SQL queries that operate inside the database are not always sufficient for complex data mapping tasks. MapForce 2012r2 adds additional database sorting functionality to the existing MapForce SQL-WHERE component to become SQL-WHERE/ORDER, which is especially useful when database input requires additional processing that cannot be accomplished in a SQL query, or other data or conditions can impact the sorted order of data rows.

Upgrade Info

Check out the rest of the features added in Release 2. This new version is free to download and install for customers with Support and Maintenance. If you’re not already an Altova customer, you can download a free, fully functional 30-day trial.

XSLT Technology Training

We are thrilled to announce the latest Altova Online Training course, XSLT Technology. This free, online, self-paced class introduces students to the concepts of XSL, XSLT, XPath, XSL-FO, and more, through guided tutorials and videos. You can practice working with these technologies using the tools of the Altova MissionKit to transform XML to XML, to HTML, and to PDF.

Altova Product Consulting

Have you ever wished you could purchase a few hours of a product expert’s time – whether you need to determine if a particular tool could solve your problem, or need help creating a schema or mapping project, or simply require in-depth product support? We’ve heard from a lot of customers with this very requirement – and in response we have created Altova Product Consulting.

Altova's Product Consulting engineers are experts on Altova software and related technologies. Services include determining if an Altova product meet the needs of a particular project, creating a MapForce mapping file (.mfd), designing a StyleVision design (.sps), and so on. Unlike typical complicated consulting engagements, Altova Product Consulting services are sold per hour, the allotment of which is agreed upon in advance, so there are no surprises.

Get more information on specific services provided, pricing, and how to get started.

Model Driven Architecture with Altova UModel

2012-02-14T08:04:00.000-05:00

For Version 2012, UModel introduces Model Driven Architecture (MDA), with platform-independent models and a Model Transformation feature that transforms all code relevant modeling elements to and from UML, C#, Visual Basic, Java, databases, and XML Schema.

Model Transformation

A Model Driven Architecture approach to software engineering with platform independent models provides two primary advantages:

During the design phase, developers do not need to be concerned with the details and variations between software languages
An existing UModel project can be transformed from one source code language to another. For instance, a UML model for a C# application can become a Java or Visual Basic project

Users can even apply model transformation to projects that were reverse engineered from existing source code. For instance, an existing Java application can be reverse-engineered by UModel then transformed to generate Visual Basic classes, and many other possibilities are available.

Platform Independent Models

Model Driven Architecture is a set of standards and methods for applying the UML (Unified Modeling Language) administered by the Object Management Group. In Model Driven Architecture, the UML model of a software project is a platform independent model (PIM) that can be fully described without concern for the details of any specific programming language. This development strategy allows software architects and other developers to focus exclusively on logic required by the subject domain, rather than characteristics of any programming language.

Data Type Mapping

During model transformation, UModel maps data types from the source to the target to accommodate differences between languages. The Type Mapping dialog lets you review or even edit type mapping pairs.

UModel also automatically adds the target language profile to the transformed project.

UML Class Diagrams

As part of the model transformation, UModel creates new UML classes and class diagrams for the target, reflecting classes and class diagrams in the original project. The screen shot below shows the Hierarchy of Account diagram for Visual Basic after model transformation from Java. The new Account class in the new folder named VB Target in the model tree contains Visual Basic syntax for all properties and operations. For instance, the new balance property is defined as the Visual Basic Single data type, whereas in Java the data type was float.

After transformation, the original Account class for Java is preserved in the model in its original location in the model tree. The original UML design for Java will now generate code in multiple source code languages – Java and Visual Basic.

Persistent Transformation Parameters

The transformation paradigm extends to updating existing transformations and merging the updates into the specified target models. Transformation parameters are stored in a Model Transformation Profile in the model. The Transformation Profile can be set to run transformations automatically before forward engineering code generation, and/or after reverse engineering, to update elements for one target language based on changes to model elements for another.

These Transformation Profile settings can also be changed at any time.

This functionality lets UModel automate much of the maintenance of multiple source code languages as your cross-platform model evolves.

If you’d like to try out Model Driven Architecture and model transformation with UModel 2012, you can download a free 30-day trial.

Data Exchange for the Mobile Workforce

2012-02-01T12:13:00.000-05:00

Data Exchange for the Mobile Workforce

Organizations have been forced to adapt many of their internal business processes to accommodate an increasingly mobile workforce. Although there are technological solutions that address many of today’s communication needs, the plethora of different document formats in use – even within the same organization – means that some tasks remain vexing. For example, how does an organization remain flexible enough to facilitate the exchange of data among mobile workers yet retain the ability to bring that data into internal IT systems?

Altova offers an inexpensive solution with StyleVision®, a graphical stylesheet and report designer with electronic forms capability, and Authentic®, a WYSIWYG XML and database editor in which end users can view and edit electronic forms created in StyleVision. The Authentic Community Edition is available from the Altova Web site as a free download so that anyone can be brought into your workflow, whether they are internal or external to your organization.

In this post we’ll present a sample case showing you how to create an electronic form that mirrors an existing paper form (in our example it is a reimbursement form) and then we’ll follow it as it makes its way around a fictional organization.

Please note that the example we use here is simplistic and was designed only to illustrate the process of developing and deploying an electronic form. Although you can add additional data sources and perform validation and other complex functions in StyleVision, we have not illustrated these here.

It is extremely easy to design electronic forms in StyleVision. To start, we simply select New – New from XML Schema/DTD/XML … from the File menu, browse to an XML Schema file, and select the type of design we’d like to create.

For this example we created an XML Schema and instance file in XMLSpy, Altova’s XML editor and development environment, based on the fields on the paper reimbursement form. You can also base a StyleVision design on a database or XBRL taxonomy.

Below is a copy of the reimbursement form we will be using along with the XML Schema we created.

Once we select the XML file in StyleVision, we are prompted to select either a free-flow or form-based document. In a form-based document all design elements (e.g., text boxes for user input, images, buttons) are fixed in position – ideal for data entry forms.

When we create a form-based document, we can upload a “blueprint image” so that we can recreate a paper-based form exactly as it was originally designed. This is the option we’ve selected below. The image will appear in the background of the design window and we will simply place design elements on top of corresponding elements on the form. Of course, the blueprint image overlay does not appear in the final output.

The screenshot below shows the blueprint image as it appears in the design window in StyleVision – how cool is that?

Now, using the Insert menu at the top, we can simply insert design elements onto the blueprint image in the design window.

Available design elements include form controls (e.g., input boxes, combo boxes, radio buttons), images, tables, charts, and “layout containers” for exact positioning.

We’ll start by adding input fields to capture employee information (i.e., First [Name], Last [Name], Title, etc. from the top part of the form). Once we click Insert – Insert Form Controls and select Input Field, the Insert Design Element dialog box appears.

We have highlighted the First [Name] element in the dialog box below – the input field will now be associated with the First element. This way, when the end user types data into the input field and saves the form, this information will populate the First [Name] element in the XML file.

We now add design elements throughout the rest of the form, associating input fields with their respective elements from the XML file.

When we are finished adding input fields, a logo, lines, a table for the expense items, and labels, the design looks like this – we’ve set the opacity attribute for the blueprint image to 0 to make it easier to view the design elements.

Please note also that we’ve done some additional design work such as adding calendars in date fields, drop down boxes, and a currency sign that changes according to user input. For more information about fine tuning your form please see the StyleVision User and Reference Manual in the StyleVision application.

We can preview how the end user will see the form we designed in StyleVision by clicking on the Authentic eForm tab at the bottom of the design window (below).

Note that the end user is prompted to enter data directly into each data input field. We accomplished this by placing the prompts (e.g., Insert First Name) in between the relevant tags in the XML file associated with our design. The end user simply highlights the prompt and replaces it with text.

Once we are finished designing the reimbursement form we can save the entire design – including the XML Schema and instance files, images, and any other associated files – in a single PXF® (Portable XML Form®). Saving the design as a PXF will enable us to email the form along with data updated in the underlying XML form among people both inside and outside the company’s LAN.

Once we hit OK we are prompted to select the files to include in the PXF. Notice that we’ve selected HTML, RTF, PDF, and Word 2007+ under the Generate and store XSLT files … heading. This will allow an end user to generate the form – with data – in these formats directly from Authentic.

Now that we’ve saved it in a PXF, the electronic form we designed in StyleVision is ready to be deployed in a business environment.

In our example, we have a team of salespeople working across the globe who need to request reimbursement for business and travel expenses incurred. The salespeople complete expense reports, forward them to their managers for approval, and then send approved reports to the corporate office so that the information can be added into the accounting system.

The PXF makes this easy.

Once a salesperson is ready to complete a reimbursement request, she simply opens the PXF in Authentic and can immediately begin entering information onto the form.

Below is a screenshot of a reimbursement form that has been completed in Authentic – notice that the form still needs a manager’s signature.

Now the salesperson must send it to her manager for approval. It’s easy to initiate an email with the form attached directly from Authentic.

Once the manager receives the email, she can simply double click the attachment and it will open in Authentic. Here the manager has clicked the Approved check box and added her name and the date.

The manager can then email the updated PXF back to the salesperson, who in turn emails it to the corporate office so it can be imported into the accounting system for processing. Our fictitious corporate office of course receives hundreds of reimbursement requests each day and has established a process for importing them into the relevant Oracle databases in the accounting system.

We’ll use Altova MapForce, a graphical any-to-any data mapping, conversion, and transformation tool, to populate the corporate database with the data from the quotations. After setting up the mapping, we’ll automatically generate code from MapForce so that we can automate the transformation either through batch processing or a real-time conversion.

First we’ll set up the mapping.

We’ve inserted the XML file ExpRpt which we’ve extracted from the PXF into the left side of the MapForce design window and then inserted the Oracle database on the right side of the design window.

Now we can drag and drop fields from the XML file with the reimbursement data into the Oracle database.

We can also transform data, as we’ve done with the Approved element. Here we’ve used the built-in boolean function to convert the string value stored in the XML file (“true” or “false”) into the numeric equivalents (1 or 0). We can also create our own functions.

The mapping we’ve created appears below.

Please note that this post offers a very broad overview of how to use both StyleVision and MapForce. Please visit the online training section of the Altova website for more in-depth instructions on how to use these and other Altova products.

And there you have it. With the PXF, the fictitious Nanonull Corporation allows a group of far flung sales reps and their managers to easily exchange and edit information via electronic form. The PXF also provides a way for Nanonull to populate the accounting database without offering these employees direct access to company IT systems.

All without busting the IT budget.

What could your organization do with a flexible, portable interactive document? Please share your ideas with other users by commenting on this blog post. Have you used StyleVision or other Altova products in an interesting project and think it would make a great case study? Email us at marketing@altova.com. We’d love to hear from you!

Intuitive User Interface Features

2012-01-23T13:35:00.000-05:00

Here at Altova we like to share user interface features across products to give the MissionKit a consistent look and feel, and to help users leverage experience gained using one tool to get up to speed more quickly with the others.

In version 2012 we introduced new visual alignment guides in both UModel and MapForce to make it easy to work very rapidly, yet still produce a neat, organized result that communicates effectively with other team members.

As users drag elements in the diagram window, alignment snap lines appear automatically to allow any component to align with any other component.

In the UModel class diagram shown above, the developer has collapsed the properties and operations compartments to concentrate on class associations. As the CheckingAccount subclass is dragged upwards on the screen, a visual alignment guide appears and offers instant snap-to alignment with the other subclasses of the Account class.

Complex data mappings in Altova MapForce might include dozens of components, functions and constants, and visual alignment guides can help organize the mapping view. In the screenshot below, the developer used alignment guides to collect split-name functions together, while concat functions are aligned in a separate group.

Constructing the mapping diagram this way can greatly clarify the developer’s intent when multiple complex string manipulations are needed!

Of course, aligned components also improve the value of printed diagrams that become part of the permanent documentation for UModel and MapForce projects.

We also understand that not everyone likes to work the same way. If you prefer not to see guide lines and to turn off automatic alignment, this feature can be deselected in the Tools / Options menu selection in both UModel and MapForce.

If you’d like to see for yourself how intuitively tools in the Altova MissionKit 2012 work together, click here to download a free trial!

Get More Mileage from Your StyleVision Designs with Dynamic Selection of CSS Files

2012-01-10T10:00:00.000-05:00

One of the great things about StyleVision is the flexibility that it affords. With StyleVision you can design visually sophisticated stylesheets and reports for output to multiple formats including HTML, PDF, and Authentic electronic forms. Now StyleVision makes it even easier to accommodate different formatting needs in a single design with dynamic selection of CSS files – a new feature introduced in StyleVision 2012.

Although you can still manage virtually all formatting tasks from the StyleVision design itself, dynamic selection of CSS files means that you can create a single template for use in multiple situations. To demonstrate, we’ve created an invoice for the fictional Nanonull Corporation for which the design changes based on the number of days that have elapsed between the invoice issue date and the due date. Although we could have used XPath to change the formatting of each element based on the number of days that have elapsed, in this case it is more efficient to create individual CSS files that apply to different scenarios.

Below is the invoice that we designed in StyleVision. Notice that beyond the bold headings it is almost devoid of formatting – we’ll be applying formatting based on the number of days that have elapsed between the invoice issue date and the due date via CSS files.

Now we can create our CSS files in XMLSpy, Altova’s XML editor with integrated support for editing CSS2 and CSS3.

First we’ll create a CSS file for invoices with due dates after the invoice issue date (i.e., invoices that are not overdue). Here we’ve simply created the body selector with a yellowish background and the Nanonull logo and a header class.

Now we’ll create a more elaborate CSS for overdue invoices. The body selector will include a past due image, the paragraph selector will have 20 point bold red font, and the header and small header classes will have red bold font in different sizes.

Now we can assign the CSS files to the StyleVision design and subsequently assign classes to different design elements.

In StyleVision, we simply click add new CSS file in the Design Overview and navigate to the CSS files we created in XMLSpy – StyleVision supports multiple CSS files in the same design.

Our design now looks like this – notice that formatting from both CSSRegular and CSSOverdue have been applied in StyleVision design view.

However we would like to assign the CSS file based on the distance between the invoice issue date and the due date. Therefore, we’ll right click on the arrow next to the CSS file in the Design Overview and choose Select One CSS File with XPath (below).

This will invoke the Select CSS File Using XPath dialog box (below). We can use XPath in this dialog box to select the appropriate CSS file based on dynamic input – here we’ve instructed StyleVision to use the CSSOverdue.css file if the invoice due date precedes the invoice issue date and the CSSRegular.css file in all other cases.

Here is the complete XPath we entered into the Select CSS File Using XPath dialog box above.

Now we can assign the classes defined in the CSS files to individual design elements in the StyleVision design.

Here we’ve assigned the paragraph containing the text “Invoice” to the class “header “ in the Styles pane – based on the contents of our CSS files this text will appear in red 20 point bold font for overdue invoices and black 20 point bold for invoices whose due date is in the future.

Likewise, we’ll assign the invoice due date to the class “small header.”

Now we’re ready to preview the invoice.

Below is the HTML preview for an overdue invoice – note that the text “Invoice” and the due date are in red bold font and that Past Due image is stamped in the middle.

Now let’s look at the same invoice with a due date in the future – note the yellow background, Nanonull logo, and that “Invoice” and the due date appear in black.

The ability to select a CSS file based on dynamic input opens up a wealth of possibilities and makes your StyleVision designs even more adaptable. With this feature, you can make formatting changes on the fly via the CSS files associated with a design – especially handy for designs with many elements.

Created a great project using the StyleVision stylesheet and report designer or any of Altova’s other tools and want to show it off? Please share your story with other Altova users by commenting on this blog post.

If you think it would make a great case study please visit the Altova case studies page – if we use your story you’ll receive a $200 Amazon gift card. We’d love to hear from you!

XML Editor Supports HTML5 and CSS3

2012-01-03T09:00:00.001-05:00

The Altova MissionKit Web tools received an important update with our recent Version 2012 release: support for HTML5 and CSS3. You’ll find support updated to include the most recent versions of these Web standards in both XMLSpy 2012 for code editing and StyleVision 2012 for graphical stylesheet and report design.

Let’s focus on the HTML5 and CSS3 editors in XMLSpy here – StyleVision functionality will be covered in a future article.

HTML5 Editor

XMLSpy has long supported editing of HTML4 and, of course, XHTML – and now those intelligent coding features extend to HTML5.

If you’re already an XMLSpy user, you’ll immediately recognize the helpful syntax coloring, source folding, and line numbering in advanced Text View when you open your HTML5 file for editing. As you type, you’re presented with valid HTML5 element and attribute choices in a drop down menu as well as in static entry helper windows, so you can complete code in your preferred working style. At the same time, code completion helps you work faster while ensuring elements are closed properly.

These intelligent editing features are applicable to the version of HTML you’re working with – when you open an existing HTML5 document or start a new file from scratch, all the HTML5 elements and attributes are immediately available in the entry helper windows and drop down menu. Some of the most notable new elements in HTML5 include:

<video> and <audio> for media playback
<canvas> for dynamic rendering of 2D images
<article>, <section>, <header>, <footer>, and <nav> for including richer semantic information to describe content
<calendar>, <date>, <time>, and other form control elements
And so on

XMLSpy includes an integrated Browser View that lets you see the results of your HTML5 coding immediately. The Browser View renders your page using your installation of Internet Explorer directly in XMLSpy…

…but also allows you to immediately view your HTML5 Web page in an instance of any browser you have installed on your machine.

This allows for quick testing and debugging to ensure cross-browser compatibility.

To get an idea of how some of the new HTML5 features look in action, check out the simple HTML5 example document that is supplied in the XMLSpy 2012 Examples folder and linked from the Example project. To learn more about HTML, there are many excellent resources on the Web, including http://www.w3schools.com/html5/ and http://dev.w3.org/html5/spec/Overview.html.

CSS3 Editor

Working hand-in-hand with the HTML5 editor is the XMLSpy CSS3 editor, which also provides syntax coloring and entry helpers, as well as bookmarking and source folding in Text View.

A CSS Outline window displays an outline of the document organized by its selectors listed in groups. Each group can be collapsed and expanded, and clicking a selector in the CSS Outline highlights it in the document. CSS Properties and HTML elements entry helpers are shown in windows as well as context sensitive drop-down menus, and XMLSpy even includes screen tips that provide a definition of each property and its possible values as you type.

You can take advantage of XMLSpy’s integrated Browser View here, too, to see the results of your CSS edits immediately in a linked HTML page.

Why XMLSpy for HTML?

Sure, XMLSpy is known for all things XML, but it’s also a clear choice for HTML development. HTML5 and CSS3 editing in XMLSpy is facilitated by support for related technologies including XML, XSLT, WSDL, and others, as well as integrated project management functionality, support for popular version/source control systems, and Microsoft^® SharePoint^® Server integration – giving you all the tools you need to develop the next generation of Web sites and apps.

We’d love to hear how you’re using HTML5 now – please drop us a line by leaving a comment below.

New in StyleVision 2012 – Composite Styles for Enhanced Formatting

2011-12-20T10:30:00.000-05:00

StyleVision is an intuitive stylesheet and report designer that transforms XML, XBRL, and database content into HTML, RTF, PDF, Word 2007+, and Authentic electronic forms – all from a single design. With the 2012 release (available for download here), StyleVision now offers even more formatting control so that you can design even more visually sophisticated output.

One of the more versatile features introduced in StyleVision 2012 is support for composite styles for output to RTF, Word, and PDF as well as HTML and Authentic electronic forms. This feature allows you to combine styles defined in an XML instance document with those you set in the report itself. You can also build a composite with XPath to control multiple style features of the same design element (e.g., font, background color, alignment).

Support for composite styles means that you can quickly and easily change the look of a design component by selecting an attribute from the XML instance file or by changing the XPath expression. This feature is used most often in cases where the XML document includes HTML fragments that contain style information – now you can use an XPath selector to extract style information from the HTML fragment and apply it directly to an output document.

Here for example we’ve used XMLSpy, Altova’s XML editor and development environment, to create an XML instance file containing the contents of a music library. (We also created the Schema in XMLSpy.)

The StyleIt attribute of the Recording element pictured below includes formatting instructions for this individual recording – according to our file the Fun Factory recording should be red and bolded.

Now we can move to StyleVision and start creating a design based on our XML instance document.

All we need to do to apply the formatting instructions in the XML instance document is to call the StyleIt attribute from the composite style drop down in the Properties pane in our StyleVision design.

The Fun Factory recording appears in red bold in the resulting output.

We can also choose to ignore the formatting instructions from the instance file and provide our own.

Here we’ve replaced the StyleIt attribute in the drop down list with an XPath if-then-else statement that assigns formatting based on an attribute of the Recording element called PlaylistCode – party tunes are in blue Papyrus 12 point font, easy listening favorites are in maroon Pristina 14 point font, and background music by default is in green Onyx 14 point font.

Here’s what the output file looks like now.

Support for composite styles is only one of the new styling features in the StyleVision 2012 stylesheet and report designer. Click here to read more about the new features across the entire Altova product line.

Have you used created a great project using the StyleVision stylesheet and report designer or any of Altova’s other tools? Want to show it off? Please share your story with other Altova users by commenting on this blog post. If you think it would make a great case study please visit the Altova case studies page – if we use your story you’ll receive a $200 Amazon gift card. We’d love to hear from you!

Announcing Altova FlowForce® Server Beta 1

2011-12-15T09:08:00.000-05:00

Altova FlowForce® Server Beta 1 is an exciting new tool for execution of automated data mappings designed to provide comprehensive management and control over data transformations performed by dedicated high-speed servers, virtual machines, or even regular workstations, depending on the size of the task.

To gather user input and accelerate product development, Altova is offering Altova FlowForce Server Beta 1 as a free public beta test to all licensed users of Altova MapForce® 2012 Enterprise Edition and MapForce® 2012 Professional Edition.

Users employ Altova MapForce data mappings for two different types of data transformations:

One-time data conversions
Data transformations that are repeated by date or time, when new source data is available, or based on some other external event

While command-line execution, royalty-free code generation, and the MapForce API can assist with automation of repeated transformations, FlowForce Server Beta 1 provides much greater power and flexibility. FlowForce Server Beta 1 is a server-based tool with a Web interface that makes it much easier to implement, manage, or modify data transformation jobs in a busy data processing environment.

FlowForce Server Beta 1 can administer multiple transformation jobs simultaneously, lets users define and adjust a variety of job triggers and actions on the fly, can perform housekeeping tasks like moving output files or cleaning up intermediate work, records detailed logs of all activity, and much more.

FlowForce Server Beta 1 consists of four components that work together as illustrated in the diagram below.

The FlowForce Server continuously checks for trigger conditions, starts and monitors job execution, and writes detailed logs.

MapForce Server is an implementation of the MapForce Built-in execution engine that executes mapping packages previously deployed via the MapForce graphical environment.

The FlowForce Web Administration Interface is a standalone web application that runs in an internet browser and provides the front-end of FlowForce Server.

MapForce Beta is an enhanced version of the Altova MapForce application with an integrated deployment feature to deploy MapForce data mappings to a FlowForce server package.

Altova FlowForce Server Beta 1 is available immediately as a free public beta test to all licensed users of Altova MapForce® 2012 Enterprise Edition and MapForce® 2012 Professional Edition.

Visit the FlowForce Server Beta 1 page at the Altova Web site for more information!

Processing the Groupon API – Epilogue

2011-11-28T00:05:00.000-05:00

Rare edge cases can derail loosely coupled data mapping applications. This is especially true when you are consuming large datasets available over the Internet and have little or no influence over the source data.

In this article we describe a debugging technique that lets developers working on data mapping and transformation projects quickly identify and accommodate unexpected data in a stream from a remote source.

The Problem

Last summer we wrote a series of blog posts describing how to work with the Groupon API to retrieve a subset of offers in all Groupon cities and format the list for a web browser or mobile device.

We concluded with a command line to run a MapForce data mapping that calls the Groupon API over 150 times -- once for each Groupon city, then filters the data to extract deals sold on the Internet instead of a physical location, and formats the results in HTML using StyleVision. Every morning we run the command line in a batch file that saves the HTML output on a local server so our colleagues can check it out with any Web browser to find interesting offers from all over the country.

The mapping ran fine for more than two months until one day it failed with this error message: “Source-value “” of type dateTime could not be converted into target-type dateTime.”

The specific explanation is that somewhere in the mapping where we expected a dateTime, we received an empty value. On a more abstract level, the error suggests a potential defect in the logic of our mapping strategy.

Every time we call the Groupon API we receive a well-formed XML data stream enclosed in a <response> element, but the API specs do not include an XML Schema defining the data that may be returned. When we developed our mapping we needed to analyze the raw data and select the output we wanted, so our first step was to call the API to capture all the Groupon deals for one large metro area.

We assumed we would get a large enough data sample to include every possible option in the API response. After our mapping ran successfully for two months, the API finally delivered a rare edge case that did not fit the pattern we expected.

Debugging Tools

MapForce provides debugging help. We can run our data mapping using the MapForce built in execution engine to see more details in the Messages window.

The lines labeled Related location are hyperlinked back to components in the mapping where the error occurred. Clicking on the result error takes us to a format-dateTime function.

We can either click the “” error or trace the value connector to identify the input element to the format-dateTime function. Either way, we locate the element that triggered the error.

The suspect element resides in the input component that captures all the data returned by our calls to the Groupon API before any filtering or conversion takes place. When we designed the mapping, the endAt element in our sample data always reported the ending date and time for each Groupon offer, but for some reason we must have received an empty value in this field.

If the error had occurred by running a local input file we could simply examine the file contents, but in this case the data came from multiple URLs, and is only held temporarily until it is mapped to the output component.

Fortunately, we can apply a trick to easily modify the mapping and preserve all data received from the Groupon API. We simply copy the input component and paste a duplicate into the mapping. We can connect the response element from the original to the duplicate, which simultaneously maps all the child elements between the components.

Our original input component is now connected to two output components. We can select which output component will be generated by the MapForce built-in execution engine by clicking the eye icon at the top right corner of any output component. The new output component simply saves a copy of everything in the input component.

When we examine the raw data using XMLSpy, sure enough we find an empty element where we expected a date and time:

The Solution

Now that we know an offer might have no specific end time, we can plan for that possibility in the mapping. In the revised treatment of the endAt element, we do an if-test before the original format-dateTime function and provide an alternate output when the endAt element is empty.

We had to work fast because all Groupon data is time sensitive. The edge case would eventually expire and disappear from the data stream. This experience showed us how important it is to have powerful debugging tools and to use them creatively, even after you think a data mapping project is running successfully!

Altova MapForce is available in a free trial – the next edge case you solve could be your own.

Editor’s Note: Our original series on mapping data from the Groupon API ran in three parts you can see by clicking the links here:

Part 1 of Processing the Groupon API with Altova MapForce describes how to create dynamic input by collecting data from multiple URLs.

Processing the Groupon API with MapForce – Part 2 describes how we filtered data from the API and defined the output to extract only the most interesting details.

Processing the Groupon API – Part 3 describes formatting the output as a single HTML document optimized for desktop and mobile devices, and reviews ways to automate repeat execution.

Analyze Football Statistics using the Altova MissionKit

2011-11-22T06:00:00.002-05:00

In this article we use stats from NFL.com and ESPN.com to show how easy it can be to process and analyze online data in new ways – even when it uses different metrics and is only available in textual format.

We have seen in previous blog posts how easy it is to gather data from the Internet that is widely available in XML formats. But what about interesting data that is available online but not in an XML format, or data that is buried in legacy data processing systems and only available in textual report format?

One such example involves quarterback ratings. The NFL has used a Passer Rating that rates quarterbacks solely based on a passer’s completions, attempts, touchdowns, and interceptions. ESPN introduced a new rating system this year called the Total QBR (Quarterback Rating). The Total QBR incorporates more data, including an expected points average and a clutch play index, that ESPN claims gives a more accurate measure of a quarterback’s performance.

Let’s compare the rankings that these system produce to see if we can garner some useful information. For this example we’ll be using the data importing and analysis tools of the Altova MissionKit to compare the ratings. If you want to try this out yourself, the MissionKit is available to download for a 30 day free trial from the Altova web site. You can access the files used in this example here.

The first thing we need is the raw data to analyze. Let’s use the entire 2010 season as a data source. We can get the table with Passer Ratings from NFL.com and then copy and paste it as a new text file.

We can access a similar table of Total Quarterback Ratings from the ESPN web site and create a second text file.

We now have two text files with tables of data in different orders. The next step is to combine the tables into one file and generate charts.

First, we need a schema file for the destination of the data. In XMLSpy, we can create an XSD file quickly, and graphically, to contain a series of QB nodes with child nodes of first and last name, team, passer rating and rank, and total QBR and rank.

Now, in MapForce, we open the text documents and use FlexText to parse the text and change it into a list of categories.

We then build a mapping file in MapForce to map the data from the text files to the destination XML file. Built-in functions make it easy to extract the first and last names from the Player string, and a value-map will change the team abbreviation to a string (ARI is changed to Arizona Cardinals, ATL to Atlanta Falcons, etc.). We set the Priority Context in the test of our filters to make sure we get the correct set of data for each unique quarterback.

Once we execute the mapping, we can save the resulting XML data file and use it as the source file in StyleVision to design a stylesheet. In this stylesheet, we create a table of the top ten ranked passers and charts showing the Passer Rating and the Total QBR graphically.

Now that we have a visual representation of the rankings of the two rating systems, we can examine their differences and try to see which works better. For example, Peyton Manning was tenth in passer rating, but was second in Total QBR. This can be explained by the Total QBR taking clutch points into account and knowing that Peyton Manning had a few late game comebacks in the 2010 season.

Since we now have a collection of files (the XSD file built in XMLSpy, the FlexText and mapping files from MapForce, and the stylesheet design created in StyleVision), we can update the text data files easily to analyze new sets of quarterback data. Later in the season, we can update the text tables with 2011 data, and allow the data to flow through the mappings and into the stylesheet to update the charts and see the rankings for the current season.

This example focuses on numbers from the NFL, but this method can easily be adapted to other data sets and data sources that are accessed as text files as well as in other formats.

You can learn more about how to use the products in the Altova MissionKit by taking our free online training courses.

Mastering Paid Keywords

2011-11-17T00:02:00.001-05:00

Anyone who manages paid keyword search knows it is hard work! You can look at vast reports of raw statistics and quickly get lost in trivia. At Altova we designed a better way to analyze and manage the performance data for our Google Adwords campaigns. We can creatively query the numbers to:

· Quickly aggregate results for subcategories of campaigns, for instance by product, geographical region, or any other grouping

· Easily identify trends over time

The chart below illustrates these advantages by collecting data for a single Altova product – SemanticWorks – from multiple campaigns over six individual months.

Starting Out

Like many keyword advertisers, we were viewing statistics in Adwords, downloading CSV files, then spending hours massaging and manipulating the data in spreadsheets to identify and format the information we required.

We wanted more immediate and in-depth reporting of keyword performance while retaining full control of the process and managing everything internally. SQL queries of a database of keyword statistics offer a powerful and flexible alternative.

In the remainder of this post we explain how the database design, data mapping, and reporting features of the Altova MissionKit can be applied to create an architecture to efficiently track paid keyword performance.

Database Design

Our choices were to implement a keywords database on an existing database platform already running in the company, an express edition of a commercial database, or an open-source database, since the Altova MissionKit works with SQL Server®, MySQL®, Oracle®, IBM DB2®, PostgreSQL®, Sybase®, and Microsoft® Access®.

We chose SQL Server for our database platform. We connected with DatabaseSpy and used the graphical database Design Editor to create the table shown below.

Most columns correspond to fields in a keywords report. In order to store multiple rows for each individual keyword – one row for every month of statistics – the table also includes columns for the month and year.

Populating the Table

The Google Adwords online interface lets users create reports of keyword statistics of specific date ranges and download them as CSV files. We downloaded individual CSV files containing our performance data for each unique month.

We used MapForce to map values from the CSV files to columns in the database table and insert the month and year data for each row.

The string functions at the bottom center of the mapping diagram remove percent signs and commas from fields we want to treat as numerical data. By doing this in the mapping, we don’t have to massage the columns of data in the CSV files before importing them.

Since the CSV files for each month all have the same structure, the mapping needs only minor revisions to import each new month’s data: update the constants at the top that define the starting row id, month, and year.

MapForce processes the mapping with its built-in execution engine, reading the CSV input and generating SQL INSERT statements for each row of data. MapForce then allows users to execute the entire generated SQL script by clicking a toolbar icon or from a selection in the Output menu:

Querying the Database

Back in DatabaseSpy, we can query the database from the SQL Editor window. This query reports the top ten performing keywords for SemanticWorks in October 2011. For data privacy, some fields in the Results chart are hidden.

To get additional interesting results, the SQL statement can be easily modified. For instance, the ORDER BY line can sort for highest cost, most clicks, or any other characteristic.

The WHERE statement combines data from multiple campaigns. The LIKE keyword treats the percent signs around SemanticWorks as wildcard characters to match any campaign with SemanticWorks anywhere in its name. Other queries could add a geographic identifier such as US or EU, or match on an entirely different column such as adgroup. Of course, all these options depend on a consistent and predictable campaign and adgroup naming system.

We created a DatabaseSpy Project to collect all our favorite SQL queries for sharing and convenient reuse. Here is the query we used to generate the chart right in DatabaseSpy that appears at the top of this post:

This query goes beyond simple SQL reporting to perform calculations on a subset of the data and format the results.

Database Reports

We designed reports for the executive team using Altova StyleVision, based on the queries and charts we had already designed in DatabaseSpy. We simply copied our queries from the DatabaseSpy SQL Editor window and added them as sources in the StyleVision Design Overview window.

Saving our report design in a StyleVision SPS stylesheet makes it is easy to regenerate an updated version every month. Here is the HTML output for a SemanticWorks Keyword Trends report based on the query above, displayed in the StyleVision Preview window:

If you follow the conventional wisdom for building your own paid keyword campaigns, you will develop segmented campaigns with many small, highly specialized ad groups, and you may also find yourself overwhelmed by the data in Adwords reports.

If you’d like to try managing your own keywords the way we describe here, a fully functional trial of the Altova MissionKit is available.

DiffDog Takes to the Cloud

2011-11-15T06:00:00.001-05:00

Techy folks generally have a good diff tool they rely on to compare and sync files and directories. But what happens when, as more and more info is bound for the cloud, your data lives on servers accessed via URL?

There are myriad applications today that live on servers accessed via HTPP – but let’s take a look at a common example: SVN. Subversion (SVN) repositories include WebDAV as a commonly used server option. WebDAV is a natural protocol for SVN because its concern is hierarchy, structured metadata, and versions. Since WebDAV is an extension of HTTP it gives easy access to basic information about files and folders to any HTTP-aware client, including DiffDog – Altova’s diff/merge tool for files, directories, and databases. However, DiffDog knows a few tricks that set it apart from the other breeds.

Diff/Merge via WebDAV

SVN clients typically support command line differencing; however, a text-only representation of the changes in even one file can be hard to read and use. When you want to compare the trunk against a tagged version, the problem is magnified.

There are several visual differencing tools available that can help with analyzing version changes in SVN. They have varying degrees of compatibility with how SVN works. Some tools are well integrated with the SVN command line. DiffDog includes all the common comparison options for a tool that is tightly integrated with SVN clients. Where it excels is its ability to talk to SVN servers.

Accessing an SVN repository with DiffDog using WebDAV is simple. The easiest starting point is to open Directory Comparison View and paste in the URLs of the folders you want to compare. In this case we’re comparing SVN branches on Projectlocker.com. The two sets of files open, and DiffDog provides a color-coded, browsable view of the differences between the two directories.

Clicking on either one of a pair of files opens a detailed file comparison.

DiffDog's ability to distinguish between changes to XML and meaningful changes is key in this situation – most development trees have some amount of XML in them. DiffDog also supports comparing Word docs and databases – so all bases are covered.

Of course, folders you compare do not have to both be WebDAV SVN folders. It is equally straightforward to compare the SVN server with a local directory.

DiffDog’s ability to access servers via HTTP (or FTP) opens a world of possibilities: comparing a local directory with a Google Docs directory, or diffing a local Web server against files hosted on the Amazon CloudFront , or even just synching photos between your local drive and your chosen back- up service.

If you’d like to try DiffDog, it’s available for a 30-day trial over on the Altova Web site.

Digging deeper with the Twitter API: iPhone 4S vs. Galaxy Nexus

2011-11-08T06:00:00.004-05:00

We found some interesting data when we dug below the surface of the iPhone 4S vs. Galaxy Nexus debate using the Twitter Search API.

In today’s world there is a vast quantity of data available online that can be used for research, market analysis, and competitive intelligence. While “Big Data” can be a problem for those who produce it, store it, and compile it, it is highly beneficial for those of us who are looking for answers.

Some of that data is fortunately available to be queried online, and, in particular, there is a vast quantity of data on social media interactions out there.

In this article we will explore how to use the Twitter Search API from MapForce, Altova’s data mapping/conversion/integration tool, to aggregate data on recent user submissions (“tweets”) on two highly popular topics – the Apple “iPhone 4S” vs. the “Galaxy Nexus” as the latest hot Android phone – and extract some statistical data about the users engaged in those discussions.

One of the benefits of this abundance of data available to us today is that we can query it in interesting ways and extract new meaning from it. While there are undoubtedly many existing services that already provide trends over Twitter topics (e.g., Trendistic), those services only offer very simple trends and do not allow us to query any deeper.

But all of the underlying data is available for grabs if you are just willing to learn a tiny bit about web service APIs and how to use them to extract XML data for further processing. As a starting point, let's use the Twitter Search API to query the stream of recent tweets for the last 100 postings that are about the “Galaxy Nexus”. The Usage Guidelines for Twitter Search tell us that using both words in a query will result in the use of the default operator, which is AND, so we are going to search for posts that contain “Galaxy AND Nexus”. So let’s try that and request the most recent 100 items:

http://search.twitter.com/search.atom?q=galaxy+nexus&rpp=100

If you follow this link, you will get a second window with a lot of raw XML data that is formatted according to the Atom Syndication Format specifications. Alternatively, you could request the data in JSON format, if you wanted to directly process it via JavaScript code by hand, but we will use the XML-based Atom format so that we can easily analyze the data and extract the information we want.

Viewing the above search result in a browser is not very user-friendly, so we can take a quick peek at the XML data in our favorite XML Editor using the Open from URL function:

As you can see, the data for each entry includes a language code, so for this example we will extract data from this Twitter feed as well as from a second search result on the “iPhone 4S” and combine them into one intermediate XML file for further analysis.

Extracting XML data is really easy in MapForce: using the “Insert XML File” option to drop in an XML source, we can again specify the same URL as before. If needed, MapForce will automatically create an XML Schema for the supplied data so we can visualize it and extract information from it:

In our mapping we have dropped in two sources on the left side – one using a query string to search for “Galaxy Nexus” and the other to search for “iPhone 4S” – and on the right side we have dropped in a simple XML Schema that will allow us to aggregate our data and analyze it more conveniently going forward. In this case the mapping between the two sides is straight-forward as we are only extracting basic information about the user, the date, and the language of the tweet, but in other applications the mapping could be more complicated and include functions as well as queries to other data sources, databases, or web services…

Previewing the resulting XML data can be done directly inside MapForce using the output tab, and this is what we see as a result of our data transformation:

Now we can easily use the reporting capabilities of StyleVision to group this data by language within each topic and count the number of posts in each language. We can then report this data in the form of pie charts, which produces the following interesting results:

Obviously, this data is highly dependent on the date of execution and time of day, as well as the particular announcements happening about these products, so the numbers will fluctuate quite a bit, but it can be used as a nice monitoring for seeing different language-specific trends. And once this has been set up, the report can be refreshed easily with the click of a button to get a snapshot at that point in time. For more long-term analysis it would of course be necessary to modify the mapping a bit to query more than 100 recent tweets.

In this article we have used Twitter’s Search API as one example data source and only looked at language as one unique data point, but there are many more interesting sources of data available online today, and this approach can be used on all of them in a similar fashion.

If you want to experiment with other data sources and other kinds of information that you want to extract, we invite you to try for yourself. A free 30-day evaluation version of MapForce is available, and there are no limits on how you can use the other features of Altova’s data mapping and conversion tool for data processing tasks that go beyond analyzing social media trends…

Case Study: Altova Customer Succeeds with XBRL

2011-11-03T06:00:00.003-04:00

XBRL is mandated for most public companies. So why are private organizations and non-profits jumping on the bandwagon? This case study examines a real-world success story.

We were really excited when the folks at MACPA told us about their success working with XBRL. They set out to discover if XBRL could be used successfully (without a huge upfront investment) by small businesses and NPOs and ended up confirming not only that, but realizing benefits to their internal financial processes, as well.

Toward Ubiquitous XBRL

With close to 10,000 members, the Maryland Association of Certified Public Accountants (MACPA) is often looked to for their expertise on issues relevant to the field of accounting. The US Securities and Exchange Commission’s (SEC) mandate that public companies submit financial data in XBRL is one of those issues.

Despite the potential of XBRL for reducing costs and increasing efficiency, many organizations are concerned about the time and expense that will be required to convert all of their financial data into XBRL, a process that can be further complicated when financial data is housed in multiple systems.

MACPA set out to prove that these obstacles are easily surmountable: with the right tools, it’s possible to bring XBRL transformation in-house to not only comply with mandates, but realize greater efficiencies and transparency in various scenarios. In the process they discovered that tagging data in XBRL is valuable to private entities and non-profits as well as public companies facing a mandate.

They took advantage of widely available XBRL software tools including the Altova MissionKit, which interfaces with multiple relational databases for XBRL mapping, tagging, and reporting.

In the end, the project turned MACPA’s financial data into a force for driving efficiencies and accountability. Once their internal accounting data was mapped to XBRL, they were able to automate burdensome data collection, transformation, and analysis tasks to gain more insight into their financial data.

For instance, MACPA used their XBRL data to populate their financial Key Performance Indicator (KPI) system, significantly reducing the amount of time and effort required to prepare the KPI documentation. This in turn enables them to run the system at more frequent intervals. They are also now able to automate previously onerous tax filing tasks by mapping the association's financial data in XBRL to the 990 tax return. (With almost 1.5 million exempt organizations in the US filing hundreds of thousands of Form 990s each year, the efficiency gained by using XBRL could be significant.)

“Ubiquitous XBRL could do for accounting/taxation what barcodes did for retail.” - Skip Falatko, MACPA Director of Finance and Administration

This project not only enabled MACPA to learn about XBRL and advise their members, but also to automate and enhance the way they dealt with their own financial data. And utilizing affordable tools like the Altova MissionKit confirmed that handling XBRL in-house is the way to go.

“Why outsource tagging [your data in XBRL]? If you tag it in house, then you own the data and can use it in myriad different ways as a productivity tool.” - Tom Hood, MACPA CEO and Executive Director

Check out the complete case study to learn how MACPA brought XBRL transformation in-house to effect changes in efficiency and transparency. If you’re an accounting or technical professional who needs to learn more about XBRL, Altova offers free, self-paced online training and an educational XBRL whitepaper.