Coffee & Revolution

Vim + Ctags Tip!

2005-12-14T21:05:00.000-05:00

I always wanted to locate the tag file automatically.

How do I configure Vim to locate a tags file in a directory tree?

Note that the following will work only in Vim 6.0 and above. You can set the 'tags' option to make Vim search for the tags file in a directory tree. For example, if the 'tags' option is set like this:

set tags=tags;/

Vim will search for the file named 'tags', starting with the current directory and then going to the parent directory and then recursively to the directory one level above, till it eitherlocates the 'tags' file or reaches the root '/' directory.

Quaqua look and feel

2005-12-11T19:50:00.000-05:00

I always envied Mac OS users. Wait a sec! There is a way. We can emulate the look and feel of Mac OS with Quaqua look and feel in Java applications! Check it out. Yes, it is not intended for other platforms, but you can use it in Windows too. Not perfect though. :(

What I lack

2005-12-11T18:47:00.000-05:00

A list of what I lack in computer science

Deep understanding of algorithm complexity
Ability to analyze the performance
Inexperience in GUI programming
Skills in IDE tools
Mathematical backgrounds
and so forth...

Performance Analysis

2005-12-11T18:35:00.000-05:00

Recently, I am working on a toy artificial intelligence agent. The agent doesn't know anything about the environemnt and the effect of actions. However, it gets rewards and punishments for each state. This is what we call a reinforcement learning. I used some variations of Q learning agents and tried to compare the performance of agents.

However, the problem was not so easy. It was hard to normalize the rewards in differnment environments. Not deterministic characteristics of environments make it worse. I've got to know that I don't know well about the performance analysis.

I feel I must study. Oh God...

Introduction to XPath in Java Using Jaxen

2005-12-11T14:36:00.000-05:00

Introduction to XPath in Java Using Jaxen seems to be a pretty good slides for Xpath and Jaxen. It explains how it evaluates the XPath query.

XPath Explorer

2005-12-11T14:22:00.000-05:00

XPath Explorer is a good tool to visualize the XPath expression. It helps developers work interactively with XPath.

Basically, you type in a URL (to an XML or HTML document) and an XPath expression, and it displays the elements or attributes from that document which match that expression. It also displays the value (string, number, or boolean) of the expression, and (in a stunning coup de grace) displays the entire XML tree of the original document, but with the matching nodes highlighted in bold. This makes it easy to play with and debug your XPath expresions.

XPath query is Java String. So we can't get any help from the Java language type checker. It is really painful to guess the correct behaviour of XPath query. A tool like XPath explorer can greatly reduce the time and lower the learning curve for new technology. Try it!

2005-12-08T18:14:00.000-05:00

My picture: This is a picture posted by Hello.

Do you know launch4j?

2005-12-08T15:02:00.000-05:00

launch4j is a cross-platform Java application wrapper for creating Windows native EXEs.

One of the reasons why Java is not so popular in Windows client, especially in Korea is its lack of ability to distribute easily. Java applications need pre-installed JRE, it's not an easy task to install the application in one-step.

launch4j solves this problem. It has features:

Wraps jars in Windows native executables and allows to run them like a regular Windows program

Doesn't extract the jar from the executable

Native pre-JRE splash screen in BMP format shown until the Java application starts

Process name as the executable filename to easily identify your application

Works with a bundled JRE or searches for newest JRE / SDK in given range

and so forth.

I think spalsh screen is a big win. Many people think that Java is slow not because it is really slow, but because it doesn't show anything until JVM warms up and actually starts executing the Java code. Splash screen is now supported in Java6 mustang, but it's not released officially yet.

Bottom line: Try to use launch4j when your target platform is Windows.

Programming Language and IDE support

2005-12-08T09:15:00.000-05:00

I read "An Interview with TestNG's Cedric Beust Dynamic Languages"[1]. I totally agree with him. Recently I'm convined that IDE supports are essential for a language to be widely adopted.

I've tried various dynamic script languages including Python, Ruby and Groovy. I was fascinated by the elegance of these languages. However, I seldom use them in practice. Different syntaxes and styles are the first barrier, but it is not a major one. The more important thing is that I don't have a full-featured IDE(intergrated development environment).

With Eclipse/Java, I am now test-infected and love refactoring whenever possible. But these are really painful tasks without the help of IDE. I've tried Eclipse plugin for Groovy these days, but it doesn't seem to work well. Moreover, I can't see any significant progress in plugins for dynamic languages.

I hope I will get one soon or later.

References
[1] An Interview with TestNG's Cedric Beust Dynamic Languages

URI, URL, URNs

2005-12-05T15:15:00.000-05:00

URI, URL and URNs are most frequently used technical terms in the web world. The problem is the distinction among them are not so clear. Is URL a subclass of URI? However, in many specifications, they seem to be used interchangably. Many people as well as I also are confused. W3C has a official clarificationfor this issue.

1 URI Partitioning

There is some confusion in the web community over the partitioning of URI space, specifically, the relationship among the concepts of URL, URN, and URI. The confusion owes to the incompatibility between two different views of URI partitioning, which we call the "classical" and "contemporary" views.
1.1 Classical View

During the early years of discussion of web identifiers (early to mid 90s), people assumed that an identifer type would be cast into one of two (or possibly more) classes. An identifier might specify the location of a resource (a URL) or its name (a URN) independent of location. Thus a URI was either a URL or a URN. There was discussion about generalizing this by addition of a discrete number of additional classes; for example, a URI might point to metadata rather than the resource itself, in which case the URI would be a URC (citation). URI space was thus viewed as partitioned into subspaces: URL and URN, and additional subspaces, to be defined. The only such additional space ever proposed was URC and there never was any buy-in; so without loss of generality it's reasonable to say that URI space was thought to be partitioned into two classes: URL and URN. Thus for example, "http:" was a URL scheme, and "isbn:" would (someday) be a URN scheme. Any new scheme would be cast into one or the other of these two classes.
1.2 Contemporary View

Over time, the importance of this additional level of hierarchy seemed to lessen; the view became that an individual scheme does not need to be cast into one of a discrete set of URI types such as "URL", "URN", "URC", etc. Web-identifer schemes are in general URI schemes; a given URI scheme may define subspaces. Thus "http:" is a URI scheme. "urn:" is also a URI scheme; it defines subspaces, called "namespaces". For example, the set of URNs of the form "urn:isbn:n-nn-nnnnnn-n" is a URN namespace. ("isbn" is an URN namespace identifier. It is not a "URN scheme" nor a "URI scheme").

Further according to the contemporary view, the term "URL" does not refer to a formal partition of URI space; rather, URL is a useful but informal concept: a URL is a type of URI that identifies a resource via a representation of its primary access mechanism (e.g., its network "location"), rather than by some other attributes it may have. Thus as we noted, "http:" is a URI scheme. An http URI is a URL. The phrase "URL scheme" is now used infrequently, usually to refer to some subclass of URI schemes which exclude URNs.
1.3 Confusion

The body of documents (RFCs, etc) covering URI architecture, syntax, registration, etc., spans both the classical and contemporary periods. People who are well-versed in URI matters tend to use "URL" and "URI" in ways that seem to be interchangable. Among these experts, this isn't a problem. But among the Internet community at large, it is. People are not convinced that URI and URL mean the same thing, in documents where they (apparently) do. When one sees an RFC that talks about URI schemes (e.g. [RFC 2396]), another that talks about URL schemes (e.g. [RFC 2717]), and yet another that talks of URN schemes ([RFC 2276]) it is natural to wonder what's the difference, and how they relate to one another. While RFC 2396 1.2 attempts to address the distinction between URIs, URLs and URNs, it has not been successful in clearing up the confusion.

Yakker: A Parser Generator for Network Protocol Messages

2005-12-03T01:56:00.000-05:00

About three weeks ago, I attended "NJ Programming Languages and Systems Seminar" held in Univ. of Maryland. The first session was particulary interesting. Trevor Jim from AT&T gave a presentation about his work.

His research is about "Yakker: A Parser Generator for Network Protocol Messages" The main idea is quite simple. Write a parser generator whose inputs are RFC documents. The format of RFCs are pretty standardized and it is actually possible to parse them without any intervention of people.

Once a parser generator is well-written with a secure language such as Java, a automatically generated parser is much safer than hand-written parsers which cause various security problems nowdays. Moreover, we can formally proof that some protocols are ambiguous and need to be revised.

Automation techniques always seem to be pretty cool wherever they are possible, don't they?

Memo Function

2005-12-03T00:29:00.000-05:00

The same old ideas are repeated again and again in many fields. One of such things is the idea of caching. When something is quiet slow and you tend to request it frequently, just put them in a special area which is way fatster. The stroage hiearchy from the fastest regiters through L1, L2 cache, and memory down to slow disks is a typical example of caching.

The same principle is also applied to so called dynamic programming. Especially AI people love solving their NP-hard problems with dynamic programming. Their algorithms are likely to be exponential more than O(2^n), and they often try to solve it more efficiently storing previous computed results and reuse them.

The idea behind the memo function is essentially the same. A function rememebers which arguments it has been called with and the result returned, and if called with the same arguments again, returns the result from its memory instead of recalculating it. It was first invented by Professor Donald Michie of Edinburgh University. However, the idea is quite old.

GC and VM

2005-12-02T17:59:00.000-05:00

I've recently checked J2SE 5.0 Tiger VM garbage collectors. They are really cool. The parallel GC provides throughput, while the mostly concurrent GC gives us low latency. Ergonomics solves the hard configuration problems because the JVM itself now tries to adjust the various factors such as younggen/oldgen size, GC method, server/client VM and so forth.

One thing I see most of JVM don't talk much is about the interaction with the underlying virtual memory system. As I use Eclipse for my favorite IDE, when I minimize the Eclipse window and try to do some other things and get back to work, I see it scratches my hard drive a lot. I guess this is because most pages are swapped out while I don't use Eclipse, once I get back and a GC is triggered, it touches every page and the VM swaps in all the pages again.

I know there is a cool Eclipse plugin called KeepResident from Stanford Univ. The idea is simple. It uses two functions in Windows API SetProcessWorkingSetSize() and VirtualLock() - to encourage Windows to keep more of the Eclipse Java process in physical RAM. However, it keeps other processes from getting more memory.

Is there any GC algorithm available, which takes the interaction with VM into consideration?

Java code coverage tools

2005-12-02T17:42:00.000-05:00

Today I've looked up several Java code coverage tools. Emma is one of Java code coverage tools freely available.

Distinctive features of Emma include:

Instrument classes 1) offline, before load time 2) online, application classloading
Various report types: text, html, xml
Converage subset filtering
Fast: unit of work is basic blocks

