Blog On Tech By Kenyth

Common sense: difference between application database and data warehouse

2007-09-03T15:13:00.001+08:00

(This post is a collection of information found available on line)
Introduction

I'm a beginner in this aspect. Basically, an app database and a data warehouse have in common is that they're both databases. However they serve for different purposes.

Diff

cite from resource 1:
The primary difference betwen you application database and a data warehouse is that while the former is designed (and optimized) to record , the latter has to be designed (and optimized) to respond to analysis questions that are critical for your business.

Application databases are OLTP (On-Line Transaction Processing) systems where every transaction has to be recorded, and super-fast at that. An application database system is designed to make sure that every transaction gets recorded within the time users are served.

Data warehouses are designed as OLAP (On-Line Analytical Processing) systems, these databases contain read-only data that can be queried and analyzed far more efficiently as compared to your regular OLTP application databases.

cite from resource 3 (read this resource linked below for a thorough understanding):

A common way of introducing data warehousing is to refer to the characteristics of a data warehouse as set forth by William Inmon:

Figure 1-1 Contrasting OLTP and Data Warehousing Environments

Text description of the illustration dwhsg005.gif

More words on either one

An application database mainly serve for processing real time business data. It shows the whole picture of the business objects world. Every application should normally have an application database to gain any feature concerning persistence. However, a data warehouse is not a must for every business application. It is mainly for analysis of historical (or accumulated) data, and sometimes for real time. Because it is for analysis, it is normally configured as read only for the analysis that is based on it (that is, the end user). In data warehouses there're not only data directly reflecting the status of business objects of some time, but also (and mainly this kind) data derived from business objects data.

data in data warehouse:
Raw data: mappings of business object data
Summary data: monthly statistics
Meta data: day, month, year, etc

Further reading:

Resources

Smartly load your properties

2007-08-05T23:29:00.001+08:00

Method	Parameter format	Lookup failure behavior	Usage example
`ClassLoader. getResourceAsStream()`	"/"-separated names; no leading "/" (all names are absolute)	Silent (returns `null`)	`this.getClass().getClassLoader() .getResourceAsStream ("some/pkg/resource.properties")`
`Class. getResourceAsStream()`	"/"-separated names; leading "/" indicates absolute names; all other names are relative to the class's package	Silent (returns `null`)	`this.getClass() .getResourceAsStream ("resource.properties")`
`ResourceBundle. getBundle()`	"."-separated names; all names are absolute; `.properties` suffix is implied	Throws unchecked `java.util.MissingResourceException`	`ResourceBundle.getBundle ("some.pkg.resource")`

and there're more tips in the linked resource below.

Resources

Smartly load your properties

Difference Between ResourceBundle and Properties Classes in Java

2007-08-05T18:40:00.001+08:00

GMHK wrote:
> Can anyone tell me the whats the difference between the resource bundle
> and Properties classes in java.
> As both uses the .properties file to get the string constants.

No, they don't necessarily. A resource bundly does not have to be
file-based. The common implementation, however is. And that common
implementation (PropertyResourceBundle) indeed uses properties files and
thr Properties class.

However, resource bundles also come with a particular lookup-schema to
select a particular bundle according to the Locale. Something which you
don't get with Properties, but which is important when you do some
actual localization.

> At what point of time would the programmer decide to choose which of
> the either classes.

A resource bundle (properties file based or otherwise) when in need for
the lookup of locale-specific data. A naked properties file when in need
for keeping some small (FSWO) set of data persistent (e.g. application
configuration data), which is not supposed to be translated.

You didn't mention Preferences. I still preferen Properties over
Preferences because of the easy-to-work-with text file format, but they
can be used for the same purpose as Properties, without the need of
having to deal with files.

> What i understood so far is resourcebundle makes uses of String manager
> to get the string.
> where as the Properties tries to read the properties directly.

Both map keys to values. The biggest difference is how they get that
mapping. ResourceBundles follow a build-in lookup schema taking a locale
into account. Properties need to be provided with some InputStream,
which the programmer has to handle explicitely. Properties have an easy
way to be written to an OutputStream, while ResourceBundles are ment to
be read-only.

/Thomas

Resources

Difference Between ResourceBundle and Properties Classes in Java

Multiple Eclipse Installation Management

2007-08-01T12:00:00.001+08:00

Resources

Regular expression and CharSequence in Java

2007-07-27T15:17:00.001+08:00

Introduction
Regular expression, specified as a string, is first compiled into an instance of Pattern. The regular expression constructs supported by Pattern are almost the same (see comparison to Perl 5 in javadoc of class pattern) as that supported by Perl 5. The Pattern engine performs traditional NFA-based (Nondeterministic Finite Automate) matching with ordered alternation as occurs in Perl 5.

The regex Package
Two major class Pattern and Matcher, both of which have non-public constructor which means the client can't new instances of them directly. A Pattern instance is the compiled intermediate representation, plus some helper methods, of the string form regular expression. Instances of Pattern are immutable which means they're thread-safe. And each instance of Matcher, produced by factory method of Pattern, corresponds to each matching between the bound regular expression of the target string ( i.e., the string to be matched). Further information about how to use this package in a program can be found in the resources section.

regex matching in CharSequence
Despite being as part of the java library, the regex package is also used by other parts of the library. These usages are listed below:
boolean String.matches( String regex );
String String.replaceAll( String regex, String replacement )
String String.replaceFirst( String regex, String replacement )
String[] split( String regex )

Note that rather than class String or some other concrete representation of CharSequence, interface CharSequence is widely depended upon both in Pattern and String. Classes implementing CharSequence mainly include String, StringBuffer and StringBuilder. And the implemented methods include such methods that we usually use with String as charAt(int), length(), and subSequence(int, int).

Resources

Tips of Using Escape Characters

2007-07-25T10:25:00.001+08:00

First, what is the differences between '\n' and '\r\n'?

Cite here: )

It goes back to mechanical teletypes; if you issued a line feed followed by carriage return you got a few characters printed backwards in a diagonal stripe because there was insufficient time for the carriage to move back to the left before it started printing. To overcome this, the carriage return is issued first to give the carriage enough time to return, whilst line feeding, before printing started. It has stuck as a standard ever since.

and here:

Different Operating Systems handle newlines in a different way. Here is a short list of the most common ones:
DOS and Windows

They expect a newline to be the combination of two characters, namely '\r\n' (or 13 followed by 10).

Unix (and hence Linux as well)

Unix uses a single '\n' to indicate a new line.

Mac

Macs use a single '\r'.

When string are read from user input, escape character can't be explicitly input. For example, in case which string are read from the command line argument, when the user give argument "hello\nworld", the string read in and stored will be "hello\\nworld". This is because escape characters usually are parsed as format presentation rather than literal occurrence (actually, this is the "unescapted" meaning). For the same reason, in the programming codes escape characters, the literal form of format presentation, are used instead of draw a format presentation that the compiler could understand, which is obviously of non-sense.

Note that using escape characters to specify the format presentation is not the definition of escape character, though in many cases they're used in this way.

Tips on XML Spec

2007-07-24T16:34:00.001+08:00

Which set of characters and their combinations can be used as literals of attribute value?

[10]	`AttValue`	::=	`'"' ([^<&"] \| Reference)* '"'`
			`\| "'" ([^<&'] \| Reference)* "'"`

If double quotes (single quotes) are used to quote the string then the same quotation mark (single-quote character or double-quote character), in addition to the other two characters specified in the above production, can't appear in the enclosed string. But what if one wants to use the same quotation mark as the enclosing ones inside the enclosed string? In this case, """ and "'" can be used instead.

e.g., <xxx yyy="..."..."> incurs errors because of the extra double-quote character, instead, <xxx yyy="..."..."> can be used.

Resources:

xml spec 1.0

TDS: Tabular Data Stream Protocol

2007-07-05T13:26:00.001+08:00

Below cites here:

TDS is a protocol, a set of rules describing how to transmit data between two computers. Like any protocol, it defines the types of messages that can be sent, and the order in which they may be sent. Protocols describe the "bits on the wire", how data flow.
In reading this manual, it may be helpful to keep in mind that a protocol is not an API, although the two are related. The server recognizes and speaks a protocol; anything that can send it the correct combination of bytes in the right order can communicate with it. But programmers aren't generally in the business of sending bytes; that's the job of a library. Over the years, there have been a few libraries — each with its own API — that do the work of moving SQL through a TDS pipe. ODBC, db-lib, ct-lib, and JDBC have very different APIs, but they're all one to the server, because on the wire they speak TDS .
The TDS protocol was designed and developed by Sybase Inc. for their Sybase SQL Server relational database engine in 1984. The problem Sybase faced then still exists: There was no commonly accepted application-level protocol to transfer data between a database server and its client. To encourage the use of their product, Sybase came up with a flexible pair of products called netlib and db-lib.
netlib's job was to ferry data between the two computers. To do that, it had to deal with the underlying network protocol. Remember, in those days TCP/IP was not the ubiquitous thing it is today. Besides TCP/IP, netlib ran on DECnet, IPX/SPX, NetBEUI and the like.
db-lib provided an API to the client program, and communicated with the server via netlib. What db-lib sent to the server took the form of a stream of bytes, a structured stream of bytes meant for tables of data, a Tabular Data Stream.
In 1990 Sybase entered into a technology sharing agreement with Microsoft which resulted in Microsoft marketing its own SQL Server. Microsoft kept the db-lib API and added ODBC. (Microsoft has since added other APIs, too.) At about the same time, Sybase introduced a more powerful "successor" to db-lib, called ct-lib, and called the pair OpenClient.
ct-lib, db-lib, and ODBC are APIs that — however different their programming style may be — all use netlib to communicate to the server. The language they use is TDS.
The TDS protocol comes in several flavors, most of which have never been openly documented. If anything, it's probably considered to be something like a trade secret, or at least proprietary technology. The exception is TDS 5.0, used exclusively by Sybase, for which documentation is available from Sybase.

Resources:

FreeTDS User Guide.

Test publishing from email

2007-07-05T09:52:00.001+08:00

Test publishing from email

Test publishing from email
Test publishing from email
Test publishing from email
Test publishing from email
Test publishing from email
Test publishing from email

Difference among Swing, AWT, SWT and JFace

2007-05-07T00:48:00.001+08:00

Introduction

I know questions like telling the differences among Swing, awt, SWT and JFace or some of them are frequently asked in an interview for Java programmers. I don't use them very often and extensively, nor do I know too much about those four things, especially from the implementation perspective or the guru's best practice perspective. But I do read some materials and figure out some conceptual difference between those four things that I think would suffice answering such questions in an interview.

AWT and Swing

-AWT

AWT stands for abastract window toolkit which comes with an early release of the Java Programming Language ( about 1.1 ). AWT components are referred to as heavyweight components. It is implemented as having "peer" native code for every widget you create. Most of the significant logics (including the core event handling logic) of the toolkit are written in C/C++, for which via JNI (Java Native Interface) your GUI program may directly calls those "peer" native code. It means all of the drawings of your GUI are done directly by the graphic API of the underlying operating system. This implementation underlies several limitations:

Not all the operating system support the same set of native widgets, so a "least common denominator" philosophy is used when shipping the AWT library, that is only a basic set of components are provided as library via which you write your GUI. So no complex components such as slider, tree and table can be found in AWT components, which you have to build yourself either through directly writing native code as AWT is implemented, or through writing Java codes which wraps AWT ( this is the way Swing is implemented).
Because the core logic are hided from you in the native code, debugging your GUI program can be annoying.

This kind of implementation also results in your GUI implemented with AWT always having the same look and feel as the underlying OS.

-Swing

In contrast, Swing components are known as lightweight components, because Swing doesn't implement the underlying drawing and event handling logic which are delegated to the toolkit in this case AWT, on which it is built on. As mentioned above, Swing is implemented by pure Java codes. So it is conceivable that Swing has the portability that AWT doesn't have, and that Swing has almost all the nontrivial complex components. Swing can also have the same look and feel on all OS, and can also be switched to another style of look and feel at runtime regardless of the underlying OS. It is said that Swing has a better performance than AWT, however, from the implementation logic so far I've known, I can't tell why. Swing seems well known for its good design and architecture.

-Never intermix AWT and Swing

I know a lot has been said and written about this subject. The first item in the resources section is a good example of that.

SWT and JFace

-SWT

SWT, short for standard widget tookit, is originally introduced by IBM, as a substitute of AWT. SWT now is as part of the eclipse platform based on which the eclipse GUIs are implemented. SWT is very similar to AWT conceptually, however, the underlying implementation is a little different. Different from implementing all the core logic in "peer" logic in native code, SWT bears a thin JNI layer which is used for directly call the GUI API of each underlying platform. All the significant logics are written in pure Java codes in which the thin JNI layer is used. So almost all the limitations AWT has are elimintated in SWT. Other than this, better performance are gained, for which I don't know the specific reason. As of AWT, SWT has a consisten look and feel as the underlying OS.

Disadvantages of using SWT:

Reuire a native library (This also holds true for AWT).
Low level of abstraction (This also holds true for AWT).

-JFace

JFace is conceputally similar to Swing. The relationship between JFace and SWT is very similar to the relationship between Swing and AWT. It works above the level of raw widgets, in this case, SWT. JFace has a rich set of complex widgets.

Resources

Technorati tags: GUI, SWT, JFace, Swing, AWT, Java, Eclipse

Exception as Non-Exception

2007-05-03T18:31:00.000+08:00

Introduction

Quotes: One of the unexpected benefits of exception handling is better performance because many errors can be processed centrally instead of after each function call. - by Bruce Eckel, the author of Thinking in Java.

-First, what is exception?

In JVM SPEC, an exception is defined to be an error that JVM would signal to a program if a program violates the semantic constrains of the Java programming language. But that’s not the complete fact, more generally, causing an exception is considered to be an exceptional condition or abnormal state that a program is in. So besides violating the semantic constrains of a programming language, which may be a critical and unrecoverable condition, breaking the assumption on the logic functionality of a program can also be considered to be exceptions. From a more formal perspective, every statement, method or generally, module are expected to fullfill some implicit or explicit contract, and an exception indicates the inability to fullfill the contract. Regardeless of the context of the specific programming languge (such as Java) exception handling mechanism, exception and error are interchangeablely used.

-Second, what is exception handling?

Informally speaking, exception handling is what you do about the exceptional condition. However, though an agreement on the defintion of exception are generally achieved, exception handling mechanisms are from time to time debated on. Generally, three techinques / mechanisms / notions are concerning with exception handling. First, exceptions can be identified by returning distinguished error values and handling exceptions is immediately done based on the error values. This is the most conventional way of identifying and handling exceptions. Many large system written in C or most conventional procedure languages utilize this way. Second, exceptions identifying and handling are distinguished from other features that a porgramming language provides. This can be found in many modern OO language such as C++ and Java. An Exception class (or method ?) is and can be designated for each kind of exceptional condition, and special satements with special keywords are introduced to notify ( or throw ) the condition and then handle the condition, usually at different places in your program. Third, exceptions are covered or at least not emphasized based on the assumption that a module and the client of a module take clearly divided responsiblities. This is mainly concerning an OO design principle called design by contract, DBC for short.

