1. SWT Programming with Eclipse
2. What exactly is the “Event Dispatch” thread (aka “AWT” Thread)?
3. When exactly is the AWT thread started?
4. Getting started with SWT
5. Getting Started with Eclipse 2.1 and the SWT

详见新闻，其实内环线以内可能早就有了，有人4月份就发现了（里面还包括了详细的技术参数）。这里说的EDGE在5.17商用可能是在上海全境覆盖。我是看了这条新闻才昨天在自己的手机上注意到以前显示信号的那个G （GPRS）变成了E（EDGE/EGPRS），但还是会时常在G和E之间跳动，不知道是为什么，大概还在测试吧。

总体感觉在网速上还没有多明显的变化，和以前感觉差不多，其实上海GPRS网络不稳定（跟上海移动的客服反应过，没有明确答复，叫我重启机器重新搜索网络），就我的使用经验来说，GPRS的速度都还可以容忍，所以比较赞成这位朋友的看法，注重用户体验，虽然他是从资费的角度来讲的。

对两者的网速有些说法。首先理论峰值，GPRS：171.2kbps，EDGE：473.6kbps；稳定（不在高速移动的情况下）的时候实际值，GPRS：57.6kbps，相当于56k的猫，EDGE：190kbps。所以EDGE的速度是GPRS的2～4倍。

另外，CDMA1X的理论峰值307.2kbps，实际稳定值有153.6kbps，几乎是GPRS的4倍。

要注意的是换成字节的速度（B, Byte）都要除以8。

实测

我用手机上的operaMini上网在这里测了一下速度，一共测了三次，前两次的结果差不多都是：

240kbps communications

29.8kBps storage

39s 1MB file download

第三次的测试结果为（信号显示又变回了G，但是199.8kbps也超出了GPRS的理论值，confusing）：

199.8kbps communications

24.4kBps storage

42s 1MB file download

测试结果项目的解释见这里，有这么快么，感觉没这么快啊，怀疑ing。

现在市面上的手机应该有很多都支持EDGE的。

BUZZ

别人的体验和评论：1，2，3，4，5。

引述别人的一个评论泼一下冷水：

别吹了,当年中国移吹的gprs能达到171.2k.而实际有多少,人少的时候能达到2-3k,人多时就只有那200个字节左右.远比1x差远了,现在又造出什么EGPRS,号称470k,也就gprs的2.5倍 ,本人没用过,但按2.5倍算,充其量就是最大7k.小500字节,中国移动的东西大大打折扣,你们别信它 .这就是广东推EGPRS半年多,也没几个人用,人们还去买1x的原因.

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

1. Why You Shouldn’t  Mix AWT and Swing
2. What is the difference between AWT and SWT
3. what is difference between swing and awt

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 < 0, -2, if …, -3 if …

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

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

基本上是按照网上流传甚广的一套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

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

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

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

1. The Architecture of Eclipse. This article refers to and linked to a lot of valuable resources.
2. 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.
3. About the OSGi Service Platform - Technical Whitepaper Revision 4.0
4. 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.
5. org.eclipse.ui.workbench_3.2.2.M20070119-0800.jar source code.
6. eclipse 3.2.2 startup.jar : org.eclilpse.core.launcher.Main.class source code.
7. Contributing to Eclipse: Principles, Patterns, and Plugins (Paperback)
8. 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

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: <absolute-size> | <relative-size> | <length> | <percentage>
Possible Values:

* <absolute-size>
o xx-small | x-small | small | medium | large | x-large | xx-large
* <relative-size>
o larger | smaller
* <length>
* <percentage> (in relation to parent element)

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

1. Font Size
2. Point (typography)
3. Typeface
4. CSS改变字体大小而不影响网页
5. 【知识】字体中“号”“磅”及“毫米”的关系
6. Length Units
    

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

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 <aJavaProject, aClasspathContainer>. 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 –> <aContainerPath, {<aJavaProject, aClasspathContainer>, …}>.

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 <aJavaProject, aClasspathContainer> 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