I think the only thing it lacks is the integration with existing IDE tools like Eclipse. It is certainly good to get reports everyday from the build system, but developers really want to get the coverage information interactively as they write code and test cases.

I found somebody posted a simple requirements for Emma eclipse plugin.

perhaps instr filters could be intergrated with Eclipse
filter/worksets
coverage markup should be done directly in the original
source code if possible
(re)instrumentation could be (optionally) done in the
background just like code compilation

It was posted about a year ago, but I still can't see any progress in it. So I've decided to start writing my own Emma Eclipse plugin.

A Note On Distributed Computing

2005-11-23T13:36:00.000-05:00

Java RMI로 코딩할 일이 있어서 Java 5 RMI 관련 문서를 다시 읽어보다가 Distributed Computing에 관한 고전 논문인 A Note on Distributed Computing을 읽어 보았습니다.

이 논문의 핵심을 한 줄로 요약하면, "local computing"과 "distributed computing"은 latnecy/memory access/partial failure/concurrency 등에서 현격한 차이가 있으므로 이를 하나로 통합하려는 unifed objects는 실패할 수 밖에 없다는 것입니다.

object는 아니지만, distributed computing과 local computing의 차이를 무시했을 경우 나타나는 결과를 가장 잘 보여주는 예는 NFS입니다. NFS는 기존의 파일 시스템 인터페이스(open, close, read, write...)를 그대로 사용하여 원격에 있는 파일 시스템을 로컬 파일 시스템인 것처럼 접근할 수 있게 해줍니다. 따라서 로컬의 파일을 쓰듯이 원격 파일을 접근하고 사용할 수 있는 장점이 있습니다. 그러나 문제가 있습니다. 파일 시스템 인터페이스는 같은 머신에서 disk full이나 disk crash 같은 심각한 오류에 대응하도록 만들어져 있지, 네트웍 failure나 다른 머신의 crash 같이 distributed 환경에서 빈번하게 발생할 수 있는 문제를 다루지 못하기 때문입니다.

