stevie@box:~/dev/myproject/common [master]$


If you add the following lines into your ~/.bashrc you’ll always know which branch you are on.

Additionally you’ll be informed if the remote branch (if any) has been changed by adding “*” to the branches name. How cool is that?

stevie@box:~/dev/myproject/common [master *]$


Here are the lines to add which will do the magic for you:

1
2
3
4

export GIT_PS1_SHOWDIRTYSTATE=true
export GIT_PS1_SHOWUNTRACKEDFILES=true
export GIT_PS1_SHOWSTASHSTATE=true
export PS1="${PS1::$((${#PS1}-3))}\$(__git_ps1 ' [\[\e[34;1m\]%s\[\e[0m\]]')\$ "

I thought I’d share it with the world.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  /**
   * formats the xml output readable
   *
   * @param $simpleXmlObject instance of SimpleXmlObject to pretty-print
   * @return string of indented xml-elements
   */
  function format(&$simpleXmlObject){
 
    if( ! is_object($simpleXmlObject) ){
        return "";
    }
      	//Format XML to save indented tree rather than one line
  	$dom = new DOMDocument('1.0');
  	$dom->preserveWhiteSpace = false;
  	$dom->formatOutput = true;
  	$dom->loadXML($simpleXmlObject->asXML());
 
  	return $dom->saveXML();
  }

PS: In case you don’t know how to get a SimpleXml-Object.

JKS has a big advantage over the PKCS12-format: It knows trusted certificates. This way you can use certificates, normally untrusted by your application because the Certificate Authority (CA) is not trusted within the default keystore.

To convert your PKCS12-keystore to a JKS-type use the following line:

1

 keytool -importkeystore -srckeystore oldkeystore.pkcs -srcstoretype pkcs12 -srcstorepass oldsecret -destkeystore newkeystore.jks -deststoretype jks -deststorepass newsecret

After execution of this line you will have a 2nd keystore in the directory named “newkeystore.jks”.

Speed – or to be more precise the lack of it – is one of the major annoyances and a main reason for users to not come back. So it is in your own best interest to reach the best possible speed.

I found a very extensive list of website optimization techniques which I wanted to share with you (and to keep a link for future references). I can’t really say that by now I even follow half the list of improvements but I will certainly try to make the next app better than the one before – as always.

Link: www.chazzuka.com: Website Optimization Best Practices, speed up your website load

The guys of JavaRanch.com try to accomplish just that:

Grab your marshmallows and a stick and gather ’round the campfire for some Java stories. The Ranch writers won’t be winnin’ any literary prizes, that’s fer sure. But ya still might learn a thing or two.

I find this approach very refreshing and I’m sure some of you dealing with certain more technical description will enjoy the casual written, funny illustrated yet informing stories.

So hop on your horse, ride on over to the ranch and give it a read @
JavaRanch Campfire – Getting in Touch with your Inner Class.

I guess many people had this problem before and I think everybody managed to solve this quite similar. Anyways, just in case this is useful for anybody: here’s how I added a pagination to a site recently.

Given you have an array of products for example. Or maybe search results, a list of articles… something like that. Unfortunately they are too many to display them on a single page. Well, sure, you could but let’s be honest: that isn’t an option as the page would exceed its “scrollable-with-no-harm-to-scroll-fingers” length. And you don’t want to get sued by your visitors, right
Ok, so you’re going to add a nice pagination to your site, so that everybody is happy.
What I found out to be a bit tricky was to calculate the actual number of pages. We need that number so that we know, how many page links we will show next to our current view.

Two simple examples to illustrate the probelm:
Let’s say we have 8 items. 8 divided by 4 is 2, so we’re going to need two pages. No big deal, right?
Okay then we try this with 9 items. 9 divided by 4 gives us 2.25. So we will clearly need a 3rd page for product number 9, but how do we calculate this from our result?

$itemcount = $res->length();
$pagemin = $itemcount / 4;
$pagemax = ceil($itemcount / 4);
if ( $pagemax - intval($pagemin) === 1) ) {
$pages = $pagemax;
} else {
$pages = intval($pagemin);
}


The code explained

That’s why I compare two values here: the actual division result and the next bigger integer. Now we try to find out if both values differ. If they do, we have a scenario where we do want another page, so we pick the bigger result as our page number. If not we are just happy and use the smaller number.

So now that we know our actual page count we can do something (slightly simplified) like this:


while($i = 0;$i < $pages; $i++) {
print '<a href="?page=' . $i . '">Page ' . $i . '';
}


With a little bit of styling this even looks nice. And of course, this is just a start. You also might want to add “previous” and “next buttons”, or those “first page”, “last page” buttons, limit the maximum number of page links shown, or you could center the currently viewed page in the middle, hide the previous button on the first page, etc… There are a lot of fine tuning options that will improve the user experience of your pagination.

