Jun 10 2009

Hudson Continuous Integration and Eclipse Update Sites

I was looking for a development build of the IvyDE plug-in for Eclipse tonight and I stumbled across the Apache Hudson server. You have to check this out. Pretty cool, Hudson running over 150 jobs!  Their build farm consist of both Solaris and Ubuntu servers. What I found most interesting was how they used Hudson for creating an Eclipse update site. I subscribe to the Hudson mailing list, summarized here, to follow what is going on with the project. People seem to use Hudson for a variety of different purposes, such as a cross platform testing tool and even as a deployment tool. I have only been able to get people interested in Hudson as a “Cruise Control” replacement…. but at least it is a good start!

This site also demonstrates how multiple projects can be linked together, triggering builds of dependent downstream projects.  I’m not exactly sure how these jobs were assembled, but at a high-level, Ivy and IvyDE each have its own build loop (job). Each job is responsible for creating build artifacts. After a successful build of either job, a third job is triggered which creates/updates and Eclipse update site.  Pretty slick. (As any FYI, the dev plug-in looks better, new presentation and several new new options)

Another small plug for Continuous Integration. We recently set up something kind of cool (trivial, but cool)! As we continue trying to convince the powers that be, to move away from Weblogic towards Tomcat (or even JBoss), we found a really nice little feature. Since Tomcat and JBoss can hot deploy a new version of the WAR file, just by noticing a difference on the file system, combined with the fact that we can spin up a Tomcat instance in about 2 minutes, we actually created an auto deployment mechanism.  Our Weblogic environment seems so cumbersome in comparison…. We could have built the WAR and deployed in in our build loop, but that would have minimally added another 25 minutes to the loop (let’s just say we have an interesting deployment process). With Tomcat, we did a one time deployment to the location of the WAR file inside the Hudson workspace. Now, with each series of check-ins, we build the WAR as normal and Tomcat instantly deploys it, in seconds! If we were a little more sophisticated, we would write some jUnits to bang against it, making sure we did not break anything or create any new dependencies.  Maybe I will throw that in during my next project!!! I know this integration was possible before (with Weblogic), but no way as simple!  Even better Continuous Integration… on my last project I had Ant spin up an embedded Jetty web server, ran my jUnits against the Clover instrumented code, and finally had Ant shut down Jetty…. Pretty slick, from a code coverage collection perspective…

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


Jun 02 2009

The Best Eclipse Plug-ins

Category: EclipsePhil @ 8:50 pm

I’ve ran across several blogs that listed their favorite Eclipse plug-ins.  Since I am such a huge Eclipse fan and am always preaching about the power and benefits, it seemed like a good idea for me to document my preferences and experiences. First, you need to start with the Eclipse Java EE version, probably the Ganymede version (3.4), but Galileo (3.5) will be released next week. This Eclipse bundle will give you more than you need, but is the best starting point. Out of the box, Eclipse has many useful features:

  • Mylyn – Task focused development support; here is some background information.
  • Web Standard Tools – Gives you all of the nice editors for XML, HTML, JSP, etc.
  • J2EE Standard Tools – Provides support for J2EE projects, such was the Servlet and EJB.
  • Remote System Explorer – Excellent plug-in for accessing remote systems. It enables you to remotely edit files and provides shell access, including SSH.

Here is my personal Top 10+ list of Eclipse Plug-ins:

Category Plug-in Overview
Code Quality Checkstyle Simple to use. Great for keeping the code consistent and helps enforce many good coding standards. My only dislike of this tool is the suppression implementation. Hopefully they will move to the PMD annotation style. A major new version (5.0) was just released, I have not tested it yet.
Code Quality PMD Little more complex to setup than Checkstyle, but is probably my favorite plug-in. It looks at the structure of your code, evaluating cyclomatic complexity, jUnit usage, and attribute scoping. It has some overlap with Checkstyle, but both tools together give you a complete solution.
Build Support Ivy I have blogged about Ivy in the past. Not my favorite plug-in, but required when using Ivy within Eclipse. If you work on multiple projects or do a lot of prototyping, Ivy is an awesome time saver.
Construction Spring IDE If you develop Spring-based applications, you will want to install this plug-in; it is a must have! The plug-in has numerous helpful views; and makes creating and managing your context files much simpler.
Construction Log4E Log4E make Java logging significantly easier, no more cutting and pasting from other classes. The free version supports the common logging frameworks, but unfortunately not the current open-source community favorite, SLF4J.
Construction Subversive This plug-in is used to integrate Subversion into the Team Perspective/View. It also appears to no longer be required with Eclipse 3.5.
Construction Subversive Team Provider There are two options for integrating Subversion into Eclipse, you can choose either the Tigris or Polarion implementation. The Tigris plug-in seemed easier to get working, but has less features than the Polarion implementation. I started with Tigris, but have settled on the Polarion version about a year ago.
Construction Implementors This plug-in allows you to navigate from any interface to an implementation of that interface. Especially helpful when you are programming with the Spring Framework. This feature is finally part of Eclipse 3.5, so you might not needs this one any more.
Testing Clover Clover is my only commercial plug-in; Clover is used to collect code coverage metrics. You have to be a little careful when using this plug-in. Never let Clover instrument the entire project, Eclipse will most likely become completely unresponsive and unusable. If you have a large project, I highly recommend using Eclipse Working Sets to selectively control which files you collect coverage data on.
Testing Findbugs This is actually on my to do; I have been very happy using Findbugs thru Ant, but have not had a chance to try out the plug-in.
Database SQL Explorer A database explorer tool is included with the Java EE Eclipse bundle, but it seems to have some usability issues. Most developers seem to be very dissatisfied with the included version and prefer the SQL Explorer plug-in. Probably not perfect, but it works good enough for us Java guys.

Just a random link of several more plug-ins, http://www.plentyofcode.com/2007/07/most-useful-top-50-eclipse-plug-ins.h6tml There were a few plug-ins on the list that looked interesting, maybe you will think so too. Make sure you read the comments!

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


May 26 2009

Eclipse – Project Facets

Category: EclipsePhil @ 7:38 pm

This Eclipse feature has been around for a couple years, but seems to stay hidden from most developers; probably because they have not had a chance to take advantage of the Dynamic Web project type. It seems like once a project is setup, nobody ever wants to change it! The Dynamic Web project type is used in conjunction with the Eclipse Web Tools Platform (WTP) plug-in, which has been on my “Upcoming” list for some time now…

<HISTORY>I was a huge fan of the MyEclipse plug-in suite a few years ago; it was a predecessor to the nicely bundled Eclipse distributions that can be downloaded today. MyEclipse provided a very elegant Eclipse / Weblogic integration capability; as well as many other nice features that otherwise were difficult to manually enable. I worked with many different teams and it was always a hassle to convince them to purchase or convert their projects to the structure required by MyEclipse. As I became more familiar with the Ganymede release and the maturing Web Tools Platform plug-in, this Eclipse bundle seemed to be a much easier to sell and better alternative. MyEclipse is still a very popular and well put together product; be as I recall, it always took them too long to catch up with the current Eclipse versions, which I was fond of using as well.</HISTORY>

To use WTP, your project needs to have some additional features, namely Facets. Facets are used to define characteristics and requirements for Java EE projects. Originally, only Java EE projects had Facets; but this seems to be changing. I recently added some J2EE Module Dependencies to a web project, Eclipse enabled Facets in the simple Java project included as a dependency. To convert an existing project to a Faceted project, you need to manually modify your .project file. It is best to only enable Facets and let Eclipse add the additional nature; these natures will be added as you enable extra characteristics. To convert a Java Project to a Web Project, modify the .project file and add the following two lines.

<nature>org.eclipse.wst.common.project.facet.core.builder</nature>
<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
 

You will not notice any visual difference in your project after making this change. However, if you open up your project’s properties and search for the word facet, you will see a new configuration option. At this point, you can select the Dynamic Web Module option and configure your runtime environment (Tomcat, Jetty, etc).

If you have successfully converted your project, you will see a small globe appear on the project folder icon. You can now add the project to the Servers view and easily deploy the project in your locally configured runtime environment. I have glossed over some of the WTP setup, but will cover that in another post. I thought it was important to explain Facets; I had previously wasted significant time, manually converting projects to Dynamic Web projects. Unfortunately, the manual approach only worked about 50% of the time. Once I learned about Facets, it made my life a lot easier!

FYI, the (S) on the folder, next to the globe, indicates a Spring IDE plug-in enabled project.  If you are developing Spring-based applications, you have to install this plug-in; it makes creating and managing your context files many times simpler.

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


May 25 2009

Galileo – Eclipse 3.5 Coming Soon?