"Joel On Software"의 책을 보면 "Every abstraction is leaky"라는 챕터에서 비슷한 이야기를 하고 있습니다. 윈도우즈의 삼바 같은 경우 NFS와 마찬가지로 원격의 파일 시스템을 액세스 할 수 있게 해주는데, 인터페이스는 파일 시스템 인터페이스를 그대로 사용합니다. 따라서 네트웍이나 느려지거나 멈췄을 때 이에 대응할 수 있는 방법이 인터페이스 차원에서는 사실상 없게 됩니다. 따라서 삼바 자체의 구현과는 상관 없이 안정성을 보장할 수 있는 방법이 없는 것입니다.

위 논문은 distributed object 레벨에서 이야기를 하고 있는데, local object와 distirubted object 구분 없이 프로그램을 할 수 있는 unifed object 모델이 다음 3가지 근본적인 차이 때문에 성공하기 힘들다고 말하고 있습니다.

1. latency

local object와 달리 distributed object의 invocation은 network communication을 동반함으로 훨씬 느린데, 이를 사용자가 알 수가 없습니다.

2. memory access

local object를 access하기 위해 pointer를 사용하면, 이는 unifed object 모델을 위배 되는 것이고, 그렇다고 모든 pointer access를 remote object인 것처럼 다루면 local object의 경우 필요없는 성능 저하가 생깁니다.

