Sciology = Science + Technology

Commonsense in Technology

Archive for the ‘Java’ Category

XML Processing with Oracle JDeveloper 11g : Book Review

Posted by sureshkrishna on May 23, 2009

Oracle XML Developer Kit (XDK) is a set of components, tools and utilities in Java which is available in Oracle Database, Oracle Application Server and on OTN that eases the task of building and deploying XML-enabled applications with a commercial redistribution license. XDK has several useful components such as XML Parsers, XSLT Processors, XSLT VM, XML Schema Processors, XML Java Beans, XML Class Generator, XML SQL Utility and XSQL Servlet.

Oracle JDeveloper provides a rich set of tools and utilities for the XML processing. JDeveloper includes the XDK and any developer can make use of its powerful features to develop any XML based applications. Processing XML Documents with Oracle JDeveloper is a great book and i would highly recommend for everyone working with XDK, and JDeveloper.

The author Deepak Vohra did a good job in describing the various steps for the XML Processing, XML Schema Validation, XPath Support, XML and XSLT Transformations. For more advanced users of XML, this book also talks about the topics such as Java XML Binding (JXB), API for comparing the documents, Converting XML to PDF, Converting XML to MS Excel, and finally storing the XML in Oracle Berkley DB XML.

This book provides a quick reference guide to any developer who starts their XDK development using JDeveloper. Author emphasized well enough about the small details that every developer should know in XML processing. Author gives a good introduction about all the technologies that he talks and mentions the APIs in detail. I really liked the part where the author gives  a complete java source code (in almost each chapter) along with the comments to explain the purpose of the following code. This book did a good job in setting up the context for running the applications. Author describes the steps to setup the extra environment variables to bet set, jars to be added and how to navigate in JDeveloper. With this sort of detailing, any developer could just look at the book and will be able to start the development right away. Also, the publisher, Packt extracted chapter (Chapter 4: XPath) from the book and you can find it here: http://www.packtpub.com/files/processing-xml-documents-with-oracle-jdeveloper-11g-sample-chapter-4-xpath.pdf.

I would definitely recommend this book for the XML developers using XDK and JDeveloper.

Advertisements

Posted in Java, JDeveloper, Technology | Tagged: , , , , | Leave a Comment »

Plugin Release : XPath Workbook (beta)

Posted by sureshkrishna on February 24, 2009

Last couple of months have been quite hectic with my job and also in my personal life. Effectively this is my first blog entry this year on Eclipse. In the last one year i have been deeply involved creating XML manipulations and Eclipse plugins. XML and XPath development usually involves lot of experimentation with the XPath expressions and in the real time situations different functions and namespaces can get real creepy.

I could not afford licensing costs for the professional XPath and XML IDE integrations, i wrote one small “XPath Workbook” utility by my self. Even if would have got the license, i might not need all the features that a sophisticated plugin might provide. I am hoping that this is very helpful for others too, who would want to use it as-is or extend it further. I provided the downloads for update site and source on google code and in a short time i am planning to provide the documentation too. If you are working on XML/XPath centric projects, would encourage you to try this plugin and provide me feedback. I am also open, if anyone wants to participate or contribute to this project.

I am providing few screen shots of the plugin…

#1 XPath Workbook as a View

xpathworkbook-1

#2 XPath Workbook with Source XML to be tested

xpathworkbook-2

#3 Xpath Workbook with dynamic content assist

xpathworkbook-3

#4 XPath Wrokbook with Results

xpathworkbook-4

Happy Eclipse’ing.

Posted in Eclipse, Java, Plugin | Tagged: , , , , , | 6 Comments »

My JDeveloper Training

Posted by sureshkrishna on March 27, 2008

I have been undergoing the Oracle ADF and JDeveloper training for a future project. It was pretty hard for me to accept that i am undergoing this training considering my strong belief in eclipse-as-a-platform. I started the training by asking, if all/many of the JDeveloper features are available in Eclipse and soon realized that JDeveloper does have a strong set of database feature set.

There are some discrete set of database features that are available for Eclipse. These 2 projects do provide good plugins to improve the productivity of the database developer on Eclipse.