Category: EclipsePhil @ 8:09 pm

I only played with Galileo for about 10 minutes and I am already very intrigued. Based on my last post, I wanted to see if I could get Ivy and Eclipse to work better together and explore the new features. The first difference appears to be the way that plug-ins are installed and managed. Eclipse 3.4 significantly changed the way plug-ins were installed and it looks like they are changed again. Plug-in management was never as smooth as NetBeans. NetBeans provides a fully integrated solution for searching through available plug-ins, with click and go installation. The new Eclipse implementation looks promising, maybe not as polished as NetBeans, but a step in the right direction. As shown to the right, you can now view all of the available plug-ins in a much more controlled and usable approach. Managing additional software sites is much cleaner than before too.

At first glance, there seems to be a lot of small, subtle changes, rather than any big, must have features. The Eclipse release process appears to be taking longer and longer; the first milestone release was last August! This is the first time I have not jumped on the milestone builds, preferring to stick with the Ganymede release for my daily usage. Another small change is the way the network proxy panel works; it actually seems more complicated than it was before! They finally added (or re-implemented) one on my favorite plug-ins,  the “open implementation” option. How could that feature not been part of Eclipse before this? It is an absolute necessity when programming with Spring. Overall, I think Galileo looks a little more polished than before; I will start using it for my daily work and try to find more interesting new features to report on!

A new to me feature… After adding the IvyDE plug-in to Eclipse, the next step is to add the Ivy managed dependencies to the project. I found a new project properties panel, Java EE Module Dependencies. I thought this was a new feature, but it appears this feature was available in Eclipse 3.4 too. I hoped this was the answer to my Ivy problem! The panel allows you to pick other projects and/or their class path entries to be added as web library dependencies; it suggested that these dependencies would be resolved at deployment time. I gave it a try, but unfortunately it only half worked. The dependent project part worked perfect; making a JAR file out of the secondary project and copying it over to the exploded WAR’s WEB-INF/lib directory. This seems like a good solution when working with external projects, especially when you are activity integrating them into your primary project. The unfortunate part is that Eclipse still completely ignored the Ivy dependencies; not copying any of the Ivy resolved JAR files to the WEB-INF/lib directory. What a drag! I will have to continue my quest for a workable Ivy / WTP solution!

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


May 24 2009

Still on the Jetty Bandwagon… Go Embedded?

Category: Eclipse,Software DevelopmentPhil @ 2:23 pm

image I was searching for some information on using the Eclipse IvyDE plug-in and found a post that reminded me of some work I did last summer. For the most part, I’m happy with the way the IvyDE plug-in works, but sometimes you have to be a little tolerant of its usability issues. Every so often, IvyDE seems to forget about my configuration and refuses to add libraries to the class path. My only option is to remove Ivy Dependency Manager and re-add it to the class path.  One problem that I’ve been unable to solve, is the integration of an Eclipse Web Tools Platform (WTP) project and Ivy; I cannot get the Ivy resolved libraries added into a “Dynamic Web Project”, making them available to the Tomcat. I have tried a dozen different configurations and settings with no success. Hopefully, I will get this working in the near future. If anyone has this working, please give me some tips!

The real thought behind this post was echoed in this post by Daniel Spiewak, So Long WTP, Embedded Jetty For Me. I was really fired up about Jetty last summer. When compared to my experience developing Weblogic-based applications, the utter simplicity and flexibility of Jetty was amazing. I was working on a custom Servlet-based web service framework and decided to do my development with Jetty. I created a very small Java program that configured Jetty to deploy my Servlet, in about 20 lines of code! The best part is there was no special Eclipse project type, no special environment, and zero deployment work; making debugging and testing especially easy.  I never used the word embedded when I talked about Jetty, but that was exactly what I wanted. I always deployed in the Weblogic container because of our corporate standards. I should have explored this a little more, further highlighting the point that Weblogic and all of its complexity is truly unnecessary.

Following the BEA Bible, you end up with specific machines, specific file systems, specific networking, and hardwired clusters. Combine that with an environment that is highly controlled, it can take a dozen change control tickets and multiple days to bring up a new instance. Not exactly what I call agile or responsive. How cool is would it be to just drop a WAR file on a machine (any available machine), launch java to bring up a web server, add it to the load balancer and instantly expand your processing capacity? Pretty powerful idea, I think.