3. partial failure/concurrency

local에서는 프로그램의 수행될 때 모든 게 deterministic한 반면에, distributed object는 network이나 다른 컴퓨터가 crash 되는 partial failure를 볼 수 있습니다. 그리고 network이 끊어졌을 때 network 문제인지 다른 문제인지를 명확하게 집어낼 수 있는 방법도 없습니다. 따라서 이런 종류의 failure를 처리하기 위해서는 다른 인터페이스가 필요한데, distributed object만 다른 메커니즘을 제공하면 unifed object 모델에 위배되고, local object도 이런 메커니즘 통합해 제공하면 필요 없는 오버헤드가 생기게 됩니다.

결론을 이야기하면, reliability 문제는 interface와 별개로 implementation만 잘해서 해결할 수 있는 것이 아니라는 겁니다. interface 자체가 어떤 error를 발생할 수 있는지 명확히 표시를 해주어야만, 이를 사용하는 프로그래머가 이를 반영하며 안정적인 소프트웨어를 만들 수 있다는 것이죠.

Java theory and practice

2005-11-13T17:53:00.000-05:00

Java theory and practice

This is a place where Brian Goetz talks about the new features and concepts in Java. He is the coauthor of the cool cocurrency book, "Java Concurrency in Practice" I found myself multithreading and JVM stuffs are more interesting.