OK, but dont feel happy about it. For the set of features that JDeveloper has, its difficult to compare the feature set with Eclipse. In my view we should not even compare. At the end of the training, i am sort of started believing that its apt to call JDeveloper as Integrated Services Environment (ISE). Its has many things inside. For me it looked like the concepts of Application, Project, Module, Entity Object and View Objects are tightly integrated with JDeveloper. I cant imagine to build a complex application “-which is tightly integrated with DataBase and ADF-” without JDeveloper.

Of-course i “think” its possible to develop some decent ADF applciations without JDeveloper. We can still develop the UI with the help of the ADF Faces and JSF in Eclipse, but there is no support (as i know) of ADF BusinessComponents in Eclipse till date (03/27/2008). I guess people can still develop some good Oracle ADF applications with the help of EJB3 and JPA stuff.

In the end JDeveloper does many things with Database/Class Diagrams, ADF Components, Business Rules, EJB, Toplink, WebServices, Database Connection, SOA Stuff (not sure what exactly it does with SOA), JSP, JSF, Struts and much more. Some of the features can be pulled into the eclipse and one can use pulse to do this.

As an Eclipse lover, i am just waiting for a good ADF plugin into the Eclipse world. ahem….

Posted in Eclipse, Java, JDeveloper | Tagged: , , | 2 Comments »

UI Designers dilemma !!!

Posted by sureshkrishna on December 7, 2007

Eclipse Visual Editor, NetBeans Matisse project and Instantiations SWT Designer are wonderful WYSIWYG editors that i have used till now. With few projects that i have done, i have always hand coded the UI’s. And of course i have done UI development on the Eclipse through out. So all the perspectives, views, editors, wizards, preferences and properties are hand coded and i am quite comfortable with it. I do agree that probably it takes more time for me to hand code but i feel “personally” satisfied.

When i discuss this with few of my colleagues, there are for and against the UI Designers. For me and many others, Layouts and adjusting the controls on the screen are the challenges. I do spend a lot of time in adjusting the controls in a layout.

Why they like UI Designers…

  •  UI can be build very very fast, without knowing whats in the code
  • With the advanced UI Designers, its easy to adjust/auto-adjust the Layouts
  • The easy-to-use drag-and-drop paradigm makes it easy to quickly visualize
  • Properties are set in the palette and the same is reflected dynamically on the UI preview
  • Control and Widget hierarchy is what many appreciate. I know precisely, which controls are in UI

Why they want to handcode…

  • I can code. I am a developer. I am used to it.
  • Code generated by UI Designers are not optimized. I want my code to be optimized.
  • Many a times, generated code is not readable to customize.
  • It might make me less creative and insecure, as i do not know whats happening at the code level.

I am sure many of us share some of the above views and you might definitely have great experience in building UIs. Its really interesting to know, if there are really more number of developers who would use UI Designers. For now i would stick to the hand-coding. Do share your experiences with the UI Designers …

Posted in Eclipse, Java, Net Beans 6.0, SWT | Tagged: , , , | 7 Comments »

Application Performance : Part II

Posted by sureshkrishna on October 28, 2007

I have been dealing with many of the java applications for years and in the recent past i am finding all the areas that effect the performance. I have been reading lot of books and articles and i thought that a summary would help everyone. In the past 2 months, i have been reading the book Java Performance Platform. Thanks to the authors, they have really given valuable information in this book. As always, “Its not enough to read this book but to consciously write applications that takes care of the memory management and performance”.

Many of the developers and IT does complain about the huge foot print by applications and some times its difficult to know whats causes the foot print. Applications becomes memory hogs and instead of looking into the root cause, we tweak JVM settings, increase the virtual memory, increase the PermGen size, custom class loading. I am sure and any of you would agree that we do “all sorts of things” for the application performance. I have written some notes on the Garbage Collection  (which is Application Performance – Part I) in my previous blog. The current “notes” concentrates on the causes for the RAM footprint and different aspects of the things that we need to be aware of.

Memory foot print of the program is tricky to find out. Many of developers do look into the TaskManager to see RAM usage by the application. This definitely gives an idea of how much of memory your application requires. When this memory increases over a period of time, we suspect memory leaks and take corrective actions.

