CHERUB in PHD

Report A Google Shut Down

2006-03-07T21:39:00.000Z

Suddenly, My Google shut down from about 2000 to 2130, 07/03/2006. I dont know why at all. Only Google involved.

12.01.2005 - 14.01.20005 What's DONE

2006-01-15T00:32:00.000Z

Reading

Ramsin How to search & modify within XML documents using XPath queries
Chilkat Find XML Records

Coding

ReadPDF project C#
ReferenceManager project C#

Software

X-Ray, Firefox Extension, review html tags without checking the source file

08.01.2005 - 11.01.2005 What's DONE

2006-01-12T14:20:00.000Z

Reading

Norberto Ezquerra, Steve Capell, Larry Klein, and Pieter Duijves, Model-Guided Labeling of Coronary Structure, IEEE Trans. on Medical Imaging, Vol. 17, No. 3, June 1998
James F. O'Brien and Norberto F. Ezquerra, Automated segmentation of coronary vessels in angiographic image sequences utilizing temporal, spatial, and structural constraints, SPIE Visualization in Biomedical Computing Vol. 2359, pp.25-37, 1994
S. L. Lauritzen, The EM Algorithm for Graphical Association Models with Missing Data, Computational Statistics and Data Analysis 19, 191-201, 1995

Blogging

回诸友

Software

Google GMail Loader (GML) Import existing email to GMail
Google Video Player save and play gvp file
win2vnc, one set of mouse and keyboard to control two windows desktop, works very cool.
VNC 4 Free Edition Compatibility, VNC server, for win2vnc usage

Writing

Scheme of Model Based Tracking, roadmap by Viso
EM approach to learning link matrix of hidden nod

Technorati Tag: cherub blog EM Bayesian_Network VNC win2vnc Google_Video Gmail

05.01.2006 - 07.01.2005 What's DONE

2006-01-07T17:25:00.000Z

Reading

Mark A. Peot and Ross D. Shachter, Fusion and Propagation with Multiple Observations in Belief Networks, Artificial Intelligence, 48 (1991) 299-318

Blogging

牙疼！

Software

Hamachi a P2P client
Skype 2.0

Writing

A General Framework of Using Hidden Nodes in Polytree Bayesian Network

Technorati Tag: cherub blog bayesian_network skype hamachi p2p hidden_node

04.01.2006 What's DONE

2006-01-05T00:45:00.000Z

Reading

Kevin Murphy, A Brief Introduction to Graphical Models and Bayesian Networks
Cecil Huang, Adnan Darwiche, Inference in Bayesian Network a Procedural Guide
Kevin Murphy, Pearl's Algorithm and Multiplexer Nodes
Machtelt Garrels, Introduction to Linux, A Hands on Guide Chapter 3

Technorati Tag: cherub blog reading bayesian_network linux

03.01.2006 What's DONE

2006-01-03T23:04:00.000Z

Reading

Machtelt Garrels, Introduction to Linux, A Hands on Guide Chapter 1 - Chapter 2

Blogging

Try MyBlogLog free blog stats service

Software

千千静音, recommended by Shuang Feng, very good!
Doxygen Update to 1.4.6

Technorati Tag: cherub blog 千千静音 MyBlogLog linux Doxygen software read

31.12.2005 - 02.01.2006 What's DONE

2006-01-03T01:08:00.000Z

Coding

BayesianNetwork Project C++

Modified CNode & CTreeLookupTable structure

TechnoratiTag Project C#

Blogging Doom (★★★★★☆☆☆☆☆) Technorati Tag: cherub blog done CSh CPP

30.12.2005 What's DONE

2005-12-31T01:43:00.000Z

Blogging

10 of 2005

Software

Civilization IV

Tags:

29.12.2005 What's DONE

2005-12-30T01:04:00.000Z

Software

Sing that's iTune! Wideget
Sudoku Pill Widget

22.12.2005 - 28.12.2005 What's DONE

2005-12-29T00:29:00.000Z

Merry Christmas! Coding

PZMath libray C++

PZCombinationGenerator

BayesianNetwork project C++

version 0.2

Blogging

Software

MusicBrainz Tagger Automatic MP3 files Tagger, but not fully support Chinese albums. :(

Video

21.12.2005 What's DONE

2005-12-21T23:07:00.000Z

Blogging

March of the Penguins (★★★★★★★★☆☆)

Software

V4S Send voice messages to any email or Skype™ contact, Voicemail for Skype everywhere - even on mobile phones!
VMware Workstation 4.5.2
Mandrake Linux 10.1
KNOPPIX Linux 4.0.2 Live DVD/CD
Ubuntu Linux 5.10 Live CD
iTunes 6.0 One of the best app of 200

DONE

To-Do List Google Module

20.12.2005What's DONE

2005-12-21T00:15:00.000Z

Software

SearchStatus Firefox Exension, provides extensive search-related information about a site
Performancing for Firefox Firefox Extension, a full featured blog editor that sits right within Firefox

19.12.2005What's DONE

2005-12-20T01:24:00.000Z

Reading

The Nerd? Geek? or Dork?

Coding

PZMath Library C#

PZMath_multimin_fminimizer
PZMath_multimin_fminimizer_nmsimplex

TestPZMathMultimin project C#

Blogging

DONE

Flickr Zeitgeist to my blog
Blogger Post Template

The Nerd? Geek? or Dork?

2005-12-19T09:41:00.000Z

I have never expected to be a geek, or a nerd, since I am such an average person. However, driven by the curiosity on how dork I am, I tried a 60 questions test. The 60 % Nerd, 43% Geek, 21% Dork satisfied my average judgement. It is interesting, isn't it?

16.12.2005 - 18.12.2005 What's DONE

2005-12-19T01:03:00.000Z

Reading

Numerical Recipes in C

David Byatt, Ian Coope, Chris Price 40 Years of the Nelder-Mead Algorithm

Coding

Debugging BayesianNetwork project C++

Blogging

14.2005 - 15.2005 What's DONE

Software

14.12.2005 -15.12.2005 What's DONE

2005-12-16T01:24:00.000Z

Coding

PZMath Library C#

PZMath_multifit_linear

Scanline Tool of iLab project C#

TrackResult
ConsequtiveScanlineTracking
TaskTryConsequtiveScanlineTracking

TestPZMultifit project C#

multifit_linear

TEST_GSL_MULTIFIT_DIF_FULL project C++

Main_linear

Blogging

13.12.2005 What's DONE

Software

Audacity The Free, Cross-Platform Sound Editor, very professional
File Recovery Version 4.0 for recovery deleted files
View Cookies Firefox Extension
FickrDownloadr download Flickr photos as a batch
Tab X Firefox Extension
nLite How to use?
FlickrWallpaper With C# source code, cool!

13.12.2005 What's DONE

2005-12-13T20:48:00.000Z

Coding

PZMath Library C#

PZScanline
PZInterpolate

Scanline Tool of iLab project C#

Interpolate
ExtractScanline

Documentation of PZMath Library, by NDoc

Blogging

Software

NDoc C# documentation tools

12.12.2005 What's DONE

2005-12-12T22:23:00.000Z

Coding

Rediculus Float problem: C++

sqrt(4000) != 10.0 * sqrt(40);
t = 1.0; tt = exp(-0.1 * t); y1 = 1.0 + 5.0 * tt; y2 = 1.0 + 5.0 * exp(-0.1 * t); y1 != y2;

Debugging TestPZMathMultifit project C#
Update PZMath project C#

Blogging

11.10.2005 What's DONE

Software

Yahoo! Widget Engine 3.0

Writing

Simple Model

11.12.2005 What's DONE

2005-12-11T17:41:00.000Z

Reading and Notes Taken

Blogging

Software

Miranda IM A multi protocal instant messenger, but I feel it is ugly and useless due to dis-orgnized and lack of functions.

DONE Webnote is DOWN! and recovered on 11.12.2005 Visiting Caerleon Roman Fortress Baths High Steet, Caerleon, Newport, NP18 1AE, UK

10.12.2005 What's DONE

2005-12-11T00:02:00.000Z

DONE

Download "The Magic Flute", Mozart, from 华人音乐网. Cracked the source addresses by tracing down the URL in HTML files.

09.12.2005 What's DONE

2005-12-10T02:02:00.000Z

Reading and Notes Taken

gsl_multifit source codes

Coding

TEST_GSL_MULTIFIT_FULL project C++
PZMath Library C#

PZMath_random
PZMath_random_ParkMiller
PZMath_random_ParkMiller_Normal

TestPZMathMultifit project C#
Steve Lautenschlager C# RandomProvider Class SourceCode

Blogging

推介一下我老妹的blog

老婆怀孕日记（Week 18)

2005-12-08T23:24:00.000Z

发现胎动，老婆很兴致盎然的让我“骚扰”bb然后bb就会动 -_-

04.12.2005 - 08.12.2005 What's DONE

2005-12-08T21:56:00.000Z

Coding

gsl_multifit package

Blogging

The List of List 2005

Software

DONE

One Reference Letter and One Personal Statement for Meng

Download (To Read)

02.12.2005 - 03.12.2005 What's DONE

2005-12-04T02:22:00.000Z

Reading and Notes Taken

Coding

BayesianNetworkMainProcessFlow C# project, using Treeview control to display main() thread of BayesianNetwork C++ Project
BayesianNetwork C++ Project

CTreeLookupTable

Software

Azureus

DONE

BayesianNetwork Document, by Doxygen

Download (To Read)

Nir Friedman & Moises Goldszmidt Learning Bayesian Networks From Data
Nir Friedman, Dan Geiger, Mosies Goldszmidt, Bayesian Network Classifiers (1997)
R. Chen, K. Sivakumar, H. Kargupta, Learning Bayesian Network Structure from Distributed Data
David Heckerman, A Tutorial on Learning With Bayesian Networks
Jie Cheng, David Bell, Weiru Liu, Learning Bayesian Networks from Data: An Efficient Approach Based on Information Theory
A Brief Introduction to Learning Bayesian Networks
K. Murphy and S. Mian, Modelling Gene Expression Data using Dynamic Bayesian Networks

28.11.2005 - 01.12.2005 What is DONE

2005-12-01T19:31:00.000Z

Reading and Notes Taken

Daryle Niedermayer, An Introduction to Bayesian Networks and their Contemporary Applications

Coding

BayesianNetwork project C++
PZCodes Library C++

-- PZError
-- PZMath
-- BayesianNetwork

Software

Doxygen
Peter Jackon's King Kong
Firefox 1.5 (abandon Flock)
del.icio.us extension for Firefox .15

DONE

Use Remember the milk as Todo List;
Use Webnote as note taking
All have been combined to Google Personal Homepage

Writing

Personal Statement

25.11 - 27.11. 2005 What is DONE

2005-11-27T23:35:00.000Z

Coding

PZMath Project

SYS -- PZMath_sys.cs

C# PhilipPZ Project

Class DataSet

Class TestSet
Class TrainingSet

Class CountItem
Class CountItemHypo
Class CPT
Class LookupTable
Class TenFoldCrossValidation and Class Generate

C++ T5_1P Project

24.11.2005 What is DONE

2005-11-25T01:52:00.000Z

Coding
1. PZMath project (for Lab), translating GSL include:
-- Blas

-- PZMath_blas.cs

-- Deriv

-- PZMath_deriv.cs

-- General

-- PZMath_errno.cs
-- PZMath_machine.cs
-- PZMath_math.cs

-- Linalg

-- PZMath_linalg.cs

-- Matrix

-- PZMath_matrix.cs

-- Multifit

-- PZMath_multifit_fdfsolver.cs
-- PZMath_multifit_fdfsolver_lmsder.cs
-- PZMath_multifit_nlin.cs

-- Permutation

-- PZMath_permutation.cs

-- Vector

-- PZMath_vector.cs

2. TestPZMath_deriv project

Software

Age of Empire III

technorati tags: done

23.11.2005 What is Done

2005-11-24T01:03:00.000Z

Reading and Notes Taken

C# tutorial: delegate
MSDN C# Tutorial: Delegate
The dark side of C# Delegates The compiler plays a major role in making the delegates work. Encountering a delegate declaration, the compiler actually generates a class with an Invoke method that matches the delegate declaration's signature. Then, when a delegate instanciation is compiled, it gets verified (type-wise) and replaced by a call to the delegate constructor passing in an object and a method reference (via an int). And last, the compiler recognizes delegates invocations and compiles them as call on the Invoke method.
Satya Komatineni, Understanding the Nuances of Delegates in C# A delegate exhibits the qualities of a class and a function. delegate has more things in common (syntactically) with a class than with a function delegates are immutable. you can retrieve a target from a delegate, cast the target to an appropriate class, and call the additional methods on that object. Member function GetInvocationList() of delegate allows us to iterate through the individual delegates of a composite delegate.
C# Tutorial, Lesson 12: Delegates
Creating Strongly Typed Custom Collections in C#

Coding

Read through source codes of GSL Multifit Pack
TestReferenceTypeCasting

test delegate as function pointer and reference type downcasting as void *

Blogging

Harry Potter and the Goblet of Fire

Software

CHM To PDF Converter
CHM 浏览器
ChmMagic
FreeCHM 1.2

technorati tags: done

22.11.2005 What is DONE

2005-11-23T12:25:00.000Z

Reading (Notes Taken)

Tom Germano, Wavelets in Multiresolution Analysis,
E. J. Stollnitz, T. D. DeRose, D. H. Salesin, "Wavelets for Computer Graphics: A Primer Part I", IEEE Computer Graphics and Applications, 15, May 1995.
E. J. Stollnitz, T. D. DeRose, D. H. Salesin, "Wavelets for Computer Graphics: A Primer Part II", IEEE Computer Graphics and Applications, 15, July 1995.

Done

Subscribed RSS of PAMI, Medical Image, Signal Processing Magzing, Signal Processing, Signal Processing Letter, Image Processing

Coding

filter MultiresolutionAnalysis_pz
add MathNet.Numerics library into project (Math.NET Numerics: Iridium)

Blogging

ShaPolang

technorati tags: done

老婆怀孕日记(Week 14)

2005-11-13T19:03:00.000Z

今天是周六，早上老婆和bb醒来，大概10点，老婆上了厕所，做爱，11点起床。吃完早饭，驱车去了天鹅湖，叫Roth Park，有一个很长的湖，有数不清的天鹅，鸭，鸥，以及不知名的小鸟，湖被绿树环绕，各种各样，由于秋天来了，树的颜色很奇妙，黄，绿，还有白的。看到很多小孩拿着面包喂天鹅，看到很多天鹅围在一起抢面包，蔚为壮观。一路走，看到很多游人和天鹅，还有狗。看到一只小雪橇犬，它上来闻老婆，老婆为了bb没有摸它，我摸了它。老婆吃了个冰淇淋，一边吃冰淇淋一边看天鹅鸭子海鸥争抢吃的，回头突然看到一只小狗，比鸽子还小，但跑得很快。这时，头顶突然漂过一片云，下起淅淅沥沥的小雨。停车时老婆坚持把雨伞放在车里，我们只好冒雨继续步行，有时会在树下避雨。这时会有天鹅走到岸上，走近人，一只眼睛看老婆手里的冰淇淋。这是老婆第二次和天鹅亲密接触，上次是在Cambridge的剑河上。天鹅伸直脖子头可以到我老婆的胸部。天鹅走路是内八字！很多鸟一只脚站着，把脖子藏在身体里睡觉，其实是假睡。天气一会儿晴了，我们继续散步，走的很开心，bb在老婆肚子里也很开心。我们想在湖边买一套房子，带着bb过幸福的生活，还有一只狗。之后开车返回到家里，因为今天说好要去market买鱼。我们停车在家门口后穿过市中心步行去market。这是老婆第一次去，我是向导。但因为今天是周末，光顾顾客太多了，剩的鱼选择很少，所以我们并没有买；后来又去看了看肉、蛋和水果，东西都很贵并且不是很新鲜。最后决定周一再去，空手回来。回来路上在Marker Spenser买了裤子。老婆肚子日益见大：上周去MS的时候试的同样的裤子，试的是八号，感觉还可以，有点余地，由于当时觉得太贵了，就没有下决心，拖到了今天。今天再试，发现裤子已经很紧了，再试了10号，发现效果和一周前8号一样。因为实在没有裤子了，所以咬牙花了25块买了。谁知道下周会不会穿12号了，谁让bb不停的长。但是我出主意：下周如果穿不了了，可以干脆退掉，或者换一条。就在老婆付款的时候，MS的柜员向老婆推荐申请一张MS的信用卡，老婆就申请了，这样她马上会有两张信用卡。她说不会花很多钱，因为要省钱给bb买车，买吃的，买尿布。。。之后，我们欢欣鼓舞的回到家里，我做了红烧肉和西红柿鸡蛋。老婆在做饭之间就睡觉了，我做好饭叫醒她，她和bb都很感动。今天晚上，老婆带bb洗了泡泡浴，虽然浴缸不是很合适，但听音乐泡澡很好。今天老婆和bb都很开心。（老婆口述，我纪录 -_-）

老婆怀孕日记 (Week 14)

2005-11-08T18:37:00.000Z

13周，老婆和bb独自度过，bb不高兴，老婆也不高兴，老婆坚持为bb做好吃的，保证bb健康生长。仍有壬辰反应。周末看了母婴用品商店，发现老婆想买的我都不想买，bb可能会在一个二手的环境中生长。我终于回来了。。。

14周，第一天 11月7日，壬辰反应显著好转，因为我在中午做宫爆鸡丁，晚上做鱼香肉丝。食量未比之前增加很多，体重未知，但腹部明显变大，需买新的裤子。

11.8，壬辰反应持续好转，之前靠和绿茶抑制口水分泌，现在仍坚持和绿茶。中午吃滑溜鸡片及熏鱼，晚场吃酱爆肉丁及熏鱼，但配通心粉，大为逊色。但菜很美味，bb很开心。现在我和老婆还有bb每天看“24”，大长今已经看完了。未完待续。。。

老婆怀孕日记 (Week 14)

2005-11-08T13:23:00.000Z

害喜现象明显好转。肚子比较明显涨大。吃得也多起来，我尽量做不同花样的菜。最近运动比较少，需要加强。

老婆怀孕日记(Week 12)

2005-10-25T10:43:00.000+01:00

昨天去University Hospital of Wales作了第一次的B超检查。很清楚看到一个小孩的样子，在动胳膊动腿，脑袋很大。身子长67mm，脑袋23mm大小。很神奇，不到10公分的东东已经是人样了，有三张B超照片。体检正常，前一段尿样检验也正常。体重还是42公斤，需要增加体重。一整天没有明显的呕吐现象，害喜基本趋于稳定。晚上吃糖醋鱼片，羊肉和白菜。

老婆怀孕日记(Week 11)

2005-10-21T11:46:00.000+01:00

饮食不详，但据说口水情况又趋严重。

老婆怀孕日记（Week 11)

2005-10-20T01:24:00.000+01:00

早红薯粥，鸡蛋，面包，自己倒一碗牛奶，没喝。中午热昨天的排骨，下新鲜油菜，排骨面。下午吃香蕉苹果梨等水果。晚上牛肉胡萝卜盖饭以及BBQ排骨。晚饭吃得略少，但临睡前喝了点剩粥。吃一碗葡萄，并睡前把所有碗洗了。放屁很臭，肚子不舒服，疑大便不畅，肠胃不适。近24点才睡觉，稍晚。从晚上看3集大长今情况看，流口水症状减轻，没有呕吐。但愿是害喜症状开始减轻。晚洗澡时拍了当前身材的照片。另，中午收到NHS信件，预约24号下午B超体检。

老婆怀孕日记（Week 11）

2005-10-19T02:07:00.000+01:00

早饭白粥，鸡蛋，面包。午饭素菜烩，白饭，酱豆腐过辣。晚餐排骨炖白菜，红薯饭。吃得还算好，还啃了一个玉米，一个西红柿。口水情况也看似比昨天好，似乎没有呕吐现象。买了些饼干和点心做零食。晚上看三集大长今，耽误了工作。另外因为我，心情不太好。23点过后就寝，这日记是我写的，明天再咨询。

老婆怀孕日记 (Week 11)

2005-10-18T00:50:00.000+01:00

16 Oct 2005 从早至晚不停流口水，上午吐少许方便面。早饭方便面，面包，黄油。午饭布丁和茶。晚饭浓鸡汤面。餐前吃玉米一个。去Forest of Dean, walking for 4 hours. 17 Oct 2005 早白粥两鸡蛋，中午白粥蔬菜，下午香蕉苹果，5PM呕吐。中午去诊所体检，体重42KG（毛重），血压（100/65)，尿样有血丝，送进一步化验，尿中无蛋白质。晚饭土豆牛肉，烤鸡腿。流一天口水。临睡前呕吐。

Teach Yourself XML in 21 Days, Day 14

2005-07-18T12:34:00.000+01:00

