A DI container Guice, which is written in Java and released from Google, has fascinated Japanese Java programmers since its 1.0 release in March 8, 2007. Everyday, they write blogs about Guice and shows how much they are zealous to explore Guice. It is clear that Guice made a good start in Japan. I'll introduce what they have written in their blogs.
Many bloggers refer to the online magazine article that explains what is Guice and how we write code using Guice. This article, http://journal.mycom.co.jp/articles/2007/03/14/googleguice/, was publishd in March 14, 2007, just six days after the release. The title might be "It is just like Google to think much of the sense of balance" in English. The author emphasizes Guice would be an effective DI container to innovate into Java based system because it realizes DI by API only.
Among bloggers, committers of Seasar2, which is a de facto DI container in Japan, express concerns for Guice. One of them wrote the result of the benchmark test including Guice, Spring and Seasar2 on the web site, http://d.hatena.ne.jp/arumani/20070316 . The code used for the benchmark test is based on PerformanceComparison class distributed with other Guice source code, and its patch to the original code can be seen at http://docs.google.com/Doc?id=dd3xcjm8_6ddtd3k . According to the result, we know Guice works far faster than Spring, while Seasar2's performance is very close to Guice. The Seasar2 committer analyzes the delay might have come from the slow start of an OGNL library.
Another blogger has trasnlated the User's Guide of Guice into Japanese for a couple of days, which can be read on the blog site, "http://d.hatena.ne.jp/iad_otomamay/ ." The blogger's activity would help to accelerate increasing Guice users in Japan because most Japanese programmers are reluctant to read English documents. Of course, there are some bloggers writing code snippets by using Guice. These would also help to swell up the number of Guice users since how to make a program is interpretted in Japanese.
Current situation would be the first Guice boom raised by skilled programmers who are good at reading source code; therefore, it might take more time for ordinary Java programmers to start to use Guice. Probably, the ordinary programmers would need more documents and articles to decide to embrace it so that they don't lose the way while they are writing code. However, Guice will surely thrive after gaining large amount of users.
Sunday, March 18, 2007
Thursday, March 15, 2007
A complement to the example of Guice struts plugin

