A place for SGML and XML application developers.

July 2, 2020

OXygen XML Editor GIT Plug-in

Filed under: Uncategorized — cangione @ 6:49 pm

oXygen XML is my IDE of choice. I used to use Eclipse with the oXygen plugins put find myself using the actual oXygen IDE now as Eclipse is pretty heavy unless you are doing actual Java development. One of the other benefits has been that it had a Git client built in. Now the oXygen Editor has an add-on that incorporates a built-in Git client directly. Once the add-on is installed, a Git Staging view is available that includes various actions that perform common Git commands, such as push, pull, change branch, commit, and more. It also includes a built-in tool for comparing and merging changes!

To install the add-on:
1. Go to Help > Install new add-ons... to open an add-on selection dialog box.
2. Enter or paste

March 23, 2018

View a JAR manifest without opening it from a Terminal Window

Filed under: Java,Linux — cangione @ 9:14 am

unzip -p jdiff.jar META-INF/MANIFEST.MF

Because the -p option specifies that the unzip command should write its output to standard output rather than to an actual file, there is no need to clean up any files.


unzip -p ant.jar META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.7.1
Created-By: 10.0-b22 (Sun Microsystems Inc.)

Name: org/apache/tools/ant/
Specification-Title: Apache Ant
Specification-Version: 1.7.1
Specification-Vendor: Apache Software Foundation
Implementation-Version: 1.7.1
Implementation-Vendor: Apache Software Foundation

June 3, 2016

Shenzhen for viewing Mobile Provision Information

Filed under: iOS,Software — cangione @ 8:32 am

Shenzhen for viewing Mobile Provision Information

Highly recommend this open source program for MACs to disply the embedded .mobileprovision Information in IPA files:

This allows you to look at how an ipa file was signed and when it expires without having to unpack the file.
It’s easy to install from a command line:

        sudo gem install shenzhen

Then you can run a command like this:

        ipa info MYAPP.ipa 

Example Result:


December 29, 2015

Removing the right hand pane in Adobe Acrobat Reader DC

Filed under: Rants/Musings,Software — cangione @ 9:09 pm

The right hand pane in Adobe Acrobat Reader DC takes up a ton of room and is irrelevant to my life. Here is a hack to stop it from appearing:

  1. Go to the install directory, i.e." C:\Program Files (x86)\Adobe\Acrobat Reader DC\Reader\AcroApp\ENU".
  2. Create a new subfolder (I used "Disabled").
  3. Move 3 files from the "ENU" folder into the new "Disabled" folder:
    • AppCenter_R.aapp
    • Home.aapp
    • Viewer.aapp

November 11, 2014

Using Task Tags In Eclipse

Filed under: Eclipse — cangione @ 8:46 pm

The following diagram shows you how to setup Task Tags in Eclipse. I find this useful when I am stubbing out code and when I am trying to debug things.


September 24, 2014

Technique for finding invalid bookmarks in a PDF file

Filed under: Software — cangione @ 3:42 pm

Technique for finding invalid bookmarks in a PDF file

I have been encountering invalid bookmarks on a regular basis within PDF files lately. I went looking for a technique that would allow me to quickly determine if there were any broken bookmarks in a PDF file.

The solution I came up with involves using pdftk [] and your favorite MAC or Linux command line:

pdftk mypdf.pdf dump_data | grep -B 2 "PageNumber: 0"


BookmarkTitle: 10.2 Oxygen equipment
BookmarkLevel: 3
BookmarkPageNumber: 0
BookmarkTitle: 10.2.1 Chemical oxygen system:
BookmarkLevel: 4
BookmarkPageNumber: 0

July 27, 2014


Filed under: Software — Tags: — cangione @ 9:29 am


I have never been a fan of the heavy UI for writing. I find tools like Word distracting, and yet a simple text editor doesn’t have enough power to justify the time in creating content that will require you to go back and format it when your done.

The majority of my content is created initially for:

  • Email
  • White papers
  • Blogs
  • Wikis or online notebooks

If the content created becomes valuable enough, it will ultimately end up as a DITA topic for reuse in some future structured creation.

I have been looking for a markup language that will allow me to quickly support the various uses and evolution of my content without formatting distractions during creation. The Markdown language was created in 2004 with the goal of allowing people to write using an easy-to-read, easy-to-write plain text format, and optionally convert it to structurally valid XHTML.

Additional Information

July 23, 2014

Using Apache ANT to run XSLT

Filed under: ANT,Eclipse,XML,XSL,XSLT — cangione @ 5:38 pm

I have been using Apache ANT within Eclipse to run XSLT. The advantage to using ANT is you can easily setup a processing pipeline utilizing various XSLT filters.

Example Ant Target:


November 1, 2012

Portable Network Graphics (PNG)

Filed under: Linux,XML — cangione @ 11:31 pm

I like Portable Network Graphics for bitmap images. PNGs improve on the GIF format and are presentable in either PDF or web-based formats.

I was dealing with a client's data this week that included PNG graphics. The output quality was really poor but when I opened each graphic in a program like GIMP the image quality was fine. Turns out the source PNG files were corrupt. GIMP was fixing them before rendering them to the screen.

I found the corruption by using a Linux based command line utility called pngcheck.


Once I discovered the problem, I used another command line utility called pngcrush with a shell script to loop through all the graphics and fix the errors.


I love command lines!

C. Angione

August 18, 2011

Determining if XML Content should be printed on 8.5 x 11 or A4 Paper

Filed under: XSL — Tags: , , — cangione @ 3:24 pm

