You can download an example project at here and remember that only Spring version from 3.0.1 supports JPA 2 fully.

I. Add properties and dependencies into your POM.XML file

1. Add properties

<properties>
       ...
       <wicket.version>1.4.9</wicket.version>
       <spring.version>3.0.2.RELEASE</spring.version>
       <hibernate.version>3.5.1-Final</hibernate.version>
</properties>

2. Add Wicket dependencies

<!--  WICKET DEPENDENCIES -->
<dependency>
    <groupId>org.apache.wicket</groupId>
    <artifactId>wicket</artifactId>
    <version>${wicket.version}</version>
</dependency>
<dependency>
   <groupId>org.apache.wicket</groupId>
   <artifactId>wicket-extensions</artifactId>
   <version>${wicket.version}</version>
</dependency>

<!--  WICKET-SPRING DEPENDENCIES -->
 <dependency>
 <groupId>org.apache.wicket</groupId>
 <artifactId>wicket-spring</artifactId>
 <version>${wicket.version}</version>
 </dependency>

3. Add Spring 3 dependencies

<!--  SPRING DEPENDENCIES -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-orm</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 <version>${spring.version}</version>
 <scope>test</scope>
 </dependency>

4. Add JPA 2.o /Hibernate 3 dependencies

<!-- HIBERNATE 3.5.1 JPA -->
 <dependency>
 <groupId>org.hibernate.java-persistence</groupId>
 <artifactId>jpa-api</artifactId>
 <version>2.0-cr-1</version>
 </dependency>
 <dependency>
 <groupId>org.hibernate</groupId>
 <artifactId>hibernate-entitymanager</artifactId>
 <version>${hibernate.version}</version>
 </dependency>
<!-- C3p0 for Datasource -->
 <dependency>
 <groupId>c3p0</groupId>
 <artifactId>c3p0</artifactId>
 <version>0.9.0.4</version>
 </dependency>

<!-- H2 DEPENDENCIES for testing -->
 <dependency>
 <groupId>com.h2database</groupId>
 <artifactId>h2</artifactId>
 <version>1.2.125</version>
 </dependency>

II. Create applicationContext.xml for Spring 3
1. Create application.properties for datasource and jpa configuration:

# connection pool config (c3p0 ComboPooledDataSource)
# all time values are in seconds
c3p0.minPoolSize=2
c3p0.maxPoolSize=20
c3p0.maxConnectionAge=21600
c3p0.maxIdleTime=3600
c3p0.idleConnectionTestPeriod=300

# Development config with H2 database
jdbc.driver=org.h2.Driver
jdbc.url=jdbc:h2:~/your_database
jdbc.username=sa
jdbc.password=

jpa.databasePlatform=org.hibernate.dialect.HSQLDialect
jpa.generateDdl=true
jpa.showSql=true

2. An example applicatonContext.xml:

 <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-3.0.xsd  http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 <context:annotation-config />
 <context:component-scan base-package="com.duydo.model" />
 <tx:annotation-driven transaction-manager="transactionManager" />

 <context:property-placeholder location="classpath:application.properties"/>

 <bean id="dataSource">
 <property name="driverClass">
 <value>${jdbc.driver}</value>
 </property>
 <property name="jdbcUrl">
 <value>${jdbc.url}</value>
 </property>
 <property name="user">
 <value>${jdbc.username}</value>
 </property>
 <property name="password">
 <value>${jdbc.password}</value>
 </property>
 <property name="minPoolSize">
 <value>${c3p0.minPoolSize}</value>
 </property>
 <property name="maxPoolSize">
 <value>${c3p0.maxPoolSize}</value>
 </property>
 <property name="checkoutTimeout">
 <!-- Give up waiting for a connection after this many milliseconds -->
 <value>20000</value>
 </property>
 <property name="maxIdleTime">
 <value>${c3p0.maxIdleTime}</value>
 </property>
 <property name="idleConnectionTestPeriod">
 <value>${c3p0.idleConnectionTestPeriod}</value>
 </property>
 </bean>

 <bean
 class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

 <bean id="entityManagerFactory"
 class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
 <property name="persistenceUnitName" value="wsjhPU" />
 <property name="dataSource" ref="dataSource" />
 <property name="jpaVendorAdapter">
 <bean>
 <property name="databasePlatform" value="${jpa.databasePlatform}" />
 <property name="showSql" value="${jpa.showSql}" />
 <property name="generateDdl" value="${jpa.generateDdl}" />
 </bean>
 </property>
 </bean>
 <bean id="transactionManager">
 <property name="entityManagerFactory" ref="entityManagerFactory" />
 <property name="dataSource" ref="dataSource" />
 </bean>

 <bean id="wicketApplication" class="com.duydo.WicketApplication"/>

