Zarick's Blog | Incipio

Concise guide for technical mind on image metadata (EXIF, IPTC, XMP, etc)

2016-05-02T19:33:00.000+08:00

Almost everyone realize the importance of media metadata when you have a non trivial amount of files to manage. However, various standards come into play whenever one try to dig deeper and to understand how all these thing fit together.

In an attempt to migrate my iPhoto library to Lightroom, I found this topic is interesting yet messy. All image metadata, file format, schema are well maintain and published as some kind of standard, but there seems no easier way to make sense these topics easily. Consider the target is just to ensure I can migrate and manage the metadata in a rational and sensible way, it does not make sense to go through all the information with days of effort.

Hence, I try to summarize this information in a concise manner (hope this can be digested within 1 hour for people with technical background). If you are technical person but just new to image metadata, and you want to have a sound foundational knowledge, you should benefit from this article (at least this is my goal).

This article will first go through various kind of Metadata, following technical details on how this metadata embedded in the image file. Finally, the document will illustrate how to use exiftool tools to better understand the data.

Types of Metadata

EXIF is probably the earliest types of data. It primarily focus is technical information (here technical in the sense of photography). Sample information include capturing time, capture location (GPS), exposure setting (aperture,ISO,shutter), camera/lens maker and model. The standard defined the tag schema (what is the meaning for each tag) as well as on binary level how EXIF meta data can be represented.

IPTC is a metadata schema originated by news/media agency. The focus on IPTC is support annotation and organization (for example Keywords). There are two generation of IPTC, IPTC IIM (Information Interchange Model) and IPTC4XMP. Usually when people refers IPTC tags, it refers to IPTC IIM. (We will come back to IPTC4XMP later on when we discuss XMP). IPTC IIM also define the both the logical schema and binary representation.

XMP define a logical schema for representing media metadata. Very general in nature. The serialization format is XML/RDS. It defines how the standard can be extended to cover different vocabulary (via namespace). The standard consists of 3 parts, the first part different some serialization details (for example how to represent scalar values and tuples/lists. Part 3 define some details on how to represent the XMP data in binary files. This also define how XMP can exists as a sidecar file.

IPTC4XMP bring the vocabulary of IPTC under the XMP standard. It consists of IPTC-Core and IPTC-Extension. In additions to IPTC/XMP, XMP also include dulin core (XMP-DC namespace), Dublin Core are general XML schema for metadata. It originated for librarian purpose.

There are some overlap between IPTC and Dublin Core (given both try to solve the problem for information organization). A few field are defined as inter-changeable between two schema. The most important one probably is: IPTC:Keywords vs DC:Subject).

Image File Format for Embedding Metadata

JPEG file consists of 'segment', each segment starts with 2 bytes to denote the type of segment. For example, 0xFF0xD8 refers to Start of Image, 0xFF0xE1 refers to APP1 segment, 0xFF0xEC refers to APP13 segment. The 'App' segment is generic mechanism for application extension. Usually App segment also follow with additional application tag. The 0xFF0xE1 App1 segment is followed with EXIF to denote the segment is an EXIF block. The block content will then be encoded according to EXIF.

Similarly, 0xFF0xEC refers to App3 which is used by IPTC IIM, while 0xFF0xE1 with a segment header "http://ns.adobe.com/xap/1.0/\x00" denote a 'XMP' segment.

A typical JPEG pictures will both embedded with EXIF segment, IPTC-IIM segment and XMP segment. While the XMP segment will include IPTC core elements, Dublin Core elements as well as application specific extension like XMP:LR namespace will contains Lightroom specific extension under XMP format. XMP is serialized as XMP hence you can see an XML text embedded in the JPEG file if you open it with a hex or text editor.

Different metadata schema have some overlap, application usually will synchronize the meta when saving the information. In Lightroom, when an external tools update the Subject tag (part of XMP:DR), LR can be instructed to read this, when LR save the metadata, it will populate the value into both IPTC-IIM:Keyword and XMP-DC:Subject, as well as XMP-LR:HierarchicalSubject.

TIFF have similar mechanism, and most all RAW format is derived from TIFF (include CR2, ARW, and DNG). While RAW files have extension mechanism for embedding metadata, however, Lightroom allow metadata to be written as a sidecar file (all metadata, include post processing settings, are serialized in XMP format, as a separate file seat aside the original file).

Playing with Metadata

EXIFTool is a friendly CLI tools to manipulate image metadata. You can use it inspect file in details or update the metadata (hence you can write simple script and batch update a particular tag)

To read the tags, simple dump
exiftool myPhoto.jpg

Each tag is prefixed with the group (ie: whether it is EXIF, IPTC, XMP, etc)
exiftool -G myPhoto.jpg

To print all meta data in XMP
exiftool -X myPhoto.jpg

To update a particular tag
exiftool -Subject='OuterSpace' Photos/IMG_4882.jpg

To make Lightroom recognize meta data is updated, need to update IPTC Digest tag
exiftool -Subject='OuterSpace' -IPTCDigest=new Photos/IMG_4882.jpg

Further References

In additions to reference provided within the text above, some other sites provide very indepth information:

Linux goes mainstream on Desktop

2014-05-11T22:12:00.001+08:00

Linux goes mainstream on Desktop!