2005-11-13T17:37:00.000-05:00

David Dagastine's blog: Java Synchronization Optimizations

Java theory and practice: Synchronization optimizations in Mustang

Compiler가 Synchroniztion과 관련해서 수행할 수 있는 최적화 방법을 설명하고 있는 글들이다. 자바 6 무스탕에 적용된다고 하는데, Escape Analysis를 통해서 Thin Lock까지 없애버리는 Lock Elison이 인상적이다.

Lock elison
Adaptive locking
Lock coarsening

Studying computer science

2005-10-30T18:28:00.000-05:00

Recently I need to separate my time into "studying computer science" and programming. Once I start programming, I can't stop. I seldom read papers and textbooks while I am coding.

To balanace the theoritical understanding and practical skills, I will spend Mon/Wed/Fri studying computer sciecne and programming on ther other days.

:)

Good luck to me.

Programming Language Research Reading List

2005-10-21T16:51:00.000-04:00

# Aho, Sethi, Ullman, Compilers: Principles, Techniques, and Tools
# Appel, Compiling with Continuations.
# Barendregt, Lambda Calculi with Types (web download).
# Clarke, Grumberg, and Peled, Model Checking.
# Gries, The Science of Programming.
# Hankin, Lambda Calculi: A Guide for Computer Scientists. (Out of print, but available at the library.)
# Huth and Ryan, Logic in Computer Science: Modelling and Reasoning about Systems (Note: new version coming our real soon now)
# Mitchell, Foundations for Programming Languages.
# Muchnick, Advanced Compiler Design and Implementation.
# Nielson and Nielson, Semantics with Applications: A Formal Introduction (web download).
# Nielson, Nielson, and Hankin, Principles of Program Analysis.
# Pierce, Types and Programming Languages.
# Winskel, The Formal Semantics of Programming Languages. (Out of print, but available at the library.)

Null Object Pattern

2005-10-18T19:46:00.000-04:00

From CMSC433 lecture note,

Anytime you have an field that could be null, and you find yourself
inserting a lot of checks to see if that field is null, consider
whether it makes sense to have define a special singleton null object,
and use a reference to the null object rather than a null reference.

public class LinkedListWithNullObject {
interface Node {
boolean stopSearchHere(Object e);
Node tail();
E2 data();
}
static class NonEmptyNode implements Node{
NonEmptyNode(E2 d, Node n) {
data = d;
next = n;
}
E2 data;
Node next;
public boolean stopSearchHere(Object e) {
return data.equals(e);
}
public Node tail() {
return next;
}
public E2 data() {
return data;
}
}
static class EmptyNode implements Node{
E2 data;
Node next;
public boolean stopSearchHere(Object e) {
return true;
}
public Node tail() {
return this;
}
public E2 data() {
return null;
}
}

Node head = new EmptyNode();

public void insert(E e) {
Node n = new NonEmptyNode(e, head);
head = n;
}

public boolean contains(Object e) {
Node n = head;
while (!n.stopSearchHere(e)) {
n = n.tail();
}
return n instanceof NonEmptyNode;
}
public E removeHead() {
Node n = head;
head = n.tail();
return n.data();
}

}

My new project: Mono project

2005-10-18T18:39:00.000-04:00

I'm currently taking the class, "Programming Language Technologies and Paradigms". The goal of this class is to make students get accustomed to the development of big software. It covers the followings:

Design Pattern
Concurrency
Open Source Project

One of the requirements is to make a contribution to one of exisiting open source. The open source project must be large. Students can patch bugs, implement new features and add functionalities.

I've finally selected a project: the Mono project. Mono project is to develop an implementation of Microsoft .NET CLR and compilers. Because I've maintained JVM for more than two years, I guess I can contribute. Keep your fingers crossed for me.

Decreasing CS graduate students

2005-10-18T18:34:00.000-04:00

A recent news, Gates goes to college talks a lot about the future of computer sciecne graduates.