</beans>

III. Modify your PERSISTENCE.XML as following

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
 xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
 <persistence-unit name="wsjhPU" transaction-type="RESOURCE_LOCAL">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 </persistence-unit>
</persistence>

IV. Modify your WEB.XML as following

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
 version="2.4">

 <display-name>wicket-spring-jpa-hibernate</display-name>

 <context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:applicationContext.xml</param-value>
 </context-param>

 <filter>
 <filter-name>open.entitymanager.in.view</filter-name>
 <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
 </filter>

 <filter>
 <filter-name>wicket.wicket-spring-jpa-hibernate</filter-name>
 <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
 <init-param>
 <param-name>applicationFactoryClassName</param-name>
 <param-value>org.apache.wicket.spring.SpringWebApplicationFactory</param-value>
 </init-param>
 <init-param>
 <param-name>configuration</param-name>
 <param-value>development</param-value>
 </init-param>
 </filter>

 <filter-mapping>
 <filter-name>open.entitymanager.in.view</filter-name>
 <url-pattern>/*</url-pattern>
 </filter-mapping>

 <filter-mapping>
 <filter-name>wicket.wicket-spring-jpa-hibernate</filter-name>
 <url-pattern>/*</url-pattern>
 </filter-mapping>

 <listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
</web-app>

I will use Wordpress for example. We all know that every post in wordpress blog system has a status with possible values: draft, pending-review, published…

There are some ways to model the post entity. We can save status as an integer value in database: draft -> 0, pending-review -> 1, published -> 2

Version 1

@Entity
public class Post {
	private Integer status;

	public Integer getStatus() {
		return status;
	}

	public void setStatus(Integer status) {
		this.status = status;
	}
}

Well that’s ok. A client can use:

	Post post = ...;
	//Draft post
	post.setStatus(0);
	repository.store(post);

But this is not safe, the client can set any integer value for status. For more save, we can define constants for status values like that:

public class PostStatus {
	public static final Integer DRAFT = 0;
	public static final Integer PENDING_REVIEW = 1;
	public static final Integer PUBLISHED = 2;
}

The client can use:

	Post post = ...;
	//Draft post
	post.setStatus(PostStatus.DRAFT);
	repository.store(post);

But it is still not safe, because the client maybe do not use PostStatus class. So for more safe, what we need to do?
Yes, we can force the client use PostStatus by declaring PostStatus as an Enum and make it dependency in Post class:

Version 2

public enum PostStatus {
	DRAFT, PENDING_REVIEW, PUBLISHED;
}

@Entity
public class Post {
	@Enumerated
	private PostStatus status;

	public PostStatus getStatus() {
		return status;
	}

	public void setStatus(PostStatus status) {
		this.status = status;
	}
}

And now client can use it:

	Post post = ...;
	//Draft post
	post.setStatus(PostStatus.DRAFT);
	repository.store(post);

Well, it is better. But wait…
We know that JPA persists all enum constants in order we declare them in PostStatus with value started from 0. This is limitation, we can not change order of constants, we only can append a new constant. How does we solve this limitation?

Version 3

Enum type in Java 5 is wonderful, we can add constructor and do some business logic in it. Apply it we can re-write PostStatus like this:

public enum PostStatus {
	DRAFT(0),
	PENDING_REVIEW(1),
	PUBLISHED(2);

	private final Integer value;
	private PostStatus(Integer value) {
		this.value = value;
	}
	public Integer getValue() {
		return value;
	}
}

And Post class is re-wrote like this:

@Entity
public class Post {
	private Integer status;

	public PostStatus getStatus() {
		//TODO we need a helper to convert status value to PostStatus enum
		return ...;
	}

	public void setStatus(PostStatus status) {
		this.status = status.getValue();
	}
}

Great!!!

Now client can use code safety and we can add many constants as we want into PostStatus without worry about order of them.

It reminds me of the sentence the guy talked in Java4Ever trailer: “Look how beautiful, robust, secure, portable and scalable it is”

0. Install basic lib

sudo apt-get install build-essential libboost-dev automake libtool flex bison pkg-config

1. Get Thrift:

wget http://www.apache.org/dyn/closer.cgi?path=/incubator/thrift/0.2.0-incubating/thrift-0.2.0-incubating.tar.gz

2. Install Thrift

tar zxvf thrift-0.2.0-incubating.tar.gz
cd thrift-0.2.0-incubating
./bootstrap.sh
./configure --with-boost=/usr/local
make
sudo make install

3. Done

Làm quả screenshot cho vui nhà vui cửa

Trong quá trình đi minh ít khi nào dừng lại nghỉ, chủ yếu đi vệ sinh hoặc khát nước thì dừng lại. Cảm giác đi lên đèo thích lắm . Rất tiếc là lúc đó mình chưa có máy quay phim chứ không giờ có được thước phim ” Hành trình Quảng Ngãi – Sài Gòn bằng xe máy” cho ae thưởng ngoạn rồi hehe.

Ban đầu đi ai cũng không cho nhưng mình và bạn gái quyết định đi một chuyến cho biết cảm giác. Thật sự thì đi cũng không nguy hiểm như mọi người thường nghĩ. Kinh nghiệm của mình đi xe máy là phải luôn có kính chiếu hậu để quan sát dòng xe cộ phía sau, luôn cho xe chạy cách xe ô tô hoặc xe máy khác một khoảng cách an toàn, không bám đuôi hoặc cắt ngang đầu xe khác. Và khi đi phải nhìn xa xa để tránh mấy con chó hay chạy băng qua đường. Đang chạy tốc độ cao mà đụng mấy con này là coi như toi mạng. Chuyến đi này mình chỉ tốn 165.000 tiền xăng.

Tết này mình cũng chạy xe máy về Quảng Ngãi, anh em nào muốn thử cảm giác đi xe máy thì mình hẹn ngày lập hội đi cùng

When you run Page Speed, you get immediate suggestions on how you can change your web pages to improve their speed. For example, Page Speed automatically optimizes images for you, giving you a compressed image that you can use immediately on your web site. It also identifies issues such as JavaScript and CSS loaded by your page that wasn’t actually used to display the page, which can help reduce time your users spend waiting for the page to download and display.

You can download and install Page Speed at here

The idea of  “Fluent Interface” is instead of returning void in  setter methods of an object, returning an object to promote object chaining.

Example:

class Query {
    private String props;
    private String table;
    private String condition;

    public Query select(String props) {
        this.props = props;
        return this;
    }

    public Query from(String table) {
        this.table = table;
        return this;
    }

    public Query where(String condition) {
        this.condition = condition;
        return this;
    }

    public String buildQuery() {
        return String.format("SELECT %s FROM %s WHERE %s", props, table, condition);
    }
}

Instead of:

Query q = new Query();
q.select("username");
q.from("user");
q.where("username = 'duydo'");
String sql = q.buildQuery();

We can write:

Query q = new Query();
String sql = q.select(”username”).from(”user”).where(”username = ‘duydo’”).buildQuery();

This will make code more readable, but be careful when use this technique.

Mấy hôm nay rảnh rỗi ngồi ở nhà nên tôi tìm đọc lại một số bài viết về Einstein. Đi khắp các nhà sách trong thành phố gần mấy tháng nay mà vẫn không tìm được cuốn sách viết về Einstein của Nguyễn Xuân Xanh. Hôm kia cùng “bà xã” đi vào nhà sách Nguyễn Văn Cừ (CMT8) vô tình thấy cuốn sách này, thế là bưng về nhà ngay.

Có thể nói đây là cuốn sách tiếng Việt đầy đủ nhất về cuộc đời của Einstein, cùng với những phát kiến vĩ đại của ông trong ngành Vật Lý Lý Thuyết. Đọc cuốn sách này tôi càng thấu hiểu vì sao Einstein đã đi đến kết luận: Trí tưởng tượng quan trọng hơn tri thức (Imagination is more important than knowledge). Đọc cuốn sách này giúp tôi hiểu hơn về một số nhà khoa học khác cùng thời với ông như Max Planck (người tìm ra hằng số planck h) , Pauli, Bohr, Erwin Schrodinger (người tìm ra phương trình sóng Schrodinger), Heisenberg (cơ học lượng tử)…

Ngoài hoạt động khoa học, Einstein còn tham gia hoạt động chính trị. Ông đã từ bỏ nước Đức ra đi lúc 15 tuổi  vì chủ nghĩa bài trừ Do Thái do Hitler khởi xưởng. Cuộc sống khó khăn, tình hình chính trị rối ren nhưng không hề ngăn cản nổi ông trên con đường đi tìm chân lý khoa học, kể cả chân lý chính trị và đạo đức.

Một cuốn sách đáng để chúng ta đọc, suy ngẫm và học tập.

Einstein is quoted as having said that if he had one hour to save the world he would spend fifty-five minutes defining the problem and only five minutes finding the solution.

This quote does illustrate an important point: before jumping right into solving a problem, we should step back and invest time and effort to improve our understanding of it. Here are 10 strategies you can use to see problems from many different perspectives and master what is the most important step in problem solving: clearly defining the problem in the first place!

The Problem Is To Know What the Problem Is

The definition of the problem will be the focal point of all your problem-solving efforts. As such, it makes sense to devote as much attention and dedication to problem definition as possible. What usually happens is that as soon as we have a problem to work on we’re so eager to get to solutions that we neglect spending any time refining it.

What most of us don’t realize — and what supposedly Einstein might have been alluding to — is that the quality of the solutions we come up with will be in direct proportion to the quality of the description of the problem we’re trying to solve. Not only will your solutions be more abundant and of higher quality, but they’ll be achieved much, much more easily. Most importantly, you’ll have the confidence to be tackling a worthwhile problem.

Problem Definition Tools and Strategies

The good news is that getting different perspectives and angles in order to clearly define a problem is a skill that can be learned and developed. As such, there are many strategies you can use to perfect it. Here are the 10 most effective ones I know.

1. Rephrase the Problem

When a Toyota executive asked employees to brainstorm “ways to increase their productivity”, all he got back were blank stares. When he rephrased his request as “ways to make their jobs easier”, he could barely keep up with the amount of suggestions.

Words carry strong implicit meaning and, as such, play a major role in how we perceive a problem. In the example above, ‘be productive’ might seem like a sacrifice you’re doing for the company, while ‘make your job easier’ may be more like something you’re doing for your own benefit, but from which the company also benefits. In the end, the problem is still the same, but the feelings — and the points of view — associated with each of them are vastly different.

Play freely with the problem statement, rewording it several times. For a methodic approach, take single words and substitute variations. ‘Increase sales’? Try replacing ‘increase’ with ‘attract’, ‘develop’, ‘extend’, ‘repeat’ and see how your perception of the problem changes. A rich vocabulary plays an important role here, so you may want to use a thesaurus or develop your vocabulary.

2. Expose and Challenge Assumptions

Every problem — no matter how apparently simple it may be — comes with a long list of assumptions attached. Many of these assumptions may be inaccurate and could make your problem statement inadequate or even misguided.

The first step to get rid of bad assumptions is to make them explicit. Write a list and expose as many assumptions as you can — especially those that may seem the most obvious and ‘untouchable’.

That, in itself, brings more clarity to the problem at hand. But go further and test each assumption for validity: think in ways that they might not be valid and their consequences. What you will find may surprise you: that many of those bad assumptions are self-imposed — with just a bit of scrutiny you are able to safely drop them.

For example, suppose you’re about to enter the restaurant business. One of your assumptions might be ‘restaurants have a menu’. While such an assumption may seem true at first, try challenging it and maybe you’ll find some very interesting business models (such as one restaurant in which customers bring dish ideas for the chef to cook, for example).

3. Chunk Up

Each problem is a small piece of a greater problem. In the same way that you can explore a problem laterally — such as by playing with words or challenging assumptions — you can also explore it at different “altitudes”.

If you feel you’re overwhelmed with details or looking at a problem too narrowly, look at it from a more general perspective. In order to make your problem more general, ask questions such as: “What’s this a part of?”, “What’s this an example of?” or “What’s the intention behind this?”.

For a detailed explanation of how this principle works, check the article Boost Your Brainstorm Effectiveness with the Why Habit.

Another approach that helps a lot in getting a more general view of a problem is replacing words in the problem statement with hypernyms. Hypernyms are words that have a broader meaning than the given word. (For example, a hypernym of ‘car’ is ‘vehicle’). A great, free tool for finding hypernyms for a given word is WordNet (just search for a word and click on the ‘S:’ label before the word definitions).

4. Chunk Down

If each problem is part of a greater problem, it also means that each problem is composed of many smaller problems. It turns out that decomposing a problem in many smaller problems — each of them more specific than the original — can also provide greater insights about it.

‘Chunking the problem down’ (making it more specific) is especially useful if you find the problem overwhelming or daunting.

Some of the typical questions you can ask to make a problem more specific are: “What are parts of this?” or “What are examples of this?”.

Just as in ‘chunking up’, word substitution can also come to great use here. The class of words that are useful here are hyponyms: words that are stricter in meaning than the given one. (E.g. two hyponyms of ‘car’ are ‘minivan’ and ‘limousine’). WordNet can also help you finding hyponyms.

5. Find Multiple Perspectives

Before rushing to solve a problem, always make sure you look at it from different perspectives. Looking at it with different eyes is a great way to have instant insight on new, overlooked directions.

For example, if you own a business and are trying to ‘increase sales’, try to view this problem from the point of view of, say, a customer. For example, from the customer’s viewpoint, this may be a matter of adding features to your product that one would be willing to pay more for.

Rewrite your problem statement many times, each time using one of these different perspectives. How would your competition see this problem? Your employees? Your mom?

Also, imagine how people in various roles would frame the problem. How would a politician see it? A college professor? A nun? Try to find the differences and similarities on how the different roles would deal with your problem.

6. Use Effective Language Constructs

There isn’t a one-size-fits-all formula for properly crafting the perfect problem statement, but there are some language constructs that always help making it more effective:

• Assume a myriad of solutions. An excellent way to start a problem statement is: “In what ways might I…”. This expression is much superior to “How can I…” as it hints that there’s a multitude of solutions, and not just one — or maybe none. As simple as this sounds, the feeling of expectancy helps your brain find solutions.
• Make it positive. Negative sentences require a lot more cognitive power to process and may slow you down — or even derail your train of thought. Positive statements also help you find the real goal behind the problem and, as such, are much more motivating.
  For example: instead of finding ways to ‘quit smoking’, you may find that ‘increase your energy’, ‘live longer’ and others are much more worthwhile goals.
• Frame your problem in the form of a question. Our brain loves questions. If the question is powerful and engaging, our brains will do everything within their reach to answer it. We just can’t help it: Our brains will start working on the problem immediately and keep working in the background, even when we’re not aware of it.
• If you’re still stuck, consider using the following formula for phrasing your problem statement:
  “In what ways (action) (object) (qualifier) (end result)?”
  Example: In what ways might I package (action) my book (object) more attractively (qualifier) so people will buy more of it (end result)?

7. Make It Engaging

In addition to using effective language constructs, it’s important to come up with a problem statement that truly excites you so you’re in the best frame of mind for creatively tackling the problem. If the problem looks too dull for you, invest the time adding vigor to it while still keeping it genuine. Make it enticing. Your brain will thank (and reward) you later.

One thing is to ‘increase sales’ (boring), another one is ‘wow your customers’. One thing is ‘to create a personal development blog’, another completely different is to ‘empower readers to live fully’.

8. Reverse the Problem

One trick that usually helps when you’re stuck with a problem is turning it on its head.

If you want to win, find out what would make you lose. If you are struggling finding ways to ‘increase sales’, find ways to decrease them instead. Then, all you need to do is reverse your answers. ‘Make more sales calls’ may seem an evident way of increasing sales, but sometimes we only see these ‘obvious’ answers when we look at the problem from an opposite direction.

This seemingly convoluted method may not seem intuitive at first, but turning a problem on its head can uncover rather obvious solutions to the original problem.

9. Gather Facts

Investigate causes and circumstances of the problem. Probe details about it — such as its origins and causes. Especially if you have a problem that’s too vague, investigating facts is usually more productive than trying to solve it right away.

If, for example, the problem stated by your spouse is “You never listen to me”, the solution is not obvious. However, if the statement is “You don’t make enough eye contact when I’m talking to you,” then the solution is obvious and you can skip brainstorming altogether. (You’ll still need to work on the implementation, though!)

Ask yourself questions about the problem. What is not known about it? Can you draw a diagram of the problem? What are the problem boundaries? Be curious. Ask questions and gather facts. It is said that a well-defined problem is halfway to being solved: I would add that a perfectly-defined problem is not a problem anymore.

10. Problem-Solve Your Problem Statement

I know I risk getting into an infinite loop here, but as you may have noticed, getting the right perspective of a problem is, well, a problem in itself. As such, feel free to use any creative thinking technique you know to help. There are plenty to choose from:

You may want to give yourself an Idea Quota of problem statements. Or write a List of 100 problems to solve. SCAMPER your problem definition. These are just some of dozen techniques you can try.

Of course, how much effort you invest in defining the problem in contrast to how much effort you invest in solving your actual problem is a hard balance to achieve, though one which is attainable with practice.

Personally, I don’t think that 55 minutes of defining a problem versus 5 minutes acting on it is usually a good proportion. The point is that we must be aware of how important problem defining is and correct our tendency to spend too little time on it.

In fact, when you start paying more attention to how you define your problems, you’ll probably find that it is usually much harder than solving them. But you’ll also find that the payoff is well worth the effort.

References:

• Einstein’s Portrait: Yousuf Karsh.
• Einstein’s Quote: Cracking Creativity.
• Source : http://litemind.com