Handling XLinks, XPointers, and XForms Today you're going to take a look at three more XML applications: XLinks, XPointers, and XForms. In HTML, you can use hyperlinks to link documents, but in XML, you have more options, which is what the XLink and XPointer specifications are all about. XForms are desigend to replace the standard forms you see in Web pages, which display buttons, text fields, and so on; XForm is designed to bring that kinds of functionality into the XML world. You use XLinks to create hyperlinks in XML and XPointers to get even more specific node or node set. XForms brings the idea of Web controls into XML. Introducing XLinks The XLink 1.0 specification is a W3C recommendation. You use XLinks to link on document to another or to link one location inside a document to another. e.g.

<link xmlns:xlink = "http://www.w3.org/1999/xlink" xlink:type = "simple" xlink:show = "new" xlink:href = "http://www.w3c.org" onClick="location.href='http://www.w3c.org'"> health insurance </link>

In the above example you set the xlink:type attribute to "simple" and the xlink:show attribute to "new"; this means the browser should open the linked-to document in a new window and set the xlink:href attribute to the URI of the new document. Bear in mind that the form of XML URIs isn't settled yet either and may grow more complex and comprehensive in time. XLinks can go far beyond the simple. Here are a few of the current implementations of XLinks:

X2X, from empolis GmbH, is a XML XLink engine. It allows linking between documents and information resources.
Fujitsu XLink Processor, developed by Fujitsu Laboratories, Ltd., is an implementation of XLink and XPointer.
xlinkit.com is a lightweight application service that provides rule-based XLink generation.
Mozilla is a browser that supports simple XLinks.
Amaya, the W3C test browser, supports simple XLinks.

In fact, any XML element can create an XLink. You create an XLink by using attributes, not by using a particulra element. The XLink attributes specify what kind of XLink you're creating. Using xlink:type The xlink:type attribute is the most important XLink attribute because it sets the type of XLink you're creating. Here are the possible values:

simple -- Is used to create a simple link.
extended -- Is used to create an extended link.
locator -- Is used to create a locator link that points to a resource.
arc -- Is used to create an arc with multiple resources and various traversal paths.
resource -- Is used to create a resource link, which indicates a specific resource.
title -- Is used to create a title link and can hold the location of element markup for further information on a title.

Using xlink:href The xlink:href attribute is called the locator attribute. You use it to give the URI of a remote resource. When you work with simple URLs, the values you can assign to this attribute are fairly simple. But when you work with general URIs, which can include XPointers, things can get pretty complex. Using xlink:show The xlink:show attribute specifies how to show the linked resource. Using xlink:actuate The xlink:actuate attribute specifies when a link should be traversed. The xlink:actuate attribute has these predefined values:

onRequest -- Means that the link should be traversed on the user's request.
onLodad -- Means that the link should be traversed when the resource is loaded.
other -- Specifies a custom preference.
none -- Specifies that there be no actuation.

Using xlink:role and xlink:title You can use the xlink:role and xlink:title attributes to describe a remote resource. The xlink:title attribute is designed to be read by people, whereas the xlink:role attribute is designed to be read by software. Using xlink:arcrole and xlink:label The xlink:label attribute contains a human-readable label for an XLink. The xlink:arcrole attribute works with XLink arcs, which are sets of the links that can contain multiple resources and various traversal paths. Beyond Simple XLinks Extended links can involve multiple resources, multiple paths between those resources, and multidirectional paths. Consequently, actual implementations of extended links are a little vague compared to those of simple links because no one has really determined how extended XLinks will really be supported. In technical terms, an extended link is called a directed labeled graph, and they are very general constructs. An extended link can really only be characterized as being made up of connections between resources. Those resources many be local, which means they're actually part of the extended link element, or remote, which means they're not part of the extended link element. If a link contains resources, it's called an inline link; if it does not contain any resources at all, it's called an out-of-line link. Inline links have their xlink:tpe value set to "resource". Out-of-line links have there xlink:type attribute value set to "locator". Creating Arcs In order too create a extended link, in terms of many conceivable paths between the resources, you can create an arc to add more direction to what's going on. All the possible paths between resources are arcs. You represent thos paths in XML elements by setting the xlink:type attribute to "arc". Arcs use xlink:from and xlink:to elements to specify traversal paths. You set the values of xlink:from and xlink:to to match the xlink:role attribute of the source and target resources. e.g.

<arc1 xlink:type = "arc" xlink:from = "California" xlink:to = "Massachusetts" xlink:show="new" xlink:actuate="onRequest"> </arc1>

The way these arcs are actually used or activated depends on the software you're working with or that you've created. Creating Linkbases When you place out-of-line links in their own documents, those documents are called linkbases. The set of out-of-line links in a linkbase is called a linkset. You typically have three types of links in a linkbase: extended links, locator links and arcs. Introducing XPointers When you use XLinks, you can link to a particular document, but many times, you want to be more precise than that. XPointers let us point to specific locations inside a document, and they are coming into more common use. Here are 2 other package that support XPointers:

Amaya supports XPointers but does not support the full XPath specification that you can use with general XPointers.
Fujitsu's XLip has a full implementation.

W3C divided the XPointer specifications into three recommendations and a working draft:

The XPointer framework, which gives general background and points to the other three schemes.
The element scheme.
The namespace scheme.
The general XPointer scheme.

Using Barenames The XPointer Framework specification says that you can use barename -- i.e., just the names of elements -- as XPointers. You can append an XPointer to the end of a URI by precedingit with a #. e.g.

xlink:href = "http://www.xmlpowercorp.com/insurance.xml#data">

which points at the <data> element in www.xmlpowercorp.com/insurance.xml. Using the Element Scheme The element scheme was broken out of the general XPointer scheme to make XPointer easier to implement. In the element scheme, you use element() to indentify element by ID, not by name. e.g.

xlink:href = "http://www.xmlpowercorp.com/insurance.xml#element(data)">

You can also specify child sequences by number, e.g., to pick out the <data> element's third child element and then identify that element's first child element:

xlink:href = "http://www.xmlpowercorp.com/insurance.xml#element(data/3/1)">

Using the Namespace Scheme The namespace scheme indicates how to use namespace when pointing to data. e.g. if the <data> element you want to pick out is part of the xpc namespace, you could speicify that element this way:

xlink:href = "http://www.xmlpowercorp.com/insurance.xml#xmlns(xpc = "http://xmlpowercorp)xpc:data">

Using the XPointer Scheme The Xpointer scheme extends XPath. Here's what a full XPointer might look like -- note that you use xpointer() here:

xlink:href = "http://www.xmlpowercorp.com/insurance.xml#xpointer(/child::*[position()=199]/child::*[position()=last()])">

This pick out the last child of the 119th element in www.xmlpowercorp.com/insurce.xml. Here, you can use full XPath expressions with general XPointers. In addtion, the general XPointer scheme extends XPath by letting us select points and ranges besides normal XPath nodes. A point is a specific location in a document, and a range is made up of everything between two points. To support points and ranges, the general XPointer scheme extends the concept of nodes to locations. A location is an XPath node, a point, or a range. Node sets become location sets in the XPointer sepcification. Although XPointers use the same axes as XPaths, there are some new node tests:

point() -- Matchs a point in a resource.
range() -- Matchs a range in a resource.

Creating XPointer Points To define an XPointer point, you use two items -- a node and an index that can hold a positive integer or zero. The node specifies an origin for the point, and the index indicates how far the point you want is from that origin. There are two different way of measuring the index: in terms of characters in the document and in terms of a number of nodes. Measuring in Characters If the starting node can contain only text, but not any child nodes, then the index is measured in characters. Points like these are called character-points. Character-points do not have proceding or following siblings or children. Note also that the general XPointer specification collapses all consecutive whitespace into a single space for counting purposes. Measuring in Nodes When the start node, also called the container node, has child nodes, the index of a point is measured in child nodes. Using Point Fucntions When it comes to creating points, you can use the point() function with a predicate. e.g. you want to locate a point right before the l in California in the state example from ch1001.xml:

xpointer(/states/state[1]/name/text()/point()[position()=2])

Creating XPointer Ranges When it comes to creating ranges, all you need are two points: a start point and an end point. This is true as long as they are in the same document and the start point is before or the same as the end point; if the start point and the end point are the same point, the range you create is called a collapsed range. The general XPointer specification adds to the function in XPath a number of functions to handle ranges:

range(location-set) -- Takes the locations you passed to it and returns a range that completely covers the locations. range-insed(location-set) -- Returns a range or ranges covering each locaiton inside the location set; if you pass an element, the result is a range that encloses all that is inside the element. range-to(location-set) -- Returns a range for each location in the locaiton set.

Besides these functions, the XPointer specification includes a fucntion for string matching, string-range(). You can use this function to return a range for every match to a search string. e.g.

string-range(location-set, string, [index, [length]])

There's a lot more powe with XLinks and XPointers than you'll find with simple HTML hyperlink. Introducing XBase XBase specification lets us specify a base URI for XML documents, just like the <BASE> element in HTML documents. You can use the xml:base attribute in an XML document to set the document's base URI. The other URIs in the document are then considered relative URIs, and the URI specified as the base is used to resolve them. Introducing XForms XForms comes from a parallel construct in HTML -- Web Forms. A Web form lets us display controls such as buttons or list boxes in an HTML page, and XForms are intended to do the same thing in XML. XForms 1.0 is in candidate recommendataion from. A number of software packages support XForms to some extent. Writing XForms XForms are used in XML documents, typically in XHTML, so each one needs to start off with an XML declaration. The next element, the document element, is the <html> element, and you use it to put everything into the XHTML namespace and define 2 other namespace -- ev for XForms events (such as button clicks) and xforms for XForms elements, e.g.:

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:xforms="http://www.w3.org/2002/xforms/cr">

Separating Data from a Presentation A major feature of XForms is the separation of data from presentation; this means that the data for the controls in an XForm is stored separately from the presentation part. You use the <xforms:model> element to specify what data an XForm should hold. You can create an XForms model in the document's <head> element. Inside the model, you specify the submission mechanism for the data in an <xforms:submission> element. And you store the actual data in an <xforms:instance> element. In this example, you'll have an input control whose data will be stored in an <input> element, a select control whose data will be stored in a <select> element. e.g.

<head> <xforms:model> <xforms:submission localfile="data.xml"/> <xforms:instance> <data xmlns=""> <input>Hello!</input> <select>1</select> <selectboolean>true</selectboolean> <message>Hello!</message> </data> </xforms:instance> </xforms:model> </head>

Creating Input Controls In the <body> section, you'll start creating the controls you'll use, starting with the input control. You create an input control by using the <xforms:input> element. You tie this control to the data you've stored in the <input> element in the <head> element by using the ref attribute, which you'll set to "/data/input" in this example:

<xforms:input ref="/data/input"></xforms:input>

Creating Select Controls A select control can display either a list of items to choose from or a drop-down list, and you create these controls by using the <xforms:select> element or the <xforms:select1> element (which creates single-selection select controls). You should display a list of all items in the controls by setting the appearance attrebute to "full". e.g.

<xforms:select appearance="full" ref="/data/select"> <xforms:item> <xforms:value>1</xforms:value> <xforms:label>Item 1</xforms:label> </xforms:item> <xforms:item> <xforms:value>2</xforms:value> <xforms:label>Item 2</xforms:label> </xforms:item> <xforms:item> <xforms:value>3</xforms:value> <xforms:label>Item 3</xforms:label> </xforms:item> </xforms:select>

Creating Buttons Clicking the example button will display a message box that shows the text stored in the <message> element in the doument head's <data> element: To display text in a message box, you can use the <xforms:message> element. To display a button, you use a <xforms:trigger> element and give it an caption by using <xforms:label> element. To display a message box when the button is clicked, you set the <xforms:message> element's event attribute to "click"; to display the message, you set the message box's ref attribute to "/data/message". To make the message box display pear automatically after a few seconds, you set its level attribute to "ephemeral". e.g.

<xforms:trigger> <xforms:label>Click Me</xforms:label> <xforms:message ev:event="click" level="ephemeral" ref="/data/message"/> </xforms:trigger>

Creating Select Booleans You use the <xforms:selectboolean> element to create one and a <xforms:label> element to give it a label. You can connect the select Boolean to the data in the <data> element's <selectboolean> element by using the ref attribute. e.g.

<xforms:selectboolean ref="/data/selectboolean"> <xforms:label>Click Me</xforms:label> </xforms:selectboolean>

Creating Submit and Rest Buttons The final controls for the XForms example are Submit and Rest buttons; the Submit button submits the XForm and store its data in data.xml, and the Reset button resets the data in the XForm back to its original value. These controls are supported by their own element:

<xforms:submit> and <xforms:reset>. e.g. <xforms:submit> <xforms:label>Submit</xforms:label> </xforms:submit> <xforms:trigger> <xforms:label>Reset</xforms:label> <xforms:reset ev:event="DOMActivate"/> </xforms:trigger>

BTW: Here's how to declare XLink elements and attributes to make the documents valid:

<!ELEMENT link> <!ATTLIST link xmlns:xlink CDATA #FIXED "http://www.w3.org/1999/xlink" xlink:type CDATA #FIXED "simple" xlink:href CDATA #REQUIRED xlink:show (new | replace | embed | none | other) #IMPLIED "replace">

Teach Yourself XML in 21 Days, Day 13

2005-07-13T00:09:00.000+01:00

Creating Graphics and Multimedia: SVG and SMIL Today you're going to take a look at 2 XML applications -- Scalable Vector Graphics (SVG) and Synchronized Multimedia Integration Language (SMIL). SVG lets you create 2-dimensional graphics, and SMIL lets you create multimedia presentations, including images, text, and music. Introducing SVG There have been a number of XML-based 2D graphic languages over the years. One of them -- Vector Markup Language (VML) -- is supported only in Internet Explorer. It's more correct to call VML a semi-XML language, actually. VML has a major drawback: it is supported only in IE. However, Google Map API using VML to draw polyline on its map. SVG is more broadly based, and by using the SVG Viewer plug-in from Adobe, you can use SVG in various Web browsers. The W3C recommendation for SVG 1.0 and SVG 1.1. SVG is a general-purpose 2D graphic language that supports all kinds of powerful tools. SVG allows for three types of graphic objects: vector graphic shapes, images and text. SVG includes lots of built-in elements and predefined color names. We can only have a very basic understanding of SVG today. Creating an SVG Document SVG is really XML. You use an XML declaration at the beginning of an SVG document. Each SVG document should be in the official namespace http://www.w3.org/2000/svg. The public identifier for SVG 1.0 is "PUBLIC "-//W3C//DTD SVG 1.0//EN". The DTD for SVG is at http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg1.0.dtd. The MIME type for SVG (which is important if you want to create SVG document on a Web server and send them to a browser) is image/svg+xml. And you give SVG documents the extension .svg. Note that you can use the <svg> element's height and width attributes to limit an SVG display to a specific box. All the SVG will go inside the <svg> document element, beginning with the <title> element. e.g.

<?xml version="1.0" encoding="UTF-8"?> <svg xmlns="http://www.w3.org/2000/svg"> <!DOCTYPE svg "PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg1.0.dtd"> <title> Title </title> ... </svg>

Creating Rectangles To create rectangles, you can use the <rect> element. The required attributes are height and width. As in CSS, dimensions in SVG can be specified with px, pt, in, or cm; the defalut measurement is pixels. In addtion, you can use abstract units in SVG. e.g.

<rect x="100" y="100" width="300" height="100"/>

Using CSS Styles In turns out that SVG elements have a style attribute that you can assign CSS styles to. e.g.

<rect x="100" y="100" width="300" height="100" style="fill:none; stroke:blue; stroke-width:2"/>

You can also use many CSS properties directly as attributes of SVG elements. e.g.

<rect x="100" y="100" width="300" height="100" fill="none" stroke="blue" stroke-width="2"/>

Creating Circles You use the <circle> SVG element to create circles. e.g.

<circles r="100" cx="150px" cy="150px" style="stroke:blue"/>

Creating Ellipses You can create an ellipse by using the SVG <ellipse> element. e.g.

<ellipse cx="150" cy="150" rx="150" ry="150" style="stroke:blue"/>

Creating Lines The SVG <line> element lets you draw lines. You can use the x1, y1, x2, and y2 attributes to draw a line from (x1, y1) to (x2, y2). e.g.

<line x1="180" y1="80" x2="190" y2="50" style="stroke:blue"/>

Creating Polylines SVG has a <polyline> element that lets you draw multiple lines in connect-the-dots fashion. The points attributes is assigned a list of points like this : "x1, y1 x2, y2 x3, y3......" e.g.

<polyline points="80,80 80,100 100,100" style="stroke:red"/>

Creating Polygons The <polygon> element is the last of the basic shape elements in SVG. It requires a points attribute that holds a list of points. The <polygon> element connects the dots and creates a closed figure. e.g.

<polygon points="30,120 70,80 110,120 90,180 50,180 30,120" style="fill:red"/>

Creating Text You use <text> element to display text. It isn't empty; you enclose the text you want to display in it. This element has no required attributes, but to position text, you can use the x and y attributes to specify the location of the upper-left cornet of the text. e.g.

<text x="40" y="100" style="font-family:sans-serif"> TEXT </text>

Creating Gradients SVG supports many sophisticated graphics effects, such as color gradients. e.g. You start out by defining a gradient in an element named <defs>. You're goint to create a linear gradient and name it gradient1, and you can do this by using the <linearGradient> element and its id attribute. This gradient starts with black at a location 5% of the way through the figure, which you can specify with a <stop> element. The gradient becomes pure blue at 95% though the figure. All that remains is to put it to work, and you can do that by referencing it in the fill attribute as "url(#gradient1)". e.g.

<?xml version="1.0" encoding="UTF-8"?> <svg xmlns="http://www.w3.org/2000/svg"> <defs> <linearGradient id="gradient1"> <stop offset="5%" stop-color="#000000" /> <stop offset="95% stop-color="#0000FF" /> </linearGradient> </defs> <rect fill="url(#gradient1)" stroke="blue" x="40" y="100" width="300" height="150"/gt; </svg>

Creating Paths Another sophisticated aspect of SVG is that it enables you to create visual paths, which you do by using the <path> element. This element has one required attribute, d, which defines the path. The syntax of this attribute is a little involved; it contains of coordinates and single-letter commands, such as:

M -- Indicate a "move to" operation.
L -- Indicate a "line to" operation.
H -- Draw a horizontal line.
V -- Draw a vertical line.
S -- Draw a cubic Bezier curve from the current point to (x, y). The first control point is assumed to be the reflection of the second control point in the previous command.
C -- Draw a cubic Bezier curve from the current point to (x, y), using (x1, y1) as the control point at the beginning of the curve and (x2, y2) as the control point at the end of the curve.

e.g.

<path style="stroke:blue" d="M100,160 C100,60 250,60 250,140 S400,260 400,160"/>