Old-fashioned style by returning distinguished error values

When encountering an error, return distinguished error values that are not considered normal return values. For example, a method that is to calculate the square root of a number doesn’t consider a negative number as a normal return value, so returning -1 / -2 / -3 indicates an error. The client code can distinguish a normal return value from error return values, so the client programmer can write code to cope with each exceptional condition according to returned error values, each of which indicate a kind of exceptional condition. E.g.,

int sqrt( int num )

{

if ( .. ) return -1;

else if ( … )

{

…

return -2;

}

…

}

-pros and cons

pros: Both notifying and handling exceptions are light weight. 1) No extra mechanisms are needed to notify and handle exceptional condition, which means codes notifying and handling exceptional conditions are executed in exactly the same way other codes that solving the core problems runs. 2) This will not introduce any extra runtime overhead for exception handling.

cons: 1) This idiom tend to cause spaghetti codes. It will complexicate your method codes by having to place many error checking codes. 2) Agreements on what each error value means must be established between the author and the user of the method. And if the same meaning of an error value must be used among more than one method, the global agreement is hard to be established. For instance:

return -1, if the passed in argument <>

3) For the client code, it is not enforced to handle any exceptional conditions. In other words, it’s completely up to the client programmer whether or not to handle any exceptional conditions. 4) In addition, even exceptional conditions are to be handled, duplicate codes must be written for each call of the mehod, that is, several calls to the same method requires several times of handling several same kind of exceptional conditions which means codes for handing exceptional conditions can’t be centralized and thus be reused. 5) More worse, handling exceptions must usually be followed immediately after recieving the error values, regardless of whether or not the then’s current context can provide enough information to handle the exceptions. That is, it is hard to propagate the exception to the right level of abstraction only on which such exceptions can be properly handled.

Exception handling style

Utilize dedicated constructs, such as Exception types, to represent the exceptions and collect information about the exceptional conditions, and handle exceptions based on information wrapped in such constructs.

-pros and cons

pros: 1) Exceptions and their handling are standardized as part of the features of a programming language that are distinguished from other features of that language. Handling some kinds of exceptions are enforced by the compiler, which means the learning curve are to some degree flattened. It less depends on the experiences, but are forced to be done. 2) Agreements on what exception means are easily established by the kind of dedicated constructs. And global reuse of these agreements needs no extra effort. 3) Though, it will stil cause spaghetti codes, it is alleviated by exception handling mechanism enabling that some exceptional conditions (such as access members on a null reference) are automatically notified in the standard way which means less error checking codes are needed. 4) Exceptions notifying and handling are loosely coupled, that is, identifying exceptions and handling them can be at two point far away from each othe in the control flow. This also means it is easy to propagate exceptions to the right level of abstraction on which such exceptions can be properly handled. 5) Due to easily propagating exceptions, handling the same kind of exceptions can be centralized, for which someone argues that unexpected performance benefits will be get as opposed to old-fashioned error values way.

cons: 1) Extra runtime overhead are needed to notify and handle exceptions for which at the implementation level, extra transfer of control is needed. 2) Client codes are complicated by exceptions handler codes which are more obvious if exceptions notifying are misued and/or overused.

Design by contract

A contract is established, explicitly or implicitly, between a module and the user (client code) of the module. Any side must comform to the contract at any time, under any circumstance. The contract consists of precondition, invariant and postcondition. Whenever wherever the module is called (used) the precondition must be met, and after executing the module, the postcondition must be met. In the whole process the invariant must always be met. Obligations and benefits for both parties are specified. It is the obligation of the client to ensure the precondition is met before calling the module, and that of the module to ensure the invariant and postcondition are met. So any party is committed to its obligation regardless of the other party’s obligation.

More specificly, the client will check and ensure the precondition is met before it calling the module, so on most occassions, no exception mechanism is needed. Because if the contract is always conformed to, no exceptions are foreseen. But, usually, extra mechanism, such as assertion, is needed to help tell and/or check whether or not the contract is conformed to. However, even no such extra mechanism is provided, the idea behind DBC can also be used to prevent from overusing exceptions which may be caused by defensive programming. In general, DBC is sometimes considered to be a formal method.

p.s., the DBC community considers returning error values and exception handling two rivals

Defensive programming

The philosophy of defensive programming can be summed up as: Better to check too much, or check redundantly, than to check little. This is in contrast to DBC which advocates guaranteeing more by checking less. It is conceivable that defensive programming is caused because the contract in DBC is not established at all. Actually, defensive programming goes to another extreme. It assumes that the other party never burden its obligation, such as ensuring the precondition, so the module will itself burden others’ obligations, such as checking for the precondition. This is mainly responsible for complexity and obscureness of codes. For instances, we have a module:

int sqrt( int num )

{

if precondition is met then

solve the problem; return …

else return …

}

and we have a snippet of client codes to call that module:

if preondition for sqrt( .. ) is met then

call sqrt( .. );

Pseudocodes in bold are caused by defensive programming. This way of programming are extensively common.

Exception handling in Java

When an exception is thrown, the JVM will transfer the control from the point where the exception occur to the point that can be specified by the programmer. During the process, the JVM abruptly completes, one by one, any expressions, statements, method and constructor invocations, static initializers, and field initialization expressions that have begun but not yet completed the execution in the current thread. The process continues until a handler for the thrown exception is found. If no such handler is found, then the method uncaughtException is invoked for the ThreadGroup that is the parent of the current thread.

If a finally clause is executed because of abrupt completion of a try block and the finally clause itself completes abruptly, then the reason for the abrupt completion of the try block is discarded and the new reason for abrupt completion is propagated from there.

If a method throws an exception, it must assume that exception is “caught” and dealt with. One of the advantages of Java exception handling is that it allows you to concentrate on the problem you’re trying to solve in one place, and then deal with errors from that code in another place.

Goal of exception handling

Make your program more reliable, robust and error-tolerant. Usually, it provides measures for you to be notified of the exceptional condition and recover from that condition.

Best practices in Exception handling

Below are some best practices in exception handling citing from the book “Effective Java”.

-Use exceptions only for exceptional condition

Prevent from overusing exception.

-Use checked exceptions for recoverable conditions and runtime exceptons for programming errors

Three kinds of exceptions: checked exception, unchecked exception and errors. By convention, errors must be used only by JVM. Programming errors may be considered to fail to fullfill the contract and are generally unrecoverable.

-Avoid unnecessary use of checked exceptions

Two reasons: first, exceptions handling needs extra runtime overhead; second, checked exceptions are forced to be caught which would complexicate your client code. This to some degree conforms to DBC by advocating the client code calls state-testing methods which actually is to ensure the precondition.

-Prefer standard exceptions over user-defined exceptions

For learning curve about your codes, understanability and portability of your codes.

-Throw exceptions appropriate to the abstraction

Exception translation, Exception chain.

-Document all exceptions thrown by each method

Javadoc style, or declaration using the keyword throws which is also called the exception specification.

Exceptions as a part of the specification of a method.

-Include failure-capture information in detail message

Refers to the goal of exception handling

-Strive for failure atomicity

Refers to the goal of exception handling

-Don’t ignore exceptions

No empty catch block.

Other guidelines

-User visible error message should not be the same as the failure message wrapped in the exception object (needs further investigation). The latter are only for programmer to debug the program.

-Don’t assume the way which the client codes burden their obligation and/or the degree to which they burden their obligations. However, unfortunately, defensive programming is often needed, though you should try your best to avoid.

Resources

Chapter 8 Exceptions, Effective Java.
2.16 Exceptions, Java Virtual Machine Spec.
Chapter 10 Error Handling with Exceptions, Thinking in Java 2nd version.
Building bug-free O-O software: An introduction to Design by Contract(TM)
Design By Contract
Design By Contract (DBC)

Java基础复习

2007-04-30T18:30:00.000+08:00

Introduction

基本上是按照网上流传甚广的一套Java的面试题目来的，一个一个问题回答。

谈谈final、finally、finalize的区别

其实除了名字类似，是不沾边的三个东西。

final

Final is a keyword that can be used for classes, methods and data ( field / arguments ). It means what it modifies can’t be changed anymore. For final classes, they can’t be extended or derived; for final methods, the method’s behavior can’t be changed by overridden; for final data, they can only be initialized once and not be assigned values any more. But remember there’re two reasons for preventing change: design or efficiency.

> final methods

There’re two reasons why you make a method final: 1) quite small final method can be inlined when they’re called which is more efficiently; 2) you don’t want a method to be explicitly overridden.

Private methods are considered to be implicitly final, because in whatever cases, you can’t access or override a private method.

> final data

A misconception ( maybe it’s only mine : ) is that declaring data to be final doesn’t necessarily mean that its value is known at compile-time. The value can be run-time determinable. And data can also be declared to be final without any initialization value. In this case the final datum is called blank final field which has to be initialized in constructor or static initializer, or somewhere before use.

> final classes

Defining classes as final simply prevents inheritance — nothing more. Since a class declared to be final can’t be inherited, all its methods are implicitly final and the complier can opt to bring efficiency for you as with other explicitly final methods.

finally

Finally is to do with Exception handling which can introduce a piece of code that you want to execute whether or not an exception is thrown within a try blok or catched in a catch block.

finalize

Finalize which is the name of a method of Object is to do with garbage collection, that is to do with memory release. Garbage collection in java is a two-pass process. In the first pass in which case the object is eligible for garbage-collected, garbage collector will call finalize(), and in the second pass in which case the running programm may reach the point of runing out memory, garbage collector may physically release memeory of eligible objects. So the storage of a finalized object isn’t necessarily get released.

Anonymous Inner Class （匿名内部类）是否可以extends（继承）其它类，是否可以implements（实现）interface（接口）

The answer is yes for both cases.

Inner class constructors get passed a hidden parameter, a reference to the outer class object that created them. static nested classes don’t have this hidden parameter. This is analogous to the way instance methods have hidden this parameter, where static methods do not.

Inner classes are not permitted to have static methods or fields. That is not quite true. They are allowed static final compile time constants, which are treated as if there were literals. If inner classes need statics, they have to get the outer class to hold them, or you have to use static nested classes or you have to inherit the static fields. Oddly, inner classes are permitted to extend classes that do have static methods and fields.

Anonymous inner class can’t define constructors. An anonymous inner class implements an interface, say, ITest, by:

new ITest() { .. }

and extends a class, say, Test, by:

new Test( name) { .. }

where Test( String name ) is an non-default constructor of Test, and default constructor can’t be used here!

For which kind of classes an anonymous class can extend / implement, refer to nested classes : Java Glossary.

Static Nested Class 和 Inner Class的不同

Differs in creating instance of them, and linking with the outter class /instance.

&和&&的区别

& is bitwise AND ( 位与) operator, while && is logical AND (逻辑与) operator.

Shift operators

The left-shift operator( << ) produces the operand to the left of the operator shifted to the left by the number of bits specified after the operator( inserting zeroes at the lower-order bits ). The signed right-shift operator( >> ) produces the operand to the left of the operator shifted to the right by the number of bits specified after the operator( inserting zeroes / ones at the higher-order bits ). There’s an unsigned right-shift operator( >>> ) will produces results inserting zeroes at the higher-order bits regardless of the sign.

Shift operators can be combined with equl sign, such as, <<=, >>=, and >>>=.

Talk about collection framwork in Java 2

Main interfaces: Collection, List, Set, Map. There’re actually only three collections List, Set and Map, and only two or three implementations of each one. And Map is not derived from Collection. The reason putting it the collection framwork is because a Map can produce collections from its key set and value list. Refer to chaper 9 of Thinking in Java 2nd version and Sun’s Java library for full details.

All collection implementation requires type checking ( especially with generic feature in Java 5 ) or bounds checking, or both.

Vector is synchronized, which means it’s thread-safe.

ArrayList is much like an array except it is variant-sized which brings extra run-time overhead.

The List interface provides four methods for positional (indexed) access to list elements. Note that these operations may execute in time proportional to the index value for some implementations (the LinkedList class, for example). Thus, iterating over the elements in a list is typically preferable to indexing through it if the caller does not know the implementation.

For the Set interface, a speicial case of prohibition is that it is not permissible for a set to contain itself as an element.

Diff between Collection and Collections

First Collections is the name of a conceptual framework coined by the designers of Java to represent a collection of interfaces and / or classes that enables an object holding a group of objects and variaous operations on it. It is generally called the collections framework ( or container classes before Java 2 ).

Collection as a type name is the name of an interface which is the root of the collecitons framework hierarchy and is located at package java.util. While it is the root of the collection hierarchy, there’re some collection classes that aren’t rooted from it, such as Map.

While Collections is a class also located in the package java.util which consists of a variety of static methods that operate on or return collections. This is common technique used to organize a bunch of related PO paradigm interfaces* ( may be not types, but methods ) into one module supported by OOP paradigm to improve the modularity and/or accessability of such interfaces*. In some cases, this is called the facade design pattern. Similar classes examplifying this techinque are Arrays, Math, etc.

Diff between HashMap and HashTable

String, StringBuffer, and StringBuilder

String class represents character strings. All string literals ( e.g., “Kenyth” ) in Java program are implemented as instances of String class. Strings are constant, namely immutable, as opposed to mutable StringBuffers. Their values can’t be changed after they’re created, which makes they can be shared ( refer to a compiler theory book about handling of constants ). And any modification to a String will produce a new instance of String, explicitly or implicitly. Concatenation of String is implemented as operations on StringBuffer( see the class file bytecode ), and conversions from an object to String is facilitated by the toString() method defined in Object class.

StringBuffer class represents a sequence of characters. It is mutable. It allows for data being appended to and inserted into it. It is thread-safe.

StringBuilder is like StringBuffer, but is not intended to be used by multi threads, that is not synchronized, or not thread-safe. It is introduced as of Java 5.

When to use assert

( Actually I’ve never used this keyword in my programming ) For the full details refer to Sun’s official document Programming With Assertions.

Simply speaking, assert in Java provides you a debugging facility similar to macros in C/C++. You can enable/disable your assertions when starting your program by passing in JVM command-line arguments ea/da. However, by default assertions are disabled at run-time.

There’s one guideline for deciding where/when to use assert that you should never use it for what your programming code do, such as method contract enforcement. Because since it is just a helper tool for debugging / observing your program and can be disabled, you must not depend the functionalities of your program on it.

more are coming soon…

Resources