Programmatic Memory Usage : Certain in formation can be derived from the java.lang.Runtime class. This class can look for the heap size of the JVM. Two methods namely Runtime.totalMemory() and Runtime.freeMemory() gives the size (in bytes) information that many of us want. Heap memory can only give the size of the objects. But the actual size of the application is a combination of the Objects, Classes, Threads, Native Data Structures, Native Code.

App Runtime Size = funtion of (Objects + Classes + Threads + Native Data Structures + Native Code)

Depending on the OS, JVM and application the actual memory consumption changes. So any one of the above parameters could be the number one memory consumer for a particular application. In general the memory consumption depends on following items (but not limited to).

  • usage the native code
  • usage of java core libraries
  • bulk of the frameworks used in the application
  • number of classes loaded against the objects used

Most of the developers do have a great deal of control over the Objects and their sizes. It could help if the developer knows the approximate size contributed by the objects at the run-time to see what is the optimization area. i.e. if object memory is only a small % of the total size then perhaps we could concentrate on the classes or native libraries, etc.

When classes are loaded into the memory, there are few more dependant entities that contribute to the RAM footprint. Bytecodes is the intermediate format that a java class file gets compiled to. It is necessary that the bytecode gets loaded into the RAM. All the related contents are parsed and reflective data structures are created for methods and fields.  Constant pool is defined for all the classes. e.g. all the String literals are present in this constant pool along with all the class, method and fields names. Threads are another important item that could cause a large memory foot print. Its necessary to see what kind of computation is done in the Thread and what data-structures are used. Many of the UI level libraries/frameworks like SWT, AWT does depend on some sort of the native libraries. Its difficult to know which class of these frameworks directly access the native libraries.

Knowing some of the entities that increases the memory footprint would help many of developers. If not completely avoid the large memory footprints, we can at least be aware and work towards conscious usage of resources.

Posted in Java | Tagged: , , , , | 2 Comments »

Do you care about Garbage Collection ?

Posted by sureshkrishna on October 23, 2007

Recently there have been few instances our RCP application crashed with the OutOfMemory exception and it took lot of time to look reasons behind the crash. An easy solution is to increase the PermGen from 64mb (default) to 256mb (recommended). Well, this works for the application and i am happy. Since then, i explored few books and articles to look into the memory allocation, objects creation and garbage collection can effect the application and its memory needs.

Garbage Collection is the concept that its publicized as “JVM does automatic GC”. But in reality this does not seem to be as cool as it sounds. Developers should not completely relay on JVM to take care of your applications memory needs and garbage collection. A solid understanding on “How GC works” is essential to write robust and high-performance applications.

Its necessary to understand the complete life-cycle of an object and how it transforms its state from declaration till garbage collection. We will look into each of the state in detail.

  • Created
  • In Use
  • Invisible
  • Unreachable
  • Collected
  • Finalized
  • Deallocated

Created: Creating the object makes many things to happen. Space is allocated for the Object. Object constructor is called. If at all there is a super class, it constructor is called. Instance variables are initialized. In the end its important to realize that the object construction does take time and this depends on the JVM implementation for sure.

In Use : Once an object has strong reference, its said to be In Use. It is normal for any object to be In Use state for relatively longer than any other states.

  1. public class InUseClass {
  2. static List someList = new ArrayList();
  3. static void doSomething() {
  4. Customer customer = new Customer();
  5. somelist.add(customer);
  6. }
  7. public static void main(String[] args) {
  8. doSomething();
  9. }
  10. }

In the above code you can see that the at the time doSometing() is executing, there are 2 instances of the Customer that’s holds on. One in the line 4 and one in the line 2. Once the doSomething() returns, there is only one instance that remain of Customer which is line from line #2. Which is a reference of the Customer object in the List. Thus you can imagine that there would be lots of references that remain strongly referenced even after they are used up.

Invisible : When an object is no longer strongly referenced but references still exists, its said to be in Invisible state. Its not necessary that all objects go via this state. In the following code snippet you can see that the strong object references are lost once the something() method is returned. In other words, they go out of scope once the method is returned.

  1. public void something() {
  2. for (int i =0; i<5;i++) {
  3. Customer customer = new Customer();
  4. customer.printName();
  5. }
  6. }