Embedding a web server is a good idea when building a web-based application, both for development and operational reasons. A good example is the Hudson Continuous Integration tool. Hudson is distributed as a single WAR file that you can pop in any Servlet container; but it also includes an embedded web server. This approach is becoming more and more common, as several open-source and commercial products are shipping their products with embedded web servers. The real benefit is flexibility. It literally took me seconds to get Hudson up and running; no messing around with Tomcat, no configuring security realms, no anything! It allowed me to focus on Hudson, rather than the environment to make it work. Down the road, if I want to deploy Hudson in the standard application server environment, it should be an easy switch, This is quite different from my recent experience installing a few open-source code review tools; installing multiple Python packages, configure an Apache web server, setting up database servers, etc. I don’t think I have to say much more; the better choice is pretty obvious.

image It is pretty hard to beat the Eclipse WTP – Apache Tomcat integration as a development environment, but directly embedding Jetty into your environment (no WTP) would make the environment even simpler. I have been trying to encourage teammates to develop from a container independent perspective, demonstrating higher productivity with no additional risk to the project. If we can move from large, monolithic applications to smaller, self contained services, the attractiveness of Jetty goes way up. The flexibility of running a moderately sized collection of small, independent services, verses a small tightly coupled clusters of monoliths, has to be an attractive architectural vision.

Unfortunately, many corporations don’t eagerly embrace open-source software solutions, preferring to pay for name recognition and guaranteed support. I personally feel that Jetty is a viable option, but it seems to be relatively unknown to most developers. Apache Tomcat and JBoss have a much higher exposure level, giving them more perceived viability. Jetty is no slouch, check out the Powered by Jetty page. Hopefully, this and Daniel’s post demonstrate there are alternatives to the J2EE Silver Bullet, and that we don’t really need to do everything by the J2EE book. There are a lot of simple alternatives out there for us to take advantage of, all we have to do is keep an open mind!

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


Mar 03 2009

Evolution: Emacs to Eclipse

Category: Eclipse,JavaPhil @ 11:10 pm

Early in my software development career, I had the good fortune to be mentored by someone who was an Emacs guy.   After much complaining about the crazy, obscure key combinations, Emacs became my weapon of choice and I actually became pretty good at hacking LISP! I am still an Emacs guy, but only those crazy key bindings live with me today. We used to joke that Emacs was not an editor, but an operating system! I would start up Emacs in the morning; it was the only tool I needed all day. I could read my email, read news, compile code, debug, and even play games (which I never did, but thought it was cool!).

So, why is this history lesson important? It is all about focus and productivity. By allowing the developer to accomplish multiple activities within a single tool, helps them stay focused on the task which they are trying to complete. By minimizing the need to switch tools, the developer can easily toggle between the different activities, without interruption. Think about all of the different tasks that one does developing software; the most basic ones being managing problem tickets or programming assignments, interacting with the configuration management system,  writing code, and executing unit tests.  I have worked in environments where every tool operated in its own isolated world, with little or no integration to other tools. Each time I changed tasks, it was like a huge context switch: 1.) start the problem ticket tool 2.) Locate the ticket information 3.) Put the ticket in the correct state 4.) Check out the code 5.)  Edit the code 6.) Test the code  7.) Repeat selective steps.  Quite a process; it could actually involve using four different tools, just to change the code! The problem is even worse, when you are working on multiple tickets?  It can be a little more than challenging to keep the changes associated with the proper ticket.

Eclipse and other Integrated Development Environments (IDE) have evolved into the world that was once dominated by Emacs. These IDEs have literally hundreds of custom plug-ins that allow the developer to stay focused on the task at hand.  The IDE provides more than simple access to the supporting tool (via a plug-in), well designed plug-ins are able to integrate information into the current context of the developer’s activity. Plug-ins seem to take one of two integration approaches, task management or task support.  I consider task management a major activity such as ticket management or debugging. The plug-in developer would provide a big picture (multi panel) view of that task, a perspective in Eclipse terminology. From this perspective, the developer can focus on all of the activities that are relevant to that task. Task support is the alternate integration approach; this allows the developer to customize the task management perspective, by adding additional, supporting  panels; a view is Eclipse terminology. These panels show specific, subset information about different, potentially related task, such as coding problems, J2EE server status, or a selected class hierarchy.