1. Setting the Java build path
2. JDT 3.2 Source Codes.

Technorati : Eclipse, JDT, classpath, java, plugin

总的来说是把你的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

1. Bugzilla Bug 108242 Full Indexer in CDT3.0 extremely slow or does not work
2. Eclipse3.2.1中使用CDT经常CPU100%问题的解决方法
3. Eclipse CDT开发C++速度慢的解决方法
4. CDT Indexer导致CPU 100%的解决办法
5. Eclipse+cdt+MinGW 建立C++工程問題

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

1. Getting Started with the MetaWeblog API for Windows Live Spaces
2. Blogger Data API Developer’s Guide
3. More…

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

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 ，用来测试机房速度和当前连接的路由节点。

参考资料：

1. 首次托管服务器经验
2. 服务器结构中的1U 2U 3U是什么意思?
3. 机架式服务器和塔式服务器的区别
4. 服务器有哪些种类？
5. 典型用户案例
6. 什么是机架式服务器？
7. BananaSkin（持续关注IDC方面的博客）
8. 服务器有关的Post（1，2，3）（豆瓣blog）
9. 如何挑选服务器？哪个牌子的最好？（1万元以下的）
10. 关于”个人网站申请备案”经验
11. 业内人士教您如何选择IDC
12. 服务器托管—你会选1U还是2U服务器？
13. ICP专栏：介绍ICP相关知识，ICP申请、ICP备案流程及所须资料等
14. 【转载】教你如何租服务器和选择机房
15. 差价缩小：现在你考虑1U还是2U？
16. 中国IDC产业发展调查暨年度大典官方网站
17. 找小说网正式拥有属于自己的服务器

• [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:

1. aspectj doc
2. aspectj-user-request mailing list

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:

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

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:

1. Uniform Resource Identifiers (URI): Generic Syntax
2. Format for Literal IPv6 Addresses in URL’s
3. JavaTM 2 Platform Standard Edition 5.0 API Specification

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

Spec. Intro.

1. What Is RSS
2. Content feeds with RSS 2.0
3. RSS 2.0 Specification
4. The Atom Syndication Format
5. OPML 1.0 Specification
6. OPML 2.0 draft spec

Feed Reader Impl.

1. A Java pen source reader: RSSOwl(bin, src)
2. XML Processing With Java Overview
3. Three ways of validating a xml document with Java
4. Comment on W3C DOM and various implmentations in defferent PL
5. Unicode, UTF等字符编码摘记
6. Control a Web Browser From Within a Java Programm

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

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:

1. Java Tip 66: Control browsers from your Java application
2. JavaTM 2 Platform Standard Edition 5.0 API Specification
3. The JACOB Project: A JAva-COM Bridge
4. SWT Browser
5. Package org.eclipse.swt.browser
6. Developer Forums java to invoke IExplore?

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

在半年前还在公司实习期间想到的,很多点子都记录在我的小的笔记本上面.我当时的概念是一种knowledge sharing的概念(跟foody和xiaokun提起过),比阿凡提的概念更广泛一些.当然这种基于音频的协作方式是我想到的主要方式,我当时考虑的是用第三方的VoIP工具(如skype就是我当时考虑的),但是这样支付和计费都是有风险的,用户可以绕过你的支付和计费系统”作弊”,阿凡提用了自己的VoIP工具,这样把支付,计费和协作工具可以整合在一起,很好的解决了这个问题.

我当时的灵感来源于一个基于skype的.org网站,它提供一种服务,让讲不同语言的人可以快速的找到可以一起学习各自语言的language partner,我当时试用的时候由于user base还不是足够大,所以效果不是很明显.

在思考knowledge sharing期间看到老冒的一个post里面看到提到的一个国内的网站,做的是收费的问答服务,这个网站已经运营了有好几年了.但是不同于Yahoo Answer,它提供平台(相对来说比较简陋)让用户可以向公司用户提供商业解决方案,当然这些方案都是可以数字化的东西,如公司logo的设计,ad poster的设计,甚至广告语的设计,上面的公司用户发的单子已经有上千RMB的了.有趣的是甚至有个人用户发单子要别人为自己刚出世的孩子取名字提供意见.

我基于一个最简单的想法,当一个电脑白痴(没有恶意和歧视性的称呼)想要配一台性价比高的兼容机(不要问我他不懂电脑为什么还要配兼容机,这正是这种服务的价值所在)时knowledge sharing这种服务可能会对他有用,但一般的用户想要获得生活的方方面面相关的法律咨询(很多电台节目就是做这个)的时候,这种服务可能会对他有用,而且获得这种服务的价格都相对比较低廉.所以提供这种服务是有价值的,而且具有起码的可行性.

其实knowledge sharing关键在于数字化一切可以数字化的东西,再提供各种各样的协作系统,建立良好的可以无限扩展的参与架构.

详细的想法这里不说了,有时间再说.这里说说我当时幻想的如果这种knowledge sharing网站做成功的话会出现什么盛况(yy总是充满乐趣的:),所谓成功是说在这个网站上形成了自己的生态系统,网站上的资深用户(阿凡提里面的专家用户)可能会出现高级的自由打工者,百万富翁级的soho一族,肯定会获得传统媒体的免费公关宣传,成为talk of the town,还会出现不可一世的传统巨头在上面发单,中小企业更是可以很好的利用这一平台,有一批核心用户可能会依靠这个平台来获得自己的唯一生活收入,等等.yy归yy,风险是大大的有的,但是看到有人去做我非常兴奋.

上面写的很没有逻辑,再说一句,你可以甚至用这种网站向公司用户提供call center服务,所谓的外包商业流程的一种.

类似于这种把智力,知识没有任何障碍的直接转化为财富的网站服务应该会越来越多,有人也在做文化衫的design的交易,qq zone里面的falsh的design的交易,甚至有bt的学术研究在研究可以让所有人都参与进来的知识构建模型(完全不同于wikipedia).

再一次证明单独的想法是不值钱的,资源掌控能力和执行力的结合才能产生价值.好好做一个看客: ).