Well, this is a statement I read almost every year on Internet. But I never really think it is going to be the case (even I'm paid to work on it). Yet my thoughts changed recently. Not because the state of Linux is getting significantly better than its rivals. Rather it is caused by the dynamics happens on the industry.

Think about what had happened over last few years. The web is advanced so much. More and more device comes to the market with great success. People is now reading books, surfing, listening music, chat, watching movie on tablet / iPad / or even with just a smartphone. In their home, new TV have a OS there which you can do a lot of thing. Anticipating the advance on web based platform, IoT and wearable computing, I imagine in near future, general users don't need a PC anymore.

When general users don't need a PC, who needed it? What kind of users still need a PC? Users who need powerful computing like developers, video editing, scientists will be the key user of PC. In this situation, which platform is most suited the needs? I think it is OSX and Linux, obvious Linux will be choice for developers, IT specialists, scientists.

No one know what the future will looks like, this is just my wild guess. Let's put this article aside, come back and revisit after 5 years!

Tips for improving Eclipse Performance

2011-03-20T19:36:00.006+08:00

Eclipse is a great development platform. However it may seems getting slower and slower over time. While I believe real solution to performance problem only comes after correctly identify the actual root cause, doing an objective measurement, however, will take some time. Before actually spent time on perform serious profiling, I gathered some "Tips" through googling. The tips are re-organized and presented below.

Tuning the Environment

Tools only perform well if you put it on a properly configured environment. Tips below suggest different means to ensure the environment is properly tuned for development purpose. These tips are general enough to applicable on different development platforms.

Disable anti-virus on demand scanning

During clean, build, running test, and launching application application, lots of file is being read, class files are created (temporary) and a lot of library (jar) is being loaded as well. Turning off On-demand scanning is the most important tips.

Disable file index (for example: Win7/Vista file indexing)

Eclipse will create a lot of output files, which have no sense to be indexed. Exclude these files from indexing.

Putting JVM, and Eclipse install on RAM Disk

By putting Eclipse and JDK on RAM Disk, Eclipse and JDK tools can be loaded more quickly.

Use the latest JDK and Eclipse

Traditional wisdom. Always stay on the latest stable!

Eclipse Startup Configuration

Another kind of tips involve fine tuning the Eclipse start up configuration. To a certain extents, this is a matter of arts, as the correct configuration may vary from case to case and requires in-depth knowledge on how JVM work.

Explicitly define the version of JDK to use, and point directly to the DLL instead of a Java Home directory.

In the configuration, use the "-vm" parameter to points to the jvm.dll directly:

-vm
C:/Program Files/Java/jdk1.6.0_24/jre/bin/server/jvm.dll

This brings the following advantages:

Splash screen coming up sooner.
Eclipse.exe in the process list instead of java.exe.
Firewalls: Eclipse wants access to the Internet instead of java.
Window management branding issues, especially on Windows and Mac.

This tips can be found on various StackOverflow post, and one of the Bugzilla entry on Eclipse

Tuning the Heap size and GC parameters

Depending on the size of the workspace, Eclipse should be given sufficient heap space. When large heap space is required, we also need to ensure a good GC and configuration is used.
The following is a proposed solution by VonC on StackOverflow:

-Xms128m
-Xmx384m
-Xss4m
-XX:PermSize=128m
-XX:MaxPermSize=384m
-XX:CompileThreshold=5
-XX:MaxGCPauseMillis=10
-XX:MaxHeapFreeRatio=70
-XX:+CMSIncrementalPacing
-XX:+UnlockExperimentalVMOptions
-XX:+UseG1GC
-XX:+UseFastAccessorMethods

Eclipse User Preference

In Eclipse user preference, some functions may not be useful in every situation. As a result, the following options may worth spending time to fine tuned.

Disable unused options on Eclipse

Following options may have little use, consider turning it off

Label Decoration
Validators (Some validator may have nothing to do with the project you are working on)
UI fancy stuff
Disable unused content assists (For example, disable SWT proposal if you are not working on SWT based project)

Avoid too many local history

If version control system is deployed and used properly, a short local history is sufficient is most case.

Close unused View and use correct perspective

Unused perspective take some memory, unused view will take sometime to refresh without any added-value.

Disable unused plugins

This is controversial, as some people reported that, Eclipse load plugin lazily, so disable it doesn't bring too much benefits.

Misc Tips

Apart from the three categories of tips, one more tips looks useful as well:

Keep Eclipse clean without out-dated or broken meta-data

Start eclipse with the parameter:

eclipse -clean

The details for this parameter is can be found Eclipse Wiki, and further explained at EclipseZone.

Reference

Disclaimer

Tips in this post are merely an recap from other peoples. I personally haven't tested all of the tips above (when I try it out latter, I'll keep posting update if the tips is not correct.). As a result, take it at your own risk.

The best CLI tools all the time

2010-12-18T17:25:00.000+08:00

Every December, each geeky website will prepare "Best Windows/Mac Software of 20xx". Why there is not a "Best CLI Tools All the Time" article?

Why not "Best CLI Tools of 20xx"? Sorry, there would not be too useful to have such a list every year. As good CLI goods all survive throughout years. Ever since I know the use of ssh, it keeps to top on my list. What software allow you to forward whatever port you like and execute commands on different hosts?

While "Best CLI Tools All the TIme" comes to be head, I googled an interesting site: http://www.commandlinefu.com/

Does Dynamic Programming Languages more Productive for Web Development?

2010-12-11T22:52:00.001+08:00

While Dynamic Programming Languages like Python and Groovy are hot topics in recent years. Surprisingly, there is not a clear definition for "Dynamic Programming Language". So, what "Dynamic Programming Language" refers to and does it really helps to spped your next web application?

Dynamic Programming Language

In general, dynamic programming language refers to the languages which exhibits the following nature:

Dynamical Typing support
Meta-programming support
Support for functional-programming
Support for aspect-orient features

And most likely, all the three dynamic languages mentioned above have the following natures:

Intrepreted
Web Application Framework support rapid application development, usually emphasis convention over configuration

How does these features is considered a good thing? Below, I'll use Groovy, Python as the examples to demostrate the capability of these language on traditional / mainstream language like Java.

Dynamic Typing Support

Through automatic type coercion, dynamic languages like Groovy free you statically defining type.

Metaprogramming Support

Metaprogramming is the foundation for all kinds of fancy features in this new language. For example, we can easily use Metaprogramming to implement dynamic proxy or implement mixin, all these are traditionally hard to implements.

Functional Programming

Groovy provide closure. While in Python, lamba, map and reduce is built-in functionI, in additionsl and method is just another object in Python. All this allow programmer easily define template and as well as implementing some logic in functional style.

Aspect Oriented Programming

Usually through the support of the meta-programming facility, implementing AOP in dynamic language is relatively much easily. For example, in Groovy, Meta Object Protocol provide tonless means to injecting / intercepting method join, which is one of most commonly use case of AOP. In Python, new style class and decorator provides similar kind of foundation for injecting extra functions.

Intrepret Language

Intrepret nature, in other words, new code can be compiled at runtime can greatly save the development time and improving the turn around for each cycle. This seems a by-product of the dynamic language. Contrary to tradional language which rely on compiling linking, dynamic language usuing resolve the method at runtime, it also allow each file can individually updated, without re-compiling the whole package / module.

Frameowkr which favors Convention over Configuration

Interesting, all these new language also accompanied with new web application framework which emphais convention over configuration. For example, there is Grails (on Groovy) and Django (on Python). These framework allow developers create new function without paying too much tax on the configuration.

