I came across Seth in an interview he did with Merlin Mann. He talked a lot about fear and the lizard brain: the part of our brain that is only hungry, scared, selfish and horny. Its the part of our brains that ruled in high school.

It will also sabotage us if we let it.

Whenever we get close to completing something big or interesting or important to us, the lizard brain senses a threat. “What if we fail?” “Ridicule is painful!” “Better to go along in life quietly, then do something that might get us noticed.”

The lizard brain tells us to quit when success is near. Seth mentioned in his interview that he listens to his lizard brain… and then does the opposite. If his lizard brain is quiet, he probably isn’t doing anything important. If his lizard brain is screaming bloody murder, he knows he is on the right track.

I picked up a couple of Seth’s books, including Tribes, The Dip, and his new book, Linchpin. As I come across more interesting tidbits I will share them.

Enter Jekyll, the static page blog generator behind Github Pages. So far the workflow of managing text files in a Git repository is working well for me. Not being able to leave well enough alone I created a Rakefile to manage certain tasks like create a tagcloud for the sidebar, creating tag specific pages listing posts, and creating a draft post.

Creating a draft post was pretty straightforward:

desc 'create a new post in draft mode'
task :new => [:require_input] do
  title = ask("Title: ")
  filename = title.downcase.gsub(/[^a-z0-9]/,"-")
  template=File.read "lib/post_template.markdown"
  File.open("_drafts/#{filename}.markdown", 'w+') do |f| 
    f << template.gsub(/POST_TITLE/, title)
  end
  sh "git add _drafts/#{filename}.markdown"
end

Publishing a draft to the blog will consist of a git mv of the draft file to the _posts directory with the data appended to the filename.

As for comments I have switched over to Disqus, which allowed me to import my Wordpress comments and link to them on my Jekyll blog.

So I am resetting. Grabbing the code that works, dropping Tapestry (the documentation on the IoC container and testing is not great) and going back to basics. Hibernate, Spring, Sitemesh…

• Created a basic project structure using a maven archetype
• Checked that structure into source control
• Setup a Hudson job to run continuous integration

Today I have a light load (since it falls to me to feed the wife). I want to get my first page to render in Tapestry and continue research into the elements I will need like custom dispatching.

So Tapestry supplies its own IoC container, so no Spring at this point. Also there is a nice Hibernate integration, so I am starting to mess with my entities and figure out the needed annotations.

Maven profiles seem to manage the different configuration aspects of my application such as properties for development versus a Hudson build. So I can find it in the future, here is the profile snippet for development with a in memory database:

<profile>
    <id>development</id>
    <properties>
        <hibernate.dialect>org.hibernate.dialect.HSQLDialect</hibernate.dialect>
        <hibernate.connection.driver_class>org.hsqldb.jdbcDriver</hibernate.connection.driver_class>
        <hibernate.connection.url>jdbc:hsqldb:mem:autoblog</hibernate.connection.url>
        <hibernate.connection.username>sa</hibernate.connection.username>
        <hibernate.connection.password></hibernate.connection.password>
        <hibernate.connection.pool_size></hibernate.connection.pool_size>
        <hibernate.connection.autocommit>true</hibernate.connection.autocommit>
        <hibernate.cache.provider_class>org.hibernate.cache.HashtableCacheProvider
        </hibernate.cache.provider_class>
        <hibernate.hbm2ddl.auto>create-drop</hibernate.hbm2ddl.auto>
        <hibernate.show_sql>true</hibernate.show_sql>
    </properties>
</profile>

The plan is to write stories that capture the work to be done in a month, hold one week sprints to execute stories, and release a functional (if not pretty) program at the end of November.

This is the first time I have tried a time-boxed activity like this, so we will see what happens. I will attempt to blog about the experience, but will focus on completing the stories first.

I decided to focus on Java development for this project. I have not done any serious Java programming in YEARS, so I needed a problem set that I understood well so I could focus on the HOW instead of on the WHAT.

SO, here it is. In one month I plan to write (with tests) a blogging platform. I know! Its so cliche… But I understand the issues and there is lots to learn.

Now, no one just writes Java code anymore (or so it seems) so I will be using some tools along the way. Hibernate (duh) will be used for persistence. Spring (double duh) will be used for IoC. I am thinking about Tapestry for presentation, but I have not gotten that far.

Stay tuned, boys and girls. It should be a wild ride.

Oh, and why didn’t I choose Grails? I am pretty sure I can do this all in Grails. I want to know I can do it in Java as well.

I spent the morning talking with Barbee Davis and Suzie Lewis Ship about topics ranging from science fiction to Agile development. As a result I missed Ken Sipe’s Iteration 0 panel.

7 Habits of Highly Effective Developers - Ken Sipe

Ken’s session is about applying the The 7 Habits of Highly Effective People by Stephen Covey to software developers.

Covey’s seven habits are:

• be proactive
• begin with the end in mind
• put first things first
• seek first to understand, then to be understood
• synergize
• sharpen the saw