Gates goes to college to encourage students to major in computer sciecne. When somebody encourages to do something, it means it is not desirable and people are avoiding it. What's the problem? After the dotcom buble in 1999, is there no hope for IT industry?

Execution Environments for Building Dependable Systems

2005-10-18T14:28:00.000-04:00

Sun Microsystem has made significant changes to Java, while they have tried not to touch their JVM specification. Even though the JVM is not an ideal solution for Java, they don't seem to pay much attention to the runtime. It is partly because they want old Java programs to run on new JVM.

I think it's time to think about the future of the Managed Runtime Environments such as JVM and CLR of Microsoft.

Abstract:

Managed Runtime Environments (MREs) (aka virtual execution environments or simply runtime systems) have evolved in functionality and complexity for over 40 years. MREs, such as the JVM and CLI, have absorbed functionality once only available from the operating system, and at the same time MREs support diverse and highly dynamic
application configurations. While current MREs are clearly effective for many applications, opportunities remain to improve their design and broaden their applicability. In my talk, I focus on current issues with runtime systems and consider where hardware and software trends are likely to take these systems in the future. I consider MREs from the perspectives of performance, reliability, and ease of use, drawing on published experiences from both the CLI and Java communities. These experiences suggest important design directions for future MREs, including ways to improve support for modularity, error handling, concurrency, and componentization. One of the important future challenges for MREs is to demonstrate that they are up to the task of implementing the lowest-level system software, a
domain where they are needed. The Bartok and Singularity projects, at Microsoft Research, are investigating this challenging problem.

Speaker Bio:

Ben Zorn is a Senior Researcher leading the Software Design and Implementation Group in Microsoft Research. After receiving a PhD in Computer Science from UC Berkeley in 1989, he served eight years on the Computer Science faculty at the University of Colorado in Boulder, receiving tenure and being promoted to Associate Professor in 1996. He left the University of Colorado in 1998 to become a Senior Researcher at Microsoft Research, where he currently works. Dr. Zorn's research interests include programming language design and implementation and performance measurement and analysis. He also serves as an Associate Editor of the ACM journal Transactions on
Programming Languages and Systems and the ACM journal Transactions on Architecture and Code Optimization.

http://research.microsoft.com/~zorn/

Building an OS from scratch

2005-10-18T14:10:00.000-04:00

After I read many articles from developers' blogs, I've got to know that many people just want to make thier own operating systems from scratch. I understand the reason pretty well because operating systems are the fundamental component of modern software. However, they are dominated by large software vendors such as Microsoft, Sun and HP. Even the open source project, Linux is too hugh for a single developer to access.

Some programmers try to make a tiny operating system for themselves. This is good because they can learn a lot from making an OS by understanding the interaction between software and hardward/between the kernal and applications.

What I just want is that developers who wish to make an OS should pay attention to why they want to make a brand-new OS. Do they have a new idea to incorporate into the operating system? If there's no single difference from the exisiting operating systems, though you still can learn from it much, other people can't learn anything from your project.

Add some research idea in your OS project. For example, try to blur the distiction between the kernel and applications like SPIN. Or try to make a single-address-space OS. Or you can use a high-level language such as ML to build most part of operating system. Then many people will be interested in your project and you can learn more from it.

English Writing with Google

2005-10-17T19:47:00.000-04:00

Google is one of the most interesting tool people have ever invented. People enter a search keyword and can look up a ride range of information in a second, which makes many people enthusiastic about Google. However, searching, what Google provides, is not a brand new idea. People usually have looked up a yellow page when they need a phone number. Similarly, maps have been used when people are lost in a strange place. Google just has broadened the category of what you can look up, so now you can find virtually everything you want in the Internet. One interesting extended usage of Google is using it for correct writing. In this essay, we are going to present a new method on how to utilize Google to write a correct English essay.