Technorati : VoIP, collaboration, knowledge sharing
Del.icio.us : VoIP, collaboration, knowledge sharing

卖掉了自己早已经就不用的内存，12.5号才正式上架拍卖的，经过14天的拍卖，和买家沟通，快递发货等一整个过程，到今天才正式交易成功。期间买家的支付宝出了点问题，所以付款不是很及时，本来应该能在更短的时间内完成交易。

拍卖的目的完全达到，甚至超过预期。从一元起拍，经过４８次的加价，这个过程是比较好玩的，看着价钱一天一天的涨。价格上升过程基本上这样的，发布的第一天竞拍的买家比较多，通过这一天的竞拍价位基本上就上升到世面上同等物品的价位（以下称为应有价位）的８０％左右。随后的两天时间里价位继续上涨到应有价位的９０％，接下来的10天里面几乎没有竞拍者。在最后一天才圆满的达到应有价位，然后进入交易阶段。整个过程比较符合常识，也完全符合买家的心理，另一方面来说，淘宝的竞拍系统基本上做的是非常成功的。下面详细说说 好玩的点在哪里，也说说一些C2C交易里面一些基本要素。

先要说一下，之前我对正规的拍卖的流程、方法基本上就是一般人的常识水平（不知道现在还是不是？）。

当初选择拍卖这个东西，基本上出于以下下考虑。我卖的东西是二手的东西，没办法跟市场上买的东西去比较来定价，虽然我已经找到相类似的二手物品（价位150，找到完全一样的不是不可能，在淘宝这个大市场里面应该是可以找到的，但是唯一的代价是时间），但是和我的二手货也不完全相同，包括品牌、新旧程度，所以也不能根据别人的价位来精确定价。

我非常有限的经济学常识告诉我最好的定价方式是让市场来定价，当然这个是有一定风险的，如果我们稍微多想一下的话。如果你的拍卖信息不能在让足够多的有购买意向的买家看到的话（包括在竞拍前、竞拍中），很可能被低于真正市