Thinking in java version 2.
JAVA面试题目（去了两家公司，都是这样的题目）：一个很好的问题导向的复习提纲。
初识Java内部类：关于内部类的好处，静态内部类以及非静态内部类。
`final’ variables and inner classes: explains why access from anonymous inner class to non-final outter variables is not allowed.
nested classes : Java Glossary: contains very detailed explanation of the terms nested / inner class and their usages.
Programming With Assertions

Technorati : basics, java, programming
Del.icio.us : basics, java, programming

The Architecture of Eclipse

2007-04-20T18:26:00.000+08:00

Introduction

If explaining every bit in detail, you must be missed in the details and can’t see the architecture from a global perspective, nor will you be benifited in your practise. So I’m trying to explain the architecture based on senarios such as what will happen when you startup elipse, what will happen when an action that you contribute is fired, etc. I hope in such a way it will do help in your practice with Eclipse.

And, it is worthy to point out this is not an overview on the architecture of Eclipse for which there are tons of articles written about.

Startup of Eclipse

What will happen when the file eclipse.exe is executed.

Startup of Eclilpse begins by running a system specific executable binary file called eclilpse.exe which is located under the root directory of the eclipse installation. This executable will then lauches the org.eclipse.core.launcher.Main, located in startup.jar. After that the entry point of Main, that is static main method of Main is invoked. Below we will illustrate the calling path of important methods to demonstrate the post startup process of Eclipse.

Main.run( args )

Main.basicRun( args )

Main.getBootPath( .. ) : locate boot plugin ( in “plugin” directory of your eclispe installation ), within which Main.getDevPath( .. ) is called, within which Main.addBaseJars( .. ) is called, within which Main.readFrameworkExtensions( .. ) is called; invokeFramework( .. ): invoke EclipseStarter

the class EclipseStarter ( indicated by STARTER field ) is loaded by a URLClassLoader defined as an inner class with Main; EclipseStarter.run( .. ) is invoked in a reflective way

EclipseStarter.startup( .. ) : starts the platform and sets it up to run a single application

OSGi.new( .. ) : an instance of OSGi service platform is created

OSGi.launch() : start the OSGi framework

Framework.launch()

SystemBundle.resume() : SystemBundle subclasses Bundle to provide a system Bundle so that the framework can be represented as bundle

StartLevelManager.launch( .. ) : StartLevelManager is the startLevel service implementation for the OSGi spec

StartLevelManager.doSetStartLevel( .. )

StartLevelManager.incFWSL( .. )

StartLevelManager.getInstalledBundles( .. ) : Build an array of all installed bundles to be launch; StartLevelManager.loadInstalledBundles( .. ) : Load all bundles; StartLevelManager.resumeBundles( .. )

Framework.systemBundle.context.start() : Framework. :SystemBundle. :BundleContextImpl.start(), start the system bundle, BundleContextImpl.start() calls bundle’s BundleActivator.start()

BundleHost.loadBundleActivator() : Load and instantiate bundle’s BundleActivator class

BundleContextImpl.startActivator( .. ) : calls the start method of a BundleActivator which you have to extend when you create a plug-in.

Eclispe can also be started from with a client ( which is not part of the current Eclipse platform ), say, written in java, by using the EclispeStarter class located in org.eclipse.core.runtime.adaptor.

Action delegate and proxy

What will happen when your contributed action is fired.

Adding an action in a programatic way is different from adding it via contribution to an action extension point. For the former case, you have to implement some special API to create an action directly, while for the latter case you will have to only implement IActionDelegate+ which enables the lazy loading of the action.

At startup the registry is read and a PluginAction( extends Action, implements *Selection*Listener, IPluginContribution ) is created for each action extension point. The instance of PluginAction is an action proxy which directly represent an action in run time but doesn’t do the job a real action does. When the action that the action proxy represents is fired, the real action( the action delegate ) is created by the action proxy. After that point the action proxy delegate everything that is requested to the real action, the action delegate. This mechanism makes it possible to load the action extension lazily which is called lazy loading.

Following depicts the flow of action proxy and delegate:

read from registry ( IExtensionRegistry ) -> a PluginAction created for each action extension point ( while the action is fired -> an action delegate created -> action is delegated )

Contribute an Extension

to be continued…

Extension Pattern

Adapter pattern is extensively used in Eclipse to contribute extensions ( different from extensions to extension point ) to type or instance. This mechanism is enabled mainly by implementing IAdaptable and IAdapterFactory. For the detailed explanation with examples, please refer to Chapter 31 of the book Contributing to Eclipse: Principles, Patterns, and Plugins (Paperback).

Resources

The Architecture of Eclipse. This article refers to and linked to a lot of valuable resources.
A First Look at Eclipse Plug-In Programming. Contains a very detailed comparsion between Sun’s awt and swing and Eclipse’s SWT and JFace and anatomy of the process of Eclispe startup.
About the OSGi Service Platform - Technical Whitepaper Revision 4.0
org.eclipse.osgi_3.2.2.R32X_v20070118.jar : org.eclipse.core.runtime.adaptor.EclipseStarter.class source code, org.eclipse.osgi.framework.internal.core.AbstractBundle.class source code, org.eclipse.osgi.framework.internal.core.BundleContextImpl.class source code, org.eclipse.osgi.framework.internal.core.BundleHost.class source code, org.eclipse.osgi.framework.internal.core.Framework.class source code, org.eclipse.osgi.framework.internal.core.OSGi.class source code, org.eclipse.osgi.framework.internal.core.StartLevelManager.class source code, org.eclipse.osgi.framework.internal.core.SystemBundle.class source code, org.osgi.framework.BundleActivator.class source code.
org.eclipse.ui.workbench_3.2.2.M20070119-0800.jar source code.
eclipse 3.2.2 startup.jar : org.eclilpse.core.launcher.Main.class source code.
Contributing to Eclipse: Principles, Patterns, and Plugins (Paperback)
Eclipse Help

to be continued…

Technorati : Architectrue, OSGi, component oriented, eclipse, java, open source, plug-in
Del.icio.us : Architectrue, OSGi, component oriented, eclipse, java, open source, plug-in

Knowledge on font size

2007-04-19T18:24:00.000+08:00

声明：全部摘抄自网络资源，准确性和完整性不能保证，请读者自己辨别。

Introduction

一种字体（font）是一组字形（glyph）的集合，每一个字形代表了特定字样（typeface）的字符集（character set）里面的一个字符。

A font is a set of glyphs (images) representing the characters from a particular character set in a particular typeface. In professional typography the term typeface is not interchangeable with the word font, which is defined as a given alphabet and its associated characters in a single size. For example, 8-point Caslon is one font, and 10-point Caslon is another. Historically, fonts came in specific sizes determining the size of characters, and in quantities of sorts or number of each letter provided. The design of characters in a font took into account all these factors.

Measurement of font size

Point (pt, 磅)

在排版印刷中1pt是最小的测量单位， 12pt是1pica，具体是多长视情况而定。传统的排版印刷中1pt可能在0.18到0.4mm之间，这依赖于对foot的定义，现代的桌面出版中（Desktop Publishing Point）1pt是1/72inch，也就是约0.3527mm，所以6pica是1inch。

Pixel（像素）

Inch（英寸）

millimeter（毫米）

Commonly used font size

9pt = 12px = 小五号

1pt = 4/3px

MS WORD中最大能定义1638pt大小的字体！

下表是字号与磅以及毫米之间的对应关系，并附以字样，以供大家在排版或调整布局时使用。

HTML和CSS中用的font size属性

Syntax: font-size: | | |
Possible Values:

Both relative and absolute length units are supported in CSS1. Relative units give a length relative to another length property, and are preferred since they will better adjust to different media. The following relative units are available:

em (ems, the height of the element’s font)
ex (x-height, the height of the letter “x”)
px (pixels, relative to the canvas resolution)

Absolute length units are highly dependent on the output medium, and so are less useful than relative units. The following absolute units are available:

in (inches; 1in=2.54cm)
cm (centimeters; 1cm=10mm)
mm (millimeters)
pt (points; 1pt=1/72in)
pc (picas; 1pc=12pt)

要注意的是，相同大小的字体在不同的具体环境下显示出来的字体的真实大小可能不一样，差别比较小的可能是用px度量的大小。

关于x-height的定义可以看Typeface中的解释，简要的说是，对每一个字体都有一个假想的水平线叫baseline（想想小时候练习写英文字母的时候每一行都有三条或者四条横线那种作业本），x-height就是从baseline到字体最高处的高度。

Resources

Technorati : CSS, HTML, Web Browser
Del.icio.us : CSS, HTML, Web Browser
Ice Rocket : CSS, HTML, Web Browser
Flickr : CSS, HTML, Web Browser
Zooomr : CSS, HTML, Web Browser
Buzznet : CSS, HTML, Web Browser

newClasspathContainerEntry

2007-03-21T18:23:00.000+08:00

Introduction

Setting Java project build path involves setting classpaths of the project which are different from the Java runtime classpath. In JDT classpaths are represented with classpath entries which roughly fall into five kinds: source folder entries, binary library entries, prerequisite project entries, classpath variables, and classpath containers.

Start you eclipse JDT, open a Java project and launch the build path configuration window, and you’ll find all the options enabling you to add/remove all kinds of classpath entries. The frequently used JAVA_HOME system variable (under Windows) can be considered as a classpath variable here. And for a classpath container, hereafter comes more.

Classpath Container

Conceptually it is a data structure which represents a set of tupes with each in the form of . An instance of this data structure can be referenced as an instance of IClasspathEntry which wrapped a unique path of type IPath called a container path. It is noteworthy that all kinds of classpath entries mentioned above are represented by instances of IClasspathEntry within which there is a field called kind identifying the kind of entries. And also, it is noteworthy that an instance of ClasspathContainer is not an instance of IClasspathEntry of kind container. Simply speaking, each instance of IClasspathEntry of kind container references as its member field a container path which uniquely identifies an instance of the data structure mentioned above which contains (or references) a set of instances of ClasspathContainer. Actually, it’s still a little complicated. But that’s it. Below is sketched the relationship.

IClasspathEntry(kind: container)-aContainerPath –> , …}>.

Ways of Creating Classpath Container Entries

The implementation details are more complicated. Class or interfaces involved in include JavaModelManager, JavaCore, IClasspathEntry, ClassContainer, IClassContainerInitializer, and other Java Model classes. The set of tupes of the form of are maintained in JavaModelManager.

Generally, there’re two ways of creating a classpath container entry. The 1st way is to hard code creating instances of ClasspathContainer, and the 2nd way is to create instances of ClasspathContainer via the lazily invoked classpath container initializer which you may define onto the extension point org.eclipse.jdt.core.classpathContainerInitializer.

The hard code way:

// create an instance of IClasspathEntry of kind CPE_CONTAINER
// but ClasspathContainer associated to this entry are not yet defined.
JavaCore.newContainerEntry(..);
…
// Create and set the classpath container
JavaCore.setClasspathContainer(..);
…
// Put container path, containers and projects into hashmaps.
// Invoked in JavaCore.setClasspathContainer(..).
JavaModelManager.containerPut(..)

The initializer way:

// Contribute an extension to the initializer extension point.

When classpath entries contained in containers get resolved, the execution process is:

// Methods resolving classpath entries will get method getClasspathContainer(..) invoked.
JavaCore.getClasspathContainer(..);
…
JavaModelManager.getClasspathContainer(..);
…
// Both ways would get this method invoked.
JavaModelManager.containerGet(..);
…
// The initializer way would get this method invoked,
// within which initializer extension(s) will be lazily invoked.
JavaModelManager.initializeAllContainers(..);
or JavaModelManager.initializeContainer(..);

Resources

Setting the Java build path
JDT 3.2 Source Codes.

Technorati : Eclipse, JDT, classpath, java, plugin

Eclipse CDT CPU Usage 100% Solution

2007-03-21T18:22:00.000+08:00

Solution

总的来说是把你的Eclipse使用的JRE换成6.0（早就download在机器上居然没有发现，2006.12.12就final release了，改成open source之后发布的速度快多了，现在都build100+了）的或者IBM的5.0实现，看别人的blog说是Sun的实现6.0以下有bug和 CDT不兼容，我试了BEA的Jrockit5，也是有问题。

换成6.0后，Indexer和Content Assist都没有问题了，不会CPU100%了。

另外，不像[1]里面说的CDT3.0才有问题，最新的CDT3.1.2也还是有这个问题。

Bonus Knowledge

Use something like “-vmargs -Xmx256M” when launching eclipse to use more memory.

Resources

Technorati : Eclipse CDT, JRE6, Java
Del.icio.us : Eclipse CDT, JRE6, Java
Ice Rocket : Eclipse CDT, JRE6, Java
Flickr : Eclipse CDT, JRE6, Java
Zooomr : Eclipse CDT, JRE6, Java
Buzznet : Eclipse CDT, JRE6, Java

Workshops of AOSD'07

2007-03-16T17:06:00.001+08:00

Refer to here for all the workshops held at AOSD'07.

Below are the ones that I'm sepecially interested in:

Workshop on of Asessment of Aspect-Oriented Technologies: The subject are really interesting and worth being noticed by all the researchers and developers. There's a researcher from mainland China in the organization committee. No papers/slides available on-line abouth the workshop.
Software Engineering Properties of Languages and Aspect Technologies: Evaluation of AO tools and technologies, serving as important criteria for improving existing ones and designing/developing new ones.
Workshop on Best Practices in Applying Aspect-Oriented Software Development: No one will not be interested in this.
Foundations Of Aspect-Oriented Languages
Workshop on Testing Aspect-Oriented Programs: This field is led by an overseas Chinese researcher Dr. Xu.

The workshop I'm intersted the most, but not appearing at AOSD'07 is Modeling and Analysis of Concerns in Software .

AOSD'07 "Report" - By others

2007-03-15T21:18:00.000+08:00

Blog Posts About AOSD'07:

AOSD Demo a success:Can't figure out what exactly the demo is from this post. I guess it is a eclipse plug-in facilitating jps indicating.

AOSD Conference Day 1:About Glassbox, overhead of load-time weaving, possible usage of AOP for run-time verification/debugging, comment on the keynote "Building Robust System", etc.

Arriving at AOSD:Inside story about the author attending the conference.

update (22/03/2007）：

AOSD 2007 Conference: Blog from Object Mentor. The author gave a tutorial on Industry Track.

No more...

It seems the academic people are too busy to blog. There are few posts about the conference.

Blog APIs

2007-03-15T18:21:00.000+08:00

Resources:

Technorati : Blog, blogger, live space
Del.icio.us : Blog, blogger, live space
Ice Rocket : Blog, blogger, live space
Flickr : Blog, blogger, live space
Zooomr : Blog, blogger, live space
Buzznet : Blog, blogger, live space

URI, URL and Java

2007-03-14T18:10:00.000+08:00

This post basically is a collection of resources.

1. What're URI, URN and URL?

A URI is a uniform resources identifier reference. A URL is a uniform resource locator. URNs name resources but do not specify how to locate them. The mailto, news, and isbn URIs shown above are examples of URNs. URLs and URNs both fall into URIs. But normally URNs and URLs doesn't interset. Refer to RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax for the syntax of a URI instance. And the java class description of URI gives a very good summary of URI, besides providing some useful resources.

2. Syntax

Below is a little breakdown on the syntax of URI, which is directly taken from the priviously mentioned JAVA API spec.

At the highest level a URI reference (hereinafter simply "URI") in string form has the syntax:

[scheme:] scheme-specific-part [#fragment]

where square brackets [...] delineate optional components and the characters : and # stand for themselves. With a further breakdown on scheme-specific-part we can get a URI in the string form:

[scheme:] [//authority][path][?query] [#fragment]

where the characters :, /, ?, and # stand for themselves. With a further breakdown on authority we can get a more general form:

[scheme:] [// [user-info@]host[:port] ] [path] [?query] [#fragment]

where the characters @ and : stand for themselves.

Note: a scheme of a URL is called a protocol, such as "http" and "ftp".

3. Examples

An opaque URI is an absolute URI whose scheme-specific part does not begin with a slash character ('/'). Opaque URIs are not subject to further parsing. Some examples of opaque URIs are:

mailto:java-net@java.sun.com /*URN*/
news:comp.lang.java /*URN*/
urn:isbn:096139210x /*URN*/

A hierarchical URI is either an absolute URI whose scheme-specific part begins with a slash character, or a relative URI, that is, a URI that does not specify a scheme. Some examples of hierarchical URIs are:

http://java.sun.com/j2se/1.3/ /*URL*/
docs/guide/collections/designfaq.html#28
../../../demo/jfc/SwingSet2/src/SwingSet2.java
file:///~/calendar

Also URIs are categorized as absolute URIs and relative URIs. An absolute URI specifies a scheme, and a URI that is not absolute is called a relative URI.

Among above examples comments in the form of "/*...*/" tell which are URLs and which are URNs.

4. Character categories

As specified in resources accessible, we quote some that matters:

RFC 2396 specifies precisely which characters are permitted in the various components of a URI reference. The following categories, most of which are taken from that specification, are used below to describe these constraints:

alpha	The US-ASCII alphabetic characters, `'A'` through `'Z'` and `'a'` through `'z'`
digit	The US-ASCII decimal digit characters, `'0'` through `'9'`
alphanum	All alpha and digit characters
unreserved	All alphanum characters together with those in the string `"_-!.~'()*"`
punct	The characters in the string `",;:$&+="`
reserved	All punct characters together with those in the string `"?/[]@"`
escaped	Escaped octets, that is, triplets consisting of the percent character (`'%'`) followed by two hexadecimal digits (`'0'`-`'9'`, `'A'`-`'F'`, and `'a'`-`'f'`)
other	The Unicode characters that are not in the US-ASCII character set, are not control characters (according to the `Character.isISOControl` method), and are not space characters (according to the `Character.isSpaceChar` method) (Deviation from RFC 2396, which is limited to US-ASCII)

The set of all legal URI characters consists of the unreserved, reserved, escaped, and other characters.

Escaped octets, quotation, encoding, and decoding

RFC 2396 allows escaped octets to appear in the user-info, path, query, and fragment components. Escaping serves two purposes in URIs:

To encode non-US-ASCII characters when a URI is required to conform strictly to RFC 2396 by not containing any other characters.

To quote characters that are otherwise illegal in a component. The user-info, path, query, and fragment components differ slightly in terms of which characters are considered legal and illegal.

These purposes are served in this class by three related operations:

A character is encoded by replacing it with the sequence of escaped octets that represent that character in the UTF-8 character set. The Euro currency symbol ('\u20AC'), for example, is encoded as "%E2%82%AC". (Deviation from RFC 2396, which does not specify any particular character set.)

An illegal character is quoted simply by encoding it. The space character, for example, is quoted by replacing it with "%20". UTF-8 contains US-ASCII, hence for US-ASCII characters this transformation has exactly the effect required by RFC 2396.

A sequence of escaped octets is decoded by replacing it with the sequence of characters that it represents in the UTF-8 character set. UTF-8 contains US-ASCII, hence decoding has the effect of de-quoting any quoted US-ASCII characters as well as that of decoding any encoded non-US-ASCII characters. If a decoding error occurs when decoding the escaped octets then the erroneous octets are replaced by '\uFFFD', the Unicode replacement character.

5. Java Impl.

URI, URL, URLClassLoader, URLConnection, URLDecoder, URLEncoder and URLStreamHandler, which are all located in package java.net.

Resources:

Uniform Resource Identifiers (URI): Generic Syntax

Format for Literal IPv6 Addresses in URL's

JavaTM 2 Platform Standard Edition 5.0 API Specification

Technorati : Java, URI, URL, URN
Del.icio.us : Java, URI, URL, URN

服务器租借与托管资料收集

2007-03-04T18:19:00.000+08:00

（本文仅仅为资料收集，不存在原创内容）

1. 名词解释

1U-4U：

U（英文中的Unit？不知道）代表架式服务器的高度，1U=1.75英寸=4.45厘米。同样的2U=4*1.75英寸=4*4.45厘米，以此类推。

机柜：

一般多个机架服务器安装在一个机柜内，一个普通机柜的高度是42U。

ICP：

ICP（Internet Content Provider）证的全称:《中华人民共和国电信与信息服务业务经营许可证》即ICP证，通过互联网向上网用户提供有偿信息、网上广告、代制作网页、电子商务及其它网上应用服务的公司必须办理的网络经营许可证。国家对经营性网站实行ICP证制度，注册资金应在100万或者100万以上的公司才能办理 ICP证，一经办理一般能在该省的通信管理局的网站查询到。同时对从事非经营性活动的网站要进行ICP备案，简称为ICP备。

2. 服务器的种类

首先,我们必需了解何谓PC服务器?所谓PC服务器（下文讨论的多为PC服务器）,即是Intel架构服务器,与一些大型服务器如 Mainframe, Unix架构服务器等不同,前者大多运行Windows或Linux等操作系统,使用较为普遍,后者多为专业用途,如银行,大型制造业,物流业,证券…等行业使用,一般人较少有机会接触到.

可以按照各种标准进行分类，按应用层次分为：入门级服务器、工作组级服务器、部门级服务器和企业级服务器；按处理器架构分为：CISC （Complex Instruction Set Computer）架构服务器、RISC（Reduced Instruction Set Computing）架构服务器和VLIW（Very Long Instruction Word超长指令集架构）架构服务器；按用途分为：通用型服务器和专用型服务器，或者WEB服务器、E-mail服务器、数据服务器、DNS服务器等等；按机箱结构分为：台式（塔式）服务器、机架服务器、机柜服务器和刀片式（bladed）服务器。

2.1 塔式服务器

优点：服务器的主板扩展性较强、插槽也多，可以进行硬盘和电源的冗余扩展，对环境要求较低，原则上不用和机柜搭配使用，价格也相对较低，集多种常见的服务和应用于一身。

缺点：塔式服务器长得跟我们平时用的台式机一样，占用空间比较大，适合小型企业自己维护，不适合放在服务器托管商那里托管，独立性太强，协同工作在空间占用和系统管理上都不方便，在一些应用要求较高的企业中，这种单机服务器无法满足要求。

2.2 机架服务器

机架式（RACK）服务器长得像卧着的台式机，可以一台一台地放到固定机架上，因此而得名。机架服务器一般采用标准19英寸的宽度设计，其高度按照一定的单位高度的设计，其单位为U，约为4.54cm。

优点：机架是服务器的机箱宽度都是相同的，可以在标准的机柜中存放服务器，减少服务器产品对空间的要求，易于服务器的集中管理。所以机架服务器便于放在服务器托管商那里托管。

缺点：购买价格相对较高，比同等配置的塔式服务器价格要高20%-30%，1U以上服务器服务器托管费用较高。由于在空间上非常紧凑，所以在扩展性和散热方面上具有一定限制，一般无法实现太完整的设备扩展，所以单机性能相对比较有限。

2.3 刀片式服务器

略

3. 服务器的购买和租借

一般服务器或者自行购买然后放到IDC（Internet Data Center）服务提供商的机房托管，或者租借IDC服务商的。租借的服务器一般IDC服务提供商都会负责托管，租借又分为送产权和不送产权两种，送产权的即租用一定时间（如1年或者2年）后服务器的产权归用户。需要指出的是租用的服务器大多数不是新的服务器，而是旧的组装服务器，当然也有宣称租用品牌服务器的IDC服务商。

下面主要说说PC服务器的基本硬件配置常识。主要的服务器国际生产商有：IBM，HP，Dell，Sun（最近也推出X86服务器产品），超微等；国内生产商主要有：曙光、联想、浪潮、方正、清华同方、华硕等；服务器芯片生产商主要是：Intel和AMD；服务器芯片主要有：Pentium 4（单路）、Itanium（安腾，64位，Dual-Core）Xeon（至强，双路）、XeonMP（Multi Processing Platform，四路）、AthlonMP（速龙MP）、Opteron（皓龙，64位，100系列是单路，200系列是双路，800系列是四路和八路）。

4. 托管服务器的流程

4.1 选择托管服务器的类型

购买全新服务器，或向服务器托管商租借。

4.2 选择服务器托管商

考察服务商、机房，最好能去现场考察，以检查其设施是否齐全。

4.3 签订托管合同

如果是自己购买的服务器，则需要运送服务器到托管商指定的机房，最后签订详细的托管合同。

5. 经验

5.1 最好不要异地托管

如果是自己购买的服务器最好不要找异地托管，因为时候要对服务器进行本地维护。

5.2 带宽保证

不管是独享带宽还是共享带宽，实际使用的带宽一般不会超过10M，甚至5M甚至更低，各地的IDC都会有限制。

5.3 ICP证

一定要检查托管商是否有ICP证。

6. 业界案例

豆瓣网，土豆网，劲舞团等等。

7. 上海的服务商简介

中国E动网：www.edong.com

8. 其他

www.linkwan.com/vr ，用来测试机房速度和当前连接的路由节点。

参考资料：

AspectJ Syntax Notes and More…

2007-01-30T18:18:00.000+08:00

Note: Some of the following items, especially items in red, are based on my experience with aspectj 1.5.3.200611221118 (AJDT 1.4.1.200611230655) , JVM 1.5.0-b64, and JDT 3.2.0.v20060609m-F7snq1fxia-Z4XP.

[Nested/Inner Aspect] Nested aspects must be static. An inner aspect has to be static, in order to get rid of the implicit “&& this()” which you get on a perthis-Aspect.
[Aspect Extension] aspects may only extend abstract aspects. It is an error for a concrete aspect to extend another concrete aspect.
[Aspect Instantiation] Because advice only runs in the context of an aspect instance, aspect instantiation indirectly controls when advice runs.
[Aspect Instantiation] The criteria used to determine how an aspect is instantiated is inherited from its parent aspect. If the aspect has no parent aspect, then by default the aspect is a singleton aspect.
[Aspect Instantiation] Static initialization occurs when the type is loaded (i.e., the Java VM
loads the resulting class file for Lolo). At that point, the implementation of the before calls the static method aspectOf to access the singleton instance of Lolo.
[Aspect Instantiation] You can get a NoAspectBoundException when there is a cycle in aspect initialization or static initialization (within one aspect, or between a chain of several aspects), most commonly when an aspect advises its own initializer.
[Aspect Instantiation] During the constructor of an aspect, calling aspectOf() on that aspect would fail. Because at that moment, no aspect instance has been bound. It is the same reason why in an after() :(execution(AspectA.new())) advice, calling AspectA.aspectOf() would fail. In this case, instead, target can be used to expose the instance of AspectA.
[Aspect Instantiation] ! Do not advise join points in cflowbelow(execution(AspectA.new())), there are bugs or flaws with aspectj which your advice may reproduce, especially when dynamically determined variable are involved in your advice body. Or don’t define your own aspect constructor, but just use the default aspect constructor, which would make your aspectj code more robust.
[Advice Execution] ! Exception or Error thrown in advice “before(String[] args) : execution(public static void *.main(String[]))” can’t be captured!
[Declaration] ! How to declare an error if some join points that are supposed to be captured are actually not captured?
[PCD] A named pointcut may be defined in either a class or aspect, and is treated as a member of the class or aspect where it is found. As a member, it may have an access modifier such as public or private. Abstract pointcuts may only be declared within abstract aspects. For completeness, a pointcut with a declaration may be declared final. Though named pointcut declarations appear somewhat like method declarations, and can be overridden in subaspects, they cannot be overloaded.
[PCD] call(Foo.new(..)) can’t be used together with target(*).
[PCD] Rather than cflow, use lexical-structure based pointcuts, within or withincode, preferablely. It will make the cross-reference view of the AJDT more accurate and less time consuming.

to be continued…

Resources:

aspectj doc
aspectj-user-request mailing list

DOM Level 3 Load and Save

2007-01-20T18:16:00.000+08:00

1. Introduction

Defined by w3 consortium, just as its name indicates, it serves as interfaces to objects that dealing with loading and saving DOM objects.

It’s noteworthy that various specific implementations doesn’t always fully support.

With java, it is well supported, though, some optional specifications are not supported (at least not always workabe from my experience). However, for web developers, there’s a quote from a book for you:

Now that XMLHttpRequest is being standardized, it seems likely that LSParser will never be supported by most browsers.

In addition, with java, you can also selectively use javax.xml.transform to deal with loading and saving DOM objects.

2. Breakdown

Cite from org.w3c.dom.ls:

DOMImplementationLS
DOMImplementationLS contains the factory methods for creating Load and Save objects.

LSInput
This interface represents an input source for data.

LSLoadEvent
This interface represents a load event object that signals the completion of a document load.

LSOutput
This interface represents an output destination for data.

LSParser
An interface to an object that is able to build, or augment, a DOM tree from various input sources.

LSParserFilter
LSParserFilters provide applications the ability to examine nodes as they are being constructed while parsing.

LSProgressEvent
This interface represents a progress event object that notifies the application about progress as a document is parsed.

LSResourceResolver
LSResourceResolver provides a way for applications to redirect references to external resources.

LSSerializer
A LSSerializer provides an API for serializing (writing) a DOM document out into XML.

LSSerializerFilter
LSSerializerFilters provide applications the ability to examine nodes as they are being serialized and decide what nodes should be serialized or not.

3. Examples

a. Write an instance of Document to a file with org.w3c.dom.ls:

DOMImplementationLS domImpl = (DOMImplementationLS)doc
.getImplementation();
LSSerializer serializer = domImpl.createLSSerializer();
LSOutput output = domImpl.createLSOutput();
output.setCharacterStream(new PrintWriter(fileName));
serializer.write(doc, output);

b. Write an instance of Document to a file with javax.xml.transform:

StreamResult sr = new StreamResult(new File(fileName));
Transformer t = TransformerFactory.newInstance().newTransformer();
t.transform(new DOMSource(doc), sr);

Note: it seems, from my experience, that example b can’t preserve the print friendly presentation.

Resources:

Document Object Model (DOM) Level 3 Core Specification Version 1.0
Document Object Model (DOM) Level 3 Load and Save Specification Version 1.0
DOM Level 3
Java Impl. Package org.w3c.dom.ls (src, api spec)

Feed Format — The Programmable Web

2007-01-13T18:04:00.000+08:00

Resources:

Spec. Intro.

Feed Reader Impl.

Technorati : RDF, RSS, feed, feed reader, programmable web, xml
Del.icio.us : RDF, RSS, feed, feed reader, programmable web, xml

Control a Web Browser From Within a Java Programm

2007-01-13T18:02:00.000+08:00

Noramlly, more than two way you can use a web browser with your Java programm.

1.Fire commands to invoke a web browser with Java runtime support.

// cmd = ‘rundll32 url.dll,FileProtocolHandler http://…’
cmd = WIN_PATH + ” ” + WIN_FLAG + ” ” + url;
Process p = Runtime.getRuntime().exec(cmd);

See the API Spec of Java for Process, and Java Tip 66 of the Resources section for more information.

2. Use a wrapped browser control

2.1 Use Jacob, the open source COM wrapper. e.g.,

protected void openIExplorer(){
comp = new ActiveXComponent( “InternetExplorer.Application” );
comp.setProperty( “Visible”, new Variant(true) );
comp.invoke( “Navigate”, new Variant[]{ new Variant((String)comboFilename.getSelectedItem()) } );

2.2 Use browser wrapper provided by SWT.

import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.CloseWindowListener;
import org.eclipse.swt.browser.LocationAdapter;
import org.eclipse.swt.browser.LocationEvent;
import org.eclipse.swt.browser.OpenWindowListener;
import org.eclipse.swt.browser.ProgressEvent;
import org.eclipse.swt.browser.ProgressListener;
import org.eclipse.swt.browser.StatusTextEvent;
import org.eclipse.swt.browser.StatusTextListener;
import org.eclipse.swt.browser.VisibilityWindowAdapter;
import org.eclipse.swt.browser.WindowEvent;

3. or any other ways I havn’t figured out…

Resources:

Technorati : firefox, ie, java, linux, netscape, safri, web browser, windows
Del.icio.us : firefox, ie, java, linux, netscape, safri, web browser, windows

对编译原理的一点总结(Beta)

2006-12-26T18:00:00.000+08:00

编译原理本人学的很差，虽然这是比较专业的课程。像大多数很多课程一样，考试的话虽然我都拿不到优秀，但是我对这些课程的内容都有浓厚兴趣（估计没人信，有兴趣还学的差？谁信啊？！）。所以，我时常会看一看，总结一下思路（只总结一部分，其他以后看到再补充），记下来，下次看的时候进入状态快一点，有错误欢迎指正，这个写的东西类似于学习笔记。

1. 概念、基础

首先编程语言分为编译型语言（或者静态（static）、半静态，半动态语言，如c/c++）和解释型语言（或动态（dynamic）语言，如 c#/java/大多数脚本语言），对这两种语言来说”编译”所做的工作是有所不同的。高层次的语言解释执行是一种趋势，现代的面向对象语言一般都是或者将会设计成解释型语言，因为动态性虽然带来的性能的损失，但是随着计算机性能的提高我们通常会愿意用性能会换取动态语言的灵活性。下面我将会尝试说明两种语言的编译过程，并在必要的时候指出某个过程是针对哪种语言的。

说一件趣事，会对你立即编译有帮助，编译在英文里面是compile，这个单词不仅用在计算机方面，还用在书籍出版方面，编译汇总一本书籍然后出版，所以compile基本上是把分散的东西（你自己的多个程序源码文件、程序语言库等）汇总起来（一个目标代码程序）使之有秩序并能为之所用。

编译的流程一般分为以下几个过程。预处理（preprocess，有时候包括在词法分析中）；词法分析（lexical analysis or scanner)；语法分析（syntax analysis）；语义分析（semantic analysis）；代码优化（code optimatization）；目标代码生产（code generation）。通常有两个数据结构与所有这些过程交互，符号表（symbol table）和出错管理器。这些过程一般都以相应模块出现在编译器中。与编译有关的过程还有链接（linking）和加载（loading）。但是对于解释型语言上面的过程可以归于编译阶段最多到语法分析，其他的过程都是在解释执行时完成的，包括链接、加载、和符号表和出错管理器的交互。

编译器的架构一般采用管道模式（pipe line design pattern），可以想想bash命令行的使用中的管道模式，但是区别是编译器里面有”遍（pass）”的概念。

编译技术为了重用和方便建造，把编译阶段分为前端和后端，有一套理论（如自展）来指导如何用一种语言来生成另一种语言的编译程序，例如如何用同一种语言来生成自身语言的编译程序。

2. 预处理、词法分析

对于编译型语言和解释型语言来说，这两个过程大体相似。

预处理完成的基本上是清洁、整理源代码的作用，包括删除注释，替换宏（或者等价的inline结构）等等。现代的程序语言有一种趋势，把越来越多的工作尽可能提到编译的前阶段来处理（只要是理论上允许，不对整个编译架构产生影响），如预处理程序能检查保留字的拼写，简单的语法错误等等。

对于注释，现代的程序语言越来越倾向于采取可识别语义的注释，如Java中的javadoc格式和annotation。这些注释本身就是另一种语言，并有可能（如annotation）对它注释的语义有补充、限制的作用。

词法分析完成的工作主要是把程序源代码中出现关键字、标识符、常量等用一种中间表示替代，在这一过程中主要涉及到符号表和出错管理器就会被建立。

3. 语法分析

4. 语义分析

5. 代码优化

6. 目标代码生成

7. 加载

8. 解释型语言的编译、加载、执行过程

下面大体以Java为代表说一下解释型语言的编译过程。

调用Javac把程序源代码java文件处理成二进制的class文件，这就是Java全部的所谓的编译过程，class文件可以理解为一种中间表示，JVM规范中定义了其格式，在class文件里面会建立常量表。

当用Java命令运行java程序（class 文件）时，JVM会接管从class文件到能够使你的程序运行起来、接受用户输入的全部过程。

JVM首先会用内建的bootstrap class loader加载一些必须的核心类（如rt.jar, i18n.jar等），这个加载过程对于运行任何java程序都是一样的。接着会使用Extension loader（不确定是属于bootstrap class loader范畴还是属于System class loader范畴）加载JAVA_HOME\LIB\EXT目录下的类，最后按照一定顺序和需要加载位于CLASSPATH上的类。可以在运行java程序时使用下面的参数看详细的加载过程。

Setting the parameter -verbose:class on the java command line prints a trace of the class loading process.

关于加载器的整个层次架构可以看资源里面的相应的文章。加载后的每一个类会用一个Class类的实例表示，这些Class实例就是JVM内部可以识别的关于类的所有信息。一个类加载器加载的类对这个加载器和他所有的子加载器可见，对其他的类加载器不可见，也就是说如果这些不可见的类加载器也加载了同样的类，那么这两个类实例在JVM内部会被识别成两个类。

加载后进行的一个过程是链接（linking），包括验证（verification，验证加载的class是否是well-formed），准备（preparation，为静态存储和JVM中内部使用的数据结构如method talbe（类比C++中的VTABLE）分配空间），解析（Resolution，解析一个类中引用到的所有类，这可能又包括一个递归的加载、链接过程）。

之后进行的是一个初始化过程，包括静态变量的初始器（initializer）和静态结构（如static {}）的初始器。接下来进行新的类实例的创建并进入程序的运行状态。

下面把这个过程和编译型语言的编译过程进行一个非常不严格的类比，以方便理解。

类加载创建Class实例和分配空间的初始化过程可能有点像编译型语言的代码生成过程，生成可以运行的二进制程序，但是生成的二进制程序不会进行固化存储。链接过程中的验证执行的是一部分的语法分析和全部的语义分析，这可能和编译型语言的编译过程倒过来了。最后的类实例的创建过程可能和编译型语言的加载二进制程序文件（类比Class的实例）并运行的过程有点类似，包括JVM也会类似于活动记录（Activation Record）的Method Frame结构，包括动态链、静态链，这些结构JVM也都会创建。

（临时发布草稿，还会不断更新补充）

Resources:

侯文永，张冬茉，《编译原理》，电子工业出版社
The JavaTM Virtual Machine Specification Second Edition
The Java Language Specification, Third Edition
金山词霸
Java programming dynamics, Part 1: Classes and class loading
Understanding Extension Class Loading
Bootstrap class loader

Technorati : compiler, compiler construction, compiler theory, java, programming language
Del.icio.us : compiler, compiler construction, compiler theory, java, programming language
Zooomr : compiler, compiler construction, compiler theory, java, programming language

关于正则表达式

2006-12-21T17:54:00.000+08:00

说明：作者放弃本文的所有权力，本文摘录自其他资料，仅作自己学习之用，请尊重摘录源的作者的版权。

1. 基本概念

正则表达式最早是由数学家Stephen Kleene于1956年提出，正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

2. 正则表达式基础

正则表达式由一些普通字符和一些元字符（metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义。

*元字符*		描述

`.`		匹配任何单个字符。例如正则表达式`r.t`匹配这些字符串：rat、rut、r t，但是不匹配root。
`$`		匹配行结束符。例如正则表达式`weasel$` 能够匹配字符串"He's a weasel"的末尾，但是不能匹配字符串"They are a bunch of weasels."。
^		匹配一行的开始。例如正则表达式`^When in`能够匹配字符串"When in the course of human events"的开始，但是不能匹配"What and When in the"。
*``**		匹配0或多个正好在它之前的那个字符。例如正则表达式*`.`**意味着能够匹配任意数量的任何字符。
`\`		这是引用府，用来将这里列出的这些元字符当作普通的字符来进行匹配。例如正则表达式`\$`被用来匹配美元符号，而不是行尾，类似的，正则表达式`\.`用来匹配点字符，而不是任何字符的通配符。
`[ ]` `[c1-c2]` `[^c1-c2]`		匹配括号中的任何一个字符。例如正则表达式`r[aou]t`匹配rat、rot和rut，但是不匹配ret。可以在括号中使用连字符-来指定字符的区间，例如正则表达式 `[0-9]`可以匹配任何数字字符；还可以制定多个区间，例如正则表达式`[A-Za-z]`可以匹配任何大小写字母。另一个重要的用法是"排除"，要想匹配除了指定区间之外的字符--也就是所谓的补集--在左边的括号和第一个字符之间使用^字符，例如正则表达式`[^269A-Z]` 将匹配除了2、6、9和所有大写字母之外的任何字符。
`\< \>`		匹配词（word）的开始（\<）和结束（\>）。例如正则表达式`\`能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。
``		将 $ 和 $ 之间的表达式定义为"组"（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 `\1` 到`\9` 的符号来引用。
`\|`		将两个匹配条件进行逻辑"或"（Or）运算。例如正则表达式`(him\|her)` 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。

3. 程序语言或环境的支持

4. 实例

临时发布，待续

Resources：

揭开正则表达式语法的神秘面纱

正则表达式之道

Technorati : re, regular expression, 字符匹配, 正则表达式
Del.icio.us : re, regular expression, 字符匹配, 正则表达式

Basics of Javascript

2006-11-20T19:39:00.000+08:00

Note:
My recent posts about basics or overview of something
mostly cite select matirials of sources listed in the Resources section of every
post. It only serves for personal study and learning. And if you like, you can
take any part or all of them as desired. It would be my pleasure.

Overview

Javascript is an html scripting language. In the official specification it is
called ECMAScript.

Built-in Features

Datatypes and Values

All numbers in JavaScript are represented as 64-bit floating-point values
(i.e., similar to double in java and C++).

Conversion between Strings and Numbers can be done in several ways in both
direction. Numbers are automatically converted to strings when needed, so are
strings converted to numbers.

Numbers to strings:

var n = 100;
var s = n + " bottles of beer.";

var n_as_string = n + "";

var string_value = String(number);

string_value = number.toString();

Strings to numbers:

var product = "21" * "2"; // get number 42

var number = string_value - 0;
(Note: adding zero to a string value
results in string concatenation)

var number = Number(string_value);

// And parseInt(), parseFloat.

In JavaScript, functions are values that can be manipulated
by JavaScript code. It means that functions can be stored in variables, arrays,
and objects, and it means that functions can be passed as arguments to other
functions.

Functions can be defined in three ways:

function square(x) { return x*x;}

var square = function(x) { return x*x; }
// function name here is
optional.

var square = new Function("x", "return x*x");
// awkward, less useful and
less efficient.

An object is a collection of named values. These named values are usually
referred to as properties of the object. Properties of objects are, in
many ways, just like JavaScript variables; they can contain any type of data,
including arrays, functions, and other objects. Objects in JavaScript can serve
as associative arrays (recall the same concept in Delphi/Pascal, if you
know that language); that is, they can associate arbitrary data values with
arbitrary strings.

image.width
image.height

image["width"]
image["height"]

Arrays may contain any type of JavaScript data, including references to other
arrays or to objects or functions. Also note that
JavaScript does not support multidimensional arrays,
except as arrays of arrays. Finally, because JavaScript is an untyped language,
the elements of an array do not all need to be
of the same type, as they do in typed languages like Java.

A corresponding object class is defined for each of the three key
primitive datatypes. That is, besides supporting the number, string,
and boolean datatypes, JavaScript also supports Number, String, and Boolean
classes. JavaScript can flexibly convert values from one type to another. When
you use a string in an object contexti.e., when you try to access a property or
method of the string, JavaScript internally creates a String wrapper
object for the string value. Note that the String object created when
you use a string in an object context is a transient one.

Primitive types are manipulated by value, and reference types, as the
name suggests, are manipulated by reference. Numbers and booleans are
easily manipulated at the low levels of the JavaScript interpreter. Objects, on
the other hand, are reference types. Arrays and functions, which are specialized
types of objects, are therefore also reference types.

Since strings (primitive type, not the wrapper) are immutable in JavaScript,
there is no way to tell whether strings are passed by value or by reference.

Variables

There's no fundamental difference in JavaScript between variables and
the properties of objects.

When the JavaScript interpreter starts up, one of the first things it
does, before executing any JavaScript code, is create a global
object. The properties of this object are the
global variables of JavaScript programs. When you declare a global JavaScript
variable, what you are actually doing is defining a property of the global
object.

The JavaScript interpreter initializes the global object with a number of
properties that refer to predefined values and functions. For example, the
Infinity, parseInt, and Math properties refer to the
number infinity, the predefined parseInt( ) function, and the
predefined Math object, respectively.

In top-level code (i.e., JavaScript code that is not part of a function), you
can use the JavaScript keyword this to refer to the global
object.

In client-side JavaScript, the Window object
serves as the global object for all JavaScript code contained in the
browser window it represents. This global Window object has a self-referential
window property that can be used instead of this to refer to
the global object. The Window object defines the core global properties, such as
parseInt and Math, and also global client-side properties,
such as navigator and screen.

For local variables, while the body of a function is executing, the function
arguments and local variables are stored as properties of another special
object. This object is known as the call object.

Each time the JavaScript interpreter begins to execute a function, it creates
a new execution context for that function. Thus,
JavaScript code that is not part of any function runs in an execution context
that uses the global object for variable definitions. A JavaScript
implementation may allow multiple "global" execution contexts. The
obvious example is client-side JavaScript, in which each separate browser
window, or each frame within a window, defines a separate global execution
context.

Object Support

ECMAScript does not contain proper classes such as those in C++, Smalltalk,
or Java. An ECMAScript object is an unordered collection of properties each with
zero or more attributes.

It turns out that every JavaScript object includes an internal
reference to another object, known as its prototype object. All
functions have a prototype property that is automatically created and
initialized when the function is defined. The initial value of the
prototype property is an object with a single property. This property
is named constructor and refers back to the constructor function with
which the prototype is associated.

Property inheritance occurs only when you read property values, not
when you write them. If you set the property p in an
object o that inherits that property from its prototype, what
happens is that you create a new property p directly in
o. Now that o has its own property named
p, it no longer inherits the value of p from
its prototype.

Navigator Object

The JavaScript
navigator object is the object representation of the client internet browser
or web navigator program that is being used. This object is the top level object
to all others.

DOM Object

Overview

The goal of the DOM group is to define a programmatic interface for XML and
HTML. It is platform- and language-neutral interface. The DOM is separated into
three parts: Core, HTML, and XML. The Core DOM provides a low-level set of
objects that can represent any structured document.

DOM is being designed at several levels:

"Level 1. This concentrates on the actual core, HTML, and XML document
models. It contains functionality for document navigation and manipulation.

Level 2. Includes a style sheet object model, and defines functionality for
manipulating the style information attached to a document. It also enables
traversals on the document, defines an event model and provides support for XML
namespaces.

Level 3. Will address document loading and saving, as well as content models
(such as DTDs and schemas) with document validation support. In addition, it
will also address document views and formatting, key events and event groups.
First public working drafts are available.

Further Levels. These may specify some interface with the possibly
underlying window system, including some ways to prompt the user. They may also
contain a query language interface, and address multithreading and
synchronization, security, and repository."

Resources

ECMAScript
Language Specification 3rd edition

Ajax
in Action

The
CTDP JavaScript Manual Version 0.6.0, December 31, 2000

W3C Document Object Model
(DOM)

DOM
objects and methods

JavaScript - The Definitive Guide, 5th Edition

This is a rough draft and published temporarily.

Study XSLT Tutorial

2006-11-15T18:06:00.000+08:00

Overview

XSL = XML Style Sheets

XSL consists of three parts:

XSLT - a language for transforming XML documents

XPath - a language for navigating in XML documents

XSL-FO - a language for formatting XML documents

The root element that declares the document to be an XSL style sheet is <xsl:stylesheet> or <xsl:transform>.

Note: <xsl:stylesheet> and <xsl:transform> are completely synonymous and either can be used!

More Color On The Overview

An XSLT style sheet consists of a set of template rules, each of which takes the form "if this condition is encountered in the input, then generate the following output." The order of the rules is immaterial, and there is a conflict-resolution algorithm applied when several rules match the same input. One respect in which XSLT differs from serial text processing languages, however, is that the input is not processed sequentially line by line. Rather, the input XML document is treated as a tree structure, and each template rule is applied to a node in the tree. The template rule itself can decide which nodes to process next, so the input is not necessarily scanned in its original document order. [via]

Use XSL To Transform a XML Document

First declare the a xsl document and then define templates:

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
<html>
<body>
<h2>My CD Collection</h2>
<table border="1">
<tr bgcolor="#9acd32">
<th>Title</th>
<th>Artist</th>
</tr>
<xsl:for-each select="catalog/cd">
<tr>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="artist"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>

</xsl:stylesheet>

Then specify the stylesheet in your xml source document, simply like this: <?xml-stylesheet type="text/xsl" href="cdcat.xsl"?>.

The match attribute is used to associate a template with an XML element. But match="/" defines the whole document by associating the template with the root of the xml source document, in which the value of the match attribute is an XPath expression.

In the element <xsl:for-each select="catalog/cd">, "catalog/cd" matches (case-sensitive match, after all an xsl instance is an xml document.) the data structure in the xml document, i.e., the value of the select attribute (a little bit like "select" in SQL) is an XPath expression.

We can also filter the output from the XML file by adding some criterions to the select attribute in the <xsl:for-each> element.

<xsl:for-each select="catalog/cd[artist='Bob Dylan']">

Legal filter operators are:

= (equal)

!= (not equal)

< less than

> greater than

Note: 'Bob Dylan' should match exactly what is between the <artist> and </artist>, including white spaces and line breaker.

We can use an <xsl:sort> element inside the <xsl:for-each> to sort the output.

To add an if statement use the syntax below:

<xsl:if test="expression">
...
...some output if the expression is true...
...
</xsl:if>

For example:

<xsl:for-each select="catalog/cd">
<xsl:if test="price > 10">
<tr>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="artist"/></td>
</tr>
</xsl:if>
</xsl:for-each>

See here for more conditional tests to filter the output by using <xsl:choose> and <xsl:when>.

Without its select attribute specified, <xsl:apply-templates> is used to apply any relevant template(s) to the matched node(s)'s children. While using this element's select attribute, you can be pickier about exactly which children of a node should be processed and in what order.

Referring to the xsl file directly in an xml docuemt requires that there be a XSLT aware browser.Actually, we could have alternatives for the transformation. First, we can use javascript on the client side to invoke a stand alone xml parser, such as MS XML Parser, to do the transformation. Second, we can also use server side scripting language (e.g., asp, jsp, python, etc) to do the transformation, which meets the cross browser needs.

The xsl:attribute element can be used to add attributes to result elements whether created by literal result elements in the stylesheet or by instructions such as xsl:element.

Little Tricks

1. Use <...select="@width"> to identify the attribute of an element, in which case width is the attribute name. The XPath expression ../@title selects the title attribute of the element that is the parent of the current node.

2. Use curly braces ({}) surrounding an expression to specifiy an attribute value template. e.g., ＜h1＞＜a href="{../link}"＞＜xsl:apply-templates/＞＜/a＞＜/h1＞ (".." may be meant to go to parent node of the current node). And see the following example for more details:

The following example creates an img result element from a photograph element in the source; the value of the src attribute of the img element is computed from the value of the image-dir variable and the string-value of the href child of the photograph element; the value of the width attribute of the img element is computed from the value of the width attribute of the size child of the photograph element:

<xsl:variable name="image-dir">/images</xsl:variable>

<xsl:template match="photograph">
<img src="{$image-dir}/{href}" width="{size/@width}"/>
</xsl:template>

With this source

<photograph>
<href>headquarters.jpg</href>
<size width="300"/>
</photograph>

the result would be

<img src="/images/headquarters.jpg" width="300"/>

3. The order in which various template rules appears in the stylesheet mean nothing to the XSLT processor.

4. The XSLT processor uses the most specific template it can find to process each node of the source tree. So template: <xsl: template match="*|@*|text()"> might do nothing if any other templates are defined, since it just matches any element, attribute and text nodes. And another example, in the existence of <xsl:template match="channel/title">, <xsl:template match="title"> might do nothing also.

Conclusion

Conceptually (the fact is almost the same most of the time), you can think of the transformation process with XSLT like this: the input xml source document is parsed as a source tree structure (DOM?), and another input, the style sheet is also parsed as a tree stucture, then it's the XSLT Processor's job to write the source tree as the result tree according to the stylesheet (mostly, template rules). Figure 1 illustrates the process.

Figure 1. Operation of an XSLT Processor

Resources:

1. XSLT Tutorial

2. XSL Transformations (XSLT) Version 1.0

3. 使用XML: XSLT 2.0和XQuery对比

4. What kind of language is XSLT?

5. Book: XSLT Quickly

6. Saxon: Anatomy of an XSLT processor

A Little Trick: XML Data Embedded in HTML

2006-11-14T17:48:00.000+08:00

You can embed xml which contained data you want to display in a html document. The line of code does this embeding thing is like this:

<xml id="cdcat" src="cd_catalog.xml"></xml>

But there's a little trick. It requires that the xml source document's name reflect the structure of the xml document. For example, below is a fragment of the source document:

<?xml ...?>
<CATALOG>
<CD>
<...

For the xml document containing this fragment of codes should be referred as "cd_catalog.xml" in the embeding html document. So below is the whole example.

The XML document containing the data:

<?xml version="1.0" encoding="ISO-8859-1"?>
<CATALOG>
<CD>
<TITLE>Empire Burlesque</TITLE>
<ARTIST>Bob Dylan</ARTIST>
<COUNTRY>USA</COUNTRY>
<COMPANY>Columbia</COMPANY>

<PRICE>10.90</PRICE>
<YEAR>1985</YEAR>
</CD>
<CD>
<TITLE>Hide your heart</TITLE>
<ARTIST>Bonnie Tyler</ARTIST>
<COUNTRY>UK</COUNTRY>

<COMPANY>CBS Records</COMPANY>
<PRICE>9.90</PRICE>
<YEAR>1988</YEAR>
</CD> ... </CATALOG>

The HTML document embeding the xml data:

<html>
<body>

<xml id="cdcat" src="cd_catalog.xml"></xml>

<table border="3" datasrc="#cdcat">

<tr>
<td><span datafld="ARTIST"></span></td>
<td><span datafld="TITLE"></span></td>
</tr>

</table>

</body>
</html>

Click this link to see the live example. And as the tutorial mentioned, it seems it only functions on IE 5.0 or later version, but not functions on Firefox.

Resourses:

XML Data Island

The Java SE 6 Platform Quiz

2006-11-13T17:47:00.000+08:00

The following quiz answers cites The Java SE 6
Platform Quiz:

1. What scripting language can you use in the Java SE 6 platform?

Answer (E): The Mozilla
Rhino engine implements the JavaScript technology
scripting language and is available in the core Java Runtime Environment (JRE).
However, the scripting API allows you to use any scripting engine that conforms
with JSR 223.

2. What is the normalization of Unicode text?
Answer (C):
The Java SE 6 platform provides the public java.text.Normalizer
class, which allows you to convert text data to common composed or decomposed
forms, allowing for accurate comparisons and searches on text. Before the Java
SE 6 platform release, the Normalizer class had been hidden in the
Java platform. The class is now a public API.

3. How do you launch your host’s default browser to view a specific
URL?
Answer (B): The Desktop
API allows your program to launch applications associated with certain file
types on the host platform. The current implementation can launch a web browser,
text editor, and email application.

4. How can I sort JTable content?
Answer
(D): A javax.swing.table.TableRowSorter wraps your existing
TableModel. You can configure it to filter or sort your
JTable contents.

5. What is the correct annotation to use to export a method as a web
service operation using Java API for XML Web Services (JAX-WS), version
2.0?
Answer (B): The @WebMethod annotation is used to
mark a method that is exposed as a web service operation. Note that the
@WebService annotation is used to specify that the class is a web
service or that the interface defines a web service. The programmer will likely
use the @WebService annotation in conjunction with the
@WebMethod annotation. See the article “Introducing
JAX-WS 2.0 With the Java SE 6 Platform, Part 1” for more information.

6. In JDK 6, the JMX Monitor API now uses a thread pool to increase
performance. What is the purpose of the JMX Monitor API?
Answer (D):
The JMX
Monitor API allows an application to sample an attribute property of an
MBean periodically and send a notification event if it passes a given threshold.
It now uses a thread pool instead of creating a thread for each monitor. Another
improvement is the ability to monitor a value within a complex type.

7. JDK 6 incorporates an advanced version of the
SwingWorker class into core Java technology. What is the purpose of
the SwingWorker class?
Answer (D): Since the 1998
publication of SwingWorker in the article “Threads
and Swing,” developers have continuously requested that it be moved into
core. At the 2004 JavaOne conference, the Desktop team presented a new version
of SwingWorker that included generification, use of the concurrency
package, and PropertyChangeListener support. Much of this
functionality assists with interthread communication. The Java SE 6 platform
release incorporates a similar version of SwingWorker
that greatly assists developers in processing GUI-driven functionality off the
event-dispatching thread, indicating status and progress and aggregating the
results.

8. What is the best Java platform to use with the upcoming release of
the Microsoft Windows Vista operating system?
Answer (A): The Java
SE 6 platform release works best with the latest user interface (UI)
enhancements of Windows Vista. According to a recent blog entry by Chet Haase: “The
primary delivery of Java for Vista is Java SE 6; that release has received most
of our focus during the Vista beta release timeframe.” Go to the JDK 6 Project site to download the most
recent version. The release is pretty close to final, so it is working very well
at this point. All of the serious Windows Vista problems have been fixed in this
release for months, so it is a particularly good test vehicle for Java
technology on Vista.

9. In the Java SE 6 platform, what key tuning option(s) are needed to
achieve high performance?
Answer (D): See the blog entry “No Tuning
Required: Java SE Out-of-Box Vs. Tuned Performance” for a comparison of
out-of-box and hand-tuned performance.

10. The Java SE 6 platform delivers a technology that can greatly
improve performance by reducing unnecessary synchronization overhead. It allows
a thread to lock and unlock an object with minimal use of atomic operations.
What is this technology called?
Answer (B): The technique called
store-free biased locking eliminates all synchronization-related atomic
operations on uncontended object monitors. The technique supports the bulk
transfer of object ownership from one thread to another, and the selective
disabling of the optimization where unprofitable, using epoch-based bulk
rebiasing and revocation. It has been implemented in the production version of
the Java HotSpot virtual machine (VM) and has yielded significant performance
improvements on a range of benchmarks and applications.

Three ways of validating a xml document with Java

2006-11-13T17:44:00.000+08:00

With the rollout of Java 5.0 last year, JAXP 1.3 was in place for use. And one of the new features provided by JAXP 1.3 is a brand new Schema Validation Framework.

The newly provided framework decouples the validation of an instance document as a process independent of parsing. The Validation APIs are in the new package javax.xml.validation and let developers obtain from a compiled schema a Validator or/and a Validator Handler which are used to validate xml against the given schema. Alternatively, a compiled schema instance could also be passed to any Reader/Parser to validate xml. So there're roughly two ways provided by the new Schema Validation Framework. And besides these two, setting the uncomplied schema source on Reader/Parser is also available due to the issue of backward compatibility. As we can see in the first article and the accompanying example codes listed in the Resources section, the newly introduced Validation Frame improves the performance, effiency and flexibility.

Below are simple code snippets to respectively illustrate how validating xml documents is done in these three ways.

1. Set uncompiled schema (since JAXP 1.2):

private static void saxParseJAXP1_2(String xmlFile, DefaultHandler dh,
String schemaFile) {
try {
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setNamespaceAware(true);
spf.setValidating(true);
SAXParser sp = spf.newSAXParser();
sp.setProperty(
http://java.sun.com/xml/jaxp/properties/schemaLanguage,
XMLConstants.W3C_XML_SCHEMA_NS_URI);
sp.setProperty(
"http://java.sun.com/xml/jaxp/properties/schemaSource",
schemaFile);
sp.parse(new File(xmlFile), dh);
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

2. Set compiled schema instance (since JAXP 1.3, FIX ME HERE)

private static void saxParseSetSchemaJAXP1_3(String xmlFile, DefaultHandler dh,
String schemaFile) {
try {
SchemaFactory sf = SchemaFactory.newInstance(
XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = sf.newSchema(new File(schemaFile));
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setNamespaceAware(true);
spf.setSchema(schema);
SAXParser sp = spf.newSAXParser();
sp.parse(new File(xmlFile), dh);
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}

3. Validator (since JAXP1.3)

private static void saxParseValidateJAXP1_3(String xmlFile,
ErrorHandler dh, String schemaFile) {
try {
SchemaFactory sf = SchemaFactory.newInstance(
XMLConstants.W3C_XML_SCHEMA_NS_URI);
Validator validator = sf.newSchema(
new File(schemaFile)).newValidator();
validator.setErrorHandler(dh);
validator.validate(new StreamSource(xmlFile));
} catch (Exception e) {
e.printStackTrace();
}

It's noteworthy that the first way and the second way can apply for both DOM source and SAX source, while the third way is usually only used to validate a SAX stream (FIX ME HERE).

Update (20061113):

Basics of using Schema

Be aware of the concept of xml target namespace and "source namespaces". The name defined in a schema are said to belong to its target namespace. Definitions and declarations in a schema can refer to names that may belong to other namespaces. In the fourth article those namespaces are referred to as "source namespaces". And here follows a little colour as to simple type and complex type. An element that doesn't contain attributes or other elements can be defined to be of a simple type, predefined or user-defined, such as string, integer, decimal, time, etc. Elements with attributes and embeded elements must have a complex type. There're a huge amount of details about XML Schema definition that are not covered here but can be found here.

Simple example

A xml instance document:

<?xml version = "1.0" encoding = "utf-8"?>
<SONGS xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
xsi:noNamespaceSchemaLocation='mySong.xsd'>
<SONG genre = "pop">
<TITLE > Hot Cop </TITLE>
<COMPOSER > Jacques Morali
</COMPOSER>
<COMPOSER>Henri Belolo</COMPOSER>
<COMPOSER>Victor Willis</COMPOSER>
<PRODUCER>Jacques Morali</PRODUCER>
<PUBLISHER>PolyGram Records</PUBLISHER>
<LENGTH>6:20</LENGTH>
<YEAR>1978</YEAR>
<ARTIST>Village People</ARTIST>
</SONG>
</SONGS>

The corresponding schema definition:

<?xml version="1.0" encoding="UTF-8" ?>
<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
<xsd:element name="SONGS">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="SONG" minOccurs='1' maxOccurs='unbounded' />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="SONG">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="TITLE" type="xsd:string" />
<xsd:element name="COMPOSER" type="xsd:string" maxOccurs='unbounded' />
<xsd:element name="PRODUCER" type="xsd:string" maxOccurs='unbounded' />
<xsd:element name="PUBLISHER" type="xsd:string" maxOccurs='unbounded' />
<xsd:element name="LENGTH" type="xsd:string" />
<xsd:element name="YEAR" type="xsd:gYear" />
<xsd:element name="ARTIST" type="xsd:string" maxOccurs='unbounded' />
</xsd:sequence>
<xsd:attribute name="genre" type="xsd:string" />
</xsd:complexType>
</xsd:element>
</xsd:schema>

Resources:

1. Easy and Efficient XML Processing: Upgrade to JAXP 1.3

2. Java 2 Platform Standard Edition 5.0 API Specification

3. Java 2 Platform Standard Edition 1.4.2 API Specification

4. The basics of using XML Schema to define elements

5. XML Schema Part 0: Primer Second Edition

Comment on W3C DOM and various implementations in different PL

2006-11-11T17:35:00.000+08:00

First I have to confess I'm quite unfamiliar with xml processing. I've only done it once extensively in Delphi due to a project I was involved in.

These days I'm studying tricks and technologies as to xml processing with java. So as I mentioned in a previous post I wrote about the overview on it. In particular, I mentioned the DOM way which is based on DOM, Document Object Model, a standard Object Model of XML maintained by the W3C Consortium. Here I first give some simple details about DOM itself.

For a simple xml document shown below:

<?xml version="1.0" encoding="UTF-8" ?>
<song genre="rock">
<name>My December</name>
<singer>Linkin Park</singer>
</song>

The DOM tree-like structure should be like this (E indicates a element node and T indicates a text node):

E:song
|--T:characters(whitespace)
|--E:name---T:characters(My December)
|--T:characters(whitespace)
|--E:singer---T:characters( Linkin Park)
|--T:characters(whitespace)

As depicted above, the root node song has five child nodes among wich two have their child nodes. I wanna emphasize the text node here. Before I start going deep into xml processing these days, I even don't know the existence of so-called text nodes. Because in Delphi, they're just ignored. So the DOM tree-like structure is like this:

E:song---E:name
|--E:singer

Only an element is called a node. I think this is quite intuitive, though definitely the official DOM structure is more theoretically complete. But with the white space and other text nodes the process of xml parsing is complicated. The example is worth a thousand words. Let's see how the simple xml document is parsed defferently in Java and Delphi:

In Java (exceptions are left unhandled):

Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(<xml file name>);
Element root = doc.getDocumentElement();
NodeList list = root.getChildNodes();
// A simple helper method
printStr("name: " + list.item(1).getFirstChild().getNodeValue());
printStr("singer: " + list.item(3).getFirstChild().getNodeValue());

In Delphi:

var
XMLDoc: IXMLDocument;
XMLNode, CtlNode: IXMLNode;
i, index: integer;
str: string;
begin
str = '';
XMLDoc := TXMLDocument.Create(nil);
XMLNode = XMLDoc.ChildNodes.Nodes['song'];
for i := 0 to XMLNode.ChildNodes.Count - 1 do
begin
str := str + XMLNode.ChildNodes.Nodes[i].NodeValue;
end;
end;

Apparently, the Java version is more awkward and will be more complicated provided the xml document is very long. This is because the element nodes can't be sequentially accessed due to the existence of white space text nodes. In contrast, with text nodes ignored, the Delphi version is quite clear and adaptive to document of any size. As I know, besides Java many implementations (at least Javascript, as I know) of DOM are aware of the text nodes, especially the white space text nodes.

So various kinds of helper method are used by developers to improve this awkward situation.
Method 1:

private Node getNodeByName(final NodeList list, final String name) {

for (int i = 0; i < list.getLength(); i++) {

final Node node = list.item(i);

// to pass the white space node

if (name.equals(node.getNodeName())) {

return node;

return null; // not found

}

Method 2:

...

NodeList list = e.getChildNodes();

for (int i = 0; i < list.getLength(); i++) {

Node n = list.item(i);

  // to pass the white space node

if (!(n instanceof Element)) { continue; }

nsFixup((Element) n, map, false);

And I believe there must be more.

I really don't see any benifits of keeping the awareness of text nodes until now. But If you know, tell me please.

Unicode, UTF等字符编码摘记

2006-11-10T17:33:00.000+08:00

两个遵守相同规范的编码标准
unicode 3.0（最新版本5.0）和ISO-10646。从Unicode2.0开始，unicode采用了与ISO 10646-1相同的字库和字码。ISO-10646也叫做UCS (Universal Character Set)。

几个术语：
UTF: Unicode/UCS Transformation Format

UTF-16: 16位编码。基本上是Unicode的双字节编码，额外附加空间用于非常用字符和未来扩充需要（一般很少用到），常用字符在0-0xFFFF，包括扩充空间的范围是0-0×10FFFF，所以最长编码位数是21位。关于扩充空间，在ISO-10646有相对应的定义。由于它是一个变长码，与CPU字序有关（例如“汉”字的Unicode编码是6C49。那么写到文件里时，究竟是将6C写在前面，还是将49写在前面？如果将6C写在前面，就是big endian。如果将49写在前面，就是little endian。），最节省空间，所以常作为网络传输的外码。UTF-16是Unicode的preferred encoding。

UTF-8: 由于UTF-16直接就是Unicode编码，没有变换，包含了0×00在编码内，这个在操作系统内（C语言）中有特殊意义（和ASCII不兼容？），会引起问题，所以有时候需要采用UTF-8编码对Unicode的直接编码做一些变换。UTF-8对ASCII不作变换，进行8位编码，其他字符做变长编码，每个字符1-3个字节。与CPU字序无关，可以在不同平台之间交流。

UCS-2: 与UTF-16基本一样。

UCS-4: 4字节编码，目前是在UCS-2前加上2个全零的byte。

内码：内码是指操作系统内部的字符编码。早期操作系统的内码是与语言相关的.现在的Windows在内部统一使用Unicode，然后用代码页适应各种语言,“内码”的概念就比较模糊了。微软一般将缺省代码页指定的编码说成是内码，在特殊的场合也会说自己的内码是 Unicode，例如在GB18030问题的处理上。

字符集：charcterset 字符的集合，例如Unicode是一种字符集。

字符编码：Encoding 如何将二进制数据识别为字符的编码，一种编码表示的字符是有限的，常常一种编码设计为表示一种字符集。例如UTF-8，UTF-16是两种字符编码，它们能够表示Unicode字符集的所有字符。

中国国标编码:

GB 13000: 完全等同于ISO 10646-1/Unicode 2.1, 今后也将随ISO 10646/Unicode的标准更改而同步更改.

GBK: 对GB2312的扩充, 以容纳GB2312字符集范围以外的Unicode 2.1的统一汉字部分, 并且增加了部分unicode中没有的字符.

GB
18030-2000: 基于GB 13000, 作为Unicode 3.0的GBK扩展版本, 覆盖了所有unicode编码,
地位等同于UTF-8, UTF-16, 是一种unicode编码形式. 变长编码, 用单字节/双字节/4字节对字符编码.
GB18030向下兼容GB2312/GBK.
GB 18030是中国所有非手持/嵌入式计算机系统的强制实施标准.

Update (20061114): ISO 8859-1:

ISO/IEC 8859-1，又称Latin-1或“西欧语言”，是国际标准化组织内ISO/IEC 8859的第一个8位字符集。它以ASCII为基础，在空置的0xA0-0xFF的范围内，加入192个字母及符号，借以供使用变音符号的拉丁字母语言使用。

其他：

UCS只是规定如何编码，并没有规定如何传输、保存这个编码。例如“汉”字的UCS编码是6C49，我可
以用4个ascii数字来传输、保存这个编码；也可以用utf-8编码:3个连续的字节E6 B1
89来表示它。关键在于通信双方都要认可。UTF-8、UTF-7、UTF-16都是被广泛接受的方案。UTF-8的一个特别的好处是它与ISO-
8859-1完全兼容。UTF是“UCS Transformation Format”的缩写。

所谓代码页(code page)就是针对一种语言文字的字符编码。例如GBK的code page是CP936，BIG5的code page是CP950，GB2312的code page是CP20936。
　　Windows中有缺省代码页的概念，即缺省用什么编码来解释字符。例如Windows的记事本打开了一个文本文件，里面的内容是字节流：BA、BA、D7、D6。Windows应该去怎么解释它呢？

　
　是按照Unicode编码解释、还是按照GBK解释、还是按照BIG5解释，还是按照ISO8859-1去解释？如果按GBK去解释，就会得到“汉字”
两个字。按照其它编码解释，可能找不到对应的字符，也可能找到错误的字符。所谓“错误”是指与文本作者的本意不符，这时就产生了乱码。

　　答案是Windows按照当前的缺省代码页去解释文本文件里的字节流。缺省代码页可以通过控制面板的区域选项设置。记事本的另存为中有一项ANSI，其实就是按照缺省代码页的编码方法保存。

　　Windows的内码是Unicode，它在技术上可以同时支持多个代码页。只要文件能说明自己使用什么编码，用户又安装了对应的代码页，Windows就能正确显示，例如在HTML文件中就可以指定charset。

趣事：

　　“endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开，由此曾发生过六次叛乱，一个皇帝送了命，另一个丢了王位。
　　我们一般将endian翻译成“字节序”，将big endian和little endian称作“大尾”和“小尾”。

Resources:
1. 对字符编码与Unicode,ISO 10646,UCS,UTF8,UTF16,GBK,GB2312的理解国际化支持 USENIX.CN - powered by Sinoprise Technology Lab （有比较详细的介绍）

2. 无废话XML

3. 简要解释UCS、UTF、BMP、BOM等名词

4. 中文编码处理(1) －－编码与字符集

5. ISO 8859-1

注：文中参考的不全是官方或权威资料，难免有错误，仅作学习用，本人对文中错误不负任何责任，并欢迎改正错误。

XML Processing With Java Overview

2006-11-10T17:31:00.000+08:00

There’re basically two ways of processing xml with Java. One is the DOM way, that is tree-structure based way, and the other way is the SAX way that is event-driven stream based way. However, the bad thing is that there’re pros and cons for both ways, and the good thing is that we can use one of them in different situation to meet different needs.

The DOM way
DOM, Document Object Model, is the standard specification released by w3c consortium. It is a tree like structure which represents the structure of a XML document and is what what we often first parse a XML document into before we do any manipulation to it. It is quite intuitive for most programmers to manipulate. With it we can easily get what we want from a XML document, element names, attributes, values of elements, etc. But the price to pay is that before any manipulation we have to read the entire xml document and parse it into a DOM object during which everything must be stored in memory. This is inefficient and sometimes impossible, especially for extremely large documents. By the way, besides DOM, there’re some unofficially object models in use, such as JDOM, XOM, DOM4J and so on.

The SAX way
It is a stream like and event-based way. We can processing a document while we’re reading it. It is a very flexible but more complicated way than the DOM way. It is flexible because the SAX stream can be redirected to other process or document. It is complicated because the event handler (usually the DefaultHandler or ContentHandler) must be first written and then registered with the Parser (alternatively reader, or something like that). And there’re other disadvantages. Because it is processed like a stream, it is impossible to make changes to it or move backward to the data stream. But it is possilbe to make some simple structure (not the data itself) changes by using xsl transformation. In general, the SAX way is much faster than the DOM way.

What make up the “XML Processing”
So-called XML processing or sometimes called parsing consists of several aspects or procedures.
Validation
Data Modification and Retrieve
Transformation
Data Query

Examples

Higher Level Application
What are mentioned above are only those basic aspects about xml processing. Seen from a more global perspective, there’re many other higher level application of xml or xml processing.

Published temporarily and remains further refinement.

Always prototyping your new features that are to be added

2006-07-26T17:29:00.000+08:00

Wow, this new feature is awesome. It’s super cool!. I woner if we could add it our product. Ok, I’m gonna do it right now.

But wait…

First develop a prototype with this new feature added. Then see how this feature functions within your product, how it collaborate with other features. If these all are just fine then change your artifacts to add it to your product extensively and “aggressively”. This would be safer.

Never do so-called feasibility analysis just in your mind or just on a paper with your pen. You’re cheating yourself. In this way you would be very excited with your analysis results at most time and say to your colleagues those words written in the first paragraph of this post.

We experienced this cheating-ourself process. And it turns out to be that this new feature actually doesn’t function as we expected but meantime we have to keep those codes modified during adding this new feature for not wasting more time removing them and bringing new risks even though we know they’re useless. This may be a lesson you can learn from.

It is noteworthy that the beta policy of most web2.0 applications goes to extremes in prototyping new features and that developping iteratively is the essence of contemporary software development.

One post of my development diary series…to be continued.

Technorati : beta, programming, software development, software engineering, tech
Del.icio.us : beta, programming, software development, software engineering, tech

Help me with automating KDE environment settings

2006-07-26T17:27:00.000+08:00

I have pasted this on some tech forums, but no one seems to be willing to help me. So I would like to also paste it here. Any help or even any response making no sence would be very appreciated.

我刚接触Linux不久，现在碰到要做这个，请各位高手支支招。

主要分为几个部分：
1. Desktop shortcut, background, etc;
2. Kicker (Panel), start menu, custom menu, etc; and
3. Konqueror, Konsole, etc.

由于KDE采用 Cascading Configuration Files的结构（至少KDE3.1+是这样），有针对所有用户的设置和用户自定义设置，主要的配置文件分别在/usr/share/config， ~/.kde/share/config。我现在采取的策略主要是写了一个脚本用定制的标准桌面环境的配置文件去覆盖 ~/.kde/share/config下面的配置文件（其实我把整个share文件夹都覆盖了）。

现在问题是其他的都似乎没有什么大问题，但是覆盖的kickerrc（配置上文提到的第二个部分中的kicker）文件没有作用，无论是在 /usr/share/config还是在~/.kde/share/config下面，kickerrc里面的设置没法被应用，而且通过手动去修改 Panel（比如增减Applet）后relog in kde session会用修改的配置覆盖掉~/.kde/share/config/kickerrc。似乎kickerrc只是反映当前的panel的设置而不是系统根据kickerrc去配置当前的panel。

我在网上查了很多资料没找到原因，不知道这里有没有人知道。

更新：我用的是Redhat 3企业版（update几忘了，等查到再来更新：）。

How to capture key combination press in java

2006-07-26T17:23:00.000+08:00

Though it may appear extremely easy to someone who has mastered it, I wanna paste some useful code here both for myself to keep a note and for those who haven’t ever addressed this problem to use as a guideline.

Code snippet (catch “ctrl+shift+`”):