Ken referred to a blog post ”Top 5 Attributes of Highly Effective Programmers”. The attributes from that post are:

• Humility
• Love of Learning
• Detail Orientedness
• Adaptability
• Passion

He has his own list:

• focused on a mission with a vision

• best researcher

• best debugger

• god complex when it comes to software development

  • not a lack of humility
  • just optimism to be able to do anything on the computer

• quality focused

• detailed oriented!

Clojure - Howard Lewis Ship

I have never programmed in Lisp. Considering the other panels in the same time slot I figured I would do something about that and increase my knowledge with the Clojure session.

Clojure is a partial Lisp clone on the JVM with support for software transactional memory to keep your concurrent processes running smoothly.

Hacking Your Brain for Fun and Profit - Nathaniel Schutta

This was the last panel I attended for the weekend, and a lot of fun. I enjoy thinking about and discussing learning techniques and such.

The only topic I will touch on here is the need for sleep. According to the research Nate referenced, if you consistently get six hours of sleep when you need eight it is like missing two nights of sleep. Staying up one night results in a 30% drop in cognitive function…

So go take a nap. A 26 minute nap gives a 34% boost to performance.

Grails is an open-source web framework written in Groovy. Grails is being used by major players like Wired.com, Taco Bell in Canada, and more.

If you have ever created a domain (model) object in Grails and noticed the scaffolding lists fields in alphabetical order, there is a simple way past this. When you add your fields to the static constraints closure, Grails will output them in the order provided.

Want to add Lucene to your application? Try this.

> grails install-plugin searchable

All that is left to give yourself a search engine is add searchable=true to your domain classes.

Once you have done that, start your application with grails run-app annd go to http://localhost:8080/app/searchable to see your search page.

Design Patterns in Java and Groovy - Venkat Subramaniam

I have always had an interest in patterns since I attended Pattern Languages of Programming (PLoP) in 2006. Venkat refered to Java as a post-pattern language; the Gang of Four Design Patterns book came out just before Java, and so patterns are far easier to implement in Java than C++. Likewise we have power and flexibility in Groovy that we do not have in Java that enables pattern implementation.

I found myself in an interesting conversation with Barbee Davis and Ted Neward, so I was late to the next session.

MOPping up Groovy - Venkat Subramaniam

This session was about meta-programming techniques in Groovy. My favorite part was the end where Venkat wrote a executable DSL (domain specific language) in Groovy.

At this point I was pretty tired and none of the last set of panels really interested me, so I went home a little early.

Effective Java - Venkat Subramaniam

Unlike many talks, Venkat let us chose the topics. He put up a Jeopardy style board with categories like ‘Syntax Sugar’, ‘Collections’ and ‘Objects’ and let us pick. The content varied wildly, not in its quality (Venkat knows his stuff) but in just how deep into the rabbit hole it would lead you.

As an example, which is better?

string1 + string2
new StringBuffer(string1).append(string2)

Normally you might think that the simple + would be less efficient, but thanks to syntactic sugar the opposite is true.

In Java 1.4 and above the simple + will use StringBuilder in the background. StringBuilder will preallocate space based on expectations and will not acquire and release locks like StringBuffer will.

There were a lot of code examples and we covered pitfalls and Java strangeness like the above.

Common Antipatterns - Mark Richards

We started talking about common antipatterns in life as an example.

There are some common causes of anti-patterns:

• haste - aggressive deadlines and budgets drive lower standards of quality
• apathy - general lack of concern about finding the proper solution to a problem
• arrogance - refusal to accept solutions or practices generally known to be effective
• ignorance - failure (intentional or non-intentional) to seek a clear understanding of the problem space
• pride - refusal to leverage existing designs, code and frameworks; builds everything from scratch

Object Orgy - insufficiently encapsulated objects result in unrestricted access to their internals.

Cargo Cult Programming - using patters, methods and techniques without understanding why.

Golden Hammer - using the same tool, product or technique to solve every problem.

With the plethora of languages available on the JVM, we have all kinds of choice. For a comprehensive list of language options, see http://www.is-research.de/info/vmlanguages/

Accidental Complexity - introducing non-essential complexity into a solution.

essential complexity: we have a hard problem

accidental complexity: we have made a problem hard

“developers are drawn to complexity like moths to a flame - often with the same result” - Neal Ford

Lava Flow - obsolete technologies and forgotten extensions leave hardened globules of dead code in its wake.

The Blob - an all encompassing class or component that knows too much and does too much.

Use a roles and responsibility model. Figure out in just a couple of sentences what the job of a given object is.

Architecture by Implication - systems lacking a clear architecture definition.

Don’t rely too heavily on past experience; every problem is a little different.

Groovy Testing - Scott Davis

There are some real benefits to using Groovy for testing. Groovy has the ability to get into the private guts of a Java object.

The concept of a ‘private’ field is a Java language construct, not a Java platform construct. This means you can get to private methods and fields.

Keynote - Venkat Subramaniam

Venkat gave the keynote after dinner; an entertaining talk about the pointy-hairness in all of us, not just bosses.