StAX - Streaming API for XML

2010-12-11T22:16:00.001+08:00

StAX, is a Java processing XML API which allow software to processing XML stream in a push streaming style. In certain scenario, StAX will be the most efficient approach for prcoessing XML stream. This article aims to provide an overview on this API as well as comparison with two other commonly used APIs: DOM and SAX.

Background

StAX, is defined by JSR 173. The API is initially provided by some industry vendor including Oracle, and BEA and finally becomes a JSR. Starting from JDK 6, it is already included in JDK as a part of the standard Java XML processing API (JAXP).

With the advent of all kind of XML API, high level (and developer friendly) tools like JAXB and XStream can be very handy for XML writing / reading. In certain situation, however, it would be desirable to implement the processing logic with lower level XML processing API. For example, consider implementing a XML message router, there is no need to process the whole message in order to perform the routing. Unmarshalling a XML message with JAXB or XStream, or even DOM will not be an efficient approach. In contrary, the best handling may be only process the header, decide the routing and dispatch the message without processing the whole XML message.

Push Streaming XML Processing

So StAX is a "Push" and "Streaming" API for XML processing. What does it actually means. Example below can help to illustrate these two idea. Let's say there is simple XML message looks like this:

  <words a="123">
    <word/>
    <word>Apple&amp;Orange</word>
    <!-- comment -->
  </words>

And below is a simple code snipplet demostrate how StAX API can be used:

  XMLEventReader reader = XMLInputFactory.newFactory().createXMLEventReader(inputStream);
  while (reader.hasNext()) {
   XMLEvent e = reader.nextEvent();
   String eventType = "N/A";
   switch (e.getEventType()) {
    case XMLEvent.START_DOCUMENT:
     eventType = "START_DOCUMENT";
     break;
    case XMLEvent.END_DOCUMENT:
     eventType = "END_DOCUMENT";
     break;
    case XMLEvent.START_ELEMENT:
     eventType = "START_ELEMENT";
     break;
    case XMLEvent.END_ELEMENT:
     eventType = "END_ELEMENT";
     break;
    case XMLEvent.CHARACTERS:
     eventType = "CHARACTERS";
     break;
    case XMLEvent.COMMENT:
     eventType = "COMMENT";
     break;
   }
   System.out.println(eventType + ":" + e.toString());
  }

Executing the sniplet above will generate be following output below:

  START_DOCUMENT:<?xml version="1.0" encoding='null' standalone='no'?>
  START_ELEMENT:<words a='123'>
  CHARACTERS:
    
  START_ELEMENT:<word>
  END_ELEMENT:</word>
  CHARACTERS:
    
  START_ELEMENT:<word>
  CHARACTERS:Apple
  CHARACTERS:&
  CHARACTERS:Orange
  END_ELEMENT:</word>
  CHARACTERS:
    
  COMMENT:<!-- comment -->
  CHARACTERS:

  END_ELEMENT:</words>
  END_DOCUMENT:ENDDOCUMENT

In this example, XmlEventReader, one of primary interface in StAX is used. XmlEventReader provides the nextNext() and next() method. XMLEventReader can be viewed as a reader, which will parse the XML stream. XMLEventReader will parse and returnn an XMLEventReader upon each next() call. The API is similar to the Java collections API. However, in StAX, what is being iterate is not a collection of items, but a series of XML processing Event.

