<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Architexa - Working with Large Codebases &#187; eclipse</title>
	<atom:link href="http://blog.architexa.com/tag/eclipse/feed/" rel="self" type="application/rss+xml" />
	<link>http://blog.architexa.com</link>
	<description>know your code</description>
	<lastBuildDate>Tue, 29 Jan 2013 13:57:52 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.5.1</generator>
		<item>
		<title>Diagrams in Open Source &amp; Successful Development</title>
		<link>http://blog.architexa.com/2011/09/diagrams-in-open-source-successful-development/</link>
		<comments>http://blog.architexa.com/2011/09/diagrams-in-open-source-successful-development/#comments</comments>
		<pubDate>Wed, 07 Sep 2011 21:15:15 +0000</pubDate>
		<dc:creator>novita</dc:creator>
				<category><![CDATA[Documentation & Communication]]></category>
		<category><![CDATA[Understanding Developers]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=310</guid>
		<description><![CDATA[When development teams are in the same room, it is not surprising to see diagrams being used &#8211; if only being shared via sketches made on pads, or through the use of whiteboards. Interestingly, despite the fact that OSS teams are distributed geographically, diagrams also play an important role in OSS development. There was a [...]]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/09/diagrams-in-open-source-successful-development/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Understanding What Others Are Upto!</title>
		<link>http://blog.architexa.com/2011/03/understanding-what-others-are-upto/</link>
		<comments>http://blog.architexa.com/2011/03/understanding-what-others-are-upto/#comments</comments>
		<pubDate>Mon, 21 Mar 2011 22:59:28 +0000</pubDate>
		<dc:creator>Seth Rosen</dc:creator>
				<category><![CDATA[Developer Tools]]></category>
		<category><![CDATA[Eclipse]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=238</guid>
		<description><![CDATA[One of the challenges when working in teams is in keeping up with your fellow developers. Spending a lot of time reading others' code not only means less time getting your own work done but also the gradual deterioration of the code architecture. This is a problem that we have heard over and over again from developers and managers alike.

We have just released additional code and architectural review tools that will help developers easily understand new features that are being built. We are pleased to announce that we will be demoing this functionality at EclipseCon 2011 as part of the Hot New Products Showcase. With this release we not only have a full fledged code review client and server, but also are making it really easy for developers to document the main parts of what is being worked on. Our new features will help developers create and maintain more comprehensive architectural documentation, solving a number of common development issues.

It's important to make sure the quality of your project's code and documentation don't degrade over time. Reviewing the architecture as well as the code itself will ensure a better documented codebase, resulting in easier to understand code and decreased development overhead.

On the other hand, we all know that poorly documented code can increase overhead. Developers are often biased to think that their own code is well documented. Another set of eyes checking the documentation as well as the code can make sure confusing code is documented before it is committed.

Code duplication is one of the main sources of bugs and headaches for developers. Code review can help minimize duplication in new code but finding redundancies in legacy code may be difficult without quality architectural documentation.

Projects with limited or outdated architectural documentation are more susceptible to code erosion since developers may not be clear on what boundaries they are constrained by. Easy access to viewing and creating documentation helps developers be more aware of the effects their code has on other components.]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/03/understanding-what-others-are-upto/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>From Java to Spring and Beyond &#8211; Making Diagrams (and UML) work for developers</title>
		<link>http://blog.architexa.com/2011/03/from-java-to-spring-and-beyond-making-diagrams-and-uml-work-for-developers/</link>
		<comments>http://blog.architexa.com/2011/03/from-java-to-spring-and-beyond-making-diagrams-and-uml-work-for-developers/#comments</comments>
		<pubDate>Mon, 21 Mar 2011 22:49:35 +0000</pubDate>
		<dc:creator>Seth Rosen</dc:creator>
				<category><![CDATA[Developer Tools]]></category>
		<category><![CDATA[Eclipse]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[UML & Diagramming]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=241</guid>
		<description><![CDATA[One of the strengths of working with Java is the large number of frameworks that are available. These frameworks are great for taking care of the basic tasks involved in building Java based apps. But they often bring about challenges in understanding - whether it is xml files or annotation based configurations, developers needing to work with these frameworks have to see how different parts of the code are connected.

With this in mind we have extended Architexa to not just show code relationships but have also built special support for popular frameworks like Spring and Struts. We are happy to announce that we will be demoing this functionality at EclipseCon 2011 as part of the Hot New Products Showcase.

We are pushing the edge here - so we are making this capability available as an 'early access' version. You can find it by default in all versions of the Architexa Suite. We would really like to hear what you think about it, and invite you to extend your trial of the product as we refine the implementation based on your feedback
 
In this release we are including early access to a number of frameworks. With Spring we have added support for Dependency Injection and Web Flow. We have also added support for Struts (1 and 2) and Tiles.

Spring Bean classes can be shown in both class and sequence diagrams along with any Property fields they contain. This allows for easy exploration of the hierarchy of beans along with a clearer view of dependency injection.

Struts support enables you to explore the actions defined in xml configurations files; specifically, the dependencies to other actions, jsp pages, and classes all within an easy to understand class diagram.

Tiles support allows you to easily see where different JSPs plug into various web components and how they relate to other java elements in a class diagram.]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/03/from-java-to-spring-and-beyond-making-diagrams-and-uml-work-for-developers/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Eclipse Tabbed Editor Extended.. Embedding a GEF Editor</title>
		<link>http://blog.architexa.com/2011/03/eclipse-tabbed-editor-extended-embedding-a-gef-editor/</link>
		<comments>http://blog.architexa.com/2011/03/eclipse-tabbed-editor-extended-embedding-a-gef-editor/#comments</comments>
		<pubDate>Fri, 18 Mar 2011 00:34:27 +0000</pubDate>
		<dc:creator>Abhishek Rakshit</dc:creator>
				<category><![CDATA[Eclipse]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[User Experience]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=232</guid>
		<description><![CDATA[Finding the right format for users to edit and view your Eclipse plugin’s data can be tricky. Eclipse provides many different types of editors for modification of its resources. Some examples of these are the Java, Text, JSP, XML, Ant editor etc. It also provides tabbed editors like the Plug In Manifest Editor which can have multiple sub editors as tabs in one editor. A simple example template to extend the tabbed editor when creating a new plug-in, is provided in Eclipse by default. For our project we needed to add a compare editor and a GEF editor as sub editors. This post should help you become more familiar with creating custom tabbed editors in Eclipse.

Editor Input
The example provided in Eclipse uses the same EditorInput for all the sub editors. This allows the same information (from the EditorInput) to be displayed and edited differently in each sub-editor. This works fine when all the editors are closely related and a single EditorInput can take care of all the resources in different tabs. If this is not the case, for any particular editor you can provide a customized EditorInput class which implements the IEditorInput interface.

Adding a GEF editor to the MultiPageEditor is not the hard part. You can simply add a GEF editor in one of the createPage methods in the MultiPageEditor. The interesting part is getting GEF to interact correctly with the UI and user commands. Below are some issues and fixes commonly seen while working with GEF in MultiPageEditors.

Selection Event issues
When embedding a GEF editor the first issue you will face is that the selections will not work properly. This is due to the fact that the selection listeners for the GEF editor are not correctly notified of events because it is nested inside the MultiPageEditor. You can do the following to fix this issue.]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/03/eclipse-tabbed-editor-extended-embedding-a-gef-editor/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Features of GEF and why they&#8217;re useful</title>
		<link>http://blog.architexa.com/2011/03/features-of-gef-and-why-theyre-useful/</link>
		<comments>http://blog.architexa.com/2011/03/features-of-gef-and-why-theyre-useful/#comments</comments>
		<pubDate>Mon, 14 Mar 2011 23:59:05 +0000</pubDate>
		<dc:creator>Seth Rosen</dc:creator>
				<category><![CDATA[Eclipse]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=236</guid>
		<description><![CDATA[GEF provides a great framework for building MVC based plugins on the Eclipse platform. It contains a great deal of the core functionality (described in more detail <a href="http://blog.architexa.com/2011/03/a-simple-intro-to-creating-a-mvc-framework-using-gef/">here</a>)  necessary for building these types of apps. In addition, GEF also provides features that greatly simplify the task of creating a robust interactive editor. I'll try to show how these different features can benefit any Eclipse developer working with GEF.]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/03/features-of-gef-and-why-theyre-useful/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>A simple intro to creating a MVC framework: Using GEF</title>
		<link>http://blog.architexa.com/2011/03/a-simple-intro-to-creating-a-mvc-framework-using-gef/</link>
		<comments>http://blog.architexa.com/2011/03/a-simple-intro-to-creating-a-mvc-framework-using-gef/#comments</comments>
		<pubDate>Fri, 11 Mar 2011 00:28:23 +0000</pubDate>
		<dc:creator>Seth Rosen</dc:creator>
				<category><![CDATA[Design Patterns & Architecture]]></category>
		<category><![CDATA[Eclipse]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[Libraries & Frameworks]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=225</guid>
		<description><![CDATA[When creating a rich graphical editor the Model View Controller (MVC) design pattern makes life a lot easier. But it is often difficult to decide which libraries/frameworks to use. On the Eclipse platform GEF (Graphical Editing Framework) is a great solution but it can be challenging to figure out how to integrate with the parts you need. Since GEF is built on top of the Draw2d/SWT graphical libraries and is able to provide a powerful and consistent UI. However there are many considerations and pitfalls to take into account when getting started with GEF.
Some of my first large scale Java coding involved using and modifying GEF code. Luckily the GEF team provides many helpful examples showcasing the different features GEF offers. I will attempt to provide a concise introduction to the points that I found best helped me understand GEF.]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/03/a-simple-intro-to-creating-a-mvc-framework-using-gef/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Making Cool Ideas Happen: Studying Our Users and Software Immigrants</title>
		<link>http://blog.architexa.com/2011/02/making-cool-ideas-happen-studying-our-users-and-software-immigrants/</link>
		<comments>http://blog.architexa.com/2011/02/making-cool-ideas-happen-studying-our-users-and-software-immigrants/#comments</comments>
		<pubDate>Fri, 04 Feb 2011 03:13:38 +0000</pubDate>
		<dc:creator>Vineet Sinha</dc:creator>
				<category><![CDATA[Agile & Development Methodologies]]></category>
		<category><![CDATA[Developer Tools]]></category>
		<category><![CDATA[User Experience]]></category>
		<category><![CDATA[apache]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=218</guid>
		<description><![CDATA[One of the nice things about being Software Developers, is that it&#8217;s really nice to spend our time working on cool ideas:  building out systems that help in situations where no solution currently exists. The problem is that often these cool ideas fail. Yes, using an Agile approach helps significantly, especially when customers/users request features. [...]]]></description>
		<wfw:commentRss>http://blog.architexa.com/2011/02/making-cool-ideas-happen-studying-our-users-and-software-immigrants/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>Supporting Open Source at Architexa</title>
		<link>http://blog.architexa.com/2010/12/supporting-open-source-at-architexa/</link>
		<comments>http://blog.architexa.com/2010/12/supporting-open-source-at-architexa/#comments</comments>
		<pubDate>Fri, 17 Dec 2010 01:47:24 +0000</pubDate>
		<dc:creator>Vineet Sinha</dc:creator>
				<category><![CDATA[About]]></category>
		<category><![CDATA[apache]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=204</guid>
		<description><![CDATA[We are working hard to help developers easily understand and document code. One thing that we have noticed is that the open source community continually faces challenges in these areas. New developers join projects frequently and at times committers have to leave a project. Without quality documentation code can quickly deteriorate. We are great supporters of [...]]]></description>
		<wfw:commentRss>http://blog.architexa.com/2010/12/supporting-open-source-at-architexa/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Eclipse Cheat Sheets: A Hands on Tutorial</title>
		<link>http://blog.architexa.com/2010/12/eclipse-cheat-sheets-a-hands-on-tutorial/</link>
		<comments>http://blog.architexa.com/2010/12/eclipse-cheat-sheets-a-hands-on-tutorial/#comments</comments>
		<pubDate>Wed, 15 Dec 2010 22:41:47 +0000</pubDate>
		<dc:creator>Seth Rosen</dc:creator>
				<category><![CDATA[Developer Tools]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[Cheat Sheets]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=184</guid>
		<description><![CDATA[Based on the great response we have had to our previous cheat sheets articles, (why they rock and tips and tricks), I have decided to post a more in depth tutorial. One of the many benefits of Cheat sheets is that they provide an immediate improvement to your product’s usability and are simple to implement. [...]]]></description>
		<wfw:commentRss>http://blog.architexa.com/2010/12/eclipse-cheat-sheets-a-hands-on-tutorial/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>Eclipse Cheat Sheets: Tips and Tricks</title>
		<link>http://blog.architexa.com/2010/12/eclipse-cheat-sheets-tips-and-tricks/</link>
		<comments>http://blog.architexa.com/2010/12/eclipse-cheat-sheets-tips-and-tricks/#comments</comments>
		<pubDate>Wed, 08 Dec 2010 22:25:29 +0000</pubDate>
		<dc:creator>Seth Rosen</dc:creator>
				<category><![CDATA[Developer Tools]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[eclipse]]></category>

		<guid isPermaLink="false">http://blog.architexa.com/?p=185</guid>
		<description><![CDATA[We talked about in a previous post why Cheat Sheets Rock. Our users have found them useful in the Architexa plugin and we are in the process of adding a great deal more cheat sheets to it. We have also had requests from our readers for more details on creating and utilizing cheat sheets effectively. [...]]]></description>
		<wfw:commentRss>http://blog.architexa.com/2010/12/eclipse-cheat-sheets-tips-and-tricks/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