A Struts plugin provided by Guice has been my big concern because Sturts is used for web applications commonly. This would be one of the most attractive features in Guice. Today, I tried the counter example included in source code directory and explained in the user's guide. However, it was not easy to get the example to work. The explanation in the user's guide covers princepal parts but is not perfect. Working on the struts plugin example for a couple of hours on netbeans, I finally succeeded in running the Guice example. This is a complement to the example of Guice struts plugin.
All files that must be edited and created to work the counter example are
web.xml, struts.xml, Counter.java, Count.java, Counter.jsp. Each of all is as follows:
- web.xml
User's Guide doesn't refer to web.xml, but Counter class uses @SessionScoped annotation. GuiceFilter is necessary.
<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xsi="http://www.w3.org/2001/XMLSchema-instance" schemalocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Struts Guice Test</display-name>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter>
<filter-name>guice</filter-name>
<filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>guice</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
- struts.xml
The path defined in a result tag doesn't seem to be correct. WEB-INF is not needed.
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name="struts.objectFactory" value="guice" />
<package name="strutsguicetest" extends="struts-default">
<action name="Count" class="com.google.inject.struts2.example.Count">
<result>/Counter.jsp</result>
</action>
</package>
</struts>
- Counter.java
I just added packge and import declarations
package com.google.inject.struts2.example;
import com.google.inject.servlet.SessionScoped;
@SessionScoped
public class Counter {
private int count = 0;
public synchronized int increment() {
return count++;
}
public Counter() {
}
}
- Count.java
I added package and import declarations and modified a static parameter SUCCESS
package com.google.inject.struts2.example;
import com.google.inject.Inject;
import com.opensymphony.xwork2.ActionSupport;
public class Count {
private final Counter counter;
@Inject
public Count(Counter counter) {
this.counter = counter;
}
public String execute() throws Exception {
return ActionSupport.SUCCESS;
}
public int getCount() {
return counter.increment();
}
}
- Counter.jsp
I edited netbeans generated jsp file, so nothing has changed in the main part.
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>JSP Page</h1>
<h2>Counter Example</h2>
<h3>
<b>Hits in this session:</b>
<s:property value="count"/>
</h3>
</body>
</html>
All libraries I set in the libraries directory are guice-1.0.jar, guice-servlet-1.0.jar, guice-struts2-plugin-1.0.jar, struts2-core-2.0.6.jar, xwork-2.0.1.jar, ognl-2.6.11.jar, freemarker-2.3.8.jar, commons-logging-1.0.4.jar, 8 jars in total. A file structure in my strutsguicetes project is shown in the above image.
The URL to make the example to run is http://localhost:8084/strutsguicetest/Count.action. Since netbeans assigns 8084 port to Tomcat 5.5.17, and my project name is strutsguicetest, I tried this URL. When I clicked a reload button, the number shown on my browser increased one by one.
Tuesday, March 13, 2007
Simple comparison with the two DI containers, Seasar and Guice
Lightweight DI container, Guice 1.0 has been released. This news draws remarkable attention of Japanese Java developers who use DI container in their products. While Seasar(http://www.seasar.org/en/), which has been developed by Japanese Java programmers, is a de fact DI container and is used broadly in Japan. To study how I can write a code using Guice, I rewrote the example introduced in Seasar's quick start tutorial(http://s2container.seasar.org/en/DIContainer.html#Quickstart) and compaired two types of programs reinforced by a DI containter.
The two programs I wrote show a simple well-known message, "Hello World!" and inject two implemented classes in each series of codes. In my programs, a GreetingClient type object uses a Greeting type object, and the implementation classes of Greeting and GreetingClient are injected. When I wrote codes for Guice, Paul Barry's blog(http://paulbarry.com/articles/2007/03/12/guice-hello-world) helped me a lot.
First three codes, Greeting.java, GreetingImpl.java and GreetingClinet.java are identical for both Seasar and Guice are utilized.
However, the implementation class of GreetingClient for Guice has an @Inject annotation to inject the implementation for the Greeting type class, while it is still POJO as a Seasar's code.
Besides, I wrote the class to inject the implementation of GreetingClient, whereas the role of this class might be performed by a Dicon file for Seasar. The Dicon is an XML file and defines dependencies, adds intercepting classes and more.
Main classes for Guice and Seasar are as follows.
Comparting two series of code powered by Guice and Seasar, I assured Guice is configuration free DI container. It is convenient, flexible and easy to understand. However, today's DI containers are not merely a DI container. They have additional useful features such as utility classes of logging, exception handling, integration to other products and etc. I wonder people who are accustomed to other DI container and have many codes depends on it can start to use Guice soon.
Anyway, Guice programming dosen't require to write XML based configuration file and is probably easy to use(I'm note sure because I just wrote one simple application).At least, it is a great advantage for users who newly started to use DI containers.
The two programs I wrote show a simple well-known message, "Hello World!" and inject two implemented classes in each series of codes. In my programs, a GreetingClient type object uses a Greeting type object, and the implementation classes of Greeting and GreetingClient are injected. When I wrote codes for Guice, Paul Barry's blog(http://paulbarry.com/articles/2007/03/12/guice-hello-world) helped me a lot.
First three codes, Greeting.java, GreetingImpl.java and GreetingClinet.java are identical for both Seasar and Guice are utilized.
//Greeting.java
public interface Greeting {
String greet();
}
//GreetingImpl.java
public class GreetingImpl implements Greeting {
public GreetingImpl() {
}
public String greet() {
return "Hello World!";
}
}
//GreetingClient.java
public interface GreetingClient {
void execute();
}
However, the implementation class of GreetingClient for Guice has an @Inject annotation to inject the implementation for the Greeting type class, while it is still POJO as a Seasar's code.
//GreetingClientImpl.java for Guice
import com.google.inject.Inject;
public class GreetingClientImpl implements GreetingClient {
private Greeting greeting;
public GreetingClientImpl() {
}
public void execute() {
System.out.println(greeting.greet());
}
@Inject
public void setGreeting(Greeting greeting) {
this.greeting = greeting;
}
}
//GreetingClientImpl.java for Seasar
public class GreetingClientImpl implements GreetingClient {
private Greeting greeting;
public void setGreeting(Greeting greeting) {
this.greeting = greeting;
}
public void execute() {
System.out.println(greeting.greet());
}
}
Besides, I wrote the class to inject the implementation of GreetingClient, whereas the role of this class might be performed by a Dicon file for Seasar. The Dicon is an XML file and defines dependencies, adds intercepting classes and more.
//GreetingController.java for Guice
import com.google.inject.Inject;
public class GreetingController {
private GreetingClient greetingClient;
public GreetingController() {
}
public void execute() {
greetingClient.execute();
}
@Inject
public void setGreetingClient(GreetingClient greetingClient) {
this.greetingClient = greetingClient;
}
}
//GreetingMain2.dicon
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE components PUBLIC
"-//SEASAR//DTD S2Container 2.3//EN"
"http://www.seasar.org/dtd/components23.dtd">
<components>
<component name="greeting"
class="examples.di.impl.GreetingImpl"/>
<component name="greetingClient"
class="examples.di.impl.GreetingClientImpl">
<property name="greeting">greeting
</component>
</components>
Main classes for Guice and Seasar are as follows.
// Main.java for Guice
import com.google.inject.AbstractModule;
import com.google.inject.Injector;
import com.google.inject.Guice;
public class Main {
public Main() {
Injector injector = Guice.createInjector(new GreetingModule());
GreetingController controller = new GreetingController();
injector.injectMembers(controller);
controller.execute();
}
public static void main(String[] args) {
new Main();
}
private class GreetingModule extends AbstractModule {
protected void configure() {
bind(Greeting.class).to(GreetingImpl.class);
bind(GreetingClient.class).to(GreetingClientImpl.class);
}
}
}
// Main.java for Seasar
import org.seasar.framework.container.S2Container;
import org.seasar.framework.container.factory.S2ContainerFactory;
public class GreetingMain2 {
private static final String PATH =
"examples/di/dicon/GreetingMain2.dicon";
public static void main(String[] args) {
S2Container container =
S2ContainerFactory.create(PATH);
GreetingClient greetingClient = (GreetingClient)
container.getComponent("greetingClient");
greetingClient.execute();
}
}
Comparting two series of code powered by Guice and Seasar, I assured Guice is configuration free DI container. It is convenient, flexible and easy to understand. However, today's DI containers are not merely a DI container. They have additional useful features such as utility classes of logging, exception handling, integration to other products and etc. I wonder people who are accustomed to other DI container and have many codes depends on it can start to use Guice soon.
Anyway, Guice programming dosen't require to write XML based configuration file and is probably easy to use(I'm note sure because I just wrote one simple application).At least, it is a great advantage for users who newly started to use DI containers.
Thursday, March 08, 2007
Jar Archive setting of NetBeans Ruby Pack
Recently, NetBeans Ruby Pack has been released, so I tried it immediately. It's very sweat and exciting except one problem. How can I set a classpath to a jdbc diver jar archive? I googled again and again putting various key words in the box, which ended up vain efforts. Instead keep searching, I looked carefully each directory related to NetBeans because JUnit tests seem to work in Ruby on Rails project on NetBeans as in the demo video. Class names of JUnit don't start with java or javax, but JUnit classes seem to be available in Ruby project. I figured out. Jar archives used in Ruby and Ruby on Rails projects exist in the directory /home/username/.netbeans/dev/jruby-0.9.2/lib. When I made a link to derby.jar in that directory, I could get my JRuby code work successfully.
Released Ruby Pack is the very first version and might have bugs and lack of convenient features. By the time those would be fixed and improved, I will avoid the jar-archive-setting problem by making links to necessary jar archives.
Released Ruby Pack is the very first version and might have bugs and lack of convenient features. By the time those would be fixed and improved, I will avoid the jar-archive-setting problem by making links to necessary jar archives.
Friday, February 09, 2007
Still now, Jini and JavaSpaces are sluggish in Japan
When I wrote about JavaSpaces a few days ago, I got the comment which pointed out my out-of-date knowledge. The real cases based on JavaSpaces (or Jini) have worked already, though my awareness was opposite. I should have researched American Web sites. Now, I know JavaSpaces and Jini have been improving steadily. On the contrary, the situation in Japan remains the same that I wrote in my blog from my old information. Jini and JavaSpaces are sluggish in Japan still now.
I googled to find out recent entries about Jini and JavaSpaces from Japanese Web sites. Many sites were listed; however, most articles were written in 1999 and 2000. Many of them has gone. Besides, I found one article written in 2002 which said Jini based application wasn't developed anymore. In this article(http://www.atmarkit.co.jp/news/200211/12/upnp.html) about UPnP, the writer said that Microsift's UPnP thrived while Jini technology was struggling to find the way. The writer also said that topics on Jini seldom showed up in those days. It is true. Everything I could find on the Japanese Internet sites was just two articles about Jini after 2002.
I don't know the reason why Jini and JavaSpaces have been depressed in Japan. I guess a simple web application would have been effective enough in the early 2000s. J2EE products would have been sold well thanks to the vendors' efforts or Japanese character that they love to act same as others. Since JEE has become too big, recently, there is obvious tendency amid Japanese Java developers to go over to lightweight language such as Ruby. This would be negative elements to popularize Jini or JavaSpaces.
I think big obstacles exist in Japan to make Jini or JavaSpaces technology be adopted into a real case right now.
I googled to find out recent entries about Jini and JavaSpaces from Japanese Web sites. Many sites were listed; however, most articles were written in 1999 and 2000. Many of them has gone. Besides, I found one article written in 2002 which said Jini based application wasn't developed anymore. In this article(http://www.atmarkit.co.jp/news/200211/12/upnp.html) about UPnP, the writer said that Microsift's UPnP thrived while Jini technology was struggling to find the way. The writer also said that topics on Jini seldom showed up in those days. It is true. Everything I could find on the Japanese Internet sites was just two articles about Jini after 2002.
I don't know the reason why Jini and JavaSpaces have been depressed in Japan. I guess a simple web application would have been effective enough in the early 2000s. J2EE products would have been sold well thanks to the vendors' efforts or Japanese character that they love to act same as others. Since JEE has become too big, recently, there is obvious tendency amid Japanese Java developers to go over to lightweight language such as Ruby. This would be negative elements to popularize Jini or JavaSpaces.
I think big obstacles exist in Japan to make Jini or JavaSpaces technology be adopted into a real case right now.
Wednesday, February 07, 2007
Is XUL obscure? That's OK.
The article of XUL appeared on XML.com this February. It's a very recent article, which is a bit strange. I mean it is the least likely appearing one. As the writer describes XUL as "a little-known use," it is obscure technology. I like XUL, and feel happy to support it; however, I admit XUL application has been slowed its development speed for more than a couple of years except products from Mozilla foundation. Accordingly, I wondered why XUL was up in this time of period. Exciting, I read the article.
This article introduces XUL, supposedly, to readers who don't know it. The writer tries to impress the readers superiority of XUL by comparing with DHTML. The tree example successfully achieved this scheme. Rendering speed is fast; appearance is good. On the contrary, the writer says DHTML is more convenient than XUL implicitly. DHTML works on every browser including Firefox. This, of course, isn't the purpose, but his concern to DHML would help the readers' interest turn to DHTML. That he introduces the utility available for both XUL and DHTML might spur the readers on. I know the writer wanted to defend from a counter-argument. The number of users of XUL-enabled browsers is very small, so programmers are reluctant to support XUL. I mind the readers conclude they don't choose XUL because they need to write not only XUL but also DHTML.
I like XUL, for its programming is simple. It has rich UI, besides, works fast. An XML file is all I need to make UI. I like to write XML, so XUL is fun for me. I think it isn't necessary for XUL to fit into the world all browsers reside. It's all right that XUL is for XUL-lovers' obscure UI. Let's pursuit fun to create own UI by XUL.
This article introduces XUL, supposedly, to readers who don't know it. The writer tries to impress the readers superiority of XUL by comparing with DHTML. The tree example successfully achieved this scheme. Rendering speed is fast; appearance is good. On the contrary, the writer says DHTML is more convenient than XUL implicitly. DHTML works on every browser including Firefox. This, of course, isn't the purpose, but his concern to DHML would help the readers' interest turn to DHTML. That he introduces the utility available for both XUL and DHTML might spur the readers on. I know the writer wanted to defend from a counter-argument. The number of users of XUL-enabled browsers is very small, so programmers are reluctant to support XUL. I mind the readers conclude they don't choose XUL because they need to write not only XUL but also DHTML.
I like XUL, for its programming is simple. It has rich UI, besides, works fast. An XML file is all I need to make UI. I like to write XML, so XUL is fun for me. I think it isn't necessary for XUL to fit into the world all browsers reside. It's all right that XUL is for XUL-lovers' obscure UI. Let's pursuit fun to create own UI by XUL.
Tuesday, February 06, 2007
Does JavaSpaces have a possibility to become major?
I found an article about JavaSpaces in TheServerSide.com a couple of days ago. I remembered this name well. I had worked for it for about a year before JINI was released. Since it was almost ten years ago, I'm interested in today's situation.
In this article, the writer explains about the definition and the feature of JavaSpaces. In addition, he introduces a small example with describing how to get it work. Every part of this article is familiar to the programmer who once got involved to JavaSpaces. However, how does JavaSpaces sound to Java programmers who don't know this technology?
In the same domain, distributed processing, Web Services technology grew to become eminent. Real Web Services applications have been in action these days. Why JavaSpaces couldn't develop like Web Services? I think the concept of JavaSpaces was too innovative to be understood easily and broadly. Strict to say, JavaSpaces isn't the server-client model. It adopts the peer-to-peer communication model. The "space" provides a place to communicate; therefore, the "space" doesn't control or manage any entries. On the other hand, the concept of Web Services follows the traditional server-client model. Newly added idea was less than that of JavaSpaces. Moreover, as an internet based application, Web Services technology well suited to today's network system.
The writer shows we already have enough tools to make JavaSpaces application. It is true, but JavaSpaces might need innovative application that only JavaSpaces can realize. This would be the most difficult and effective answer JavaSpaces leaps.
What changed is that implementations have been released in public and free. What not changed is that decisive application hasn't created yet.
In this article, the writer explains about the definition and the feature of JavaSpaces. In addition, he introduces a small example with describing how to get it work. Every part of this article is familiar to the programmer who once got involved to JavaSpaces. However, how does JavaSpaces sound to Java programmers who don't know this technology?
In the same domain, distributed processing, Web Services technology grew to become eminent. Real Web Services applications have been in action these days. Why JavaSpaces couldn't develop like Web Services? I think the concept of JavaSpaces was too innovative to be understood easily and broadly. Strict to say, JavaSpaces isn't the server-client model. It adopts the peer-to-peer communication model. The "space" provides a place to communicate; therefore, the "space" doesn't control or manage any entries. On the other hand, the concept of Web Services follows the traditional server-client model. Newly added idea was less than that of JavaSpaces. Moreover, as an internet based application, Web Services technology well suited to today's network system.
The writer shows we already have enough tools to make JavaSpaces application. It is true, but JavaSpaces might need innovative application that only JavaSpaces can realize. This would be the most difficult and effective answer JavaSpaces leaps.
What changed is that implementations have been released in public and free. What not changed is that decisive application hasn't created yet.
Monday, February 05, 2007
The answer for what is Web 2.0
I had wondered what is the definition of Web 2.0 for more than a year. Recently, the word, "Web 2.0," has often appeared in articles about Web applications. None of these articles helped me to figure out the definition of Web 2.0. Web applications, which were introduced as Web 2.0, didn't look innovative though those were useful and attractive. Yesterday, I found the entry in Martin Fowler's Bliki which was written about Web 2.0. It was the very answer for my question.
As Fowler wrote "a common misconception I run into is that Web 2.0 is all new stuff," the jargon surely misleads people. When I heard this jargon for the first time, I thought new HTTP protocol might be defined. Reading some articles and using applications of Web 2.0, soon, I knew my misunderstand. Then, why was it reported like something new? Why did they say new era had come? My question had remained until I read Fowler's entry. Fowler explained the word, Web 2.0, expresses the movement from minority to majority. Internet based application is on the way to become vital. Although Fowler admitted the naming was not the best suited to the movement, he acclaimed the concept.
Web 2.0 technology is not new. The word describes just the concept which encourages web application to develop more sophisticated. I like Web 2.0 applications, so I hope they thrive more and more.
As Fowler wrote "a common misconception I run into is that Web 2.0 is all new stuff," the jargon surely misleads people. When I heard this jargon for the first time, I thought new HTTP protocol might be defined. Reading some articles and using applications of Web 2.0, soon, I knew my misunderstand. Then, why was it reported like something new? Why did they say new era had come? My question had remained until I read Fowler's entry. Fowler explained the word, Web 2.0, expresses the movement from minority to majority. Internet based application is on the way to become vital. Although Fowler admitted the naming was not the best suited to the movement, he acclaimed the concept.
Web 2.0 technology is not new. The word describes just the concept which encourages web application to develop more sophisticated. I like Web 2.0 applications, so I hope they thrive more and more.
Wednesday, January 24, 2007
Cars bumped on a snowy road
Today, snow accumulated in Michigan. Especially, snow fall in the evening was extreme, so roads were covered by snow and very slippery. When I was heading toward the swimming pool, I saw two cars bumped about 20 feet ahead of me. One car was waiting a chance to turn left; another car was to turn right to enter into a mall. Suddenly, the car turning left changed its direction and hit the car. Though it was a small accident, it reminded me importance of speeding down and avoiding from sharp handling.
Tuesday, January 23, 2007
Revived Old Note PC
Recently, I revived my old Note PC. Newly installed OS is FreeBSD 6.2R, which is the only one choice to revive this PC. This PC, released in 1998, has only a 96M-memory(which is a max size) and an 8G-disk. Besides, it is unable to boot by CD-ROM, so I really needed FD bootable OS. I prefered to install some recent easy-to-install and easy-to-use Linux, but Ubuntu, Fedore Core, Gentoo,,, all of which don't support FD boot anymore. Only FreeBSD supports it still now. The install process wasn't easy in spite of the catchphrase in the FreeBSD web site. However, my old Note PC started working again, so I can browse the Internet by this PC connected with wireless LAN. Though responses are not prompt, a 1.19kg(2.62lb), small and easy-to-carry Note PC will give me a good time at a coffee shop.
Monday, December 04, 2006
Why so many build problems?
Reacently, I read e-mail posted to Geronimo-dev ML. One of the most frequent topics is build problem amid Geronimo developers. Why does a build problem occur so often?
The larger the program grows, the more developers updates individually, frequently. Getting caught up the totally newest Geronimo might be a hard job for the developers. Geronimo-dev ML readers would know developers' frustration. Probably, version control software for large scale software would be expected.
The larger the program grows, the more developers updates individually, frequently. Getting caught up the totally newest Geronimo might be a hard job for the developers. Geronimo-dev ML readers would know developers' frustration. Probably, version control software for large scale software would be expected.
Thursday, February 23, 2006
Is your answer yes or no?
The answer for Yes/No questions sometimes puzzle me a lot because the answer for a negative question is opposite to Japanese one. I mean Japanese answer is like this "Yes, I didn't do that." I always try to avoid mistaking, but I have answered in Japanese style many times. Therefore, I often confuse other people and in some case, I'm misunderstood. Recently, I stay away saying just "yes" or "no", instead, I make long answer. Probably, this leads less misunderstanding.
Friday, February 10, 2006
When is it?
If you got message, "Let's meet in the evening," what time do you think it is? According to LONGMAN ADVANCED AMERICAN DICTIONARY, the word "evening" means the late part of the day between about 6:00 and the time when most people go to bed. However, most Japanese think that evening is between about 4:00pm and 6:00pm, and after 7:00pm is the night. Also, the idea about the morning is different. In Japan, morning is about 6:00am through 8:00am, then the day is going to be before noon. Therefore, if Japanese people got message, "let's meet in the morning," they would be surprised. This is only one example of cultural gaps. If foreigners are puzzled to react, it often means that they have troubles caused by a different idea not from English itself.
Monday, February 06, 2006
What do they do?
What do they do? This quesition has come into my mind so many times. I live in a suburb of Detroit with my family. All of my family member are naturally Japanese. Once I come back to my house, there is Japan even if I live in the U.S. Besides, I don't have any American friends. Therefore, sometime, I do something different. Yesterday was February 7th. I went to a fitness club as usual. The fitness club was almost empty! I know sunday night isn't busy, but last night was special. What did they do?
Maybe, the reason was super bowl, but I didn't think it was such a remarkable event, so I was very surprised. In today's ESL class, teacher asked students whether we watched super bowl. To my relief, everybody answered "no." It seems to be difficult for foreigners to understand how super bowl is important.
Maybe, the reason was super bowl, but I didn't think it was such a remarkable event, so I was very surprised. In today's ESL class, teacher asked students whether we watched super bowl. To my relief, everybody answered "no." It seems to be difficult for foreigners to understand how super bowl is important.
What's this blog for?
My life in the U.S. started accidentally on the end of March, 2005. I wasn't a person who were willing to come to the U.S. I have studeid English for my job, so I could speak English a little when I arrived here. However, everthing is different from Tokyo where I have lived for about ten years. I have had so many troubles and questions.
Now, I learn English as a ESL(English as a Second Lanugage) student, so I decided to write my blog in English for a practice.
Now, I learn English as a ESL(English as a Second Lanugage) student, so I decided to write my blog in English for a practice.
Subscribe to:
Posts (Atom)