public final static int CTRL_SHIFT_MASK =
KeyEvent.SHIFT_MASK | KeyEvent.CTRL_MASK;

if ((evt.getModifiers() & CTRL_SHIFT_MASK) != 0) {
if (inputEnabled) holdInput(true);

// Press “Ctrl+Shift+`” to toggle view only option.
if ((evt.getModifiers() & CTRL_SHIFT_MASK) == CTRL_SHIFT_MASK &&
keyCode == KeyEvent.VK_BACK_QUOTE) {
boolean viewOnly = !_vc.getConfigManager().isViewOnly();
_vc.getConfigManager().setViewOnly(viewOnly);
if (!viewOnly) {
inputRecorder.setPaused(false);
inputRecorder.setLastLogTime(System.currentTimeMillis());
} else {
inputRecorder.setPaused(true);
}
clearInput();
return;
}

Here key combination restricts to the pattern of modifier key(s) (ctrl, shift, alt) plus ordinary character key or only combination of modifier keys themselves.

The end.

Thoughts after Ivar Jacobson's speech. Is Agile Process really Agile?

2005-10-26T19:38:00.000+08:00

25th Oct. Shanghai China, I heard Ivar Jacobson's speech about his understanding about the next generation of software process. IMHO, his key point is to make UP(Unified process) more agile than agile process, which he called "smart". Then I wasn't much convined, because I thought his understanding dpend too much on a intellegent product called "WayPointer" developed by one of his own company. But later when I went home and used WayPointer trial edition accompanied with the provided CD to work with Rational's product, I understand everything. It really can make RUP more agile. It's a intellegent agent acts as pair programmer, telling you when and what parts of RUP document to read.
And, another of his point supporting the key point is UP use explicit knowledge rather than tacit knowledge, which make ailge seem to be agile, used by agile process. With explicit knowledge you can learn and you can search for what to do next in the knowledge library. However, tacit knowlege is never documented and hard to be learned and harder to be searched. So the most experienced programmer have the most tacit knowledge, which make success of project primarily rely on key individuals. So, is Agile process really agile?（Anyone wants a PPT of his speech, email me at i.am.blogger at gmail dot com).
What a pity, Dr. Ivar didn't talk much about doing use case with aop, which he proposed in his latest papers and later turned out a book about AOSD(I got the book for free at the speech : ). So the following part of my blog will cover this aspect.
The report was received with complacency:" This is the nature of software--use case cross component--and there's nothing to be done about it."In RUP, use case play a very important role, elicitating requirements, coordinating stakeholder requests, measuring the grain of iteration. According to RUP, use cases are finded out, refined and then usually implemented in several components, that is, simply speaking, a use case is often devided into parts assigning to components(Classes, to simplify the matter) according to each component's reponsibility. However, that's not the end. In RUP test cases are derived from use cases, which means testing is usually conducted in terms of use case to verify every use case is correctly implemented. All we see is that it's really a use case driven way, but traditional components stands in the way, breaking down use cases. It seems if we are royal enough to use case technology, traditional component-centric development contribute negatively to the whole development process.And interestingly enough, in an AOP view, it's typically crosscutting, with every use case almost always cross cutting components. Dr. Ivar has his own way of solving this problem, which he proposed in this paper.
But I wonder if a use case driven method is widely adopted, otherwise it isn't worth much effort on this issue.
So here I wanna conduct a survey, how many companies use USE CASE technology and to what degree use case technology is adopted (only used to handle requirement issue or as a use case driven development way)?
Any comment about either my ideas or this survey would be very appreciated.