This scenario is dangerous and one of the main causes for the memory leaks. In this code block the references become invisible and its recommended to make the references null explicitly.

Unreachable: An object is in Unreachable state when there are no strong references and it will be marked for the collection. Of course “marked for collection” does not mean that JVM does the GC immediately. JVM has all its freedom to delay till memory is required by application.

Collected: When an object is unreachable the JVM readies it for the finalization. If an instance has the finalize method then it is marked and if the instance does not have any finalize method, it will move directly to Finalized state. Its very important to note that the when an instance has the finalize method, the deallocation process is delayed.

Finalized: Once the finalize method is run, if the object is still unreachable, its in the Finalized state. A finalized object is waiting for the deallocation. Its certain that the object’s life is prolonged when the finalize method is attached to the object. Also its not recommended to attach the finalize method for short-lived classes.

Deallocation: After all the above steps if the object is still unreachable, then the object is marked for the deallocation state. Its not sure when exactly the JVM deallocates, but this is dependent on the implementation of GC algorithms.

In the end, GC is not really what many of us perceive. An extra care must be taken to carefully write the applications with a special check on the object references and freeing the memory when ever possible.

“Nothing comes for free and so is GC”.

Posted in GC, Java | Tagged: , , | 5 Comments »

MyEclipse is Cool !!!

Posted by sureshkrishna on October 23, 2007

MyEclipse 6.0 GA has been released in August 2007 with a some cool features aiming at developers productivity. I just downloaded their 30 day trial version and played around little bit for two days. I was developing a AJAX and SOAEclipse IDE for my client; i was particularly interested to look into the ajax and database capabilities from MyEclipse.

Noticeable features from the 6.0 GA release includes (see myeclipse for complete list of features)…

  • Europa eclipse distribution compatibility
  • Integrated Libraries (for Java EE 5, JPA, Struts 1.1-1.3, Hibernate 2-3.2, Spring 1.2-2.0, etc…)
  • Integrated Tomcat 6.0 Server
  • Integrated Derby Server (10.2.2)
  • Java Persistence Tools
  • Visual JSF designer and Flow editor
  • AJAX Tools
  • Matisse4MyEclipse Swing Visual Designer

Ajax debugging capabilities are awesome from MyEclipse. They tried to provide most of the capabilities from the Firefox’s FireBug.

  • It has the JavaScript Inspector to look-into the scripts loaded by the webpage.
  • JavaScript Console to look into any kind of errors happening on the particular browser. One of the important issue that i was looking is to change the underlying browser that the page renders so that i can see the errors/warnings/info depending on the browser(IE/FF/SF). Some how i could not find this capability (perhaps i am missing something).
  • Ajax Request Monitor is another great tool to see how many ajax requests are happening on the page. It also shows the Request/Response along with Headers and Body. This is very helpful for debugging any kind of ajax requests to indicate time, status and request and response.
  • DOM Source view is very useful to see the code for a selected DOM node. The DOM Inspector view enables the developer to select any node on the dom and it highlights the specific area in the WebPage. This is great feature for the developer as he can see and inspect the inner elements from DOM.

Web20

I found the Java Persistence Perspective is very useful with DbBrowser, Table/Object Info, SQL Editor, Results, and Table Edit capabilities.

  • How cool is it for a developer to be able to connect to different databases (via DB Browser), select the tables and view the table Info (via Table/Object Info) and the edit the tables if needed (via Edit Table).
  • SQL Editor allows to select the different data base connections and then execute the query on a specific table or view. The query results are displayed in the SQL Results view. A developer oriented feature is to be able to copy the results on to the clipboard.
  • I really liked the ease with which we can add a capability; some of the capabilities include Add Web Service Capabilities, Add Tapestry Capabilities, Add Struts Capabilities, Add Spring Capabilities, Add JPA Capabilities, Add JSTL Capabilities. All these capabilities can be added by a single click. Configuration files and property files are automatically generated for the developer.
  • Java Persistence perspective enables to be able to select a table and create code supporting the persistence capabilities. Persistence mechanisms like JPA, Hibernate and EJB3 are supported via this feature (they call it reverse engineering… from table to code).