Creating Text Paths You can create text paths to make text flow as you want it to by using the <textPath> and <path> elements. First, you define the path, giving it the ID path1. Next you add a <text> element to enclose the text. Next you use an enclosed <textpath> element to define the path you want the text to follow, refenercing the path, path1, by using an XLink (which you'll see more about in Day 13). e.g.

<path id="path1" style="fill:none" d="M100,160 C100,60 250,60 250,140 S400,260 400,160"/> <text x="40" y="100" font-family="sans-serif" font-size="16pt"> <textPath xlink:href="#path1" xmlns:xlink="http://www.w3.org/1999/xlink"> Here's how to create an artful curved text path. </textPath> </text>

Creating Groups and Transformations SVG allows you to group visual items together by using the <g> element and treat them as on item. e.g. You can rotate and translate a group that consists of an ellipse and some text. Rotating and translating are seperate operations, and you start by translating the group by +20 pixels in the x direction and +10 pixels in the y directions. Next, you rotate the group by 20 degrees.

<g transform="translate(20, 10)"> <g transform="rotate(20)"> <ellipse cx="150" cy="100" rx="100" ry="50" fill="none" stroke="darkmagenta" stroke-width="4"/> <text x="100" y="100" font-size="20" font-family="sans-serif" fill="navy" > Rotations! </text> </g> </g>

Creating Animation SVG not only draws static 2D images, but it allows you to animate them as well, and Adobes' SVG Viewer supports animation. To animate graphics, you use the <animate> element, along with various attributes. e.g. You use <animate> element inside the <rect> element to animate the rectangle. When you animate an element such as <rect>, you really animate its attributes, such as x, y, width, height, over a period of time. To animate the x attribute of the <rect> element, making it change from a value of 200 to 100 over a period of 10 seconds, starting when the rectangle first appears. In the following example, you set the attributeName attribute to the name of the attribute you want to work with, x, and then set the attributeType attribute to "XML", meaning that this is an SVG attribute (the other option is "CSS", which means you want to work with a CSS property). The freeze attribute lets you specify whether you want the results of animation to stick around after the animation process is over. Setting freeze to "fill" means that you don't want the graphics element you're working with to return to its original appearance when the animation is done.

<rect x="200" y="100" width="200" height="100" fill="blue"> <animate attributeName="x" attributeType="XML" begin="0s" dur="10s" fill="freeze" from="200" to="100" /> </rect>

Creating Links You can create hyperlinks by using a <a> element in SVG. However, SVG uses XLinks. The XLink namespace is "http://www.w3.org/1999/xlink", and you need to define a namespace prefix, xlink, to go with that namespace. Then, use <a> element's required XLink href attribute to specify the URI to link to. e.g. You're going to use an ellipse as a hyperlink and display some underlined text in it to make it clear that the ellipse is a hyperlink.

<?xml version="1.0" standalone="no"?> <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"> <text y="40" style="font-size:24pt"> Using links </text> <a xlink:href="http://www.w3.org/TR/SVG/"> <g> <ellipse cx="200" cy="100" rx="100" ry="50" fill="cyan" /> <text y="105" x="125" style="font-size:24pt" text-decoration="underline"> Click here! </text> </g> </a> </svg>

Creating Scripts You can use JavaScrpit to work with SVG. e.g. You can add to a rectangle a script that causes the rectangle to grow when it is clicked. You start by creating the rectangle itself. Note, in particular, the onclick attribute, which lets the rectangle handle mouse-click events. There are the event attributes that element such as <rect> let you handle:

onfocusin
onfocusout
onactivate
onclick
onmousedown
onmouseup
onmouseover
onmouseout
onload

To handle the mouse-click event in rectangle, you connect a JavaScript event handler called click_handler to the click event, using the <rect> element's onclick attribute. Next, You can set up an SVG <script> element and enclose the JavaScript code in a CDATA section. To get a JavaScript object that corresponds to the rectangle, you can use the target property of the even object passed to the JavaScript function. Next, you can use its setAttribute method to set the width of the rectangle to 200 pixels.

<?xml version="1.0" standalone="no"?> <svg xmlns="http://www.w3.org/2000/svg"> <script type="text/javascript"> <![CDATA[ function click_handler(evt) { var rect = evt.target; rect.setAttribute("width", 200); } ]]> </script> <text y="40" style="font-size:24pt"> Using JavaScript </text> <rect onclick="click_handler(evt)" x="100" y="100" width="100" height="50" fill="steelblue"/> </svg>

Embedding SVG in HTML So far, the SVG documents have been dedicate SVG, but by using the HTML <EMBED> element, you can embed SVG documents in HTML pages. Note that the PLUGINSPAGE attribute lets the browser download the plug-in (after asking the user), if needed. e.g.

<EMBED WIDTH="500" HEIGHT="500" SRC="ch13_03.svg" PLUGINSPAGE="http://www.adobe.com/svg/viewer/install/">

Introducing SMIL SMIL is all about creating multimedia presentations in XML. It enables simple authoring of interactive audiovisual presentations. You can find the W3C recommendation for SMIL 1.0, and SMIL 2.0, as well. A SMIL document can be opend in RealPlayer.

Teach Yourself XML in 21 Days, Day 12

2005-07-12T23:20:00.000+01:00

Putting XHTML to Work Creating Hyperlinks: <a> In XHTML, you use the <a> element for hyperlinks with the href attribute or anchors, using the id attribute. e.g.

<a href="http://www.w3.org/markup/activity.html"> XHTML </a>

Link to Other Documents: <link> W3C provides no clear way to connect XML documents to other XML documents, so nonstandard elements such as <?xml-stylesheet?> are used. However, the <link> element can be used in XHTML as in HTML. This element is empty and appears in the <head> section of a document. You can specify a relationship between the current document and others by using the rel attribute: e.g. rel = "stylesheet" -- An external style sheet.

<link rel="stylesheet" href="ch1203.css"/>

Handling Images: <img> XHTML supports an <img> element, of which, the src (which contains the images' URI) and alt (which contains alternate text) attributes are required, and which you have to enclose with />. Surprisingly, the align attribute was not deprecated in the <img> element, as it was for just about every other XHTML element that supported it.

<img src="image.jpg" width="400" height="200" alt="The egg!" />

Creating Frame Documents: <frameset> You use <frameset> to display frames. The <frameset> element replaces the <body> element in XHTML document with frames, and in XHTML 1.0, that means you use the XHTML 1.0 Frameset DTD because the <frameset> element is supported in XHTML 1.0 Frameset only. To create the frames, you use the <frame> element. To format the display into frames, you use the rows or cols attribute of the <frameset> element. You can specify the number of rows or columns you want to use by listing their heights or widths. Creating Frames: <frame> You use the <frame> element to create individual frames. This element is an empty element, and you use it inside the <frameset> element. The one required attribute in the <frame> element is the src attribute, which specifies the URI of the document you want to display in the frame. e.g.

<frameset cols="50%, 50%"> <frame src="ch1206.html"/> <frame src="ch1207.html"/> </frameset>

Creating Embedded Style Sheets: <style> You can use the <link> element to connect an external style sheet. You can also use the XML processing instruction <?xml-stylesheet?> to connect to an external style sheet. In addition to using external style sheets, you can also use the <style> element to create an internal, or embedded, style sheet. You usually put the <style> element in an XHTML document's head. Note the type attribute is required in XHTML. In XHTML, you can also create inline styles, which means you apply styles to one XHTML element only. You create inline styles by using the style attributes that most XHTML elements support. Extending XHTML The name Extensible Hypertext Markup Language might give you the impression that XHTML is designed to be extended. e.g. You may extend XHTML by adding to it a new element, <bold>, that will display its text in bold. Firstly, you should declare this element in DTD. You also need the rest of the XHTML 1.0 Transitional DTD, so you may creating a new parameter entity. Though you've got a DTD supports not only the <bold> element, but also the rest of XHTML 1.0 Transitional, since you've given the XHTML document the extension .html, the browser may assume the fixed HTML element set and not even try to read in the DTD. So you can do a better job in this case if you treate the document as an XML file. e.g. (only show the part of DTD)

<!DOCTYPE html [ <!ELEMENT bold (#PCDATA)> <!ENTITY % XHTML1.0DTDEntity PUBLIC "-//W3C//DTD HTML 1.0 Transitional//EN" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd"> %XHTML1.0DTDEntity; ]>

By treating the markup as XML, you are able to extend XHTML.

Teach Yourself XML in 21 Days, Day 11

2005-07-11T00:59:00.000+01:00

Extending HTML with XHTML You'll begin to see XML at work today. You'll start with the XML application that has probably the most authors -- Extensible Hypertext Markup Language (XHTML). XHTML is the W3C's version of HTML 4.0, written entirely in XML. Why XHTML? The main reason the W3C introduced XHTML was that HTML has gotten pretty sloppy. HTML browsers tolerate more and more mistakes in HTML. To fix that, the W3C created XHTML, which uses stricter rules. Another reason that XHTML was introduced was that, as its name indicates, it can be extended. In XHTML, the idea is that you can define and add your own tags. Introducing XHTML 1.0 XHTML 1.0 is the current version of XHTML. XHTML is a rewritten version of HTML 4.0. The official recommendation for XHTML 1.0. There are three version of XHTML 1.0: Strict (omits all elements and attributes deprecated in HTML 4.0), Transitional (a looser version, more like HTML as it's used today), and Frameset (the same as transitional, but for use with frames instead of the <body> element). Each of these versions has its own DTD: The Strict XHTML 1.0 DTD The Transitional XHTML 1.0 DTD The Frameset XHTML 1.0 DTD XHTML version 1.1 exists as a W3C recommendation. XHTML 1.1 is a strict version of HTML, and has yet to be really accepted among Web page authors. It eliminates all the elements and attributes that were deprecated in HTML 4.0 -- and a few more as well. XHTML 1.1's major difference from XHTML 1.0 is that its DTD is desinged to be modular. This means that the XTML 1.1 DTD is really very short; it's simply a DTD driver. The newest version of XHTML is XHTML 2.0, currently in working draft form. Like XHTML 1.1, XHTML 2.0 is modular. It strips out all display elements! XHTML 2.0 is not designed to be backward compatible with HTML or earlier versions of XHTML! Writing XHTML Documents The follwoing are the basic requirements a document must meet to be an XHTML document, according to the W3C:

The document element must be <html>.
The XHTML document must validate against on of the W3C XHTML DTDs.
The document element, <html>, must use the http://www.w3.org/1999/xhtml namespace, using the xlmns attribute.
The document must have a <!DOCTYPE> element, and it must appear before the document element.

Here's also a list of main things you, as HTML authors, need to watch out for when writing XHTML documents:

Element and attribute names have to be in lowercase.
Attribute values must be in quotes.
Non-empty element need end tags.
You can not use standalone attributes in XHTML. If you have to, you can assign a dummy value to an attribute.
An empty element needs to be ended with />.
The <a> element may not contain other <a> elements.
The <button> element may not contain the <input>, <select>, <textarea>, <label>, <button>, <form>, <fieldset>, <iframe>, or <isindex> element.
The <form> element may not contain other <form> elements.
The <label> element may not contain other <label> elements.
the <pre> element may not contain <img>, <object>, <big>, <small>, <sub>, or <sup> elements.
You can use the id attribute, but you can not use the name attribute.
You must escape sensitive characters.

Dissecting XHTML document You start an XHTML document as you would in any XML document, with an XML declaration:

<?xml version = "1.0" encoding = "UTF-8" ?>

The next element is the <!DOCTYPE> element, to indicate which XHTML DTD you're using. e.g.

<!DOCTYPE html PUBLIC "-//W3c//DTD HTML 1.0 Transitional//EN" "http://www.w3.org/tr/xhtml1/DTD/xhtml1-transitional.dtd">

If possible, you should download the DTD file and use it locally. Following the <!DOCTYPE> element is the <html> element, which is the document element for all XHTML documents.

<html xmlns = "http://www.w3.org/1999/xhtml>

In this case, you're putting the entire document into the http://www.w3.org/1999/xhtml namespace. The rest of the XHTML is very much like its HTML counterpart. Validating XHTML Documents To validate XHTML documents, you can use the W3C's own HTML validator. The Basic XHTML Elements Using the Document Element: <html> In the XHTML DTDs, the <html> element is declared in such a way that it can contain a <head> element and a <body> element. Creating a Document Head: <head> In a XHTML document, the <head> element contains the document's head, which holds data about the document, scripting elements, and other data not intended for direct display. In XHTML, every XHTML document should have a <head> element, and every <head> element must contain at least a <title> element. XHTML also specified that the following elements may appear in the <head> element: <base> <isindex> <link> <meta> <noscript> <object> <script> <style> -- style sheet e.g.

<head> <title> Title </title> <style type = "text/css"> body {background: coral} </style> </head>

Giving a Document a Title: <title> The <title> element holds the title of the document. A browser displays the document's title in its title bar. Giving a Document a Body: <body> The document's body holds the document's content -- all the data that the document is meant to display. The W3C's idea in turing toward style sheets to handle the display is that it wants to separate the display details from the data details. The idea is reaching its zenith in XHTML 2.0, which doesn't support even the usual HTML display elements. Organizing Text Whe you want to organize text in an XHTML document, things work very much as they do in HTML. You can use mixed-content model in XHTML. There are a great many character entities in HTML 4.0, which is available. Creating Paragraphs: <p> The <p> element lets you create block-level paragraphs in XHTML. Note that because <p> is a block-level element, you can not display other block-level elements inside it. The <p> dlement contains text and makes it into a block-level element; the browser normally uses vertical space to offset it from other element. The <br> element is an empty element that just makes the browser skip to the next line. You can style the text in a <p> element by styling that element, but you can't style text by using the <br> element. Skipping a Line: <br> In XHTML, the <br> element is an empty element that inserts a line break in text. e.g.

<br />

Centering Text: <center> <center> element was a very popular one. You could use this element to center text and other content in Web pages. Although it has been deprecated, it is also bulit into XHTML 1.0 Transitional. Styling Block Content: <div> In XHTML, you use the <div> element to enclose sections of text or other elements. This lets you style that content as you like. e.g. The following code equals to <center>

<div align = "center" >

You can also declare <div> style in <head> element. e.g.

<head> <style> div {text-align: center} </style> </head>

Styling Inline Content: <span> You can use the <span> element to apply inline styles in XHTML. The <div> and <span> elements are more important in XHTML than they are in HTML because of the reliance on style sheets to handle formatting in XHTML. By handling block sytling, the <div> element replaces elements such as <center> in XHTML 1.0 Strict and XHTML 1.1, and by handling inline styling, <span> replaces elements such as <font>. Creating Headings: <h1> to <h6> Headings are block elements that present text in bold font of various sizes, allowing you to organize that text into sections. Formatting Text XHTML 1.0 and XHTML 1.1 both support the traditional popular HTML formatting elements, such as <b> and <i>. Using Bold on Text: <b> The <b> element applies boldface to its enclosed text. You use a <b> element to bold text with inline styling. Italicizing Text: <i> The <i> element, which supports rudimentary inline text formatting, makes text italic. Underlining Text: <u> The <u> element performs some rudimentary inline formatting by underlining text. Selecting Fonts: <font> The <font> elements lets you select the font for text, as well as its size and color. Comments: <!--> You can use the standard XML and HTML style comments in XHTML documents. XHTML 1.1 and XHTML 2.0 don't appear to support frames. Because frames are formatting elements, they're omitted. However, you can use <div> elements to format text into visible areas as you like.

Teach Yourself XML in 21 Days, Day 10

2005-07-06T15:51:00.000+01:00

Working with XSL Formatting Objects XSL specification: XSL Formatting Objects (XSL-FO) is fare more involved than XSLT. It lets you format data down to the last little detail, such as what font size to use and what margin size. However, XSL is not in as widespread as XSLT, so you shouldn't feel that you have to master today's discussion in order to maste XML. Introducing XSL-FO To let you format individual sections of an output document, the W3C has defined formatting objects such as <root> and <block> that you use as elements that XSL-FO processor supports. By using these elements, you can specify what parts of the output document you want to format. So that you can actually do the formatting, each objects has built-in properties, which you use as attributes in the corresponding element. The formatted document can be a Miscrosoft Word document, a PDF document, or anything that supports the visual formatting you've created. XSL Formatting Objects has their own namespace, http://www.w3.org/1999/XSL/Fomat. This namespace is usually given the prefix fo:, for formatting objects. The W3C recommends the XSL-FO 1.0, the specification of XSL-FO, and the specification of the properties you can use with the XSL-FO objects. Interests in XSL-FO has picked up lately, and a growing number of software packages support it. Here's a sample: Adobe Document Server 5.0 from Adobe Systems E3 from Arbortext FOP from Apache PassiveTeX from TEI XEP from RenderX XSL-FO Render from Advent Using XSL-FO What usually happens is that you take an XML document, run it through an XSLT processor to create a new XML document that uses XSL-FO (with the extention .fo), and the use an XSL-FO processor to create the formatted dispaly document (with the extension .pdf, e.g.). You do things this way because any document except a nontrivial one has many paragraphs of text or data, and to format each on by hand would be a time-consuming process. In fact, XSLT was originally developed for formatting XML documents by using XSL-FO objects. Using XSLT to Create an XSL-FO Document Although you could format an XML document by hand, it's easier to use an XSLT sytle sheet to do so. e.g.

<?xml version="1.0"?> <xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/xsl/transform" xmlns:fo = "http://www.w3.org/1999/xsl/format" version = "1.0"/>

Creating a PDF Document To use an XSL-FO document, .fo, and conver it into a PDF file, you can use what is probably the most popular XSL-FO processor, the Apache XML Project's FOP. Using XSL Formatting Objects and Properties There are 56 XSL-FO formatting objects having corresponding elements that you can use in XSL-FO documents. Also these formatting objects have 177 formatting properties. Building an XSL-FO Document Using <fo:root> The document element of XSL-FO document has to be <fo:root>. The <fo:root> element can contain both a master set layout and page sequences. The master set layout, which uses the <fo:layout-master-set> element, describes the masters, or templates, that you want to use in the document. You can specify the default page layout, such as margin size. You list the masters you want to use in the document in the <fo:layout-master-set> element. e.g. you can create a master for each page by using the <fo:simple-page-master> element. You can create page sequence masters to format pages in a sequence. Using <fo:simple-page-master> You use the page master <fo:simple-page-master> to create a template for a page and outline what goes where. <fo:simple-page-master> lays out the overall geometry of the page. You can also lay out regions in a page, such as the header, footer, and body. You can have up to five regions in a page master in the XSL_FO 1.0 specification: Body -- The body region is the body of the page. -- <fo:region-body> Before -- The before region is the header. -- <fo:region-before> After -- The after region is the footer -- <fo:region-after> Start -- The start region appears to the left of the body -- <fo:region-star> End -- The end region appears to the right of the body -- <fo:region-end> e.g.

<fo:layout-master-set> <fo:simple-page-master master-name = "mainPage" page-height = "300mm"> <fo:region-body margin-top = "10mm" /> <fo:region-after extent = "20mm" /> </fo:simple-page-master> </fo:layout-master-set>

Using <fo:page-sequence> The page sequences, which use the <fo:page-sequence> element, specify the format for a sequences of pages. e.g. you might give a series of pages the same headers and footers. Each such element refers to a page master such as the one you've already created and uses that page master to format its pages. <fo:page-sequence> element is used after <fo:layout-master-set> element. e.g.

<fo:page-sequence master-reference = "mainPage" >

Using <fo:flow> The next step is to specify the content of the page sequence, and you do that with the <fo:flow> element. To create a flow, you specify a region, and the document content flows into that region. e.g.

<fo:page-senquence master-reference = "mainPage > <fo:flow flow-name = "xsl-region-body" > &xsl:apply-templates/> </fo:flow> </fo:page-sequence>

Besides <fo:flow>, you can also use <fo:static-content> in page sequences. The content in <fo:static-content> is static, which means it stays as you've arranged it. Static content is often used for headers and footers. Using <fo:block> In XSL-FO you can use the <fo:block> element to create block-level elements, much like the ones you created when working with CSS. You use this element to create your own rectangular region that appears on its own line. e.g. To handle the data in the <name> element in XML document:

<xsl:template match = "state/name"> <fo:block font-weight = "bold" > Name: &xsl:value-of select="." /> </fo:block> </xsl:template>

Handling Inline Formatting You can also create inline formatting. A number of XSL-FO elements are designed to handle inline formatting, e.g.: <fo:bidi-override< <fo:character> <fo:inline> Using <fo:inline> The <fo:inline> element lets you perform inline formatting with text. e.g.

<xsl:template match = "state/name"> <fo:block font-weight = "bold" > <fo:inline text-decoration = "underline"> Name: </fo:inline> &xsl:value-of select="." /> </fo:block> </xsl:template>

Using <fo:external-graphic> You can use <fo:external-graphic> element to embed image files in output documents. Using <fo:page-number> You can use <fo:page-number> element to add page numbers to a document. Formatting Lists XSL-FO lets you format data in lists, by using these four list elements: <fo:list-block> <fo:list-item> <fo:list-item-label> <fo:list-item-body> To create a list, you use the <fo:list-block> element. You use an <fo:list-item> element to create an item in the list. To create a label for each item, you can use the <fo:list-item-label> element, and to create the body of the list item, you can use the <fo:list-item-body> element. It all sounds simple enough, but as with most things in XSL-FO, even simple things can end up being pretty lengthy.

Teach Yourself XML in 21 Days, Day 9

2005-07-05T22:13:00.000+01:00

Formatting XML by Using XSLT Besides CSS, there is a native XML way to format XML document for display -- using Extensible Stylesheet Language Transformations (XSLT). Introducing XSLT XSLT is actually part of the larger specification Extensible Stylesheet Language (XSL). It is really easy to use and it lets you transform XML document into other formats, such as HTML or plain text. It is a more general language that lets you format XML in great detail. XSLT is a specification of the W3C. The W3C recommends XSLT 1.0, and develops XSLT 2.0 in progress. You use XSLT to transform XML documents, and you can reformat the document's data as you want. To transform XML by using XSLT, you need two documents -- an XML document you want to transform and an XSLT style sheet, note that XSLT stylesheets are also XML documents. XSLT style shees usually use the extension .xsl. Transforming XML by Using XSLT There are three different places where XSLT transformations can happen: Server-Side XSLT There are various ways to handle XSLT on Web Servers. One of the most popular is to use JSP because Java versions 1.4 and later include complete XSLT 1.0 support. The JSP script, of which the extension is .jsp, works with the Tomact JSP server. Client-Side XSLT Internet Explorer lets you perform XSLT 1.o transformation. All you have to do is connect the XSLT style sheet to the XML document by using an <?xml-stylesheet?> processing intruction, e.g.

<?xml-stylesheet type = "text/xsl" href="ch0902.xsl" ?>

Standalone Programs and XSLT Some programs perform XSLT transformation for you. There's a great deal of XSLT support built in to the Java programming language, so many of the transformation programs use Java. Writing XSLT Style Sheet In XSLT terms, an XML document is a tree of nodes. The tree starts with the root node, and it branches out from that point. The root node corresponds to the very beginning of the document; it's not the same as the document element. The root node corresponds to the very beginning of the document, so you have access to the document's prolog, which comes before the document element. Each distinct item in an XML document is considered a node. From XSLT's point of view, there are seven types of nodes: Attribute -- An attribute Comment -- The text of a comment (excluding the  parts); Element -- An element Namespace -- The namespace's URI Processing instruction -- The text of the processing instruction (excluding <? and ?>) Root node -- The very start of the document, such as XML declaration. Text -- The text of the node To handle and search the various nodes in XML documents, the XSLT specification defines a number of elements. It also uses an XML-specific language, XML Path Language (XPath), to let you specify exactly what nodes you're looking for. You started a XSLT document with an XML declaration and by using the <xsl:stylesheet> element. Note that this is not the <?xsl:stylesheet?> processing instruction you can use in XML documents to connect style sheets to XML documents. Moreover, you associate the xsl namespace with the URI "http://www.w3.org/1999/XSL/Transform", which is the official namespace for XSLT. e.g.

<xsl:stylesheet version = "1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

To indicate what elements you want to locate and work with, you use the <xsl:template> element to create an XSLT template. A template lets you match a node or nodes in the XML document and specify what you want to do with the contained data. e.g.

<xsl:template match = "states">

The XSLT processor starts at the root node and searches for templates that match the children of the root node, but not the grandchild of the root node, according this match rule. Using <xsl:apply-templates> You use the <xsl:apply-templates> element to indicate that you have other templates to use on the child nodes of the current node. You've already used a template to match the document element <states>. And you've used the <xsl:apply-template> element to indicate that you also want the XSLT processor to process the child nodes of the <states> node by searching for additional templates that match those nodes. Using <xsl:value-of> and <xsl:for-each> To exact the name of each state, you can use the <xsl:value-of> element in the template to match every <state>; element. In particular, you can exact the data in the <name> child node inside each <state> element by using the select attribute, e.g.

<xsl:template match = "state"> <xsl:value-of select = "name" /> </xsl:template>

Note that the select attribute only selects the first node that matches. So if you have multiple nodes that could match, you can use the <xsl:for-each> element. e.g.

<xsl:template match = "state"> <xsl:for-each select="name"> <xsl:value-of select = "." /> </xsl:for-each> </xsl:template>

This example will catch all <name> elements, add their vaules to the output document. Matching Nodes by Using the match Attribute When you create an XSLT template, you need to specify what you want the template to match, and you do that with the match attribute. Handdling Elements You can match elements simply by using their names. You can use the / operator to separate element names when you want to refer to a child of a particular node. e.g.

<xsl:template match="state/name">

You can use * character as a wildcard; it can stand for any element (* can match only elements). By simply using the expression "state//name", which matches all <name> elements that are inside <state> elements, no matter how many levels deep. (These elements are called descendands of the <state> element) Handling Attributes You can handle attributes very much like you handle elements. All that's different is that you have to preface the attribute name with @. e.g.

<xsl:template match="population"> <xsl:value-of select="."/> <xsl:text> </xsl:text> <xsl:value-of select="@units"/> </xsl:template>

This example gets the values of the units attribute of <population> elements. Note that <xsl:text> element performs like inserting a space. You can use the @* wildcard to select all attributes of an element. Handling ID Attributes If you have given elements an ID attribute and have declared that attribute in a DTD or XML schema, you can match those element by using the id() expression. e.g.

<xsl:template match="id('Steven')">

Handling Processing Instructions You can match processing instructions by using the XPath expression processing-instruction(). e.g.

<xsl:template match="/processing-instruction()">

You also can specify what processing instruction you want to match if you list its name in the parentheses here. e.g.

<xsl:template match="//processing-instruction(xml-stylesheet)">

This example matches the processing instruction <?xml-stylesheet?> Handling Multiple Matches You can catch more than one match by using one match attribute if you use the OR operator, |. e.g.

<xsl:template match="bird | flower" >

This example matches both <bird> and <flower> elements. There is a default template built in to XSLT for elements, and it just inserts their values into the resulting document. When you used <xsl:apply-templates> on the child elements of the <state> element, the default template was automatically used for elements, without any explicit template. Working with the select Attribute and XPath You can assign the select attribute XPath expressions, which are used to indicate exactly what node or nodes you want to use in an XML document. W3C recommends XPath 1.0, and current is working with XPath 2.0. XPath expressions are more powerful than the match expressions you've already seen, for one thing, they're not restrict to working with the current node or direct child nodes; you can use them to work with parent nodes, ancestor nodes, and more. To specify a node or set of nodes in XPath, you use a location path. A location path consists of one or more location steps, seperated by / (to refer to a child node) or // (to refer to any descendant node). If you start the location path with /, the location path is called an absolute location path because you're specifying the path from the root node; otherwise, the location path is relative. And the node an XPath expression is working on is called the context node. Location steps are made up of an axis, a node test, and zero or more predicates. e.g.

child:state[position() = 2]

This expression picks out the second <state> child of the context node. Here, child is the name of the axis, state is the node test, and [position() = 2] is a predicate. Using Axes XPath expression supports many different axes: ancestor -- This axis contains the ancestors of the context node. ancestor-or-self -- This axis contains the context node and the ancestors of the context node. attribute -- This axis contains the attributes of the context node. child descendant descendant-or-self following -- This axis contains all nodes that come after the context node. following-sibling -- This axis contains all the following siblings of the context node, sibling refers to an item on the same level as the context node. namespace -- This axis contains the namespace nodes of the context node. parent preceding -- This axis contains all nodes that come before the context node. preceding-sibling self Note that although the match attribute can only use the child or attribute axes in location steps, which is the major restriction on the match attribute compare to the select attribute, the select attribute can use any of the 13 axes. Using Node Tests After you specify the axis you want to use in a location step, you specify the node test. A node test indicates what type of node you want to match. You can use names of nodes as node test, or you can use the wildcard * to select element nodes. You can also use these node tests: comment() -- This node test selects comment nodes node() -- This node test selects any type of node processing-instruction() -- This node test selects a processing instruction node. text() -- This node test selects a text node. Using Predicates The last part of a location step is the predicate. In a location step, the (optional) predicate narrows the search down even more. Predicate can get pretty involved because there are all kinds of XPath expressions that you can work with in predicates. There are various types of legal XPath expressions: Booleans Node sets Numbers Strings Boolean Expressions XPath Boolean values are true/false values. These are the logical operators: != < <= = > >= You can also use the keywords and and or to connect Boolean expressions. In addition, you can use the not() function. Node Sets A node set is just a set of nodes. By collecting nodes into a set, XPath lets you work with multiple nodes as once. You can use the following XPath functions to work with node sets: last() -- Returns the last node in the node set position() -- Returns the position of the context node in the node set. The first node is Node 1. count(node-set) -- Returns the numbers of nodes in node-set. id(ID) -- Returns a node set that contains the element whose ID value matches ID. local-name(node-set) -- Returns the name of the first node in node-set. namespace-uri(node-set) -- Returns the URI of the namspace of the first node in node-set. name(node-set) -- Returns the qualified name of the first node in node-set. e.g. You can use the follow script to numbering items.

<xsl:value-of select="position()"/gt;

Numbers XPath uses the following operators to hand numbers in expressions: + - * div -- Division mod -- Modulus Beside the numeric operator, XPath also has these functions that work with numbers: ceiling() floor() round() sum() Strings Strings in XPath are treated as Unicode characters. A number of XPath functions are specially designed to work on strings: concat(string1, string2, ...) -- Returns the strings joined together. contains(string1, string2) etc... XPath Abbreviations and Default Rules There are ways to abbreviate location steps to make thing easier: sefl::node() -- . parent::node() -- .. child::childname -- childname attribute::childname -- @childname /descentant-or-self::node() -- // You can also abbreviate predicate expressions: e.g.

[position() = 8] -- [8]

XSLT also has some bulit-in default rules: If you don't supply a template for an element, that element is still processed with <xsl:apply-templates/> to handle the element's child nodes. For attribute, XSLT is to place the vlaue of the attribute in the output document. For text, XSLT is to just insert the text into the output document. XPath Tools You can use XPath Visualiser by Dimitre Novatchev. This is a great way to test your XPath expressions until you get them to do what you want; all you need in order to use this tool is a browser. Using <xsl:copy> The <xsl:copy> element lets you copy nodes; it copies only the nodes that match the XPath expression you want. By using <xsl:copy<, you can copy whatever child elements, text nodes, or attributes you need. Using <xsl:if> You can use the <xsl:if> element to make choices that depend on the data in an XML document. All you have to do to use this element is assign its test attribute a value that evalutes to a Boolean value of true or false. Using <xsl:choose> You can also use <xsl:choose> to compare a test value against several possibilities. This element is used with <xsl:when> and <xsl:otherwise> elements. Specifying the Output Document Type There's actually a special rule: If the document node of the output document is <HTML>, XSLT processors are supposed to treate the output document as HTML. In fact, you can specify the type of output document you want by using the XSLT <xsl:output> element: xml -- This is the default. It makes the output documents start with an <?xml?> declaration. html -- This makes the output document standard HTML 4.0, without an XML declaration. text -- This makes the output document simple text. e.g.

<xsl:output method = "text" />

Here are some addtional useful <xsl:output> attributes: encoding -- Indicates the value of the XML declaration's encoding attribute. indent -- Indicates whether the XSLT processor should indent the output. You can set this attribute to "yes" or "no". omit-xml-declaration -- Indicates whether the processor should omit the XML declaration. standalone version doctype-system doctype-public Finally, take a look at both the XSLT specification and the XPath specification. To see the using of <xsl:sort> and <xsl:element> elements, and etc.

Teach Yourself XML in 21 days, Day 8

2005-07-01T01:10:00.000+01:00

Formatting XML by Using Cascading Style Sheets Cascading Style Sheets (CSS). You use CSS to format the data in XML documents for display. It is convencing standard Web browsers to display XML by telling them how to format the data in various XML elements (and remove all the markup). Introducing CSS CSS has ben standarized by the W3C. There are three levels of CSS available: CSS1, CSS2, and CSS3. CSS3 is still under development. There are also many CSS resources available at the W3C CSS page, including CSS tutorials and links to free tools. Style Sheets are collections of style rules, each of which shows how to format an XML element. A rule is made up of a selector, which is the element(s) you want to format, and the rule specification, which shows what formatting you want to apply. Here's how a rule might look if you want to format the text in the <title> element in bold, centered, underlined 36-point font (a point is 1/72 inch):

title {display: block; font-size: 36pt; font-weight: bold; text-align: center; text-decoration: underline}

Note that the rule specification is enclosed in curly braces, { and }. In this rule, title is the selector and {display: block; font-size: 36pt; font-weight: bold; text-align: center; text-decoration: underline} is the rule specification. display, font-size, font-weight, and so on are CSS properties. In fact, getting to know CSS largly means getting to know what properties, like these, are available. Rule specifications are made up of property/value pairs, such as display:block, seperated with semicolons. CSS style sheet files use the extension .css. Styel sheets don't look much like XML documents, but, as with XML, there are a few CSS validators available on the Web to help you check your CSS: The W3C CSS validator, checks the CSS in your pages for you; The W3C TIDY program can conver styles in HTML documents to CSS for you. Connecting CSS Style Sheets and XML Documents There's really only one way of connecting a style sheet to an XML document: by using the <?xml-stylesheet?> processing intruction. e.g.

<?xml-stylesheet type = "text/css" href="ch0802.css"?>

Actually, there is another way to connect styles to XML elements. You can create inline styles by using the style attribute. e.g.

He is free who lives as he <i style="font-style: italic"> wishes to live...</i>

Creating Style Sheet Selectors To specify what XML elements you want to format, you use selectors in a CSS style sheet. Each selector is just the name of the element you want to format. You can also group elements together just by seperating them with commas. e.g.

title, book {display:block}

Creating Style Classes You don't need to specify an element name or names in order to create a selector; you can instead use a style class as a selector. You create a class by preceding its name with a dot (.). e.g.

.standout {color:cyan; background-color: coral}

You can apply the standout class to elements such as <title> by using class attribute. Note that the class attribute isn't built in to XML; it's just used by convention. e.g.

<title class = "standout" > The Title </title>

Note that the new colors are added to the display; they didn't simply replace the other formatting that was already present. If you want to use the class attribute in a valid document, you have to declare it. In a DTD, that might look like this:

<!ATTLIST title class CDATA #IMPLIED>

In an XML schema, it might look like this:

<xsd:attribute name="class" type="xsd:text"/>

You can target style classes to specific elements as well. e.g. say that you want to format the first paragraph in the text a particular way:

paragraph.first {text-indent:40;margin-top:30}

You can put the new style class to work with <paragraph> element as shown:

<paragraph class="first">

Selecting by ID There's another way to select XML elements to format: you can use the element's ID value. You can create selectors that target XML elements that have a certain ID by using this syntax:

elementName#idValue

e.g. You create a style rule for <paragraph> elements that have the ID "first":

paragraph#first {text-indent:40}

You can use this new ID-based selector in an XML documents as shown:

<paragraph id = "first">

Using Inline Styles In HTML you can create an inline style to format just one particular element. To do this, you simply assign a style rule spacification to the style attribute of the element. e.g.

<paragraph> He is free who lives as he <i style="font-style:italic"> wishes </i> to live </paragraph>

Striclty speaking, this is not valid XML unless you also declare the style attribute in a DTD or an XML schema. Note that here <paragraph> element contains mixed-content. Some people recommend not using inline style in this way because such styles are then spread throughout the document instead of being collected into a single style sheet. Creating Style Rule Specifications in Style Sheets The style rule specificaiton is a list of property/value pairs that are saperated by semicolons. Note that when you assign values to CSS properties, you can speicy a size or a length by using points, indicated with the pt suffix. e.g. 36pt, or pixels (suffix px) , e.g. 20px. Theoretically, browsers are also supposed to be able to handle measurements in inches (suffix in), centimeters (suffix cm), millimeters (suffix mm), and picas (1/6 inch; suffix pc). If you omit the suffix for a length, pixels are assumed. Also, note that when you specify positions, the origin is at the upper left of the display window. That is positive x increases to the right, and positive y increases downward. Creating Block Elements When you assign the display property the value block, the corresponding element will be formatted in a block, which means that the data from the element will start on a new line, and the data from the next element will start on its own line as well. Specifying Text Styles There are plenty of style properties that you can use with text: font-family -- Specifies the font face. You can list a number of options, separated by commas. The first face supported by the browser will be used. font-size -- Specifies the size of the font. You can set this property to a size; e.g. 36pt. font-style -- Specifies whether to use normal, italic, or oblique face. font-weight -- Specifies the boldness of text relative to other fonts in the same font family. You can set it to bold for bold text. line-height -- Specifies the height of each line of text. You can set it to an absolute size or to a percentage, e.g. 150%, which increase 3/2 spacing. text-align -- Specifies the alignment of text. You can assign this property values such as left, right, center and justify. text-decoration -- Specifies underlining and overlining. You can set it to underline, overline, line-through, or blink; to get rid of text inherited decorations, you can set it to none. text-indent -- Specifies the indentation of the first line of block-level elements. You can set it to size. text-transform -- Specifies whether to display text in all uppercase, in all lowercase, or with initial letter capitalized. The possible values are capitalize, uppercase, lowercase, and none. vertical-align -- Specifies the vertical alignment of text. You can set it to baseline, sub, super, top, text-top, middle, bottom, or text-bottom. Styling Colors and Backgrounds There are a number of properties that you can use to set color and work with backgrounds: background-attachment -- Specifies whether the background scrolls with the rest of the document. background-color -- Specifies the background color. You can set it to a color. background-image -- Specifies the background image. You can set it to a URL. background-repeat -- Specifies whether the background imag should be titled. You can set it to repeat, repeat-x, repeat-y, or no-repeat. color -- Specifies the foreground color, i.e., the color of text. The cascading means that enclosed elements inherit styles from enclosing elements. When you work with HTML browsers, you can define your own colors as standard HTML color triplets, using this syntax:

#rrggbb

Styling Borders You can format the borders of block element by using a number of styles: border-bottom-width -- Specifies the width of the bottom of the border. You can set it to a size, or thin, medium, or thick. border-color -- Specifies the color to use for the border. Setting it sets the color of the whole border. border-left-width -- Specifies the width of the left edge of the border. border-right-width -- Specifies the width of the right edge of the border. border-style -- Specifies the border style. You can set it to dotted, dashed, solid, double, groove, ridge, inset, or outset. Most browsers only support solid. border-top-width -- Specifies the width of the top edge of the border. border-width -- Specifiesthe width of the border. It's also worth nothing that the border style lets you set an element's width, style, and color in a shortcut form. e.g.

P {border: 6pt solid ret}

Styling Alignments You can customize alignments and margins: line-height margin-bottom --Specifies the bottom margin of a block element. You can set it to a size. margin-left margin-right margin-top text-align text-indent vertical-align Styling Images You can display images in some browsers while formatting XML documents: background-image background-repeat background-attachment background-position -- Specifies the intital position of the background image. You can set it to an x, y coordination. e.g. background-position: 10px 20px. In addition to using an image as a background image, you can also display an images as a foreground image. To do that, you create a custom element whose express purpose is to display the image. e.g. you'll create an image element named <image> and make it display the image by using the CSS property background-image. You can also specify the height and width to use when displaying an element by using the CSS properties height and width. Finally, you can indicatae whether the image will float to the right or left of text by using the float property, as shown:

image {background-image: url(image.jpg); height: 60px; width: 100px; float: left}

Positioning Elements By using CSS, you can set the position of elements. Before CSS let you position items in a Web pages, HTML authors used HTML talbes to make sure that elements were at the correct locations rather than floating as the Web browser determined. position -- Specifies an element's position. You can set it to either absolute or relative. top -- Specifies the location of the top of the element. bottom left right e.g.

image {background-image:url(image.jpg); position:absolute; left:250; top:180}

Besides absolute positioning, there's another option -- relative positioning. In relative positioning, you position items relative to the locations they would have in the usual flow of elements as the browser would display them. Styling Lists You can show HTML-style lists in some browsers when you format an XML document: list-item -- Creates a list when assigned to the display property list-style-image -- Specifies the image that should appear in front of each item in the list. This property is not support by many browsers. list-style-type -- Specifies the list item marker, which appears before each list item. You can set it to various values, such as disc, circle, square, decimal, lowercase Roman, and uppercase Roman. Not all values are supported by all browsers. e.g.

paragraph {display:list-item; margin-left:10px; list-style-type:circle}

Styling Tables IE doesn't handle this formatting well......

Teach Yourself XML in 21 days, Day 7

2005-06-30T16:10:00.000+01:00

Creating Types in XML Schemas Restricting Simple Types by Using XML Schema Facets You can restrict the values that are acceptable when defining a simple type. You must base your own simple types on the simple types that are built into XML schemas. You can restrict the possible values of a simple types by using the <xsd:restriction> element. e.g.

<xsd:simpleType name="loanNumberType"> <xsd:restriction base="xsd:string"> <xsd:pattern value="\d{2} \d{4} \d{2}"/> </xsd:restriction> </xsd:simpleType>

You're using the <xsd:restriction> element's base attribute to indicate that you are basing this type on the xsd:string type. Then you're using an XML schema facet to restrict the actual text that can be stored in attributes of the type you're creating. In this example, the text in the loanNumberType type must much the regular expression pattern "\d{2} \d{4} \d{2}", which matches text strings made up of two digits, a space, four digits, another space, and two more digits (e.g. "22 6666 99"). Regular expressions used with the XML schema pattern facet are the same as those used in the Perl programming languarage. As of this writing, the complete documentation for Perl regular expressions is here. The Visual Studio .NET programming languages, such as Visual Basic.NET and visual C#.NET do support regular expression, and so they support the pattern facet. The following are the available facets and how they constrain data values: totalDigits -- Specifies the maximum number of digits fractionDigits -- Specifies the maximum number of decimal digits pattern -- Specifies a regular expression that text must match whiteSpace -- Can be se to preserve (to preserve white space), replace(to replace all white space with ) or collapse (to collapse multiple contiguous whitespace to one ) enumeration -- Constrains possible values to a specified set maxInclusive -- Specifies the maximum possible value, inclusive maxExclusive -- Specifies the maximum possible value, exclusive minInclusive -- Specifies the minimum possible value, inclusive minExclusive -- Specifies the minimum possible value, exclusive length -- Specifies the data's length, such as number of characters minLength -- Specifies the minimum possible length maxLength -- Specifies the maximum possible length Which facets apply to which predefined simple types? There are tables listing what facets you can use with the various simple data types and the addtional facets of the numeric simple types and simples types that can be ordered. One of the interesting facets is enumeration, which lets you specify a set of values that a data item can select from. Creating XML Schema Choices XML schema choices let you specify a number of items, only one of which will be chosen. To declare a choice in XML schema, you use the <xsd:choice> element. e.g.

<xsd:choice> <xsd:element name = "residentialProperty" type="xsd:string"/> <xsd:element name = "commercialProperty" type = "xsd:string"/> </xsd:choice>

This child element can be either a <residentialProperty> element or a <commercialProperty> element. Using Anonymous Type Definitions When you've created your own types, you've declared elements to be of a certain type and then declared that type. To make use of a type, you give the new type a name and then use that name when decaring an element. However, there's another way as well: you can use anonymous types. An anonymous type is useful if you want to use a type only once and don't want to create many different elements with the same type. So far, the types you've created ouselves have all had names, but if you want to use a type in only on location, it turns out that you can declare it at that location and you don't need to give it a name. This is called an anonymous type. To create an anonymous type definition, you simply enclose an <xsd:simpleType> or <xsd:complexType> element inside an <xsd:element> element declaration. You can also declare attributes in anonymous types. Declaring Empty Elements You just declare empty elements by using a complex type that has no child elements. In other words, you indicate that these are elements that do not contain any other elements, which means they are empty. Empty elements can have attributes; if you declare them using complex types, you can give them attributes. Declaring Mixed-Content Elements XML schemas support true mixed-content elements, in which you can mix text and elements. In other words, character data can appear at the same level as child elements. e.g.

<invoice> To <name> James Blandings </name>: Your monthly payment of ... on <property> The Hackeet Place </property> is due in the three weeks. Thanks. </invoice>

As you can see, both text and elements are mixed inside the <invoice> element in this example. To indicate that this element can handle mixed content, you set the <complexType> elment's mixed attribute to "true". Then all you have to do now is add the declarations for the for the elements that you can use inside the <invoice> element. Whereas DTDs provide only partial support for mixed-content models, schemas provide a more complete syntax that allows you to specify the order and number of child elements in mixed-content elements. However, it is important to note that although you can declare mixed-content elements, you should avoid doing so if possible. Ideally in XML documents, all data is enclosed inside elements. Groupint Elements Together A elements group collects elements together, and you can refer to a group by name. e.g.

<xsd:group ref="aElementGroup" />

To create the group named aElementGroup, you can use the <xsd:group> element. By using groups, you can collect elements together and refer to them by name, which means you can use those groups throughout the XML schema as needed. Grouping Attributes Together Besides grouping elements together, you can also group attributes together. You create attribute groups by using the <xsd:attributeGroup> element. You can use an attribute group named aAttributeGropu, and you can refer to that group as follows in the declaration of the an element:

&xsd:attributeGroup ref="aAttributeGroup" />

The inspiration behind element and attribute groups is parameter entities in DTDs. Parameter netities let you collect declarations together and use them by referring to them simply by using a parameter entity reference. Declaring all Groups In an all group, elements may appear in any order, but there's a catch: all the elements in this kind of group may appear only once or not at all (which means that the allowed values of minOccurs and maxOccurs are 0 and 1 only). This kind of group must be used at the top level of the content model, and the group's children must be individual element -- in other words, this group must itself contain no groups. Handling Namespaces in Schemas DTD's weren't built specially to handle namespace; as you've seen, they really treat namesapce prefixes as part of an element name. XML schemas, on the other hand, were supposed to improve on that situation, and to meet that goal, they support a new attribute: targetNamespace. The targetNamepace attribute can hold the namespaces the XML schema is targeted toward -- i.e. the namspace that the elements in the XML document uses. In other workds, a target namespace lets an XML validator know what XML schema to use to check XML elements in that namespace. It's important that you know that XML schemas treat global element declarations differently thant local element declarations when it comes to working with namespaces; this is because global elements can be used as document elements, whereas local elements can't. As you've seen, globally declared elements and attributes are declared at the top level in the XML schema, directly under the <schema> element. All the other elements and attributes delcared in an XML schema are locally declared. When you start working with namespaces, XML schemas allow you to specify whether locals need to be qualified (that is, whether they need a namespace prefix) when used in an XML document. Declaring Locals Without Qualifying Them To specify whether elements need to be qualified, you use the elementFormDefault attribute of the <schema> element, and to specify whether attributes need to be qualified, you use the attributeFormDefault attribute of the same element. You can set the elementFormDefault and atributeFormDefault attributes to "qualified" or "unqualified". e.g.

<schema xlmns = "http://www.w3.org/2001/XMLSchema" targetNamespace="http://xmlpowercorp" elementFormDefault="unqualified" attributeFormDefault="unqualified">

Because you're dealing with namespaces now, let's take a look at a shorcut way of handling the XML schema URI "http://www.w3.org/2001/XMLSchema" in an XML schema. Up to this point, you've been associating the prefix xsd with that namespace in the XML schema, e.g.

<xsd:schema xmlns:xsd=//www.w3.org/2001/XMLSchema">

However, if you make "http://www.w3.org/2001/XMLSchema" the default namespace in an XML schema, you don't need to use a prefix for the XML schema elements. Though it can save some time, but you have to be a little careful because now the XML validator will assume that everying in the "http://www.w3.org/2001/XMLSchema" namespace. That's a problem because when you say, e.g. that the <document> element is of the documentType type, the XML validator needs to know where to find the documentType type; it won't find that type defined in the default "http://www.w3.org/2001/XMLSchema" namespace. You can indicate that local types are declared locally by using a new namspace prefix, such as xmp (short for XML Power Corp) . If only two elements that are global in the XML schema, which are <document"> and <comment>, so they're the only ones that need to be qualified with a namespace prefix. Declaring and Qaulifying Locals We can require that locals be qualified with a namespace prefix. e.g., we can assign the value "qualified" to the elementFormDefault attribute instead of using "unqualified". Now you have to qualify both locals and globals in the XML documents. You can also require that attributes be qualified by setting attributeFormDefault to "qualified". Now all elements and attributes, both local and global, will have to be qualified. Rather than prefix every element and attribute with xmp:, however, you can make things easier by just putting the entire XML document into the "http://xmlpowercorp" namespace. Up to this point, you've specified that all locals must be either qualified or unqualifed, but there's also a way of working on locals individually, by using the form attribute. e.g. you can leave all locals unqualified expect for a single attribute, phone, which must be qualified:

<xsd:attribute name="phone" type="xsd:string" use="optional" form="qualified"/>

Annotating an XML Schema As with DTDs and XML documents, you can add documents to XML schemas. You can use the XML comments in XML schema. XML schemas also define three new element that you use to add annotation to schemas: <xsd:annotation>, <xsd:documentation>, <xsd:appInfo>. The <xsd:annotation> element is a container for the other two. The <xsd:documentation> element holds text intended for human readers, but it's a little more than standard XML comments because the text in <xsd:documentation> elements can be stripped out by an XML processor and used to document an XML schema. The <xsd:appInfo> element can be used to pass along instructions to the XML pocessor that is reading the XML schema. You can use these elements anywhere you like in an XML schema.

Teach Yourself XML in 21 days, Day 6

2005-06-26T16:44:00.000+01:00

Creating Valid XML Documents: XML Schemas A more comprehensive and detailed way of specifying the syntax of XML documents, followed the W3C's response, is XML schemas. A good resource on XML schemas is the W3C XML Schema Activity Page. Using XML Schema Tools More and more software tools are appearing that can generate XML schemas. Such as: HiT Software -- This is an online automatic XML schema generator and DTD to XML schema converter. You just let it upload a document, and it creates an XML schema for free. Validating XML Documents by Using XML Schemas XSV -- This is the online W3C XML schema validator XML Schema Definition Language -- XSD schema. How do you connect an XML schema, such as ch0603.xsd, to an XML document? Different XML processors do it in different ways, but a standard is emerging. If you define a namespace, usually named xsi, for the URI www.w3.org/2001/XMLSchema-instance, you can then use an attribute named xsi:schemaLocation in the document element to specify the URI of the document's XML schema. e.g.

<? xml version = "1.0" > <document xmlns = "http://xmlpowercorp" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http://xmlpowercorp ch0603.xsd" > ... </document>

It turns out that it's actually not necessary to embed an xsi:schemaLocation attribute in an XML document to validate it by using Internet Exploer -- you can use JavaScript to tell Internet Explorer where to find the XML schema. Creating XML Schemas The first thing to note about the XML schema is that it's a well-formed XML document. It uses proper XML elemnts to declare the syntax of the XML document. e.g.

<?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <xsd:annotation> <xsd:documentation> Test XML schema. </xsd:documentation> </xsd:annotation> <xsd:element name="document" type="documentType"/> <xsd:complexType name="documentType"> <xsd:sequence> <xsd:element ref="comment" minOccurs="1"/> <xsd:element name="test1" type="recordType"/> <xsd:element name="test2" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="documentDate" type="xsd:date"/> </xsd:complexType> <xsd:element name="comment" type="xsd:string"/> ... </xsd:schema>

To start, XML schema uses an XML declaration to declare the namespace prefix xsd (the usual name for this namespace in XML schemas), and it assigns the URI www.w3.org/2001/XMLSchema to that prefix, which is how the W3C says you must do things in XML schemas, in a special element named <xsd:schema>. In the example, you're putting the <xsd:documentation> element with the text "Text XML Schema" inside the <xsd:annotation> element, creating a comment in the schema. Annotations like this one are ignored by XML processors. You use <xsd:element> to declare elements and <xsd:attribute> to declare attributes. The Built-in XML Schema Elements These are the elements you can use in XML shemas. These elements are usually used with the namespace www.w3.org/2001/XMLSchema and namespace prefix xsd, so, e.g. the <all> element would usually be <xsd:all>, and so on. List -- Legal XML Schema Elements all -- Allows elements in a group to be in any order annotation -- Creates an annotation that lets you add comments to an XML schema any -- Allows any element to appear in a sequence or choice element anyAttribute -- Allows any attribute to appear in the containing complex type or in the containing attribute group appinfo -- Contains information within an annotation element attribute -- Declares an attribute attributegroup -- Creates an attribute group, which allows attribute declarations to be used as a group for complex type definitions. choice -- Allows one, and only one, of the given elements to appear in the containing element complexContent -- Specifies restrictions on a complex type that contains mixed content or elements. complexType -- Declares a complex type documentation -- Contains text that can be placed in an annotation element element -- Declares an element extension -- Extends a simple or complex type that has simple content field -- Contains an XML Path Language (XPath) expression that specifies the value for a constraint group -- Groups element declarations together so that they can be used as a group in complex type definitions import -- Imports a namespace whose schema components can be used by a shema include -- Includes teh given schema document in the current schema key -- Specifies that an attribute value or element value must be a key keyref -- Specifies that an attribute value or element value must match the value of the given key list -- Declares a simple type element as a list of values of a given data type notation -- Holds a notation to describe the format of non-XML data inside an XML document redefine -- Allows simple and complex types and groups to be redefined in the current schema restriction -- Declares constrains, such as restricting the type of data schema -- Contains a schema definition selector -- Gives an XPath expression that can select elements for an identity constraint sequence -- Constrains the given elements to appear in the given sequence in the XML document simpleContent -- Contains extensions or restrictions on a type simpleType -- Declares a simple type for use with the type attribute when you declare element or attributes union -- Declares a simple type as a collection of values of simple data types unique -- Specifies that an attribute or element value must be unique Creating Elements and Types To declare elements, you use the <xsd:element> element in XML schemas. When you declare an element, you can specify its type. e.g. the element named <comment> in the sample XML document you've been working with just contains text, e.g.

<comment> Good Rist </comment>

You can declare the <comment> element by using <xsd:element> and giving it the name "comment" and the type xsd:string, like this:

<xsd:element name="comment" type="xsd:string"/>

You've used the built-in type xsd:string. However, you can also define our own types. In fact, there are two types that you can create -- simple and complex types. Elements that enclose child elements or have attributes are complex types. In other words, complex types can have internal structure, such as child elements and attributes, but simple types cannot. For example, attributes are always simple types because attribute values cannot have any internal structure. Using Simple Types There are some built-in simple types for XML schemas, such as xsd:string, xsd:int, xsd:date, and so on. Note how detailed these types are compared to DTDs; remember that with DTDs, you can't define data types. Declaring out own types lets you restrict the values those types can take. For example, take a look at the <term> element in the XML document. This element gives the term, i.e. the length parameter, and you want that number to be 30 or less, so you can use a <xsd:simpleType> element, enclosing a <xsd:restriction> element, to restrict the possible values that can be used in the <term> element. Inside the <xsd:restriction> element, you can use the <xsd:maxInclusive> element to restrict possible values in the <term> element to 30 years or less, e.g.

<xsd:element name="term"> <xsd:simpleType> <xsd:restriction base="xsd:integer"> <xsd:maxInclusive value="30"/> </xsd:restriction> <simpleType>

Using Complex Type You create new complex types by using the <xsd:complexType> element in schemas. For example, the <document> element can contain other elements, so you need to decare it by using a complex type, which you can call documentType in our XML schema. In the XML schema, you can declare the <document> element to be of the documentType type:

<xsd:element name="document" type="documentType"/>

You create the documentType type by using an <xsd:complexType> element. In this case, you want to indicate that the subelements in <document> will be <comment>, < test1> and <test2>, in that order, so you use the <xsd:sequence> element, such as:

<xsd:element name="document" type="documentType"/> <xsd:complexType name="documentType"> <xsd:sequence> <xsd:element ref="comment" minOccurs="1"/> <xsd:element name="test1" type="recordType"/> <xsd:element name="test2" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="documentDate" type="xsd:date"/> </xsd:complexType>

You create a type in an XML schema and then you can declare elements for that type. If you want to use a complex type, you have to create it, and you do that by using the &xsd:complexType> elememt. One way of declaring elements, as you've seen today, is to specify the element's name and type, as in in following example, which declare the <comment> element;

<xsd:element name="comment" type="xsd:string"/>

Using the ref attribute lets you make use of an element that has already been declared. Note, however, that you can't just included any element by reference -- the element you refer to must have been declared globally, which means that it is itself not part of any other complex type. The other option is to declare elements inside other declarations, which is declaring them locally. A global element or attribute declaration appears as an immediate child element of the <xsd:schema> element, and when you declare an element or attribute globally, it can be used in any complex type. Using the ref attribute in this way is a powerful technique. Specifying a Number of Elements The <document> element is declared to be of the documentType type, and in that type, you use the minOccurs attribute to indicate that the <comment> element must occur at least once:

<xsd:element ref="comment" minOccurs="1"/>

You can specify the minimum number of times an element appears by using the minOccurs attribute and the maximum number of times it can appear by using the maxOccurs attribute. Keep in mind that you can use minOccurs and maxOccurs only with local declarations, not global ones. The default value for minOccurs is 1, and the default for maxOccurs is the value of minOccurs. To specify that there is no upper bound to the maxOccurs attribute, you set it to the value "unbounded". Specifying Element Default Values The <xsd:element> element has two attributes, fixed and default, that let you specify an element's default value. The fixed attribute sets the value of an element; for example, setting the <term> element's fixed attribute to an integer value of 800 means that the element will always have that vale:

<xsd:element name="term" type="xsd:integer" fixed="800"/>

The default attribute lets you set the default value of an element -- that is, the value that the element has if you don't specify any other value. For example, here's how you can specify a value of 800 as a default value instead of fixing this element's value at 800:

<xsd:element name="term" type="xsd:integer" default="800"/>

Creating Attributes To declaring an attribute, you use the <xsd:attribute> element as in the examples, which declares an attribute named phone for the recordType type.

<xsd:attribute name="phone" type="xsd:string"/>

<xsd:attribute> has a type attribute, and its attributes must always be of a simple type. You can also indicate whether an attribute is required or optional, or whether it has a default value. To do that, you use the <xsd:attribute> element's use and value attribute. e.g.

<xsd:element name="term" type="xsd:integer" default="800" use="optional"/>

Here are the vaules you can give to the use attribute: default -- If you don't use the use attribute, its value is the default vale set with the value attribute. If you do use it, its value is the value you assign it. fixed -- This value makes the attribute fixed. You can set its value by using the value attribute. optional -- This value makes the attribute optional, which means the attribute may have any value. prohibited -- This value means the attribute cannot be used. required -- This value makes the attribute required. The attribute can have any value. The value attribute contains a value if you need to specify one. For example, the following attribute declaration creates an attribute named year with the integer fixed value "2005":

<xsd:attribute name="year" type="xsd:int" use="fixed" value="2005">

Here's another example of an attribute declaration. This example gives the integer attribute year with the default value "2005":

<xsd:attribute name="year" type="xsd:int" use="default" value="2005">

Teach Yourself XML in 21 days, Day 5

2005-06-24T16:38:00.000+01:00

Handling Attributes and Entities in DTDs Both attributes and entities are essential parts of XML, this chapter is going to explain how to support them in valid XML documents. Declaring Attributes in DTDs As in HTML, an attribute is a name-value pair that you can use in a start tag or an empty tag to provide additional information for an element. You can declare a list of attributes for an element by using the <!ATTLIST> element in the DTD. e.g.

<! ATTLIST element_name attribute_name type default_value >

Here, element_name is the name of the element for which you're declaring attributes, attribute_name is the name of an attribute you want to declare, type is the attribute's type, the default_value sepcifies the default value of the attribute. A real example is:

<! ATTLIST employee supervisor CDATA #IMPLIED supervisor CDATA #IMPLIED division CDATA #IMPLIED fulltime CDATA #IMPLIED >

the use of the above declared attribute can be:

<employee supervisor = "no" division = "plastics" fulltime = "yes">

All you have to do is use an <!ATTLIST> element to declare the attributes for an element. It's a little more involved to use this element than to use <!ELEMENT>, however, because you're restricted to certain types and default values for attributes in DTDs. Using the Legal Default Values and Attributes Types When you're declaring attributes in DTDs, these are the possible default_value settings you can use in <!ATTLIST> elements; value -- Specifies a text value and must be enclosed in quotes #IMPLED -- Makes an attribute optional #FIXED value -- Sets the attribute's value to value #REQUIRED -- Means that this attribute is required and must be given a value These are the possible type values you can use CDATA -- Specifies character data, which is just text without markup ENTITY -- Specifies an entity name ENTITIES -- Specifies multiple entity names, which are seperated by whitespace Enumerated -- Specifies one value from a list of values (an enumeration) ID -- Specifies an ID attribute, which holds a proper XML name IDREF -- Holds the ID value of some other element IDREFS -- Holds multiple ID values of elements, seperated by whitespace NMTOKEN -- Specifies text made up of XML name characters, or tokens. NMTOKENS -- Specifies multiple NMTOKEN items, seperated by whitespace NOTATION -- Specifies a notation name that holds a format description (such as a MIME type) Specifying Default Values Immediate Values You can specify a default value for an attribute simply by listing that value, in quotes, in the attribute's declaration in the <!ATTLIST> element, making it an immediate value. If you give an attribute a default value and then don't use that attribute in an element, the attribute is automatically given the default value. e.g.

<! ATTLIST employee supervisor CDATA "no" >

The #REQUIRED You can specify a default value of #REQUIRED to indicate that an attribute is required. e.g.

<! ATTLIST employee supervisor CDATA #REQUIRED >

The #IMPLIED Attributes declared with #IMPLIED are optional. For example, you can use the #IMPLIED default value if you want to all the document author to include an attribute, but you don't want to require it. e.g.

<! ATTLIST employee supervisor CDATA #IMPLIED >

All the following examples are valid:

<employee supervisor = "no"> <employee>

The #FIXED The final default value is #FIXED, which you use when you want to assign a fixed value to an attribute -- a value that the attribute will always have. e.g.

<! ATTLIST employee supervisor CDATA #FIXED "en" >

Specifying Attribute Types The CDATA As you've already seen, the CDATA data type stands for character data. Unlike parsed character data (PCDATA), which is assumed to have already been parsed, the character data in attribute values is read and parsed by the XML processor. Enumerated Types An attribute enumeration is just a list of possible values that an attribute can take. e.g.

<! ATTLIST employee supervisor (yes | no) "no" >

The NMTOKEN Attribute Type The attribute type NMTOKEN stands for name token, and it lets you assign to an attribute any value made up of legal XML name characters. Note that NMTOKEN characters can not include whitespace. e.g.

<! ATTLIST employee state NMTOKEN #REQUIRED >

This attribute can be used as:

<employee state = "NY">

The NMTOKENS Attribute Type You can use the NMTOKENS attribute type when you want to list multiple values made up of NMTOKEN values, seperated by whitespace, so, it could include whitespace now. e.g.

<! ATTLIST employee state NMTOKENS #REQUIRED >

This attribute can be used as:

<employee state = "New York">

The ID Attribute Type An important attribute type is the ID type. There's a special meaning to an element's ID value because sometimes XML processors use an ID attribute to identity an element. Therefore, XML processors are supposed to make sure that no two elements have the same value for the attribute that is of the type ID in a document; in addtion, you can give an element only on attribute of this type. e.g.

<! ATTLIST employee id ID #REQUIRED >

This attribute can be used as:

<employee id = "A1112">

The IDREF Attribute Type We can also use IDREF (which stands for ID reference) attributes to tie an element to another element, using the other element's ID value as a reference. The following example gives each employee an id attribute and also creates an optional supervisor attribute of type IDREF, which will store the ID value of an employee's supervisor:

<! ATTLIST employee id ID #REQUIRED supervisor IDREF #IMPLIED >

this attribute can be used as:

<employee id = "A1112"> <employee id = "A1113" supervisor = "A1112">

The ENTITY Attribute Type The ENTITY type lets you assign to an attribute the name of an entity you've declared. The following example gives the entity name PHOTO1221 to the image file 1221.gif and the entity name PHOTO1222 to the image file 1222.gif:

<! ENTITY PHOTO1221 SYSTEM "1221.gif" > <! ENTITY PHOTO1222 SYSTEM "1222.gif" >

If 1221.gif and 1222.gif held the photos of various employees, you could indicate that this is the case by using an ENTITY attribute named photo, like this:

<! ATTLIST employee photo ENTITY #IMPLIED >

this attribute can be used as:

<employee photo = "PHOTO1221">

Using ENTITY attribute is a good way of working with entities. The ENTITIES attribute Type Attributes of this type can hold lists of entity names, separated by whitespace. The NOTATION Attribute Type You can assign to NOTATION attribute values that you've declared to be notations. Notations specify the format of non-XML data, and they're typically used to describe the storate format of external entities such as image fiels. e.g. one popular type of notations is Multipurpose Internet Mail Extension (MIME) type, such as application/xml, text/html, image/jpeg, and so forth, which are often used to specify data storage formats. There is a list of all the avaliable MIME types. When you want to declare a notation, you use the <!NOTATION> element in a DTD like this:

<! NOTATION name SYSTEM "external_id" >

You can also use the PUBLIC keyword for public natation if you supply a fomal public identifier (FPI), like this:

<! NOTATION name PUBLIC FPI "external_id" >

An example is:

<! NOTATION jpg SYSTEM "image/jpeg" > <! NOTATION gif SYSTEM "image/gif" > <! ATTLIST employee imagetype NOTATION (jpg | gif) #IMPLIED >

This attribute can be used as:

<employee imagetype = "gif">

Handling Entities An entity in XML is simply a data item. Entities can also be internal or external. An internal entity is defined completely inside the XML document that uses it. An external, on the other hand, is stored externally, such as in a file; to refer to an external entity in XML, you can use a URI. You declare an entity in a DTD, and then you can refer to it with an entity ference in the rest of the XML document. Creating Internal General Entity References You use the <!ENTITY> element to declare an entity. e.g.

<! ENTITY name definition >

In this case, the name of the entity is just the name you want to use to refer to the entity, but an entity's definition can take several different forms. The simplest way of defining an entity is just to use the text that you want XML processors to replace entiry references with. e.g.

<! ENTITY copyright "(c) XML Power Corp. 2005" >

You can use the entity copyright in the XML document like this:

<copy> &copyright; </copy>

The replacement text for internal general entity references doesn't have to be quoted text; you can use UTF-8 character codes directly. You also can nest entity references. e.g.

<! ENTITY me "Cherub" > <! ENTITY copyright "(c) &me; 2005" >

Note that although you can nest entity references, they can't be circular, or the XML processor will go nuts. e.g.

<! ENTITY me "&copyright; Cherub" > <! ENTITY copyright "(c) &me; 2005" >

Circular entity references like the above are illegal in valid documents. General entity references, such as &copyright;, are valid only in the body of the XML document, not in the DTD itself. e.g. this is not legal:

<! ENTITY employeeContent "(copy, name, hiredate, projects)" > <! ELEMENT employee &employeeContent; >

The way you should handle a situation like this ,where an entity reference is used in the DTD itself, is by using parameter entities. Creating External General Entity References You can use the SYSTEM keyword or the PUBLIC keyword when declaring external general entities. The syntax is:

<! ENTITY name SYSTEM URI > <! ENTITY name PUBLIC FPI URI >

By using external general entities, you can assemble XML documents together from various pieces stored in their own files. That can be very useful if, for example, you have standard headers or footers or copyright notices that you want to use. Associating Non-XML Data with an XML Document To declare an external unparsed entity, you use an <!ENTITY> element with either the SYSTEM keyword or the PUBLIC keyword, like this (note the keyword NDATA, which indicates that you're referring to an unparsed entity):

<! ENTITY name SYSTEM value NDATA type > <! ENTITY name PUBLIC FPI value NDATA type >

name is the name of the external unparsed entity, value is the value of the entity, such as the name of an external file, and type is a declared notation. For example, to explicitly indicate that 1221.gif is an external entity that should not be parsed, you can create a notation name gif for GIF files;

<! NOTION gif SYSTEM "image/gif" >

Next, you can declare 1221.gif as an unpased entity that uses the gif notation;

<! ENTITY PHOTO1221 SYSTEM "1221.gif" NDATA gif >

You can create an ENTITY attribute named photo for the <employee> element;

<! ATTLIST employee photo ENTITY #IMPLIED >

Finally, you can assign the photo attribute the value PHOTO1221;

<employee photo = "PHOTO1221">

Note that in this example, you do NOT use an entity reference (that is, &PHOTO1221;) because you do NOT want the XML processor to parse 1221.gif. Creating Internal Parameter Entities It turns out that it can be useful to use parameters in DTDs, and you use parameter entities and parameter entity references (which can only be used in DTDs) for that. In fact, there's one more restriction on DTDs: Parameter entity references that you use insied an already existing DTD declaration can appear only in the DTD's external subset, which means that the part of the DTD that is external. You can declare a parameter entity by using the <!ENTITY> element, but you include a % to show that you're declaring a parameter reference. e.g.

The following is an example that shows how to use an internal parameter entity:
<! ENTITY % project "<! ELEMENT project (product, id, price) >" >
When you use the parameter entity reference %project; in the DTD, it will be replaced with the text <! ELEMENT project (product, id, price) >. Using INCLUDE and IGNORE to Parameterize DTDs There are two important directives that you need to know abut when it comes to working with DTDs: INCLUDE and IGNORE. Directives are special commands to the XML processor, and INCLUDE and IGNORE are specially designed to customize a DTD by including or omitting sections of that DTD. The following is the syntax:
<![ INCLUDE [DTD Section]] > <![ IGNORE [DTD Section]]>
The reason you see INCLUDE and INGORE in DTDs is that by using these directives, you can create parameterized DTDs.

Teach Yourself XML in 21 days, Day 4

2005-06-23T14:14:00.000+01:00

Creating Valid XML Documents: DTDs We define the syntax of an XML document by using a DTD, and we declare that definition in a document by using a document type declaration. We can use a <! DOCTYPE > element to create a DTD, and the DTD appears in that element. The following forms are valid:

<! DOCTYPE rootname [DTD] > <! DOCTYPE rootname SYSTEM URI > <! DOCTYPE rootname SYSTEM URI [DTD] > <! DOCTYPE rootname PUBLIC identifier URI > <! DOCTYPE rootname PUBLIC identifier URI [DTD] >

The first step in creating that DTD is to declare the elements that appear in the XML document. To declare the syntax of an element in a DTD, we use the <! ELEMENT > element like this:

<! ELEMENT name content_model >

In this syntax, name is the name of the element we're declaring and content_model is the content model of the element. A content model indicates what content the element is allowed to have, for example, you can allow child elements or text data, or you can make the element empty by using the EMPTY keyword, or you can allow any content by using the ANY keyword.e.g.

<! ELEMENT document (employee)* >

Handling ANY content If you give an element the content model ANY, that element can contain any content, which means any elements and/or any character data. What this really means is that you're turning off validation for this element because the contents of elements with the content model ANY are not even checked. Specifying Child Elements You can specify what child elements an element can contain in that element's content model. The above example specifies that a <document> element can contain <employee> element. The * here means that a <document> element can contain any number, including zero, <employee> elements. You can list multiple elements in a content model, which is called creating a sequence. You use commas to separate the elements you want to have apear, and then the elements have to appear in that sequence in our XML document. For example, if you declare this sequence in the DTD:

<! ELEMENT employee (name, hiredate, projects) >

the <employee> elements can contain <name>, <hiredata>, and <projects> elements, and in that order. Handling Text Content In a DTD, we refer to parsed character data as #PCDATA. Note that this is the only way to refer to text data in a DTD -- you can't say anything about the actual format of the text, although that might be important if you're dealing with numbers. In fact, this lack of precision is one of the reasons that XML schemas were introduced. Specifying Multiple Child Elements There are a number of ways of specifying multiple children by using symbols:

x+ -- Means x can appear one or more times; x* -- Means x can appear zero or more times; x? -- Means x can appear once or not at all; x, y -- Means x followed by y; x | y -- Means x or y, but not both.

You can use the +, *, and ? symbols in content model sequences. e.g.

<! ELEMENT employee (name+, hiredate?, projects*) >

If fact, you can get even more powerful results by using the +, *, and ? operators inside sequences. By using parenttheses, we can create subsequences -- that is, sequences inside sequences. e.g.

<! ELEMENT employee ((name, age?, phone*)+, hiredate, projects) >

Allowing Choices By using (x | y | z), DTDS can support choices of containg either <x>, <y> or <z>. Allowing Mixed Content When using a DTD, you can allow an element to contain text OR child elements, giving it a mixed content model. Note that even with a mixed content model, and element can't contain child elements AND text data at the same level at the same time. However, you can set up a DTD so that an element can contain EITHER child elements OR text data. e.g.

<! ELEMENT product (#PCDATA | stocknumber)* >

Allowing Empty Elements Elements don't need to have any content at all, of course; they can be empty. As you would expect, you can support empty element by using DTDs. In particular, you can create an empty content model with the keyword EMPTY. e.g.

<! ELEMENT intern EMPTY >

Commenting a DTD Commenting a DTD accord to the same syntax with the XML. Supporting External DTDs We can also store DTDs externally, in entirely separate files, which usually use the extension .dtd. That way, if you want to make changes in the XML application, you only need to change the DTD once, not in dozens of separate files. There are two ways to suport external DTDs -- as private DTDs for personal or limited use and as public DTDs for public use. Creating Private DTDs You specify that we're using an external private DTD by using the SYSTEM keyword in the element, e.g.

<! DOCTYPE document SYTEM "ch04_07.dtd" >

This example specifies the name of the <document> element, the SYSTEM keyword to indicate that the example is using a private external DTD, and the name of the external DTD file. We must change the standalone attribute from "yes" to "no". e.g.

<? xml version = "1.0" encoding = "UTF-8" standalone = "no" ?>

Note that the external DTD simply holds the part of the document that was originally between the [ and ] in the inner version of element. If you want to use an onlin XML validator, you need to supply a URL like the following for an external DTD:

<! DOCTYPE document SYSTEM "http://sample.com/sample.dtd" >

Creating Public DTDs Creating and using a public external DTD can take a little more work. In this case, you use the PUBLIC keyword instead of SYSTEM in the <!DOCTYPE> DTD. To use the PUBLIC keyword, you must also create a formal public identifier (FPI), which is a quoted string of text, made up of four fields separated by //. e.g. the official FPI for transitional XHTML 1.0 is -//W3C//DTD XHTML 1.0 Transitional//EN. Here are the rules for creating the fields in FPIs:

1. The first field indicates whether the DTD is for a formal standard. For DTDs you create on your own, this field should be -. If a non-official standard body has created the DTD, you use +. For formal standard bodies, this field is a reference to the standard itself (such as ISO/IEC 19775:2003) 2. The second field holds the name of the group or person responsible for the DTD. You should use a name that is UNIQUE. 3. The third field specifies the type of the document the DTD is for and should be followed by a unique version number of some kind. 4. The fourth field specifies the language in which the DTD is written.

When you use a public external DTD, we can use the element like this:

<! DOCTYPE rootname PUBLIC FPI URI >

Using Internal and External DTDs at the Same Time You can also use BOTH internal and external DTDs if you use these forms of the <!DOCTYPE> element:

<! DOCTYPE rootname SYSTEM URI [DTD] > <! DOCTYPE rootname PUBLIC identifier URI [DTD] >

In these cases, the external DTD is specified by URL and the internal on by DTD. Combining internal and external DTDs like this is a good idea if you have a standard DTD that we share with other XML documents but also want to do some customizatoin in certain XML documents. Handling Namespaces in DTDs Another important topic when it comes to working with DTDs is how to handle namespaces. As we already know, a namespace name is really just a name prepended to an element or attribute name with a colon. That means that as far as a DTD is concerned, those new names have to be declared. The syntax is to add the following declaration in DTDs when using a namespace, (like declare an attribute of a element, which is concerned in Day 5).

<! ATTLIST emp:document xmlns:emp CDATA #FIXED "http://www.xmlpowercorp.com/dtds/" >

Teach Yourself XML in 21 days, Day 3

2005-06-14T22:03:00.000+01:00

Creating Well-Formed XML Documents A XML document is well-formed if:

1. Taken as a whole, it matches the production labeled document; 2. It mees all the well-formedness constraints given in XML 1.0 specification; 3. Each of the parsed entities, which is referenced directly or indirectly within the document, is well-formed.

Matching the Production Labeled document A XML document, to be well-formed, must follow the document production, which means that the document itself must have three parts:

a prolog a root element a miscellaneous part

siblings, child, parent relationships A parent element can enclose an indefinite number of child elements Well-Formedness Constraints 1. W3C says you should always include the XML declaration first thing; 2. Using only legal character references; 3. A XML document must include one or more elements. The first element is the root element; 4. Every non-empty element in XML must have both a start tag and an end tag; 5. Empty elements which have no content, though they can have attributes, are made up entirely of one tag, and must always end with /<; 6. The root element must contain all the other elements in the document; (It is convenient for a XML processor to navigate the entire document) 7. Nesting elements requires that if an element contains a start tag for a non-empty tag, it must also contain that element's end tag; 8. You can not use the same attribute more than once in one start tag or empty element tag; 9. You must quote every value you assign to an attribute, using either single quotation marks or double quotation marks; 10. You should avoid references to external entities in attribute values. Here the external entities mean XML style references - gengeral entity references or parameter entity references, not just, for example, using an image file's name. It also means that an XML processor doesn't have to replace an attribute value with the contents of an external entity. 11. You are not supposed to use < in attribute values, because an XML processor might mistake it for markup. 12. You should avoid using < and & for anything else than start tag and the start entity reference. For JavaScript, it is maybe a problem... Three optional solutions:

Enclose JavaScript codes in a CDATA section; Reverse the logical sense that using NOT great and equal t0 instead of below; Place the JavaScript codes in an external file and like it when necessary; (Recommended)

XML Namespaces Namespace is derived to handled the problem of tag names conflicting. Namespaces give you a way to make sure that one set of tags will no conflict with another. You prefix a name to tag and attribute names. To define a new namespace, use the xmlns:prefix attribute, where prefix is the prefix you want to use for the namespace. e.g.

<employee xmlns:hr="http://www.example.com/example">

URI, Uniform Resource Identifiers To define a namespace, you assign the xmlns:prefix attribute to a unique identifier, which in XML is usually a URI that might direct the XML processor to a DTD for the namespace. URI, Uniform Resource Identifiers, is expanded from the idea of standard URL, Uniform Resource Locators. In theory, a URI can point not just to a single resource, but to a cluster of resources, or to arcs of resources along a path. But the truth is that the whole idea of URI as the next step after URL is still being developed. After defining the hr namespace in the above example, you can preface every tag and attribute name in this namespace with hr: like this:

<hr:employee>

Using namespaces keeps elements separate by actually changing tag and attribute names. Two namespace names are reserved: xml and xmlns. You can use the xmlns:prefix attribute to define a namespace, or you can use the xmlns attribute by itself to define a default namespace. When you define a default namespace, elements and attributes without a namespace prefix are in that default namespace. e.g.

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en" xmlns:m="http://www.w3.org/1998/Math/MathXML" >

The above example create a default namespace for XHTML tags and a m namespace for MathXML tags inside element html. Namespaces aren't used solely to avoid tag and attribute name conflicts, using a namespace also indicates to an XML processor what XML application you're using.

No time

2005-06-12T11:47:00.000+01:00

Excuse me a break... Too short of time to do more things...

Teach Yourself XML in 21 days, Day 2

2005-06-08T22:53:00.000+01:00

Necessary tools necessary to help you develop your XML are editors, browsers, and validators. XML character Encoding: ASCII, Unicode, and UCS W3C chose Unicode, which holds 65,536 characters, as XML's standard Encoding. The first 256 Unicode characters correspond to the ASCII character set. There's another character encoding availabe that has even more space than Unicode - the Universal Character System, UCS, also called ISO 10646, uses 32 bits - two bytes - per character. This give it a range of two billion symbols - and a good thing, too, since there are more Chinese characters alone than there is space in Unicode. UCS also encompasses the smaller Unicode character set - each Unicode character is represented by the same code in UCS, in much the same way that the Unicode encompasses the smaller ASCII character set. XML actually supports a compressed version of Unicode created by the UCS group called UCS Transformation Format - 8, UTF-8. UTF-8 includes all the ASCII codes unchaged, and uses a single byte for the most common Unicode characters. UCS itself has also been compressed in the same way into a character set named UTF-16, which uses two bytes (instead of the normal four that UCS uses) for the most common characters, and more bytes for the less common characters. W3C requires all XML processors to support both UTF-8, and UTF-16, and those are the only two W3C requires. UTF-8 is so widespread that an XML processor will assume you're using it if you omit the encoding attribute. Character reference stands for a Unicode character and begin with &, followed by a numeric code specifying a character, and ends with ;. Understanding XML Markup and XML Data XML documents are combinations of markup and text data. The markup in a document gives it its structure. Markup includes start tags, end tags, empty element tags, entity references, character references, comments, CDATA section delimiters, document type declaractions, and processing instructions. All the text in an XML document that is not markup is data.

Tags begint with < and end with > General entity references start with & and end with ; Parameter entity reference, which start with % and end with ;, are used in DTDs.

Before XML document is parsed, text data is called character data; after it's been parsed and general entity references have been replaced with the entities they refer to, the text data is called parsed character data. Using Whitespace and Ends of Lines Spaces, carriage returns, line feeds, and tabs are all treated as whitespace in XML.

attribute xml:space

Creating Prologs Prologs appear at the beginning of XML documents, and contain information about the rest of a the document. A problog can contain XML declaractions, XML comments, processing instructions, whitespace, and doctype declaractions. W3C says you should include at least an XML declaration in all XML documents. XML DeclaractionXML declaractions tell XML processors what version of XML you're using, what character encoding the document is written in, and so on. All XML documents should start with an XML declaraction, which should be the first line in an XML document.

attibute: version, encoding, standalone (Set to "yes" if the document does not refer to any external documents or entities, "no" otherwise. It is optional)

XML Comments: You start a comment with . You're only supposed to use comments outside markup. You should not use the character sequence -- in the text of a comment. In particular, the XML 1.0 specification says that comments can not end with the sequence --->. Also, comments can not come before an XML declaraction (nothing can).In most XML processor, you can use comments to exclude sections of a document from being treated as markup. Processing Instructions: Processing instructions are instructions to the XML processor, not general data-handling items like elements. A common processing instruction is <?xml-stylesheet?>, but that's not an official W3C processing instruction built into XML. In other words, processing instructions must be understood by the XML processor, so they're processor-dependent. Creating Tags and Elements. Tags and Elements: Tag names are case sensive. Empty Elements: In XML, you close an empty element with />. Empty elements can have attributes. Root Element: Each well-formed XML document must contain one element that contains all the other elements, and the containing element is called the root element. Attributes: The values you assign to attributes must be quoted, even if they're numbers, and that if you use an attribute, it must be assigned a value. Attribute names must follow the same rules as those for element names. If the attribute value contains ingle or double quotes or both, you can use the XML-defined general entity references for a single quotation mark and for a double quotation mark.

attribute: xml:lang

Attributes, Elements, Data: Attributes hold data, and elements hold data, too. You can't specify document structure using attribute. A good rule to follow, therefore, is to use elements to structure your document, and to use attributes when you have more information to include about a specific element. CDATA Sections: escaping means you want XMl processor to avoid to replace the general entity reference to what it refer to. You can achieve escaping by placing you text data in a CDATA section. CDATA stands for character data, as opposed to parsed character data, which is PCDATA. You use the CDATA section to tell the XML processer to leave the enclosed text alone, and pass it on uncharged. You cannot nest CDATA sections. To avoid confusing an XML processor reading an XHTML page with embedded JavaScript operator, which may use the less than (<), you can enclose that JavaScript in a CDATA section. Entities: There's another type of item you can work with in XML documents - entities, which can be parsed or unparsed. An entity simply means a data item, such as a section of text or binary data. A parsed entity is one that you refer to with an entity reference. Entity references are replaced by XML processor with the entities they refer to. You can define your own general entity refereneces. Unparsed entities can be binary data that you don't want parsed, or even non-XML text, and they're usually external to you XML document. You don't refer to an unparsed entity with an entity reference, but by a name. When you refer to an entity by name instead of with an explicit entity reference, that entity will not be parsed or placed into your XML document directly.

Teach Yourself XML in 21 days, Day 1

2005-06-07T22:39:00.000+01:00

The name of the game in XML is data, because XML is all about storing your data. Unlike HTML, XML is not about displaying your data - it's about packaging that data to transport it easily. All About Markup Languages The term markup refers to codes or tokens you put into a document to indicate how to interpret the (non-markup) data in the document. All About XML XML is a meta-language, which means it's a language that lets you create your own markup languages. W3C publishes its specifications using four types of documents:

Notes; Working drafts; Candidate recommendations; Recommendations.

You're free to make up your own element names in XML, and that's XML's whole power - the capability to create your own markup. Comment that, unlike HTML, the case of a tag is important in XML. XML documents always need a root element, even if they don't have any other elements or text. Being able to create your own elements from scratch has advantages and disadvantages - you're not restricted to a predefined and limited set of tags, but on the other hand, a standard Web browser can understand HTML tags but will have no idea what do with a special tag, e.g.<message>. Looking at XML in a Browser Internet Explorer hasn't done anything more than display raw XML - it hasn't interpreted that XML in any way, because browsers are specialists at displaying data, not interpreting XML tags. One of the most popular reasons for using style sheets with XML is that you store your data in an XML document, and specify how to display that data using a separate document, the style sheet. By seperating the presentation details from the data, you can change the entire presentation with a few changes in the style sheet, instead of making multiple changes in your data ifself. There are 2 kinds of style sheets you can use with XML documents - Cascading Style Sheets (CSS), which you can also use with HTML documents, and Extensible Stylesheet Language style Sheets (XSL), designed to be used only with XML documents. All XML processing instructions start with <? and end with ?>. Working with XML Data Yourself One way of gaining access to that data in a browser is to use JavaScript. Moreover, Java has all kinds of built-in support for working with XML. Structuring Your Data An XML document actually can do more than just hold your data; it can let you specify the structure of that data as well. The software that reads your XML - called an XML processor - is supposed to check your document; if there's a problem, the processor is supposed to quit. It should let you know about the problem, but that's as far as it's supposed to do, according to W3C. There are 2 main checks that XML processors make: checking that your document is well-formed and checking that it's valid. Creating Well-Formed XML Documents Formally, for an XML document being well-formed, it means that the document must follow the syntax rules specified for XML by the W3C in the XML 1.0 recommendation or the XML 1.1 candidatae recommendation. The document must contain one or more elements, and one element, the root element, must contain all the other elements. In addition, each element must nest inside any enclosing elements properly. Creating Valid XML Documents An XML processor will usually check whether your XML document is well-formed, but only some are also capable of checking whether it's valid. An XML document is valid if it adheres to the syntax you've specified for it, and you can specify that syntax in either a Document Type Definition (DTD) or an XML schema. Using a DTD, you're able to specify the syntax your XML document should obey - what elements should be inside what other elements, what attributes an element can have, and so on - and if an XML processor can perform validation, it can check your document and head off problems. How XML is Used in the Real World XML sublanguages like MathML are called XML applications.

Mathematical Markup Language, MathML, was designed to let people embed mathematical and scientific equations in Web pages, which can be found at its W3C's specification. the Amaya browser can support MathML. Chemical Markup Language, CML, lets you view three-dimensional representations of molecules in a Jumbo browser. Synchronized Multimedia Integration Language, SMIL, lets you customize multimedia presentations, which can be found at its W3C's specification. Extensible Hypertext Markup Language, XHTML, makes HTML more rigorous and let you extend it with your own tags. XHTML is HTML 4.01 (the current version of HTML) in XML form. In other words, XHTML is simply an XML application that mimics HTML 4.0 in such a way that you can display the results - true XML documents - in today's Web browsers, as well as extending it with your own new elements. Writing XHTML is a lot like HTML, except that you have to adhere to XML syntax (which means, for example, that every element has a closing tag). HTML+TIME, is another XML application, which was created by Microsoft, Macromedia, and Compaq as an alternative to SMIL for multimedia alternative. Scalable Vector Graphics, SVG, is a W3C-based XML application, which revolves around graphics. However, Microsoft had its own XML-style graphics languages for Internet Explorer, Vector Markup Language, VML, followed by its DirectAnimation tools. The XML-based Simple Object Access Protocol, SOAP, was created to make communication between Web applications easier. SOAP defines a widely accepted lightweight XML protocol that lets you send messages between Web applications, no matter what language such Web applications might have been written in.

Using XML: Mircosoft's .NET Components in .NET use XML to communicate, often even when they're on the same machine. You don't usually see the XML in .NET, but each time you communicate between components, it is there. Online XML Resources W3C's main XML site. The W3C activity page listing what's going on with XML these days. Features a mini-tutorial called "XML in 10 Points". The W3C outline and overview of CSS programming. Packed with XML resources, discussions, and schedules of public events. A free XML tutorial. Microsoft's XML tutorial in ten lessons. An XML tutorial from XMLFiles.com Webdeveloper.com's XML tutorial A comprehensive FAQ list about XML. An XML schema tutorial by Roger L. Costello.

Service targeting to China / Chinese market

2005-06-07T12:50:00.000+01:00

I heard the Chinese version of Engadget firstly from Jan's Tech Bolg. Later, I read the following comment from The Blog Herald:

He states in his post that the new site will lose money but is an interesting experiment in launching into non-English speaking markets. Personally, I think he is either fibbing, or reading the marketplace wrongly. Firstly, Jason Calacanis doesn’t enter marketplaces he doesn’t think he can’t make money from, so in this regard, the new site might be a longer term investment, but it will eventually be successful and make money; secondly he talks only of the Chinese mainland market but conveniently ignores the massive market in Chinese language services through out the world. Even here in Australia there are numerous Chinese language local newspapers and services catering to the local Chinese community: even Telstra publishes a copy of the Yellow Pages in Sydney in Chinese. The same goes throughout the world, large Chinese speaking populations in Canada, the West Coast of the United States, even New Zealand: and guess what, demographically they are more likely to be well off, educated and computer users, and therefore potential markets for the Chinese language version of Engadget. A blog just for China? we don’t think so.

I'd like to see the trend of regarding China / Chinese market more and more.

Notes of Effective C++ 2nd Edtition (II)

2005-06-06T01:09:00.000+01:00

Item 7: Be prepared for out-of-memory conditions Deep in your heart of hearts, you know that handling out-of-memory exceptions is the only truly moral course of action. A strategy relies on the convention that when operator new cannot satisfy a request, it calls a client-specifiable error-handling function - ofen called a new-handler - before it throws an exception. So, the solution is: in the header <new>;

typedef void (*new_handler) (); new_handler set_new_handler(new_handler p) throw();

new_handler is a typedef for a pointer to a function that takes and returns nothing; set_new_handler is a function that takes and returns a new_handler; set_new_handler's parameter is a pointer ot the function operator new should call if it can't allocate the requested memory. The return value of set_new_handler is a pointer to the function in effect for that purpose before set_new_handler was called. The usage of set_new_handler like the following:

// function to call if operator new can't allocate enough memory void noMoreMemory() { cerr << "Unable to satisfy request for meomry\n"; abort(); } int main() { set_new_handler(noMoreMemory); int *pBigDataArray = new int[100000000]; ... }

A well-designed new_handler funciton must do one of the following:

Make more memory available; Install a different new_handler; Deinstall the new_handler; Throw an exception of type std::bad_alloc; Not return.

A mixin-style base class is useful by combination of both inheritance and templates to create reusable codes. More comments: 1. There is a version of operator new continues offer traditional (Until 1993) failur-yields-0 behavior. This form is called "nothrow", which is defiend in the standard header <new>. However, to handle memory allocation failures, the easiest way is to take advantage of set_new_handler, because it works with both forms. e.g.

class Widget { ... } Widget *pw1 = new Widget; // throws std::bad_alloc if allocation fails Widget *pw1 = new (nothrow) Widget; // return 0 if allocation fails

2. It is a lot more attactive than wrapping every use of new inside a try block. Item 8: Adhere to convention when writing operator new and operator delete. (coming...) It's not quite that simple, however, because operator new actually tries to allocate memory more than once, calling the error-handling function after each failure, the assumption being that the error-handling function might be able to do somthing to free up some memory. Only when the pointer to the error-handling function is null does operator new throw an exception. In addtion, the C++ standard requires that operator new return a legitimate pointer even when 0 bytes are requested. pseudocode for a non-member operator new looks like this:

void* operator new(size_t size) // your operator new might take additional //params { if (size = 0) { size = 1; } while (true) { attemp to allocate size bytes; if (the allocation was successful) return (a pointer to the memory); // allocation was unsucessful; find out what the current error-handling function is new_handler globalHandler = set_new_handler(0); set_new_handler(globalHandler); if (globalHandler) (*globalHandler) (); else throw std::bad_alloc(); } }

Item 7 remarks that operator new contains an infinite loop, and the code above shows that loop explicitly - while (true) is about as infinite as it gets. The only way out of the loop is for memory to be successfully allocated or for the new-handling function to do one of the things described in Item 7: make more memory available, install a different new-handler, deinstall the new-handler, throw an exception of or derived from std::bad_alloc, or fail to return. It should now be clear why the new-handler must do one of those things. If it doesn't, the loop inside operator new will never teminate. Given an operator new for a class X, the behavior of that function is almost always carefully tuned for objects of size sizeof(X) - nothing larger and nothing smaller. The C++ standard works in mysterious ways, and one of whose ways is to decree that all freestanding classes have nonzero size. By definition, sizeof(Base) can never be zero (even if it has no members). The conventions for operator new and operator delete (and their array counterparts) are not particularly onerous, but it is important that you obey them. If your allocation routines support new-handler functions and correctly deal with zero-sized requests, you're all but finished, and if your deallocation routines cope with null pointers, there's little more to do. Add support for inheritance in member versions of the functions, and presto! - you're done. Item 9: Avoid hiding the "normal" form of new. Item 10: Write operator delete if you write operator new. A common way for operator new to tell operator delete how much memory it allocated is by prepending to the memory it returns some addtional data that specifies the size of the allocated block. For small objects, this additional book-keeping data can more than double the amount of memory needed for each dynamically allocated object (especially if the class containes no virtual functions). It is easy to be fast when you don't have to be flexible. So one way to implement your class-specific operator new is to ask the default operator new for big blocks of raw memory, each block of sufficient size to hold a large number of class objects. The memory chunks for objects, which will be organized in to a linked list, will be taken from these big blocks. The problem is that operator new (the one defined in class) returns a pointer to memory without any header information, but operator delete(the default, global one) assumes that the memory it is passed does contain header information! Surely this is a recipe for disaster. The general rule: operator new and operator delete must be written in concert so that they share the same assumptions. If you're going to roll your own memory allocation routine, be sure to roll one for deallocation, too.

// operator delete is passed a memory chunk, which, // if it's the right size, is just added to the front of // the list of free chunks

Be aware of any semantic mismatch between new and delete. And note that if you omit virtual destructors in base classes, operator delete functions may not work correctly.

A memory leak arises when memory is allocated, then all pointers to that memory are lost. Absent garbage collection or some other extralinguistic mechanism, such memory cannot be reclaimed.

Nevertheless, the blocks of memory returned by ::operator new are never released by ::operator delelte, and there has to be some name for that. There is. You've created a memory pool. But there is an important difference between a memory leak and a memory pool. A memory leak may grow indefinitely, even if clients are well-behanved, but a memory pool never grows larger than the maximum amount of memory requested by its clients. It's interesting to see how custom memory management routines can improve program performance, and it's worthwhile to see how such routines can be encapsulated inside a class.

Notes of Effective C++ 2nd Edtition (I)

2005-06-03T14:30:00.000+01:00

Item 1: Prefer const and inline to #define In particular case, inline can not fully instead of #define conveniently. e.g. #define FIT(i) gsl_vector_get(s->x, i); I met some problem in revising the above macro with inline: template <class T> inline T FIT(T i) { return gsl_vector_get(s->x, i);} Item 2: Prefer<iostream> to <stdio.h> If you #include <iostream>, you get the elements of the iostream library ensconced within the namespace std, but if you #include <iostream.h>, you get those same elements at global scope. Getting them at global scope can lead to name conflicts. Item 3: Prefer new and delete to malloc and free Given that malloc and free are ignorant of constructors and destructors and that mixing malloc/free with new/delete can be more volatile than a fraternity rush party, you're best off sticking to an exclusive diet of news and deletes whenever you can. Item 4: Prefer the same from in corresponding uses of new and delete When you use new, two things happen. 1. memory is allocated via operator new. 2. one or more constructors are called for that memory. When you use delete, two other things happen. 1. one or more destructors are called for the memory. 2. memory is deallocated via operator delte. SO If you use [ ] when you call new, you must use [ ] when you call delete. If you don't use [ ] when you call new, don't use [ ] when you call delete. e.g. string *stringPtr1 = new string; string *stringPtr2 = new string [100]; ... delete stringPtr1; delete [ ] stringPtr2; Try to avoid the confustion intruduced by typedef by using of STL string and vector. Item 6: Use delte on pointer members in destructors Adding a pointer member in a class always requries each of the following: 1. Initializaiton of the pointer in each of the constructors. If no memory is to be allocated to the pointer in a particular constructor, the pointer should be initialized to 0 (i.e., the NULL pointer). 2. Deletion of the existing memory and assignment of new memory in the assignment operator. 3. Deletion of the pointer in the destructor. Note that deleting a null pointer is always safe. Your class destructor usually shouldn't be using delete unless your class memebers were the ones who used new in the first place.

Does Future Belong to China

2005-06-02T23:39:00.000+01:00

Have a look at this article.

Test of Drop and Blog Design using CSS

2005-06-02T15:37:00.000+01:00

Blog Trashed by Mandarin

There was a post I saw recently that had near perfect balance. It was not in English so I was looking more at the layout than reading. What I noticed was the fine balance of the three simple classes to coordinate the image with the dropcap and the pullquote. ...you don't have to know CSS to use this one It was very nicely done. It looked something like this post. We are using shorthand CSS here. Using shorthand notation can help keep the size, or weight, of the page to a minimum if the style sheet is growing. For readability we tend to leave our CSS style long and the style sheet is growing too fast. Either way works. And, no you don't have to know CSS to use this one. It's served copy-and-paste style and with the external CSS.

Blogger Weapons I : BSP

2005-06-02T10:59:00.000+01:00

BSP is short fro Blog Sevice Provider. BSP provides a novel blogger blank paper and well-aided blogging environment. Moreover, each blog has a unique domain name to be accessed by public, meanwhile, the control pane or the blog edittting interface is different with that blog domain name. e.g. Blogger.com is one of the most famouse BSP abroad, which is sold to Google recently. It provides free blog service. I registed an account and established 2 blogs of my own. One is Cherub in Sheffield, the other is Cherub in Movie. By dashboard, it is easy to choose one of my blog to do modifications, such as adding new post, changing template. To some extent, template is where to depict your own, as well as to utilize the "Blogger Weapons". Some BSP does not support user to modify the templates, such as MSN Space. Though it has provided rich options of themes, it is not suitable for bloggers who are going to pursuing higher lever application and progression. It is easy to find a BSP to start one's blogging life. But it is difficult to make decision to keep in one BSP. Blog is a creative work for anyone. People want their blogs to be read. Similar to writing diary, no one is gonna write his feeling in 5 or even more notebooks seperatedly during the same period. A short while after one starts blogging, he will consider how to publish his blog, how to improve his blog. So the flexibility of a BSP is the second to be reviewed. Actually, it is also an object of BSPs to try to save the user's honesty. Obviously, it is up to one himself. Since there is no problem in finding a blogging service (in deed, nearly every public web service provides blog nowdays), I won't do more ads here. One thing to mension that, if the following chapters of this topic is interesting to you, please make sure you could modify your blog beyond posts themselves. Template editable is the least required. By accepting the service from BSP, you are blogger now.

GMail SWAP

2005-06-02T00:18:00.000+01:00

I can not believe that GMail swap is still a hot hit of current internet. As I known, gmail account is much easier to obtained compared with Wallop account. Now, the gmail invitation of one exisited account is up to 50, from 6 at the very beginning. It won't be a problem to leech a gmail account indeed, I suppose. And, my goodness, gmail account even is being sold on EBay. Perhapys, only the account cherub@gmail.com is the most valueble one. Maybe it is worth $1 for me. However, I'd like to provide another little gmail swap chances. Leave me a comment, no swap necessary, however, if you like, a postcard is prefered. :-P Meantime, Wallop invitations are also available, though they are very rare.

XFN - Relationship behind the links.

2005-05-27T14:13:00.000+01:00

A article clearly introduced an interesting topic: XFN, which is short for XHTML Friends Network. XFN is suitable to mark the blog-roll of your webpage or blogs. Supported by CSS2, each link with different groups of tag, which demostrate the human relationship behind the links, may display variantly in style. A very simple example is:

The attribute rel indicates the relationship between Josh and me. The value of rel can be as rich as your creativity. If the browser supports the CSS2, adding the following code in style definition, the above links may display different styles according to atrribute rel.

a[rel~="friend"] {font-weight: bold;}

a[rel~="co-worker"] {text-decoration: underline;}

a[rel~="acquaintance"] {font-style: italic;}

so the above links will look like:

Josh Kat Mary

More details and applications of XFN can be found in http://gmpg.org/xfn/. See the sidebar of my blog that links to my other blogs look different (color) with the link to Jie's blog. Glad that Blogger's template is editable and flexible to adapt to these new things.

BackPackIt -> AJAX

2005-05-26T22:40:00.000+01:00

CheDong's BackPackIt试用手记 lead me to BackPackIt to feel what's online interaction experience. The claimed nice user-friend does not impress me. But the fluent web online interaction, such as adding or deleting a checkbox control, highly spur my interest. The technology behind is called AJAX. I found the definition and explicit introduction of AJAX in Wikipedia, (it seems that Wiki is another thing links me to explore in). Moreover, another reference attacted my click. Jesse James Garrett's Ajax: A New Approach to Web Applications. Nothing could be better to write down reading notes as soon as possible. Here I am right on the money. AJAX is short for Asynchronous JavaScript and XML. AJAX isn't a technology. It's really several technologies, each flourishing in its own right, coming together in powerful new ways. Ajax incorporates: * standards-based presentation using XHTML and CSS; * dynamic display and interaction using the Document Object Model; * data interchange and manipulation using XML and XSLT; * asynchronous data retrieval using XMLHttpRequest; * and JavaScript binding everything together. An Ajax application eliminates the start-stop-start-stop nature of interaction on the Web by introducing an intermediary — an Ajax engine — between the user and the server. It is not necessary for user to exchange the whole webpage contents with server at every request step. XML is in charge of demostrating received page contents. Javascript runs as much applications in user peer as possible, unless they require transfering data to and from the server peer. XMLHttpRequest performs asynchronous data transfering with server and Ajax engine. It may mean the asynchronous procedure between transferting data and displaing the content. So, user takes part in the online application instead of traditional waiting. Good AJAX experiences can be obtained from Google Suggest, seeing how it dymanically recoginize your input key words. From Google Map, you may have a look at how AJAX does well in such a huge online project. Criticisms come while thing is well known. However, most of them are advantage in understing a new burn techique or an idea through different aspects. The accessibility of Ajax and the browser compatibility limitations.

Can Ajax applications be made to work for users who have JavaScript turned off?

Security considerations with Ajax development.

Are Ajax applications easier to develop than traditional web applications? Compared with FLASH, which tech is more suitable for next generation web application. (See Microsoft's Wallop) (If you ask for a Wallop invitation, leave me a message.)

The biggest challenges in creating Ajax applications are not technical. The core Ajax technologies are mature, stable, and well understood. Instead, the challenges are for the designers of these applications: to forget what we think we know about the limitations of the Web, and begin to imagine a wider, richer range of possibilities -- Jesse James Garrett

Farewell, Google Adsense

2005-05-26T00:42:00.000+01:00

Yesterday, email from Google Adsense manager board stopped the coming PIN code and check. I admitted the fraud clicks that it is my original target to test Googl Adsense to earn extra money. Many trials have been done such as increasing impressions and clicks, actively updating blog's content to change ads, using auto proxy switcher to mimic different IP clicks. The most effective way is the last one. So, it is clear that the traffic is the base point to earn via Google Adsense. I think it is very easy to detect my clicks are fraud that they are times over visits. Happy things include checking the balance every day and discovering the ads content changed. However, they are all gone now. Nevertheless, it is not depress my interesting in blog. I'd like to stick in my won field to product paragraphs, recording my dymatically varied interests, experiences, and lives. Farewell, Googld Adsense. Farewell, extra money.

Six Degrees of Ocean's Eleven

2005-05-21T15:23:00.000+01:00

While I was writting my movie blog of Ocean's Eleven, I found an interesting key-word, SIX DEGREES, in imdb. Started from any actor or actress, end in the one stared in Ocean's Eleven For instance: Nicolas Cage was in Con Air with John Cusack who was in Americas Sweethearts with Julia Roberts who was in Oceans Eleven. another interesting result:

Valuable keywords

2005-05-21T12:54:00.000+01:00

COPY from rumata's blog, very interesting. However, I am puzzled how could she find out these high payed key words. :-D "increase web traffic" "pay per click affiliate program" "pay per click uk" "pay per click" "pay per click management" "pay per clicks" "increase web traffic" "pay per click bid management" "increase traffic" "pay per click ads" "pay per click advertising" "web traffic" "earn money" "pay per click through" "search engine registration" "pay per click program" "website promotion" "pay per click optimization" "web position gold" "more customers" "affiliate programs" "pay per click search" "search engine submission" "web site promotion" "search engine submissions" "search engines ranking" "get listed" affiliate "search engine ranking" "high search engine ranking" "getting listed" "website ranking" "pay per click management software" "domain name hosting" "domain name" "domain names" "buy domain name" "buying a domain name" "buying domain name" "cheap domain name" "domain name register" "domain name registration" "domain name renewal" "domain name reseller" "how to register a domain name" "register a domain name" "register domain name" "domain name search" "buy domain names" "buying domain names" "cheap domain names"

SNS and 6 Degrees of Seperation

2005-05-21T11:33:00.000+01:00

SNS：Social Network Sofwaret，社会性网络软件，依据六度理论，以认识朋友的朋友为基础，扩展自己的人脉。并且无限扩张自己的人脉，在需要的时候，可以随时获取一点，得到该人脉的帮助。 SNS网站，就是依据六度理论建立的网站，帮你运营朋友圈的朋友。事实上，在过去Yahoo、Google和微软对社会性网络(SNS)都已经投下巨资， Yahoo的社会性网络项目叫Yahoo360，Google的名为orkut，而微软正在试验的社会性网络项目叫Wallop，目前中文的SNS则主要是联络家(Linkist.com)、优友地带等。However, joining these SNS virtual communities requires an invitation from their members. I've faild to find out the invitation for Wallop for several times. I am suprised to hear that the SNS website is established according to 6 degrees of seperation theory. As I known, several kinds of softwares can be regarded as SNS, such as IMs, webmails, and etc. Six Degrees of Seperation, 六度关系理论：美国著名社会心理学家Stanley Milgram于20世纪60年代最先提出，在人际脉络中，要结识任何一位陌生的朋友，这中间最多只要通过六个朋友就能达到目的。就是说你想认识一个人，托朋友找朋友找认识他的人，之间不会超过六个人. Most recently, about 2003, a new Stanley Milgram's test by internet email revealing that internet, being a new tools binding people all around the world almost without gap, does no help in decreasing the number of degrees of separation between people. I am also interested about the above conclusion. It may not be rigorously proved even by the combination of mathmatical, statistical and social theories. But, it is irony to refer to social theories, since 6 degrees theroy is one of them... SNSs only provided a platform or a virtual society to group as much people together as possible, however, it does not guarantee every one in this group knows each other. 6 degrees theory is used as a kind advertisement for tempting users interest and making SNSs specially valuable compared with traditional connections. Moreover, the topic may be diverted to the recent hot hit: MSN vs QQ in Chinese IM market. Some said QQ is definately lost to MSN. The others said MSN is adpating itself to meet Chinese hobbies. Keep an eye on it, since it would be very interesting.

Very Interesting weblink-typo

2005-05-20T21:45:00.000+01:00

http://www.tabao.com/!!! :-D

Blogger and the traditional media:

2005-05-17T16:31:00.000+01:00

A recent survey showed that web blog has performed the equal function to the tradional media, such as newspaper, TV, and etc. However, web blog is not going to take place of those traditional ones. Web blog and the traditional media are good complement to each other.

blog营销真的开始了？

2005-05-14T15:56:00.000+01:00

博客营销　　理论界对哪种手法算真博客营销，哪种是伪博客营销有些争论。这里不去考虑。从营销角度，商家和消费者之间的一切都是工具。既然视野中多了一样网络行销工具。我们权且把所有利用博客进行的各种产品、品牌、形象等的营销称为博客营销。　　博客营销模式“集中营” 　　1.在博客网站上做广告。　　在博客世界，标准的、口号式的广告，就仿佛是鸡尾酒会上的大声叫唤。广告的设计要把博客考虑进去，要让博客成为广告对话的一部分。　　2.发表专业文章。　　作为专业文章的主角——产品一定要有一个知识点，用来和公众沟通，并树立权威感。　　3.打造博客团队。　　通过公关公司发布博客日记，来影响主流媒体的报道。　　4.监测博客网站。　　通过监测博客网站，及时发觉当前谈论最多的公司或时下民众最关注的话题，为潜在的公关危机做好准备。

Add-in My Blog

2005-05-13T00:17:00.000+01:00

"Feed of my blog" by Feedburner "Alter Me funciton" by MSN Alert. However, it seems not workable. "Add feed of my blog into My MSN". "Visit counting and statistic" by Site Meter. "Visual visit counting" by Bravenet More add-in and advanced developing are coming.

Blog, Blogger and Commercial Pattern

2005-05-12T13:55:00.000+01:00

Actually, it is the commercial potential of blog largely excited my interest in the relative technical regions. POTENTIAL at least means two aspects: ONE is that blog is presenting a new market, which has prepared several basic factors, such as service provider, blog website and thousands of hundreds of clients, blogger. THE OTHER is that besides the traditional web commercial pattern, such as web ad, blog has not clearly figured out a direction on earning money for investments. Today, keso posted a article talking about the commercial topic of blog. I recorded some relative references hereby. 1. 所以，从本质上说，网民对传统网站是索取，而对博客网站却是给予，索取必有代价，而给予却没有（即使这种给予是建立在博客网站提供平台的基础上），这就是博客网站与传统网站的主要差别，也是为什么博客网站兴盛了几年仍找不到盈利模式的原因。毕竟，博客的核心是自由、个性、张扬以及参与，它的魅力就在于其非商业化，就在于其不经包装的真实性，所以，博客从根本上就排斥商业（虽然它有着巨大的商业价值），即使商业进驻了博客阵地也会水土不服的。 2. 所以，鉴于目前blog的盈利模式大家还都在摸索阶段，要支撑博客中国继续做下去，必须吸引更多的投资进来，但目前无法拿收支盈余来说服投资方的话，只有从规模上讲故事，因而选择blogcn坐下来谈合并，也不是什么意外之事了。 blogbus最大的对手不是其他的BSP，是我们自己——如何保持自身的特点和优势、提供更多更好的服务给用户、不断超越自己，这才是blogbus所面临的真正问题。 3. 如果孤立地来看blog，它是什么，它也许就是网志。但是如果你把文字blog、图片blog、网摘、rss、wiki、广告插件、即时通讯插件、统计插件、图片链接插件、模板，等等等等串起来看，你会发现它们之间衍生和互相依存的关系。但是以blog为核心所展开的模式却是，blogger出内容，blog站出空间，google出广告，天天网摘出标题链接，Flickr出图片，CC创作共享出法律保护，rss出通知，统计网站出统计数据...除了提高了效率之外，网站经营模式的这种转移到底意味着什么 4. 博客世界融资、收购情况不完全汇集 5. Blog那是Internet上的文化大革命，破坏多于缔造，个人感情冲动胜于理智购物选择，想造反闹事出名容易，比如木它一下子美。想赢利，等等2008年先。 6. 我一直闹不明白，为什么很多人会把提供Blog服务的商业服务和blog与商业这个话题联系起来。在我看来，这就好比平面出版繁荣，于是有人跳出来说纸张产业是下一个商业神话，或者电视节目产业的兴旺，有人因此说电视制造业是下一个神话。很可笑。在他们看来，所谓的Blog，仅只提供Blog服务的网站/机构，他们眼里，根本就没有Blogger个人，即便有，也是构成Blog的一个分子而已，是为Blog服务商创造价值的奴隶。 7. 博客无疑有着美好的前景，但它只属于作为blogger的方兴东们，而不属于作为网站管理者和经营者的方兴东。博客能吸引网民们的眼球但不能让他们自愿掏钱，这就是商业价值与盈利模式的矛盾之处，也是所有想投资博客、经营博客的人们不能不面对的现实。 8. 而今国内的博客托管站基本上都处于烧钱阶段，而烧钱是为了积聚人气、探询出路并最终赢利，对于商人与资本而言概念永远只是一个赢利商业化的工具而已。商业化可能腐蚀一些博客本真的东西，混入一些传统的垃圾，但这并不能成为阻挡博客商业化、求生存的步伐。只有到了平民化、大众化阶段，这些模式才可能发挥网络注意力经济、眼球效用的特性，才可能成为一种持续的、明确的赢利模式。撇开用户谈应用与撇开用户谈模式都一样，都是水中花，雾中月而已。 9. 电视节目那么多，但广告一多，各个怨声载道，于是没有广告的数字电视开始大行其道，其实钱照样赚，让你烦他赚了一票，不让你烦他又赚了一票。 BLOG还是不如传统媒体成熟，它出不来南方周末，出不来体坛周报，它有媒体的气质，却没有媒体经营的思路。 DONEWS，有自己的圈子和风格，还有网摘，一赞。 UUZONE，有广泛的合作思路和好的领导人，一赞。万碟移动博客，有PDA和手机应用渠道，一赞。其他的……有待发现吧。你有技术，是最不值得一牛的东西，你有应用吗？ 10. 曾经被少数批评家喻为“拾人牙慧”的博客，在中国发展状况，不仅引起处于转型期传统媒体的注意，更受中国互联网草根族欢迎。现时情况下，是中国的“博客们”开展转化商业模式行动的时候了 11. 实际上，同传统媒体或IT新闻网站抢夺新闻，并非博客网站的核心价值。博客网站最大的价值就是能吸引特定客户，并建立很好的忠诚度。尤其是一些优秀博客，可以吸引该领域最有影响力的群体。对于那些急于想打开市场或是关注高科技受众的行销商，这无疑是博客最大的商业价值所在。博客中国就表示自己目前并没有成熟的盈利模式，其主要的收入将来自三个方面：广告收入、无线增值服务和向博客用户提供增值服务和应用程序收取的服务费。 12. 在社会观察家看来，blog重新划分了传统世界的权利格局，帮助草根阶层赢得更多的社会话语权；在媒体从业者看来，blog意味着充满活力的崭新的媒体形式，借助聚合链接功能，blog使信息传播更直接更迅捷；在博客们的眼中，blog则是表达、分享、管理自己思想的工具，代表了互联网时代新的生活态度和生存状态。正是由于这些丰富而迥异的解读，博客世界才如此的五颜六色，引人入胜。而站在商业角度观察，蓬勃发展的blog已经具备商业运作的基础，blog工具所体现出的及时、交互的特点，以及blog内容传播的广度、深度，无不蕴藏着巨大的商业价值。也许正因为如此，商业Blog的发展速度出乎所有人的意料，无论是商业模式介入blog本身，还是blog工具介入商业运作，都正迅速变为现实。增值服务是blog服务商保留用户并实现收费的重要手段。blogbus正在探索企业blog应用、移动blog等商业创新领域，为用户提供高附加值的产品，例如域名绑定、功能分类、移动发布等等。不过，blog媒体商业模式在中国还没有取得足够的进展。国内一些知名媒体从业人员的blog已经形成blog媒体的雏形，但如何走向商业化尚在争论之中。 13. 目前可以想象的博客网站赢利方式，不足以支撑专业博客网站的生存。“它的收益来源具有不可靠性。” 虽然博客爱好者每天制造了大量信息，但这些信息的价值量和含金量有限，能够具备文字加工能力，并使之推广的，只是其中的极少数，大量博客文章仍然无法产生社会效益。因此，它只能是一个信息发布平台，而无法成为媒体。当网站尚无收益时，网民会默认网站帮其扩散影响力，但当见到收益时，则会因为版权问题，使得这种模式难以实现。张林强认为，中国的博客爱好者的持续度是有限的，绝大多数网民不会是文字专业制造者，当热潮过去，更多网民只会成为读者，而不是作者。张同时认为，未来的博客形式的发展目前还很难预料。随着新技术的产生，未来的博客，也可能不仅仅是目前的以文字和图片形式来表现。

Tag and Links amone lines

2005-05-12T01:45:00.000+01:00

"Tag is so hot these days", which comes from keso's blog in Jan. 2005. Till now, I think I've made it clear that it is del.icio.us spurred the idea of "Tag". Moreover, I can only add one of my comment of the links inside the paragraph of blogger's articles. Such links may reflect that the blogger wrote the blog with full heart that he/she provided the relative references as much as possible. However, I alwasy been diverted by these links, since I can not help find out what happend behind these characters with underline. My point is that, in current internet environment, information has boomed without any control. I have to carefully pick up very few famous or valuable websites or blogs to leech desired information, e.g. I am interested in RSS and blog techniques, so I chose the hottest blogs, such as keso's blog and etc. However, even when digging into these special choices, I was tempted by willing of longing for the knowledge with intact structure and those links emerged among lines. For instance, When I was reading the artiles named "Tags对于搜索引擎的作用远大于个人" in Ding Deng's Weblog for some information about "Tag", I was drawed by a single phrase "Getting Things Done" to keso's blog. Then, I could not stop to click some of other links from keso's articles. Suddenly, I realized such a problem occuring. What I've done now is only type this problem here. RSS may do well in syndicate the information. However, we are far away from information integration or information fusion. If it realized, it is not necessary any more for me to click links to dig more relative but only seemly valuable sources, in cost of wasting more time. Sorry for that I still conserved so many links inside my post. It's only my respect to those famouse and hottest bloggers.

New Touches

2005-05-11T19:00:00.000+01:00

Recent days, I am very interested in techniques relative to RSS. After browsing sever blogs interior and abroad, it is no doubt that RSS is the hottest topic now exchanged around the whole blog world. In terms of the applications of RSS and potential commercial opportunities, people expressed different ideas and digged into nearly every espects of present RSS. The RSS is firstly introduced years ago, it's my first time to re-touch the peak of current web techniques after so many years hide inside the academic stuffs. So, some terms appear in the literatures with very high frequency still confuse me a lot. Since no more free time can be spent on searching all of them explicitly one by one, I have to record them down here to reminde me. In addition with the unavoidable project research, it is necessary to come to these web-tech closer. The unknown or not familiar terms includes (maybe some of them are web application or web service provider, which are all in my continuous attention): XML LinkBlog Tag XML/RPC FeedBurner XSLT Attention.XML TechnoRati SNS Analysis Lucene Wiki OPML Amazon's Life version BSP (Blog Service Provider) del.icio.us Google News Feed Scraper RRSmix.com FEDEX PACKAGES persistent search delivery Videoblogger online bookmarks (services) SPAM location-tagged photos Bloglines in addition with GMail WEB LOG HillTop searching algorithm Moreover, I'd like to record my study notes (they can not be regarded as RESEARCH now) later.

My Project

2005-05-10T16:55:00.000+01:00

I've seen Jie illustrated his project on his blog, I can not help post mine as following. Occlusive vascular (e.g. arteriosclerosis) disease is a major and growing health problem worldwide. Traditionally, bypass surgery has been used on this condition but is ultimately unsatisfactory because it does not produce a cure. New drug treatments have attracted much research interest but a key obstacle here is the lack of any objective methodology for assessing the effectiveness of these treatments (before and after studies). The aim of this project is to work closely with clinicians at the Sheffield Vascular Institute to establish an methodology to quantitatively assess occlusive vascular disease from the X-ray angiograms which are routinely acquired from patients. This will require the development of novel image processing algorithms to segment the arterial network and estimate its blood carrying capacity using maximal flow graph algorithms. We anticipate this methodology will be important to advancing research in drug treatments and possibly, the routine assessment of patients.

Tough, but Happy

2005-05-08T00:31:00.000+01:00

What tough days these days. Though I welcomed my wife to join my difficult life abroad, so many pressures come together around. The agenda of tomorrow is nearly fully filled. I can image the same thing would happen to my calendar in the following weeks. Nevertheless, I should carefully arrange my timetable to fit the busy work, life and leisure time. COME ON!

Pick up my wife tday

2005-05-04T00:00:00.000+01:00

JUST FOR MEMORY

newSMTH

2005-05-02T16:02:00.000+01:00

The most recently, good news come that newSMTH, which is nearly the whole copy of the SMTH except boards of departments, is alive. I have luckily activated my IDs. Then, I sent a group mail to THU-UK to say that I'd like to help friends on activating there IDs. Till now, I've helped more than 20 IDs alive. Hopefully I could do more! Nevertheless, losing SMTH is still painful.

What's Google AdSense?

2005-05-02T01:47:00.000+01:00

Recently, by chance, I toughted with RRS. Then, I browsed lots of articles about it, and part of my interest extended to the Google AdSense. Thought I've not understand what's the techniqual relationship of Google AdSense and RRs, luckily my application has accepted by Google and its AdSense has appeared on my bolg here. I'm going to spend some days tying to dig into it. What's it. How does it work. What's insight techniqual details. Nevertheless, I have to admit that I am and will be very busy these days. I don't know how many space and time left for me to extend a little tiny bit my interest! Actually, Blog, RRS... these words are so new to me that I am feeling of being behind of the time. Once, I was so exeprienced in such internet words, even techniques. But NOW...

My MSN SPACE

2005-04-28T14:18:00.000+01:00

See 184 Euro trip pics on my msn space. http://spaces.msn.com/members/sg71cherub/

CHERUB in PHD

Report A Google Shut Down

12.01.2005 - 14.01.20005 What's DONE

08.01.2005 - 11.01.2005 What's DONE

05.01.2006 - 07.01.2005 What's DONE

04.01.2006 What's DONE

03.01.2006 What's DONE

31.12.2005 - 02.01.2006 What's DONE

30.12.2005 What's DONE

29.12.2005 What's DONE

22.12.2005 - 28.12.2005 What's DONE

21.12.2005 What's DONE

20.12.2005What's DONE

19.12.2005What's DONE

The Nerd? Geek? or Dork?

16.12.2005 - 18.12.2005 What's DONE

14.12.2005 -15.12.2005 What's DONE

13.12.2005 What's DONE

12.12.2005 What's DONE

11.12.2005 What's DONE

10.12.2005 What's DONE

09.12.2005 What's DONE

老婆怀孕日记 （Week 18)

04.12.2005 - 08.12.2005 What's DONE

02.12.2005 - 03.12.2005 What's DONE

28.11.2005 - 01.12.2005 What is DONE

25.11 - 27.11. 2005 What is DONE

24.11.2005 What is DONE

23.11.2005 What is Done

22.11.2005 What is DONE

老婆怀孕日记(Week 14)

老婆怀孕日记 (Week 14)

老婆怀孕日记 (Week 14)

老婆怀孕日记(Week 12)

老婆怀孕日记(Week 11)

老婆怀孕日记（Week 11)

老婆怀孕日记（Week 11）

老婆怀孕日记 (Week 11)

Teach Yourself XML in 21 Days, Day 14

Teach Yourself XML in 21 Days, Day 13

Teach Yourself XML in 21 Days, Day 12

Teach Yourself XML in 21 Days, Day 11

Teach Yourself XML in 21 Days, Day 10

Teach Yourself XML in 21 Days, Day 9

Teach Yourself XML in 21 days, Day 8

Teach Yourself XML in 21 days, Day 7

Teach Yourself XML in 21 days, Day 6

Teach Yourself XML in 21 days, Day 5

Teach Yourself XML in 21 days, Day 4

Teach Yourself XML in 21 days, Day 3

No time

Teach Yourself XML in 21 days, Day 2

Teach Yourself XML in 21 days, Day 1

Service targeting to China / Chinese market

Notes of Effective C++ 2nd Edtition (II)

Notes of Effective C++ 2nd Edtition (I)

Does Future Belong to China

Test of Drop and Blog Design using CSS

Blogger Weapons I : BSP

GMail SWAP

XFN - Relationship behind the links.

BackPackIt -> AJAX

Farewell, Google Adsense

Six Degrees of Ocean's Eleven

Valuable keywords

SNS and 6 Degrees of Seperation

Very Interesting weblink-typo

Blogger and the traditional media:

blog营销真的开始了？

Add-in My Blog

Blog, Blogger and Commercial Pattern

Tag and Links amone lines

New Touches

My Project

Tough, but Happy

Pick up my wife tday

newSMTH

What's Google AdSense?

My MSN SPACE

老婆怀孕日记（Week 18)