Is AOP a Programming paradigm

2005-10-22T01:21:00.000+08:00

Edited by: I.Am.Blogger at gmail dot com

Prerequisite:
“A programming paradigm is a paradigmatic style of programming (compare with a methodology which is a paradigmatic style of doing software engineering). A programming paradigm provides (and determines) the view that the programmer has of the execution of the program.”
(http://en.wikipedia.org/wiki/Programming_paradigm)

Yes:
“I would argue that by any reasonable definition of paradigm, AOP is one. You can "think aspects" starting from fairly early in the design process (probably requirements too); you can design and develop those aspects; you can make the code look like the design; the aspects can be treated as independent units, with independently assessable properties and value. All the things that I at least thought made OO a paradigm seem to apply...”
By Gregor Kiczalse(http://aosd.net/pipermail/discuss_aosd.net/2004-July/001001.html)

“…Note that the original meaning of "paradigm" entails the notion that two different paradigms are incompatible, which means that the qualification as paradigms does not depend on whether you can use them independently but rather that you _cannot_ use them together. From this perspective, none of the programming paradigms in computer science are really paradigms, because it's certainly possible to mix them altogether…The analogy that I'd propose is that AOP relates to OOP as OOP relates to imperative programming, and if you describe the move from imperative programming to OOP as a paradigm shift, you also have to describe the move from OOP to AOP as a paradigm shift to the same degree.”
By Pascal Costanza (http://aosd.net/pipermail/discuss_aosd.net/2004-July/001004.html)

No:
“Mathematically, aspects form a second-order extension of any programming paradigm: while usual programming paradigms allow reasoning about single functions, messages and so forth by a function/message signature, AOP enables reasoning about entire sets of those entities by using pointcuts with wildcards in their signature. Thus one could view AOP as a powerful, logical extension, rather than as an independent paradigm. Friedrich Steimann, for example, has proposed such a view.”
Wikipedia(http://en.wikipedia.org/wiki/Aspect-oriented_programming)

“..In OOP you have communicating objects with encapsulated state. In FP you have the notion of encapsulated functionality and side-effect-freeness, however no explicit notion of state…that all the paradigms noted above can exists "on its own". You can use FP without OOP…AOP, however as I see it, always (correct me, if I am wrong here) makes use of a kind of "host paradigm", that provides basic expressiveness and then kind of provides a way for second-order reasoning on that "host paradigm"…”
(http://aosd.net/pipermail/discuss_aosd.net/2004-July/001003.html)
“…when moving from IP to OOP,one gains the new concept of encapsulated state together with the notion of messages. This changes the whole universe of reasoning: Instead of reasoning about loops or sequences of commands executed on a machine (IP) one now certainly talks about objects that are communicating via messages.…I see the difference in the fact that when moving from IP to OOP, we change the entities we are reasoning about (objects rather than commands) while with AOP we don't really. Of course AOP claims an aspect as the additional entity of reasoning. But can one really see an aspect as a single entity ,that is without any coupling of the outer world? Objects in OOP do so, also do functions in FP (due to side-effect-freeness), aspects however don't, since in all AOP languages you will always at some point have to conrecretize when and where your aspect synchronizes with the rest of the world…An object in OOP is fully compositional without exposing any of its subunits to the outer world. For functions in FP, the same holds. However, does that also hold for aspects?....”
(http://aosd.net/pipermail/discuss_aosd.net/2004-July/001005.html)

Two citations above By Eric Bodden

Note: FP=Functional Programming, IP=Imperative Programming.

XMLBeans Practice--Automate Exchanging data between XML's & Java (1)

2005-04-15T00:37:00.000+08:00

Installation of XMLBEANS
I hope this section can help solve your problems, if not all, encountered when installing XMLBEANS. XMLBEANS installation is hard to deal with and I think most of people will encounter problems when installing it and I'm not an exception.
The XMLBEANS(here it's 2.0.0-beta1) binary archive package, by convention, contains directories, bin, docs, lib, etc. And you'll have to set your path and classpath just like installing other java tools. But after that I think 90% people can't run XMLBEANS correctly. There're some points to notice and I hope your encountering problems are listed below (OS:WIN XP SP2) :

About your jdk directory. My jdk directory is under the "Program Files" directory. And when I run XMLBEANS with "scomp...." in the command line prompt, errors saying roughly like this(on my PC erro message is in Chinese): "'E:\program' is not a internal or external command, neither is it a executable or a batch file." This error message reminded me of the caution information I read when I was installing Weblogic 8.1. The information said "Don't leave a white space in your weblogic path, for it may cause severe problems". Since both of XMLBEANS and Weblogic are produced by BEA. So I move my "JAVA_HOME" to the root directory of one of my partition.
About your "PATH". When I thought I would make it. The fact again let me down. When I run "scomp...", XMLBEANS threw IOException saying "'javac' is required on the path.java.io.IOException : CreateProcess: c:\xmlbeans-1.0.2\schemas\javac @c:\DOCUME~1\alex\LOCALS~1\Temp\javac20992 error=2nulljava.io.IOException: CreateProcess: c:\xmlbeans-1.0.2\schemas\javac @c:\DOCUME~1\alex\LOCALS~1\Temp\javac20992 error=2 ", something like this. And this time I checked FAQ at here .I followed its advice but I couldn't find JAVA_HOME in my scomp script(in the bin folder). I think it's for old version of XMLBEANS and the information was not timely refreshed. And another piece of information solved my problem. There is a precedence among your JRE and JDK when java program finds java path. The former would be first located by default. So I put my JDK directory at the left most of my PATH variable.
About your "XMLBEANS_LIB". The official installation guide doesn't mention this. I found it in the scomp script. So I add a new environment variable called XMLBEANS_LIB pointing to my lib folder.

After the three steps I'm processing my XML Schema files with XMLBEANS. In addition, I wonder why BEA don't make it easier to install it just as install other java tools. Do they want to test our patience of using their tools?

Coming soon: XMLBeans Practice--Automate Exchanging data between XML's & Java (2): Working With XMLBeans

The origin of foo & bar which almost everywhere in the demonstrating codes

2005-04-13T02:45:00.000+08:00

The etymology of hackish `foo' is obscure. When used in connection with `bar' it is generally traced to the WWII-era Army slang acronym FUBAR (`Fucked Up Beyond All Repair'), later bowdlerized to foobar. (See also FUBAR.)
...It has been suggested that this might be related to the Chinese word `fu' (sometimes transliterated `foo'), which can mean "happiness" when spoken with the proper tone (the lion-dog guardians flanking the steps of many Chinese restaurants are properly called "fu dogs").
...
Other sources confirm that `FOO' was a semi-legendary subject of WWII British-army graffiti more-or-less equivalent to the American Kilroy. ...
Earlier versions of this entry suggested the possibility that hacker usage actually sprang from "FOO, Lampoons and Parody", the title of a comic book first issued in September 1958, a joint project of Charles and Robert Crumb.
...
An old-time member reports that in the 1959 "Dictionary of the TMRC Language", compiled at TMRC, there was an entry that went something like this:
FOO: The first syllable of the sacred chant phrase "FOO MANE PADME HUM." Our first obligation is to keep the foo counters turning.
For more about the legendary foo counters, see TMRC. Almost the entire staff of what later became the MIT AI Lab was involved with TMRC, and probably picked the word up there.
Very probably, hackish `foo' had no single origin and derives through all these channels from Yiddish `feh' and/or English `fooey'.
Complete explanation can be found here.

How about writing your GUI as XML files?

2005-04-10T03:16:00.000+08:00

I've got an idea from the previous project our lab is involved in. We can store all the information of a GUI, including both its layout appearance and logics behind it, in a bunch of XML files, from which then we can restore the GUI with both the same behavior and the same appearance.
As I said in my previous article, in VC++ environment we can't make it because of widely used user customed Controls in addition to lack of implementation of meta data protocol (in Java it's the reflection mechanism). But on JVM we can get every control's properties, if not all, through Java's reflection mechanism. So it is likely that we can replicate, of course not through copying binary files, a given control written in java.
However, technology is just technology and is useless if it is not practical. Now I just don't know where it can come into play. I know in MS's next generation OS Longhorn there will be a new graphical architecture, Avalon, which allows writing GUIs just like writing HTML files , and which, I wanna mention, uses XML files as the intermediate representation of GUI. That's very similar to my idea. But MS sets up an environment, a some kind of parser or engine, for use of these XML files. But in a common system not as large as a OS, I can't figure out what this technology can be used for, although I think it's not a bad idea and I subconsciously feel that it will be useful.
So I have to further think about it. And if anyone got idea on how to use this technology, please leave a comment. You'll be very appreciated.

Spending Hours Writing a Testing GUI.

2005-04-09T03:13:00.000+08:00

It's a part of our lab's arrangements. It's supposed to be finished this morning. But as I said in the last post I put off it till now.
Wirting here, I wanna talk about the project our lab recently involved in, which now proved to be infeasible. The project is to provide a very vivid environment for the user to practise or test their mastering of operating large scale Windows based ERP software. Simply speaking, what we supposed to do is to emulate the targeted ERP software, not only the user interfaces, but also some logic, which the users are interested in, behinde them.
It is not easy to write a software like that. We do a lot of experiments in which we capture as much information of kinds of control as we can from a third party software which will be finally targeted on SAP's ERP. We identify the type of a control according to its internal class name which, if not by default, arbitrary. Obviously, It's a mission impossible. Because user customed controls are everywhere, even in MS's software. So considering this, the type of a control can't be automatically identified.
My advisor has decided to turn down the project. To clarify that we really made a lot efforts and to tell our customer that this project is not feasible we have to integrate what we've done into one prototype to demonstrate our judgement.
And that's why I write the GUI. It's sort of WIN32 programming. I don't use MFC.
ps: If someone know how to work out problems I mentioned above please contact me. Thanks for any reply in advance.

AOSD'05 - A great conference.

2005-03-21T02:37:00.000+08:00

In the middle of March the Annual Aspect Oriented Software Development Conference 2005(also the fourth conference) was hosted in Chicago.
Almost all the important experts, practitioners and company in this field joined this conference and it also came with many reports online and offline.
I'm really excited about this conferece for seeing the rapid development of AO. Although I can't attend this conference I read news and blogs reporting the conferece. And I have strong confidence in AOP being more and more accepted by the industry.

The Aspect-Oriented Software Association

2004-04-11T01:21:00.000+08:00

The Aspect-Oriented Software Association is a non-profit organization whose mission is to be the primary sponsor for the annual Conference on Aspect-Oriented Software Development.
The AOSA Steering Committee members are:
Mehmet Aksit
Brian Barry
Tzilla Elrad
Bob Filman
Gregor Kiczales (chair)
Karl Lieberherr
Mira Mezini
Gail Murphy
Harold Ossher

Hello World

2004-03-26T17:42:00.000+08:00

public Class Hello {
public static void main(String[] strgs) {
System.out.println("Hello World!");
}
}