I saw a clever style sheet implementation this week. It determined the correct page layout size using the xml:lang attribute. If xml:lang is set to anything other then "en" use the International ISO standard A4 size!

US Letter is actually the most common paper size for office use in several other countries, including Canada, Mexico, Bolivia, Colombia, Venezuela, the Philippines, and Chile so there are a few more language codes that should be added for the US Letter size if you are doing business there.

January 20, 2011

Towards a Better Understanding of Software Customization

Filed under: Software — cangione @ 8:09 pm

Packaged software simplifies upgrades and maintenance because of its singularity. Support and adoption also are simplified because the single system is well known. Customization of software, by definition, is the modification of packaged software to meet individual requirements. Various valid enterprise requirements lead to customization of packaged software. In general, the benefits as well as shortcomings, of available customization techniques are poorly understood and improperly lumped together into an all-encompassing perception that all customizations inhibit evolvability.

Maintenance, or evolution, is the longest and most expensive phase of the application lifecycle. Once released, software has to be corrected and updated. Evolvability is the key metric used to judge an applications ability to incorporate updates and new revisions of packaged software while maintaining required customizations throughout the application lifecycle. This post defines three levels of software customization and their impact on application evolvability.

The Three Levels of Software Customization

An application may be defined as the combination of packaged software and customizations required to support an end user in performing user specific tasks efficiently.


The first level of customization, known as Individualization, is commonly referred to as “customization through configuration”. Important aspects of corporate-identity such as the corporate logo and corporate color scheme should reflect a corporate design. Packaged software should provide different options to different user groups. Reports should reflect company identity and reflect information necessary to support an organizations processes, workflow and individuality.

This first level of customization almost always take place for enterprise applications and tends to be a non-controversial practice. Properly executed, Individualization is well understood and requires a fairly low degree of effort to implement and maintain over the application’s evolvable lifespan.

Key metrics for Individualization are the number of properties, options and configuration settings changed from the packaged software installation baseline.


The second level of customization is Tailoring and represents a stable middle ground for the applications continued evolvability. Packaged software comes with built-in assumptions and procedures about organizations’ business processes. These assumptions and procedures seldom match exactly with those of the implementing organization’s existing processes. Therefore, most implementation projects involve some degree of software tailoring so that the software will fit current organizational processes. Tailoring may involve module selection, table configuration, or the addition of encapsulated new user functions.

In Module Selection, companies choose to implement one or more modules of a software application. In this case, customization is achieved through the company’s module selection. A Key metric for module selection is the number of implemented modules versus the total number of modules available.

Table Configuration, another tailoring technique allows an enterprise to eliminate features that are not pertinent to a give task and tailor necessary features to better suite the given task such as selecting more appropriate application defaults, or by using task-specific vocabulary in the application. A key metric for Table Configuration is the number of fields configured in each application table.

Tailoring by using Encapsulated User Functions may be broken into five categories: external input types, external output types, logical internal types, external interface types and external inquiry types.

All of these second level tailoring customization techniques utilize software “open points” built into the applications framework. Software open points, popularly known as application programming interfaces (APIs), permit changing a software system by exposing internal components in an explicit and malleable way for deployment of new or missing functions to users. Properly using these open points to extend or enhance packaged software's built-in behaviors adds the requirement for proper development and test environments and a higher degree of skill usually provided by the system integrator.

The degree to which second level customizations can easily be maintained over the application’s evolvable lifespan largely depends on the resiliency of the exposed APIs. In mature packaged software, APIs tend to be relentlessly maintained, making tailored customizations predictable during future software package/customization deployment cycles. A metric measuring the number and frequency of change to established APIs will provide insight into the stability and resiliency of the applications open points.

Core Code Changes and New Custom Software Modules

The third level of customization involves Core Code Changes and New Custom Software Module additions to packaged software. This level of customization brings with it the complexities of true software development, integration and testing during each revision/upgrade cycle. Customizations at this level frequently undermine the confidence in the packaged software's integrity and the overall application's evolvability.

The number and frequency of these third level changes should be carefully tracked. A high number of these changes indicates that the packaged software may not be suitable for an application. Additionally, adoption effort is an important metric with this level of customization since there is no baseline training or documentation upon which to rely.

A healthy evolvability metric for an application with third level customizations would be a downward trend in the number of third level customizations needed as newly available package software modules become available in future package/customization deployment cycles.


Evolvability should be an intrinsic metric in an application’s design, initial implementation and maintenance since healthy enterprise applications evolve over time. Each customization to packaged software can be categorized and measured. Properly implemented first and second level customizations provide an acceptable level of evolvability for an application. Third level customizations, while initially necessary, typically impact evolvability and should trend downward over the lifespan of a project while first and second level customization may trend upward to accommodate the configuration and tailoring of these new replacement modules.

-Charles Angione

August 5, 2010

A Simple But Useful 3D Model Use Case

Filed under: Uncategorized — cangione @ 8:17 pm

In speaking with a customer today about 3D models and their role in service information, they described a really simple but powerful use case. Part of the power of being able to rotate 3D models is not seeing the entire model from lots of different angles but from your current physical perspective.

Two scenarios were discussed:
1) A part currently in a service technicians hand and positioning the 3D model in the same orientation.
2) A person looking at the right-hand side of a complete piece of equipment when a 2D illustration only showed the left.

The utility of associating the virtual model with the physical product is obvious to me now, but I couldn't have put it into words before today.


Older Posts »

Powered by WordPress