*evernote.com##div[class*="SidebarInfoContainer"]

to the filters in the blacklist tab of adblock for chrome.

First create a label called TODO by clicking settings then labels.

now create a filter by going to settings, filters that will match the word TODO it the subject. In the second step choose apply label action and select the new label TODO that you just created.

Now from the Labs features in the settings page enable the multiple inboxes feature and select the label todo as the display setting and you’re set to go.

Now any messages that you send to your self with the subject line TODO will be shown in the second inbox.

full article

full article

The mysql client that ships with the latest mysql doesn’t play nice with the mysql gem. Even after gem install mysql you still get the annoying error that says

!!! The bundled mysql.rb driver has been removed from Rails 2.2. Please
install the mysql gem and try again: gem install mysql

Well the trick to fix this is simple. Download the old libmysql.dll from here and move it into the bin/ directory of your ruby installation and restart the mysql service.

Here’s my blabber:

Alexanders thoughts on patterns and how they come to form a living structure can be adapted to software to some extent. CA, not being an expert in the field even mentions mappings of what he calls “centers” to software objects. Objects in software can
be grouped in a few equivalence classes (interfaces, abstract classes, etc) that correspond to Alexander’s core entities and are the building blocks of patterns. Using patterns as a means of information transfer and communication guide lines is already being used extensively. CA asks about the morality and the profoundness of his pattern language and how that is used is software, if it ever is. He mentions that the objective of a living structure is to increase the quality of life of those who experience it. This can be adapted to software, but from a different point of view. Software runs on a system which means it is governed by the virtual machine it runs on and the operating system at the least. So it can only interact with the system in a very constrained way, so there is not too much room for morality here. On the other side the interaction with the humans is the place that can be improved and the software may increase the quality of the experience it offers.

I think that buildings can be alive or dead like CA mentions, but buildings are not living things. They are static. They can’t adapt to the changing environment or the circumstances. But software does have this opportunity. Software should be a living entity. Let me clarify this with a concrete example. The way many people start applications on they computers is usually by selecting the item through a variety of menus. In the DOS era such a visual aid providing an over sight of all the available applications was a contribution to the users perceived quality of life. This sort of application launching is still common today, but programs such as QuickSilver for mac (http://www.blacktree.com) take this one step further by allowing the user to conveniently type just a few letters of the program they wish to run, or an action they wish to perform (e.g copy a file) and adaptively suggest actions to the user by analyzing their usage patterns. This is what I understand from a living entity. The ability to adapt. So yes software can have profoundness and morality, but this can’t be achieved by using more design patterns, nor does using any design patterns bring this quality. This can be achieved by making the software understand the users patterns and making it more humane.

On the subject of generativity: using a patterns language can’t guarantee wholeness and coherence due to the fact that it is localized. So long as one doesn’t maintain an outlook at the whole system there is no way of achieving coherence. Hence it is no surprise that their attempt to create a living campus failed in general but delivered locally successful results. The same would be true for any system including software or hardware systems.

Another subject of patterns in software in the issue of graphical user interface design and the patterns associated with it.
This seems more in tact with the pattern theory of CA. I think in the last decade major improvements have been made to the
way we act with computers. Current user interfaces are profound and coherent. Do they increase the quality of our lives?
probably yes. Do they make the world a better place? I don’t know. These are subjective matters, and I personally am not the
type that really cares for “design” because I get bored easily. I sold my mac book pro for an ibm thinkpad, what do I understand from design. That’s why I shouldn’t be taken too seriously on these matters.

• Standard maven 2 project layout
• Spring MVC + IoC
• Hibernate ORM

The project layout had the spring xml bean definitions under the WEB-INF directory. Which later proved to be a bad choice once I started writing the integration tests. Also log4j was misbehaving and not outputting any logs to the console and complaining. Well I’ll just cut to the chase and explain my setup. By the way I’m using annotated controllers and hibernate entities.

This is the directory structure from the maven project:

Place the hibernate persistence.xml file under resources/META-INF. This is crucial if you want your hibernate annotation configured entities to be picked up automatically or else you will have to manually add each one to your persistence.xml file.

Extend your test case classes from AbstractTransactionalJUnit38SpringContextTests and annotate your test case with the following annotations

@TransactionConfiguration(transactionManager="transactionManager", defaultRollback=true)
@Transactional
@ContextConfiguration("/spring/app-config.xml")

Now spring will automatically initialize the application context for you when you run your tests, and all your hibernate entities will be picked up by hibernate. This will prevent that “Unknown Entity” exception from making your life a living hell. Also make sure your entities import the javax.persistence.Entity and not the hibernate Entity annotation. This should take care of running the tests with the application context.

Sorting out the log4j is also quite simple.

Create a testing log4j configuration file called testing-log4j.xml and place it under src/test/resources. This could be a plain copy of your production log4j.xml file it doesn’t really matter. Then you have to configure maven to understand your new configuration file. Edit your pom.xml file and add this in the build section:

		
			
				src/test/resources
				
					testing-log4j.xml
				
			
		

This will tell maven to look at the src/test/resources directory for test resources and copy them to the output directory target/ when compiling.

Next add this:

					org.apache.maven.plugins
					maven-surefire-plugin
					
						

								log4j.configuration
								testing-log4j.xml
							
						
						true
						false
					
				

This will configure the sure-fire maven test runner plug-in and make it uses the test-log4j.xml when running tests. This will prevent your production log4j configuration from overriding your test version.