It is this customization and integration with the task management perspective that highlights the true power of an IDE. Simple integrations include code quality plug-ins that highlight non-conforming or poorly structured code as the developer is type. One of my favorites is integrated code coverage tools; untested conditionals and statements are automatically highlighted in the editor after running a unit test.  This is the big win, focus plus productivity. Developers can now concentrate on their primary task and the output from supporting tools is seamlessly weaved into the process by the IDE. No need to switch windows or applications, everything they need is right there in front of them, exactly when they need it.

Just like many of my posts, they started off in one direction and end up in a completely different one! I really wanted to write about an interesting plug-in called Mylyn, which is a task focused interface for Eclipse.  The integration aspect of Mylyn with Eclipse is very  intriguing. Hopefully, my next post will explore how Mylyn could be used to make developers more focused and provide management with a more realistic perspective of the project’s progress.

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


Aug 31 2008

Setting Up Eclipse / Tomcat Integration

Category: EclipsePhil @ 8:05 am

Hopefully, this will jump start your Eclipse-Tomcat Integration. It is not really that hard, but I made some assumptions that wasted a bunch of time. I’m not sure if this is completely correct, but it will minimally allow you to deploy and debug multiple web applications from within Eclipse.

The first step is to connect a Tomcat server installation with Eclipse. This is simple, but had the first gotcha. It appears that the Tomcat installation must be “writable” by the user id running eclipse. I selected my default Ubuntu Tomcat installation, which was owned by root, and I could never associate it with a project. So, on a whim I installed another copy in my home directory (/home/phil/software/apache-tomcat-6.0.18) and solved the problem. I’m not exactly sure why the image has to be writable, but I did not want to spend any more time on that problem. Once you have Tomcat installed, goto Window / Preferences / Server / Runtime Environment in the Eclipse menu. Click the Add button and select Tomcat6.0, and your new Tomcat installation. I have mine wired to Sun’s Java 1.6 JRE, but don’t know if I’ll be using any 1.6 features.

For the next step, you have to create a “Dynamic Web Project” or convert an existing one. This is required for the deployment process to work; Eclipse will not recognize any other project types. There are just a couple of configuration lines that need to be added to your .project file if you want to convert and existing project. However, you project must be in the proper format (directory structure) for this to work. The simplest way is to create a new “Dynamic Web Project” and compare the .project file to your current one; copy the changes over and you should be good to go. When you see the little blue world icon next to the project name, you know it worked.

Now it is time to configure your server instance. You need to add the “Servers” view on whatever perspective you are using; this is typically done under Window / Show View / Other menu from Eclipse. On the Server view, right click and select New / Server. Select the appropriate Tomcat version and leave all of the other options alone. Click the Next button and you will be able to “Add and Remove Projects” for this configuration. Select your web project, click Add, followed by the Finish button.

At this point, you will see the Tomcat instance added to your view. The most interesting thing to me, was that a “Servers” project was created in the “Project Explorer” view. It appears to be a copy of all of your Tomcat configuration files. This originally confused me, as I tried to access the Tomcat administration pages and generated a ton of page not found issues. It appears that this is running a minimal Tomcat configuration, and nothing but your projects are deployed with this configuration. This configuration seems to be “disconnected” from the installation directory. There appear to be a couple of ways to configure the instance, but the more I thought about it, I figured it really did not matter! This was simple and worked; all I really need to do is compile, deploy, and debug my web application.

The real convenience is in the Servers tab. You can start and stop your instance from this view. Additionally it will automatically synchronize and restart the server based on what is happening within the web project. The best part is that when you start Tomcat in debug mode, all breakpoints will be recognized and Eclipse will switch over to the Debug perspective if it hits one. No messing around with connecting to running Tomcat instances, just plain and simple, just like debugging any other Java unit test or application.. .

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


Aug 13 2008

Cool Image Viewing Plug-in

Category: EclipsePhil @ 9:00 pm

Just installed a nice little image viewer for Eclipse tonight… called QuickImage. Seems to work pretty cool, has lots of nice features. You have view thumb nails size pictures, easily navigate around a big picture, and some in see more detail on the image.

Works pretty slick when you are looking at a big ERD or UML diagram.

https://www.beilers.com/wp-content/plugins/sociofluid/images/digg_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/reddit_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/dzone_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/stumbleupon_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/delicious_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blinklist_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/blogmarks_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/google_48.png https://www.beilers.com/wp-content/plugins/sociofluid/images/facebook_48.png


« Previous Page