Pertistance

Last but not the least, Installing the MyEclipse examples dynamically is a great feature. User can decide what he wants and then he can get a full running application. I really like the bundling of the Tomcat and Derby so that all the minimal set of pre-requisites are satisfied.

Overall, working on MyEclipse was a great experience for me. All the mentioned features definitely improve developers productivity to a greater extent.

Posted in Eclipse, Hibernate, Java, Plug-ins, Plugin, Uncategorized | Tagged: , , , , | 4 Comments »

Persist your EMF Objects with Teneo

Posted by sureshkrishna on October 9, 2007

JMatter, NakedObjects and EMF are few technologies that i have been interested recently. That fact that all these technologies allows to create the model, generate the code for UI and finally persist the UI State in Object Reational Databases, makes me get excited about these. Without the help of these frameworks, some business usecases which needs the domain model/metadata to be persisted in the databases does require a lot of hand-coding and often requires long months of implementation. JMatter and Naked Object are supposedly generate the OR mapping from the domain data to the direct database tables with the help of the Hibernate mapping.

For all the EMF and Eclipse lovers it would be difficult to change their applications to JMatter or NakedObjects.  And one reason that i do not want to do it right now is that these frameworks are yet to support the SWT and interop with EMF models. For the Object relational database persistence of the metadata and domain models i found the Teneo project from eclipse to be quite promising.

What is Teneo : Teneo is the eclipse sub-project from  EMFT, which aims at providing the database persistency solution for EMF using Hibernate or JPOX/JDO 2.0. It supports automatic creation of EMF to Relational Mappings and the related database schemas. EMF Objects can be queried and stored using the advanced queries like HQL and JDOQL.

Why use Teneo

  • Teneo allows you to start with your model (UML or XML Schema) and automatically generate the java source code and object-relational mappings.
  • Teneo takes over much (or even all) of the manual work of creating relational mapping schemes.
  • Teneo supports JPA annotations on model level, this keeps your java code clean from persistency specific constructs.
  • The integration with EMF allows you to generate Eclipse RCP editors which persist automatically to a relational database.

And More  Teneo automatically maps the EMF model to a Hibernate OR mapping. The automatic mapping can be done in-memory when your application is initialized or a separate hibernate mapping file can be generated. The generated hbm file can be adapted manually and used in the runtime layer. To handle the EMF resource management and also the Hibernate mappings, a special runtime layer called EMF-Hibernate Runtime layer was developed. Teneo takes care of instantiating the EMF Objects and getters/setters for EFeatures of EMF from database.

This project is definitely a great relief to the EMF and Eclipse developers. Now everyone can persist their models in the Databases with a cleaner Hibernate implementation.

References

Posted in Eclipse, EMF, Java, JMatter, Naked Objects, Plug-ins, Plugin | Tagged: , , , , , , | 4 Comments »

What do you do with Eclipse ?

Posted by sureshkrishna on October 7, 2007

Eclipse the ubiquitous platform has survived another challenge by releasing the Europa and the incredible download numbers speak for it. Initially it was perceived as a Java IDE  then Tool development Environment, then RCP  Platform, then Tool Integration Platform and now its an eco-system of platform, application frameworks, tools, runtimes and especially Eclipse is a universal tool platform – an open, extensible IDE for anything, but nothing in particular. The intent of the article is to highlight the different areas of the industry and how eclipse is used by different category of users.

The Eclipse open source community has over 60 open source projects. These projects can be conceptually organized into seven different “pillars” or categories:

  1. Enterprise Development
  2. Embedded and Device Development
  3. Rich Client Platform
  4. Rich Internet Applications
  5. Application Frameworks
  6. Application Lifecycle Management (ALM)
  7. Service Oriented Architecture (SOA)

The list gives a fair understanding of the different areas where eclipse is getting popular and also the business verticals, which can be transformed. It is very interesting to see what eclipse means to different people. Following scenarios give a better understanding of what can be done with eclipse (and the rest are for your imagination…)

Eclipse – Java IDE