If you could answer all these questions with a “yes” you might have noticed afterwards that you can’t do anything with this project because eclipse created it as “general project”, meaning no java, php or anything other specialized nature. This results in certain functions like Run as Java application not being accessable.

There are several solutions to that problem – but most of them are really ugly, imho. But since I don’t want to keep anything from you I will explain these methods too. So let’s get started…

The wrong way

The intuitive way you propably would start the task “to checkout a new project from SVN” might be “File -> New -> Project -> Others…-> Checkout a project from SVN”. In the result you’d have the previously mentioned “general project” which is pretty useless.

solution #1: edit .project

After the creation of the new project you quit eclipse, browse to the project folder in your file system and open the .project-file in a editor.

You’ll find these lines:

<natures>
</natures>

Change it to match:

<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>

Save the file and fire up eclipse again, you will have your svn-project recognized as Java-project. This solution might be quick but the drawbacks are the quit/edit/start-sequence outside of eclipse and the necessity to find the right “nature” for your svn project.

solution #2: delete and recreate

After having completed the checkout you will delete your project. Yes, you read right. (I told you these methods are ugly! ) But when deleting be sure you don’t check the box for physically deletion of the files (so they’ll remain inside your workspace).

When you finished deleting the project you create a new project for the kind of project the svn project should represent (i.e. java, php etc.). While in the creation wizard be sure you select the same folder where the svn project has been checked out into.

The newly created project will have the right project type and will contain all files from the repository. Sometimes it is necessary to refresh the workspace (windows: hit F5 on the project).

Although this method also results in having the right data with the correct project type it has a bad taste jumping through these hoops in order to finish a simple task like that.

Since I wasn’t pleased with all those solutions I kept on looking. Finally I found…

The right way

Besides the following solution is the one most hoopless (no pun intended) the claim “right” is justified because it seems that this is the way the eclipse devs want us to check out a project.

In order to accomplish the task at hand you have to

• open the SVN Exploring-perspective
  ( Windows -> Open Perspective -> Other… -> SVN Exploring)
• create a new repository location or select the desired source
• browse to the parent folder of your new project (e.g. trunk)
• right click on the folder, choose Checkout…
• in the new dialogue you will have the chance to select Check out as a project configured using the New Project Wizard, take that chance, fill out the rest as you please and hit Finish
• in the new project wizard which will open next you can choose your desired project type (e.g. java) and set up everything like you would in a normal project (e.g. compliler compliance level, JRE, related projects etc.)
• after hitting this finish button you will notice that the svn is queried to retrieve the code
• and you’re done!

In my opinion this way is the most hazzle-free way to check out a new project though I love to see it the other way around too (New->Project->New Project from SVN -> yada yada yada -> “Please select a project type or press OK to let it remain a generel project.”). Until this is implemented I will go with the second best solution.

The upgrade went fine but after it was finished trac (0.11.2.1 ) refused to start, throwing the error message

DatabaseError: file is encrypted or is not a database

According to the ticket system of trac the problem is the wrong version of sqlite which is used by trac. Sadly all my efforts to make the database useable again failed with the error message above.

After some research I discovered another way to let trac use the default sqlite3 but keeping my data alive. This chatlog states a simple way to convert your sqlite2 database to the newer sqlite3-format. Here is a quick walkthrough:

1. Install the packages sqlite (v2) and sqlite3 (guess the version )
   ^?View Code BASH

   1	aptitude install sqlite sqlite3

2. Dump the old database and convert it to sqlite3
   ^?View Code BASH

   1 2 3 4 5 6

   cd /path/to/trac-repos cd db mv trac.db trac.db.old-sqlite2 sqlite trac.db.old-sqlite2 .dump | sqlite3 trac.db chown www-data:www-data trac.db /etc/init.d/apache2 restart

And you’re done. The old database is now named trac.db.old-sqlite2 in case you need it for whatever reason. The new one is named with the default name trac.db so trac will use this one if not specified otherwise in conf/trac.ini.

I hope this tip saves you from some worries after upgrading to Debian Lenny. Keep on coding!

Sadly the documentation and the usage examples are very poor on this topic so PHPBuilder Forum member iceomnia decided to do something about it and wrote a quick howto on this subject.

With that information you can jump right into the code and generate your own XML files within minutes. Have fun…

Link: PHPBuilder.com, the best resource for PHP tutorials, templates, PHP manuals, content management systems, scripts, classes and more.

Note: The article mentioned here is in German. Sorry if you can’t read it. Maybe this article could be a start for you though.

Link: Code-Inside Blog: HowTo: Einstieg in “Cloud-Computing”