When you go to Google site, you can see a simple Google logo and you type in a search keyword and click on “Google Search” button. Then Google shows you the search results according to their relative importance. For example, when you enter POSTECH, it displays POSTECH on the top and a long tail of other web sites related to POSTECH. An important point here is that you can not only find the web site you want but also know that there exists an institution named POSTECH.

This simple principle also applies to English phrases and expressions. When you type in “pay attention,” Google presents you various living examples of the expression, pay attention.” It indicates that there are 6,300,000 examples which use “pay attention.” You can infer from this large number of results that it is a very common expression. On the other hand, if you enter “pay attentions” instead of “pay attention,” there are only 3,820 search results. The big difference between these two results leads us to conclude that “pay attention” is an idiomatic expression which is mostly used with a singular form.

Be careful not to omit double quotation marks when you do a phrase search. Double quotation marks represent that we only want exact matches. Google usually removes articles and prepositions because they are so common that they don’t help find useful information in usual cases. In the same context, Google sometimes ignores the difference between singular and plural nouns and it groups different tenses of verbs to form actual keywords. However, what we want to search is related English grammar, so articles and prepositions are very important at this time. If we don’t want that information to be lost, we have to be sure that we use double quotation marks around our search keywords.

Unfortunately, there is a problem. When your sentence is too specific, you may find your search result is too small to justify that your sentence is correct. For example, if you wonder which sentence is correct between “It sounds very nice, isn't it?" and “It sounds very nice, doesn’t it?” you may ask Google. The Google results are disappointing this time because 17 vs. 4 are dubious. You can’t conclude that the first one is correct because the ratio is not enough to be safe.

You can use the asterisk sign here [1]. Try “It sounds * *, isn’t it?” and “It sounds * *, doesn’t it?” instead. The results are now 13,400 and 333. Now you can be sure that the question tag, “doesn’t it” is correct in this case. In this way, you can extend the power of Google to answer grammar questions. Try other queries like “If I am a bird” vs. “If I were a bird.” You may find that Google is even better than English grammar books because it gives you thousands of real-world examples.

Asterisk sign also can be used to look up useful adjectives and adverbs. You sometimes write a boring sentence “English writing is a creative job.” After you write down this sentence, you want to add an adverb in front of “creative job.” Try “a * creative job” on Google. Then Google will bring you an adverb, “highly” in this case.

In addition, when you write an essay, you often need to look up the definitions of words which you are not familiar with. For example, suppose you have heard of the term, “Green House Effect,” but you don’t know what it really is. An English dictionary gives you the definition, “The greenhouse effect is the problem caused by increased quantities of gases such as carbon dioxide in the air.” Most people would think it is not sufficient to understand the phenomenon. Use Google instead of your old dictionary. Google has a feature called “WHAT IS.” Type in “What is the green house effect” on Google. Google presents you every definition of the green house effect on the web. It also gives you a long tail of related web sites, so you can look up further information.

Finally, Google provides a spell check feature [2]. Many people made mistakes when they enter their search keywords, some mistakes are just typos and others are difficult words which people often misspell. For instance, try “schoool” on Google, Google immediately recommends using the correct word, “school.” Similarly, if you type in “consciuos mind,” Google suggests you “conscious mind” in “Did you mean … section.” Google is more powerful than most word processors which provide spell check features because Google’s spell checker is based on people’s actual mistakes and learns from those ones.

Until now, we have inspected various features of Google which help write a correct English essay. To summarize, we can ask grammar questions on Google and we can look up a lot of useful expressions using asterisk sign, and we can find definitions of words and check correct spells. Google is better than English dictionaries because it provides every-day examples of English. It provides you the search results with the number of matching pages. So you can safely conclude that some expressions are common because they are widely used in the Internet. Though English writing is a highly creative job, an automatic tool, Google can help improve the quality of writing. Don’t forget to visit Google when you begin to write something.