As comprehended in early 2000 (even now after the europa release), its a Java IDE with which java developers can create, modify, debug, build the java projects. Eclipse provides different features like code refactoring, syntax highlighting, syntax/code checks, code completion, quick fix, compile/build, team integration with CVS, debug, jarring, etc… In this use-case scenario eclipse is being primarily used as Java IDE. Eclipse + JDT  = Java IDE. Eclipse Platform contains basic UI elements (swt, jface), runtime, help system, debug support, search support and some other IDE elements. Java IDE can be downloaded from Eclipse Site.

Java IDE

Eclipse – Plugin/Tool Development IDE

Along the similar lines of the Java IDE, the C/C++ development tools, PHP development tools, Cobol development tools, etc… have brought fabulous features in the Eclipse eco-system. These development tools not only improved the productivity of the developers but also Myth-Busters for many managers, developers. This gave the real meaning for eclipse, an open, extensible IDE for anything, but nothing in particular. Vendors were successfully able to adopt the Eclipse Platform and build several tools and Language Editors around it. The ground rule of “Everything is a contribution” perfectly fits in this scenario.
PDE (Plugin Development Environment) and JDT (Java Development Tools) are the ones that support and enable this use-case. A plugin can be developed, debugged, deployed with the help of these two tools. PHP Editor Plugin is developed with the help of the PDE and JDT. When a developer is using Eclipse to develop the PHP, it looks as though eclipse is a PHP IDE. In this scenario, the developer might not necessarily know that there is PDE and JDT in the eclipse that has been used. Thus depending on the user and what he is trying to achieve, the perception changes.

Eclipse + Ruby on Rails = RadRails
Eclipse + Ruby on Rails = 3rdRails
Eclipse + JDT = Java IDE
Eclipse + PHP = PHP IDE
Eclipse + CDT = C/C++ IDE
<!–[if !supportLineBreakNewLine]–>
<!–[endif]–>

IDE Framework


Eclipse – RCP

Application development requires a platform to relay upon, where an organization’s software product lines can be built. A Rich Client Platform (RCP) of eclipse uses the windowing and UI features of the underlying OS platform. It enables the application to use the native look-and-feel, native widgets, and all available UI features. In the end users and IT departments wants to have a uniform architecture, look-and-feel over all the applications. Eclipse RCP is considered as the minimal set of plugins that are required to build rich applications. In short if the SDK capabilities and Platform capabilities are removed, the resulting set of plugins would be RCP.
An interesting set of applications can be built with the help of Eclipse RCP.

Few examples from Open Source RCP applications included, but not limited to…

<!–[if !supportLists]–>·        <!–[endif]–>JPMorgan’s Banking application

<!–[if !supportLists]–>·        <!–[endif]–>Maestro – NASA Space Mission Management

<!–[if !supportLists]–>·        <!–[endif]–>GumTree – Australian Nuclear Science and Technology Organization – GumTree is an open source multi-platform scientific workbench for performing scientific experiment under a server-client environment. It provides easy-to-use graphical user interface for instrument data acquisition, online or offline data visualization and analysis.

<!–[if !supportLists]–>·        <!–[endif]–>RSSOwlApplications that collect data from RSS-compliant sites are called RSS readers or “aggregators.” RSSOwl is such an application.

<!–[if !supportLists]–>·        <!–[endif]–>Talend Open Studio 1.0Talend Open Studio is the first ETL open source software provider for data integration tools (ETL: Extract, Transform, Load)

Following are examples for Commercial plugins

<!–[if !supportLists]–>·        <!–[endif]–>Actuate BIRT Report DesignerThe Actuate BIRT Report Designer is a powerful tool for designing and deploying reports against data sources ranging from typical business SQL databases, to XML data sources, to in-memory Java objects.

<!–[if !supportLists]–>·        <!–[endif]–>BSI CRM on EclipseThis customer relationship management (CRM) solution is a fully configured RCP application to support the whole customer contact process from first contact to the successful project implementation and also retention management.

<!–[if !supportLists]–>·        <!–[endif]–>IBM Workplace Client Technology – IBM Workplace Client Technology is a strategic new IBM framework to enable the creation of server-managed rich client applications.

