The First Stab

Here’s my initial attempt:

Mac OS X Eclipse Logo 256x256 on Black

I’m not entirely satisfied with it, but it’s a start. Here’s how it looks in my dock:

You can download the Icon (and it’s “source”) here:

Mac Eclipse Icon Pack

If you know of any cool Eclipse icons please leave a comment below. Thanks!

From here…

Pimp My Eclipse by Lee Brimelow

I’m asking this in relation to Flex Builder, but it might apply to Eclipse in general.

Trace statements in Flex Builder get sent to an Eclipse Output Console. What is the easiest way to filter this text on the Eclipse side?

Specifically, I’d like to be able to filter (ignore) lines by patterns.

I came across Logback, but it seems like overkill for this scenario. Is there no way to script something like this Eclipse itself?

The question has been asked on Stack Overflow here:

http://stackoverflow.com/questions/669369/easiest-way-to-filter-eclipse-console-output-text

Background

I’m sure that custom built logging tools have their place, but I believe that simple trace statements can be very useful – especially when dealing with Open Source libraries where it would be impossible to agree on a standard logging tool to use.

Logging tools also add overhead. The nice thing about trace statements is that they don’t get compiled into your Release Build SWF. The only way to achieve this with a logging tool is to use Conditional Compilation – not very convienient to have to wrap every log call. Even if the logging tool has an “off” switch for Release Builds, there will still be overhead when calling the log function (even if it simply returns directly after being called, there is still the overhead of calling the function).

If there was an easy way to filter trace output on the Eclipse side we could ignore statements that we are not currently interested in (those coming from an external library for example) so long as those statements start with a certain pattern.

I’m building an application with SmartyPants-IOC at the moment and it traces a hell-of-a-lot. Luckily, all of it’s trace statements look something like this:

[DEBUG] The object ([object TermsPanelMediator]) has 4 injection points.

I’m also using a little framework that I’m building called RobotLegs which makes trace statements that look like this:

[ROBOTLEGS] MediatorFactory::createMediator – Mediator created for View Component: PijinFlex3_0.TermsPanel30

And my application might make trace statements that look like this:

[MYAPP] What the hell is going on here?! This isn’t a real example!

If I could ignore lines that begin with a certain pattern I would be very happy!

The Solution

Stack Overflow pointed me to Grep Console which can highlight patterns in the output console. Very cool.

So, I can highlight my trace statements with expressions like this:

.*(Q[DEBUG]E).*
.*(Q[ROBOTLEGS]E).*
.*(Q[MYAPP]E).*

With different colours assigned to each expression I get something almost as good as removing unwanted traces.

Grep Console Eclipse Plugin

I’ve recently switched from using SVN to using Git as my source control management tool of choice. It took a little while to get to grips with, but it rocks!

Git is not an evolution of SVN. It is entirely different. Git is a distributed revision control system – everybody working on a project has their own full copy of the repository and its entire history.

Git does not require the presence of a network connection: most commands in Git operate locally, allowing you to review your project history, make branches and tags, merge changes, but most importantly, allowing you to commit while offline.

If you’ve used SVN you’ve probably noticed the littering of .svn folders across your entire project tree, requiring the need for an export tool to retrieve clean copies of your code, and introducing problems when you delete, rename or move files or folders in your project. Git takes a slightly more sensible approach: it creates one folder (named .git) in the root folder of your project.

Git Concepts

With Git there are 3 important things to be aware of: the Git object database, the “index”, and your working area.

The Git object database contains a bunch of stuff that you typically don’t need to worry about. Essentially it’s the repository.

Your working area is the collection of files currently sitting in your project folder. You should treat these files as if they are temporary – because they are! Things you want to keep should be committed to the repository.

The Index is sometimes referred to as the Staging Area. It’s a list of what will get stored on your next commit. Conceptually it sits between your working files and the Git object database. Files that haven’t been staged to the index will be ignored when doing a commit. This gives you great control over what gets committed when.

A branch is a cheap copy of a particular state of the Git object database. Branches are easy to create and switch between, giving you a safe way to try out ideas quickly and easily. Switching to another branch updates your working area to reflect the state of that branch – this is why you should consider your working area temporary.

Installing Git on Mac OS X

Grab and install the latest OS-X Installer from:

http://code.google.com/p/git-osx-installer/

Configuring Git

You need to tell Git who you are – it uses this information for your commits etc.

Fire up your terminal, and type:

git config --global user.name "Your Name"
git config --global user.email your@email.com

Using Git

Once Git is installed on your system, creating a Git repository is easy: open your terminal, cd into the root folder of your project, and type: git init

That’s pretty much it!

After initialising your Git repository, it will most likely be empty. In order to commit files to the repository you first need to “stage” them by adding them to the index. To add all the files in your current project to the index type:

git add .

To commit these files type:

git commit -m "your commit message"

To view the status of your repository type:

git status

To Summarise

[Download and install Git]
[cd into the root of your project]

git init
ls -la
git status
git add .
git status
git commit -m "a useful commit message"
git status

[change some files in your working area]

git status
git diff
git commit -a -m "commit message. -a adds all files from your working area to the index"
git status

[delete some files from your local working area]

git status
git add -u
git commit -m "commit message. -u adds deleted files to the index"
git status

Ignoring Files

You will probably want to ensure than certain files don’t ever get committed to the repo:

http://www.kernel.org/pub/software/scm/git/docs/gitignore.html

Extra Configuration

You can enabled colorful output:

git config --global color.diff auto
git config --global color.status auto
git config --global color.branch auto

Some Bundled Visual Tools

gitk
git gui

Git Screencasts

http://gitcasts.com/

Installing Git on Windows

http://gitcasts.com/posts/git-on-windows

Some Other Git Links

• http://git-scm.com/
• http://www.eecs.harvard.edu/~cduan/technical/git/
• http://git.or.cz/index.html
• http://git.or.cz/course/svn.html
• http://git.or.cz/gitwiki/GitFaq
• http://learn.github.com/
• http://code.google.com/p/git-osx-installer/
• http://www.kernel.org/pub/software/scm/git/docs/user-manual.html
• http://tomayko.com/writings/the-thing-about-git
• http://video.google.com/videoplay?docid=-3999952944619245780

Eclipse Integration

Point your eclipse update manager to: http://www.jgit.org/update-site

More info: http://www.jgit.org/

Some Commands

Add all working files to the index:

git add .

Add deleted files to the index:

git add -u

Create and switch to a new branch:

git checkout -b newbranchname

Review last commit:

git show
git show --stat
git show --name -status
git show HEAD

Review commit history:

git log
git log tag..branch
git log -10
git log --since="May 1" --until="June 1"
git log --author=fred
git log -- some/file

Creating branches:

git branch name
git branch name commit

Switching branches:

git checkout name
git checkout -f name