References
[1] Learn English with Google [http://www.english.hb.pl/articles/tips/google/]
[2] Advanced Google Search Operators
[http://www.googleguide.com/advanced_operators.html]

Jester: A Mutation Testing Tool

2005-10-17T19:38:00.000-04:00

Jester finds code that is not covered by tests. Jester makes some change to your code, runs your tests, and if the tests pass Jester displays a message saying what it changed. Jester includes a script for generating web pages that show the changes made that did not cause the tests to fail.

The mutation test is one of the test framework originated from eXtreme Programming community. Mutation testing tools mutate code and retest the test cases and check if the test cases fail in mutated code. It assumes that test cases must fail when the original code is mutated. If not, there might be problems in test cases themselves.

The open source project, Jester is one of mutation testing tools. It targets the Java and JUnit testing framework. You can check the motto of Jester in its homepage: A tester for testers. It provides a way to check if the test cases are well written.

Other nutation testing tools

The Single Responsibility Principle

2005-10-17T18:12:00.000-04:00

"The Single Responsibility Principle" is an article about OO design pricniples.

In conclusion, one class should not have more than one reason to be modified. If you have distinct reasons why you need to modify a single class, it means you have failed to cleanly separate the responsibility among classes. In other word, it is tightly coupled.

Every OO design principle and design pattern emphasizes the change! How to cope with changes is the main theme of OO design principles.

Data races due to compiler instruction reorderings

2005-10-17T17:58:00.000-04:00

Let's assume there exists the following code,

int x, y, r1, r2
Thread 1 x = 1 r1 = y	Thread 2 y = 1 r2 = x

Can you guess the results of execution without a proper synchronization? What are the possible values of r1 and r2?

You may conclude that r1 and r2 can be 0 and 1, but not both are zero. However, if you compile the code with a optimizing compiler and you may be able to see the result: r1 and r2 are both 0. What happened here?

In fact, optimizing compilers usually change the order of instructions when the change doesn't affect the memory consistency. When you see x = 1 and r1 = y, the variables(x, r1, y) have nothing to do with each other, so that a compiler can change the order and executes it with r1 = y and then x = 1.

Consequentially, some idioms like double-check fails in instruction reordering compilers because you can't be sure which instruction is executed first. Be careful and use synchronization when the ordering must be enforced.

Witness: A Lock Order Verifier

2005-10-17T17:47:00.000-04:00

In BSDCon2002 conference, there is a paper, "Locking in the Multithreaded FreeBSD Kernel."

The most interesting tool is Witness mentioned in section 7.2. It is called a lock order verifier. In principle, it records the order of lock acquisitions in runtime and use that records to warn programmers that it may cause deadlocks when other threads do not follow the lock order.

A dynamic data race detector: checkSync

2005-10-17T17:41:00.000-04:00

There is a software project called "checkSync." It is based on a paper "Eraser: A Dynamic Data Race Detector for Multithreaded Programs". To make it short, it collects lock sets of shared Java class fields in runtime and try to find data races dynamically.

Because it is a dynamic analysis tool, it doesn't provide the completeness. However, it is quite useful to find data races if we take it into consideration that concurrency bugs such as deadlock and race conditions seldomy occurs and it is hard to find them with test cases.

Synchroniation

2005-10-17T17:32:00.000-04:00

Many developers think that synchronization is the same thing as mutual exclusion. However, syncrhonization is more than mutex. It has the following three characteristics,

Atomicity

Visibility

Ordering

Atomicity ensures only one thread can execute in its critical region, so that it prevents multiple threads from running concurrently in critical sections and may corrupt the data structures.

Synchronization also provides the memory consistency. If thread A releases the lock M and thread B acquires the lock M, syncrhonization guarantees that thread B can see the memory operations done by thread A.

Finally, ordering prevents compilers from reordering the instructions which leads to memory inconsistency between thread A and B.

Volatile fields in Java's new memory model seem to satisfy the visibility, but it can never replace the full featured syncrhonization anyway.