<!–[if !supportLists]–>·        <!–[endif]–>MyEclipse – SNAPs – Lightweight, Individual, Task-Based Developement Tools FREE as Part of the MyEclipse Distribution. MyEclipse SNAPs (Simple Non-integrated Applications) are special-purpose, Windows-integrated applications that are targeted for quick, non-IDE based development tasks.

If required, one can use plugins other than core RCP plugins e.g. one might want to use the help plugins, search plugins etc.

RCP

Eclipse – Tools Framework

Plugins makes eclipse what ever one wants it to be. For the tool integrators, this is a universal platform on which everyone can contribute and extend on. Tool development on Eclipse leverages the existing platform infrastructure to contribute and/or extend the existing functionality.

Many of such tools that are popular are like

<!–[if !supportLists]–>·        <!–[endif]–>Web Tools Project (WTP)

<!–[if !supportLists]–>·        <!–[endif]–>Eclipse Modeling Framework (EMF)

<!–[if !supportLists]–>·        <!–[endif]–>Graphical Editing Framework (GEF)

<!–[if !supportLists]–>·        <!–[endif]–>Business Intelligence and Reporting Tools (BIRT)

<!–[if !supportLists]–>·        <!–[endif]–>Test and Performance Tooling Project (TPTP)

<!–[if !supportLists]–>·        <!–[endif]–>Aptana Web2.0 IDE

<!–[if !supportLists]–>·        <!–[endif]–>MyEclipse

Tool Framework

Eclipse – Application Framework

For enterprises it makes sense to have a single application framework so that all the tools and frameworks can be built upon. Individuals and enterprises can leverage frameworks and tools provided by the eclipse eco-system and also benefit from the different release time lines of eclipse. One of the examples is to be able to create the entire development life cycle of a complex engineering activity flow of an organization in to the eclipse. Various development stages like, system requirements, software requirements, component design, function design, coding, unit testing, integration testing, system testing, delivery and finally the Issue Tracking can be integrated into Eclipse. On the technical level this transforms to writing new tools/plugins if necessary, using plugins from 3rd party vendors, using the tools and frameworks from eclipse community and finally completing the maze by integration.

Genuitec is one of the companies that extensively use the Eclipse platform and other frameworks on the eclipse to have a set of seamless integration of tools.

Innopract based its products like Yoxos and RAP on the eclipse platform.

Application Framework

Summary
Eclipse is an IDE and application framework for anything and nothing in particular. It totally depends on the user/developer’s perception and what is targeted to achieve with the help of eclipse. With the contribution rules of eclipse and platform architecture, its easy to contribute ones own functionality and/or extend the eclipse.

References :
1) Eclipse Platform Overview http://www.eclipse.org/platform/overview.php
2) Eclipse House Rules http://udig.refractions.net/help/index.jsp?topic=/net.refractions.udig.doc/html/Eclipse%20House%20Rules.html
3) Eclipse RCP Applications http://www.eclipse.org/community/example_rcp_applications_v2.pdf

Posted in Eclipse, EMF, Java, JFace, Plug-ins, Plugin | Tagged: , , , | 2 Comments »

Help me with PermGen:OutOfMemoryException

Posted by sureshkrishna on September 28, 2007

I have a plugin developed for and AJAX based application with the help of Platform + EMF + WTP combination.
Many of the clients who report this out of memory have following conditions…
# Eclipse or Windows OS is not shut down for a long time; nearly for days.
# After a long time of inactivity on eclipse, Whenever a client clicks on any of the action or an editor, application just hangs.
# When a client is working on this application for a long time CPU goes 100% and except killing the eclipse application there is not other way.
Of course at this point of time i have no idea, what makes application crash with PermGen Error. There could be some thing wrong with the plugins that we made, but at the same time i dont get any error log for this PermGen:OutOfMemoryException.

I would appreciate if anyone can let me know about some of the utilities that i can use to find out the root cause.

Anykind of suggestions and solutions will be appreciated.

Posted in Eclipse, Eclipse Performance, Java, OutOfMemoryError, Plug-ins, Plugin | 13 Comments »