XMLEvent in StAX refers to the various event when a parser is paring a XML stream. When the XML parser start parsing an XML document, it will return an Event to represent the start of document (START_DOCUMENT). When it proceed parsing, it will encounter the start of an XML element (START_ELEMENT), that is the <words> node. Similarlly, when the parser encounters some TEXT data (including whitespace and new line between two XML tag), it will report it as a Character event. When it recognize an end of tag (like </words> it will report it as an end of element event (END_ELEMENT). And finally, when it found that the parsing is finished, it will report an End of Document event (END_DOCUMENT).

In other words, in StAX, application will handle the stream of XML event. In additions, with StAX, application will proactively control the parsing. XMLEventReader will not do the parsing unless the "next()" is called. Everything "next()" is called, the XML parsing continue and stop when XML event is created and the event will then returned to the application. Application using StAX can decide whether it should read up the whole document, or pause after traversing the beginging portion of the XML stream.

XMLStreamReader and XMLEventReader

In StAX, two interface is provided: XMLStreamReader and XMLEventReader. The conceptual use of this two are basically the same. Software will use the "hasNext()" and "next()" to control the parsing. The main key difference is, with XMLEventReader each next() will return an event which encapsulate the XML parsing event. With XMLStreamReader, next() call will return the event type. To access the details (like the XML element name and attribute contents), we need to use various accessor methods on the XMLStreamReader to retrieve the information. The sample code below will try to parse an XML message and return a Message object to represent the message. The code below will demostrate how XMLEventReader and XMLStreamReader can be used to implements MessageReader interface. Consider the XML message below:

  <?xml version="1.0" encoding="UTF-8"?>
  <mf:message xmlns:mf="http://www.nixstyle.net/lab/xml/message-router">
    <mf:header>
      <mf:source>z33220011z&amp;gmail.com</mf:source>
      <mf:destination>a77662233a&amp;gmail.com</mf:destination>
    </mf:header>
    <mf:content>
      <xyz:message xmlns:xyz="http://www.nixstyle.net/lab/xml/message-sample">Yo!</xyz:message>
    </mf:content>
  </mf:message>

Below is a MessageReader interface

  public interface MessageReader {
    Message next() throws XMLStreamException;
  }

Below is an implementation of MessageReader using XMLEventReader

    public Message next() throws XMLStreamException {
      XMLEvent event = reader.nextTag();
      expectStartOfElement(event, "message");
      return parseMessage();
    }

    private Message parseMessage() throws XMLStreamException {
      Message message = new Message();
      
      XMLEvent event = reader.nextTag();
      parseMessageHeader(event, message);
      
      event = reader.nextTag();
      parseMessageContent(event, message);
      
      return message;
    }

    private void parseMessageContent(XMLEvent event, Message message) throws XMLStreamException {
      expectStartOfElement(event, "content");
      while (!isEndOfElement(event, "content")) {
        event = reader.nextEvent();
      }
    }

    private void parseMessageHeader(XMLEvent event, Message message) throws XMLStreamException {

      String source = null;
      String destination = null;

      expectStartOfElement(event, "header");

      while (source == null || destination == null) {

        XMLEvent nextTag = reader.nextTag();
        if (nextTag.isStartElement()) {

          if ("source".equals(nextTag.asStartElement().getName().getLocalPart())) {
            source = reader.getElementText();
          }

          if ("destination".equals(nextTag.asStartElement().getName().getLocalPart())) {
            destination = reader.getElementText();
          }
        }

      }

      message.setSource(source);
      message.setDestination(destination);

      XMLEvent next = reader.nextTag();
      moveToNextEndElement(next, "header");

    }

    private void moveToNextEndElement(XMLEvent event, String elementName) throws XMLStreamException {
      while (!isEndOfElement(event, elementName)) {
        if (reader.hasNext()) {
          event = reader.nextTag();
        } else {
          throw new RuntimeException("Unexpected stream");    
        }
      }
    }
    
    private void expectStartOfElement(XMLEvent event, String elementName) throws XMLStreamException {
      if (!isStartOfElement(event, elementName)) {
        throw new RuntimeException("Unexpected stream");
      }
    }
    
    private boolean isStartOfElement(XMLEvent event, String elementName) throws XMLStreamException {
      if (event.isStartElement()) {
        return event.asStartElement().getName().getLocalPart().equals(elementName);
      }
      return false;
    }

    private boolean isEndOfElement(XMLEvent event, String elementName) throws XMLStreamException {
      if (event.isEndElement()) {
        return event.asEndElement().getName().getLocalPart().equals(elementName);
      }
      return false;
    }

Below is an implementation of MessageReader using XMLStreamReader

    public Message next() throws XMLStreamException {
      Message message = null;
      while (reader.hasNext()) {
        int eventCode = reader.next();
        if (eventCode == XMLStreamConstants.START_ELEMENT) {
          String elementName = reader.getLocalName();
          if ("message".equals(elementName)) {
            message = parseMessage();
          }
        }
      }
      return message;
    }

    private Message parseMessage() throws XMLStreamException {
      Message message = new Message();
      int nextTag = reader.nextTag();
      if (nextTag == XMLStreamConstants.START_ELEMENT) {
        if ("header".equals(reader.getLocalName()) == false) {
          throw new RuntimeException("Unexpected stream");
        }
        parseMessageHeader(message);
      }
      
      nextTag = reader.nextTag();
      if (nextTag == XMLStreamConstants.START_ELEMENT) {
        if ("content".equals(reader.getLocalName()) == false) {
          throw new RuntimeException("Unexpected stream");
        }
        parseMessageContent(message);
      }
      return message;
    }

    private void parseMessageContent(Message message) throws XMLStreamException {
      if (reader.getLocalName().equals("content") == false) {
        throw new RuntimeException("Unexpected stream");
      }

      while (!isEndOfElement("content")) {
        reader.next();
      }
    }

    private void parseMessageHeader(Message message) throws XMLStreamException {

      String source = null;
      String destination = null;

      expectStartOfElement("header");

      while (source == null || destination == null) {

        int nextTag = reader.nextTag();

        if (nextTag == XMLStreamConstants.START_ELEMENT) {

          if ("source".equals(reader.getLocalName())) {
            source = extractText();
            moveToNextEndElement("source");
          }

          if ("destination".equals(reader.getLocalName())) {
            destination = extractText();
            moveToNextEndElement("destination");
          }

        }
      }

      if (reader.nextTag() != XMLStreamConstants.END_ELEMENT) {
        throw new RuntimeException("Unexpected stream");
      }

      message.setSource(source);
      message.setDestination(destination);

      moveToNextEndElement("header");

    }


    private String extractText() throws XMLStreamException {
      while (!isStartOfText()) {
        reader.next();
      }
      return reader.getText();
    }

    private void moveToNextEndElement(String elementName) throws XMLStreamException {
      while (!isEndOfElement(elementName)) {
        if (reader.hasNext()) {
          reader.next();
        } else {
          throw new RuntimeException("Unexpected stream");    
        }
      }
    }

    private void expectStartOfElement(String elementName) {
      if (!isStartOfElement(elementName)) {
        throw new RuntimeException("Unexpected stream");
      }
    }

    private boolean isStartOfElement(String elementName) {
      if (reader.getEventType() == XMLStreamConstants.START_ELEMENT) {
        return reader.getLocalName().equals(elementName);
      }
      return false;
    }

    private boolean isEndOfElement(String elementName) {
      if (reader.getEventType() == XMLStreamConstants.END_ELEMENT) {
        return reader.getLocalName().equals(elementName);
      }
      return false;
    }

    private boolean isStartOfText() {
      switch (reader.getEventType()) {
        case XMLStreamConstants.CDATA:
        case XMLStreamConstants.CHARACTERS:
          return true;
      }
      return false;
    }

In the sniplets shown above, XMLEventReader and XMLStreamReader is both used. The key difference is, XMLEventReader return an XMLEvent which provide a little bit Object oriented interface for accessing the XML event details. With XMLStreamReader, the accessor method like getText() and getLocalName() is only available on the XMLStreamReader interface. As a result, XMLEventReader is usually the preferred approach.

Compare with SAX and DOM

When comparing StAX with SAX, the most notable difference will be the control of the parsing. With SAX, the application can only provide a callback to handle the event. Once the parsing is started, parser will continue parsing the whole stream. The application will have no control on the parsing, for example, terminte the parsing after processing a message header.

When compare with DOM, the difference is more significant. When processing XML using DOM, the object model representing the whole XML structure will be constructed. When the XML message size is huge, it may be inefficient for building the whole DOM tree. Especially, most of the time, application will convert an XML into some kind of POJO. In contrary, using streaming API like StAX can eliminate the needs to building the DOM tree in memory.

On the other hand, if all the application need is performing some analysis on the XML stream, only building a DOM and manipulate with DOM tree will make more sense.

YAML - YAML Ain't Markup Language

2010-12-07T23:43:00.002+08:00

YAML, which stands for "YAML Ain't Markup Languge", is a data serialization format, which can be used to represent data or message.

This article provide a background on YAML as well as a comparison between YAML and XML using the Maven POM as a example.

What is YAML?

While there are many of data serialization format, the strengths of YAML is the focus on human readability and still provide rich constructs for representing different data structure.

In YAML, each data stream can consists of multiple YAML data, each data is separated by the '---' marker. And '...' can be used to signal an end of stream. Hash prompt '#' is used to start an comments which ended by the end-of-line. Data in YAML can be represented in three different ways: Scalar, Associative Array and Sequence.

For associative array (aka Map), it can be represented in this way:

  name: Xyz Conference
  maxParticipants: 20
  startTime: 2010-10-14 08:30:00.00
  breakfastProvided: yes

Alternatively, associative array can also model with JSON style (as a short form):

  [ name: Xyz Conference, maxParticipants: 20, startTime: 2010-10-14 08:30:00.00,  breakfastProvided: yes]

For sequence, it can be represented in this way

  - Java
  - Python
  - Ruby

Alternatively, sequence can also model in JSON style (as a short form):

  [ Java, Python, Ruby ]

The short form syntax in YAML also imply that, JSON document is compliant with YAML.

To get a taste of YAML, below is a personal organizer modeled using YAML:

---
# Document which representing my personal organizer

# Tasks
tasks:
 - 
   summary:     Prepare project proposal
   tags:        [School, Urgent]
   update time: 2010-10-14 18:59:23.17
   completed:   true
 - 
   summary:     Arrange a gathering
   tags:        [Friend, Someday]
   update time: 2010-10-14 18:59:23.17
   completed:   false

# Memos
memos:
 - 
   content:     >
                Precedence of UrlMappings for status code is defined by lexical order.
                While regex based URL mapping is defined by the precedence rules.
   update time: 2010-10-14 18:59:23.17
   archived:    false
 - 
   content:     >
                Pattern-Oriented Software Architecture Volumn 2
                http://www.cs.wustl.edu/~schmidt/POSA/POSA2/
   update time: 2010-10-10 18:59:23.17
   archived:    true

...

From the example above, it is extremely easy to comprehend the content. It consists of two tasks and two memos. The structure of each task and memo is also readily understandable. In this example, several strengths of YAML is demostrated.

Richer information model used in YAML.

Compare with XML which each documents consists of element node. YAML document consists of four types of node, which are sequence, scalar, mapping and alias. While you can certainly model sequence or key to value pair in XML, it is more clumsy when compare to the one modeled in YAML.

In YAML, indentation is used to to present the hierarchy structure of data. Child elements will have more indentation then it's parent node. However, only whitespace character (ascii x20) is used for indentation, tab character (ascii x09) is not allowed.

Readily defined type

In YAML, some commonly used data types are already defined, which include String, Time, Boolean, Integer Number and Floating Point Number.

While in XML, you can use DTD or Schema to defined the data types for each of element, for this typing is offered from YAML, any YAML document will be benefits with this offering.

A full reference of the data supported in YAML can be found here.

Flexibility on encoding String

In YAML, string can be encode without any quote. In additions, you will find that, the use of tag in YAML is minimized. It make it perfert to encoding messages block in a YAML documents. For example, we can easily put a HTML or XML block, or some code fragments in the YAML document without resorting escape the characters in the text.

In XML, if you want to encode a HTML fragment, or a Math formula, or a code fragment, you will need escape some reserved characters with escape sequence.

Space efficiency

As YAML do not rely on balanced mark up (like XML) to represent the data structure, most of the document payload is representing the data itself, instead. Compare with XML, each tag must have a balanced closing tag, the size used for representation a piece of data in YAML is usually lesser than XML. Below, a direct XML and YAML comparison will demonstrate this points

Well, YAML is full of strengths, but it don't means it will be a perfect choice for representing all kind of data or messages. As always, no one tools can serve all purpose and YAML is no exception. YAML does have some weakness, below are some key issues:

Lack of schema definition

YAML doesn't provide any facility to define the schema and the semantics of the Document.

If different parties are going to interchange a YAML document, the exact specification of the document must be specified with somewhere else.

Compare with XML, in which the schema can be defined clearly with XML Schema or Relax NG, YAML just doesn't provide this kind of feature.

Lack of supporting technology

YAML doesn't provide any "query language" (like XQuery, XPath in XML) to support querying YAML.

Lack of namespace support

YAML does not provide any namespace mechanism. Without a namespace concept, it also imply there is not possible to unambiously weaving different YAML documents.

Comparing with XML directly

While XML are the most commonly used data format, there are some problem. One frequently heard complaint on XML is the space efficiency.

The following is a sample Maven POM file which describe a project / module build configuration

<project>
  <modelVersion>4.0.0</modelVersion>
  <name>Maven Default Project</name>

  <repositories>
    <repository>
      <id>central</id>
      <name>Maven Repository Switchboard</name>
      <layout>default</layout>
      <url>http://repo1.maven.org/maven2</url>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <name>Maven Plugin Repository</name>
      <url>http://repo1.maven.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <build>
    <directory>target</directory>
    <outputDirectory>target/classes</outputDirectory>
    <finalName>${artifactId}-${version}</finalName>
    <testOutputDirectory>target/test-classes</testOutputDirectory>
    <sourceDirectory>src/main/java</sourceDirectory>
    <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>src/test/resources</directory>
      </testResource>
    </testResources>
  </build>

  <reporting>
    <outputDirectory>target/site</outputDirectory>
  </reporting>

  <profiles>
    <profile>
      <id>release-profile</id>

      <activation>
        <property>
          <name>performRelease</name>
        </property>
      </activation>

      <build>
        <plugins>
          <plugin>
            <inherited>true</inherited>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>

            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-javadoc-plugin</artifactId>

            <executions>
              <execution>
                <id>attach-javadocs</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-deploy-plugin</artifactId>

            <configuration>
              <updateReleaseInfo>true</updateReleaseInfo>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>

If it is modeled with YAML, it will looks something like this:

project:
  modelVersion: 4.0.0
  name: Maven Default Project

  repositories: 
    - id: central
      name: Maven Repository Switchboard
      layout: default
      url: http://repo1.maven.org/maven2
      snapshots: 
        enabled: false

  pluginRepositories: 
    - id: central
      name: Maven Plugin Repository
      url: http://repo1.maven.org/maven2
      layout: default
      snapshots: 
        enabled: false
      releases: 
        updatePolicy: never
      
  build: 
    directory: target
    outputDirectory: target/classes
    finalName: ${artifactId}-${version}
    testOutputDirectory: target/test-classes
    sourceDirectory: src/main/java
    scriptSourceDirectory: src/main/scripts
    testSourceDirectory: src/test/java
    resources: 
      - directory: src/main/resources
    testResources: 
      - directory: src/test/resources

  reporting: 
    outputDirectory: target/site

  profiles: 
    - id: release-profile

      activation: 
        property: 
          name: performRelease

      build: 
        plugins: 
          - inherited: true
            groupId: org.apache.maven.plugins
            artifactId: maven-source-plugin
            executions: 
              - id: attach-sources
                goals: 
                  goal: jar

          - inherited: true
            groupId: org.apache.maven.plugins
            artifactId: maven-javadoc-plugin
            executions: 
              - id: attach-javadocs
                goals: 
                  goal: jar
                
          - inherited: true
            groupId: org.apache.maven.plugins
            artifactId: maven-deploy-plugin
            configuration: 
              updateReleaseInfo: true

One notable difference amongst these two document is, the YAML one is more readable. When looks into details, the total size for the XML version is 2941 bytes while the size for the YAML is only 1714 bytes, which is effectively 42% reduction in size. In additions, the number of lines in the XML version is 110 lines, while the YAML version is only 68 lines, which is 38% reduction.

The difference is mainly due to the fact that, YAML doesn't requires a balance end tag. In additions, YAML natively providing constructs to support sequence and maps as top level elements. For example, two model lists of repository in XML, we need two tags (repositories and repository) to module a list, and two extra lines for putting the end tags. In YAML the end tag is never needed.

Conclusion

Considering both the pros and cons, YAML has great advantage on the human friendiness and clarity, while the lack of schema / namespace support will prevent it from being employed on large scale or complex environment.

Using SyntaxHighlighter at Blogspot

2010-12-05T17:43:00.002+08:00

Blogspot doesn't support syntax highlight by default. What a shame, considering that all decent Wiki engine are providing certain level of support for this already. While Blogspot isn't a wiki, but without syntax highlighting, I just keep have a feel that, Blogspot is not a place for technical post. Anyway, SyntaxHighlighter is a solution for this.

The official installation instruction require you to upload the script and link the scripts from your blogspot template. Castillo has post a workaround on how to use this lovely tools on Blogspot without having a hosting space. The post seems out-dated. It isn't too hard to figure out the way, below are the up-to-date procedure.

1. Update the Blogspot template and add following in the <head>

  <script language='javascript'   
    src='http://bitbucket.org/alexg/syntaxhighlighter/raw/b7578b438a69/scripts/XRegExp.js'/>
  <script language='javascript' 
    src='http://bitbucket.org/alexg/syntaxhighlighter/raw/b7578b438a69/scripts/shCore.js'/>
  <script language='javascript' 
    src='http://bitbucket.org/alexg/syntaxhighlighter/raw/b7578b438a69/scripts/shAutoloader.js'/>

  <link rel='stylesheet' type='text/css'
    href='http://bitbucket.org/alexg/syntaxhighlighter/raw/b7578b438a69/styles/shCoreDefault.css' />

2. Apply the following snipplets near the end of <body>

<script language='javascript'>
SyntaxHighlighter.config.bloggerMode = true;
SyntaxHighlighter.autoloader(
  'xml  http://bitbucket.org/alexg/syntaxhighlighter/raw/b7578b438a69/scripts/shBrushXml.js',
  'css  http://bitbucket.org/alexg/syntaxhighlighter/raw/b7578b438a69/scripts/shBrushCss.js'
);
SyntaxHighlighter.all();
</script>

3. In the post, use <pre> with the class attribute to define the corresponding syntax

<pre class="brush: xml>
  <echo>Hi SyntaxHighlighter!</echo>
</pre>

SyntaxHighlighter support different kind of syntax, all you need to do is just to define it in the "autoloader" call. The full list of supported syntax can be found here. SyntaxHighlighter also provided a few different theme which can be configure by importing different javascript, the full list can be found in here.

SLAX - Beautiful Live CD and Live USB

2010-09-25T01:50:00.000+08:00

SLAX is simple Live CD / Live USB distribution. It allows easily to web interface for creating tailored made build.

In additions to the modules available on the official website, it is extremely easy to create modules. To illustrate how easy it is, the following is a steps by steps:

 1. Download a vanilla SLAX ISO
 2. Boot-up the image with a spare machine or Virtual Machine
 3. After image boots up, login as root
 4. Create a directory
    $ mkdir /tmp/rootcopy
 5. Put some files under this directory
 6. Create the module file
    $ cd /tmp
    $ dir2lsm rootcopy mymodule.lzm
 7. Put this module file under /slax/modules

Fixing the Cygwin ACL Problem

2010-09-25T00:26:00.000+08:00

Cygwin is always one of the best tools for me. It provide an emulated *nix like environment include a shell environment, POSIX path, etc. Of all the emulation provided, however, the POSIX-like permission is the only thing I am not appreciated.

The purpose of permission and ACL is for controlling access of files under a multi-user environment. Whilst it will be useful for running network services, it is pointless for most development use cases. Files are mostly accessed by only one user, that is me!

When Cygwin is emulating POSIX permission using Windows ACL, it can easily caused undesirable trouble when one is trying to access the files from both Cygwin environment and ordinary Windows based tools. To get rid of this, Cygwin provided means for disabling this. Unfortunately, the mechanism is different between 1.5.x and 1.7x. And this can even more frustrating when you are trying to upgrade from 1.5.x to 1.7.x.

All the details below can be found on Cygwin manual. But it may take sometimes to dig it out even with the help of google. So, here we go!

For version prior to 1.7, the method is setting the following environment variable:

    CYGWIN=nontsec

Since 1.7, the method is setting 'noacl' as part of the mount point options in fstab. You should have a line like this:

    none /cygdrive cygdrive noacl,binary,posix=0,user 0 0

Note that, no extra entries should present for all mount point which can be mount up automatically.

For upgrading from 1.5 to 1.7, you should also clean up the mount point defined in the registry. From Cygwin 1.7, registry is only used for defining the installation directory of Cygwin itself.
When in doubt, use cygcheck to have a look, which can shows the mount point configuration inherited from registry.

Huawei B970b (Smartone Vodafone Wifi Router)

2010-05-02T04:11:00.002+08:00

Before I subscribe the Smartone Vodafone Home Broadband service, I've serviously try to seek some official answer the following questions:
1. Will the router get a public IP address?
2. Does the bundled WIFI router allow me to configure port forwarding?

And the official answer is NO!

But the fact is, YES! The router is Huawei B970b, as there is not much information on the Net at this moment, I'd share information gathered so far. Before is a summary followed with command line output capture (Yes, I can get the shell access on the router easily)!

Below is summary of import points
1. I do get a public IP!
2. The default router admin software (web-based) allow you to configure port forward
3. In addition, you can also configure DMZ server, MAC filter, DynDNS setting.
4. Telnet port (23) is opened by default (login with the admin account and you get a busybox)
5. It use dnsmasq and iptables

The following is the information I gathered after I gain root access:

# cat /proc/version
Linux version 2.4.20 (bcm@localhost.localdomain) (gcc version 3.2.3 with Broadcom modifications) #2 Tue Feb 2 18:23:23 CST 2010

# mount
rootfs on / type rootfs (rw)
/dev/root on / type squashfs (ro)
none on /dev type devfs (rw)
proc on /proc type proc (rw)
ramfs on /tmp type ramfs (rw)
/dev/mtdblock/3 on /tmp/var/custom type squashfs (ro)

# free
total used free shared buffers
Mem: 30520 13552 16968 0 1520
Swap: 0 0 0
Total: 30520 13552 16968

# cat /proc/kmsg
<4>Kernel addr reboot flag = 0xa1fff000, reboot_number = 0xa1fff004
<4>Kernel physical_mem =0x2000000 reboot flag = 0x12345678, reboot_number = 0x0
<4>CPU ProcId is: 0x00029029, options: 0x0000014d
<4>Primary instruction cache 16kb, linesize 16 bytes (4 ways)
<4>Primary data cache 16kb, linesize 16 bytes (2 ways)
<4>Linux version 2.4.20 (bcm@localhost.localdomain) (gcc version 3.2.3 with Broadcom modifications) #2 Tue Feb 2 18:23:23 CST 2010
<4>Setting the PFC to its default value
<4>Determined physical RAM map:
<4> memory: 01fff000 @ 00000000 (usable)
<4>On node 0 totalpages: 8191
<4>zone(0): 8191 pages.
<4>zone(1): 0 pages.
<4>zone(2): 0 pages.
<4>Kernel command line: root=/dev/mtdblock2 noinitrd console=ttyS0,115200
<4>CPU: BCM5354 rev 3 at 240 MHz
<4>Calibrating delay loop... 239.20 BogoMIPS
<6>Memory: 30452k/32764k available (1563k kernel code, 2312k reserved, 112k data, 68k init, 0k highmem)
<6>Dentry cache hash table entries: 4096 (order: 3, 32768 bytes)
<6>Inode cache hash table entries: 2048 (order: 2, 16384 bytes)
<4>Mount-cache hash table entries: 512 (order: 0, 4096 bytes)
<4>Buffer-cache hash table entries: 1024 (order: 0, 4096 bytes)

dev: size erasesize name
mtd0: 00040000 00010000 "cfe"
mtd1: 00340000 00010000 "linux"
mtd2: 00282970 00010000 "rootfs"
mtd3: 00060000 00010000 "resource"
mtd4: 00010000 00010000 "factory"
mtd5: 00010000 00002000 "nvram"

HTML5 port of Quake II

2010-04-02T20:44:00.003+08:00

I can imagine the this kind of things will be implemented in near future, but it is just appear sooner than I expect. I rarely play game these days, but this demo is appealing to me!

Broken Java Preference in OS X Leopard

2010-03-20T17:56:00.000+08:00

I use PPS frequently but it is broken since the last upgrade. The Login Page is a Java Applet and the problem SHOULD be solved by changing setting in Java Preference.

According to the PPS instruction, enable SSLv3 and TLSv1 in Java Preference can solve it. If you try to enable these in Java Preference, the applet is still not work. The problem is due a bug in Java Preference, when you enable TLSv1, the corresponding property is not actually saved.

To workaround this problem:

cd ~/Library/Caches/Java/

echo deployment.security.TLSv1=true >> deployment.properties

This step should be redo again every time setting is changed from Java Preference.

This information is found in a forum post:

http://discussions.apple.com/message.jspa?messageID=10859921

By the way, why Apple not fixed?

Restore application from the Dock

2010-01-03T20:27:00.001+08:00

In OS X, you can minimize a application with 'Cmd-M'.

To restore it there is no hot key to do so, but one tricks is to use spotlight. Just type the application name in spotlight and the application will be restored.

Filter file content in Vim

2009-10-31T12:25:00.003+08:00

The following is a simple method to do a 'grep' in the Vim buffer, without do it in the shell.

Consider the following file content:

  public class SomeThing {
    // some constant
    final static public String CONSTANT_A = "a";
    // another constant
    final static public String CONSTANT_B = "b";
    // yet another constant
    final static public String CONSTANT_C = "c";
  }

To filter out the constant definition lines ('final static public ...'), you can use a 'g' command in Vim to filter lines by regex and append to a register 'x'.

:g/final static public/normal "Xyy

Then, paste the register in somewhere you need it. For example, to put it in new buffer.

Vim command line editing

2009-10-31T12:23:00.000+08:00

Paste the contents of register into the command line is very useful, for example, you can edit a non-trivial command in normal vim buffer, or you can copy some text from the file. There are at least two way to do it:

The 'CTRL_R', in command mode, can be used for this [:help c_CTRL-R]

Assume you saved some text in register 'a'
Under command mode, press 'Ctrl-R a'
The text in register 'a' will pasted in the command line

One powerful alternative is the command window [:help q:]

Under normal mode, use 'q:' to enter command window
Editing the command
Press 'Enter' to execute, or 'Ctrl-C' to quit this mode

This two method is provided by Tim on the thread

CVS client in Cygwin and CVSNT doesn't play with each other!

2009-10-31T11:27:00.004+08:00

I have puzzled by the strange CVS error for a few weeks and finally I sit down and dig out the real problem. If you need to use CVS on Windows and you are a Cygwin user, read on!

If you checkout the source using CVSNT client, and try to use Cygwin client to do other CVS operation, you will found CVS client will quickly failed with the error: "Repository not found".

If you try to checkout the source using Cygwin client and try to use CVSNT client to do other CVS operation, the CVSNT client will have strange result too.

The real reason is the silly line-ending issue. CVSNT will always convert sources from Unix line ending to DOS line ending, including the CVS specific files (CVS/Root for example). If you don't enable the line-ending conversion in Cygwin (I never do this), Cygwin client will never read the CVS file correctly, and no CVS operation can be performed properly.

On the other hand, if you checkout the source using Cygwin client, all source files and CVS specific files will be in Unix line-ending. CVSNT client cannot handle this properly too! There is a setting in CVSNT client to treat the work copy in Unix line ending, but it just seems doesn't work for me.

The solution? Stick with only one tools. I choose to stick with Cygwin client as it is the more natural for me. In additions, I found Eclipse and NetBeans can handle the source checked out via Cygwin client and CVSNT client. Hence, I haven't yet got any functionality miss out in Cygwin client + Eclipse/NetBeans combination.

There is a entry in Cygwin FAQ to enable the DOS/Unix line ending conversion mode in Cygwin, I haven't try this as I believe this mode may cause some problems on other programs / tools in Cygwin.

If you need a more details on this issue, the following places may helps:

Rescue Debian on QNAP TS-209

2009-10-31T01:08:00.001+08:00

I've a QNAP TS-209 serve sitting on my home network and serving as file server, web server, etc. Thanks to the work of Martin, Debian can run on my box with only trivial effort. Just like most of the NAS, however, you can only access it via ssh/telnet unless you have serial access. If you made some silly mistake and it won't booting up properly, you will need some rescue methods. As it doesn't won't support to boot from CD/floppy, and there is no easy way to have console access, Live CD or old floppy bootdisk just doesn't help. Fortunately, the boot loader of QNAP (uBoot) support recovery mode, which will fetch a image and flash memory. This mechanism is very useful, and can be used to recover the Debian without reinstalling everything. Recovery mode is basically using tftp to download a binary image, hence, in order to use this, you must backup the correct image once you have installed the Debian. The image can be backup with the following command:

[debian-in-qnap] $ cat /dev/mtd1 /dev/mtd2 /dev/mtd3 > qnapimg.bin Once you made the image, backup it, it is the only file needed to recover the system. Note that the image is actually the linux kernel and initrd image, hence, you should redo the backup every time you upgrade kernel on the system. Now, when you need to recover the system, following the steps:

Setup tftp on the local network with IP address: 192.168.0.11
Put the qnapimg.bin under root directory of tftp
Start the QNAP in recocovery (shutdown, press and hold reset button, and start the system, release the reset until you hear two short beap sound

After some minutes, you system will restart using your recovery image.

Vim subsitute with expression expansion

2009-05-01T15:50:00.000+08:00

Just read a really interesting Vim tips and tricks post on Vim substitute with expression. In a nutshell, Vim substitute command allow you to use Vim expression, whose used in Vim script. For example, the following command will change all 'CONFIG' to 'config'.

:%s,CONFIG,\=tolower(submatch(0)),

In this example, the key is '\=' notation, which is a switch to enter expression evaluation mode. The function submatch(0) refers to the full match of the substitute command, and both tolower() and submatch() is normal Vim functions only.

Read the Vi and Vim Editor: 12 Powerful Find and Replace Examples for more examples.

5 watt Linux server in a Power Plug

2009-02-28T00:20:00.001+08:00

Marvell has announced a extremely low power consumption SoC device.

This is a really cool device, think you can have a box running web application, dhcp, dns proxy with just a power plug sized device.

When attached with an external disk, this will become an ultra low cost NAS and running media streaming, file sharing service

Oracle slow initial connection (default installation on Windows)

2009-01-21T00:56:00.000+08:00

Recently, I'm managed to create a few Oracle DBs on various Windows box for development purpose.

As all are aimed for development purpose and no special configuration is planned. However, with default DB configuration on Windows, you will experience very slow initial connection lag time. To solve this problem, you need to disable NTS authentication.

To do this, edit sqlnet.or
SQLNET.AUTHENTICATION_SERVICES=(NONE)

Note that, you should see the original setting is NTS (which is native authentication method on Windows platform).

Great profiling tools VisualVM bundled with JDK6

2008-11-09T17:05:00.003+08:00

Whenever encounter memory leak or performance problem, profiler will be your great friend.

Sometimes before, I have used some well known profiling tools like YourKit or hprof, jmap, tools, but recently, I discover JDK 6 has bundled with a new tools called VisualVM.

Indeed, the VisualVM is itself a self contained project, it provides some common monitoring features like thread/heap monitoring, as well as cpu / memory profiling features. It also allows you taking snapshots and compare memory snapshot.

IMO, it should deserve much more attention than its currently have. And it is really a perfect tools for most performance monitoring / tunning needs.

Happy Vimming again!

2008-09-27T23:43:00.005+08:00

Vim has been my favorite editor for years. However, for Java related development I've switched to Eclipse. Vim is then only been used for general text editing (writing notes, scripts, etc).

Recently, I have to do fairly amount of coding in PL/SQL. After struggling for weeks to writing code in SQLDeveloper, I remember the lovely Vim.

Vim already bundled the syntax file for PLSQL and Oracle SQL,. However, Vim doesn't bundled with a good PL/SQL indentation setup, which can be found in here.

Another important setup is connecting sqlplus and vim and it is can be done by adding the line below into glogin.sql (sqlplus init file):

 DEFINE _EDITOR='vim -c "set filetype=plsql"'

Finally, to make the sqlplus usable, it is better to use rlwrap (which bring basic readline features like command history and hot key to the sqlplus).

Olympic, China, Microsoft

2008-08-09T20:02:00.003+08:00

I'm originally going to blog about the amazing opening ceremony of the 2008 Olympic games on last night. But I just changed my mind as my good feeling is substituted with big anger!

Today is the second day of the Olympic games, I'm just going to checkout for the official means on watching the games via Internet. After all, I found that, i-cable is the only authorized company to provide the Olympic video online in Hong Kong. Hence, I visit the site and well, fail to watch any video clips.

The site shown that, Microsoft Windows Media Player 9 is required. Currently, I'm using Mac OSX as my primary desktop and I'm already installed the official WMV codec from MS website. And the sad fact is that, clearly MS Windows is prerequisite for watching the games. But hey, Olympic is the event of anyone on the earth, it seems now, Olympic is game for Microsoft users.

Nowadays, we can watch TV and listen to radio as long as you have working TV set or radio. But on the Internet, you must pay to one vendor: MS. Sorry I believe there is something wrong, what do you think?

What happens during power outage

2008-08-06T18:19:00.001+08:00

Just skimming through Slashdot and enjoyed an well-written article by Halfgaar.

What's make me think interesting is the following two points:

Different components on the system response slightly different during power outage
Another point is how aged disk will died after power failure