<?xml version='1.0' encoding='utf-8' ?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"/></head><body><h1 id="Linux_Tools_0.4_Release_Review">Linux Tools 0.4 Release Review</h1><p>Planned Review Date: 2009-11-18</p><p>Communication Channel:  linuxtools-dev@eclipse.org (<a href="https://dev.eclipse.org/mailman/listinfo/linuxtools-dev">https://dev.eclipse.org/mailman/listinfo/linuxtools-dev</a>)</p><p>Author:  Andrew Overholt &lt;overholt redhat com></p><h2 id="Introduction">Introduction</h2><ul><li>The Linux Tools project is a two-faceted project<ul><li>Firstly, it provides tools and frameworks for writing tools relevant to Linux developers.</li><li>Secondly, it provides a place for Linux distributions to collaboratively overcome issues surrounding distribution packaging of Eclipse technology. The project produces both best practices and tools related to packaging.</li></ul></li><li>Project plan:  <a href="http://www.eclipse.org/projects/project-plan.php?projectid=technology.linux-distros">http://www.eclipse.org/projects/project-plan.php?projectid=technology.linux-distros</a></li></ul><h2 id="Features">Features</h2><ul><li>GProf integration including function-based profiling and integration with the CDT</li><li>an RPM .spec editor with rpmlint integration</li><li>plugins integrating the OProfile profiler with the CDT</li><li>a Zest (GEF)-powered C/C++ call graph integrated with the CDT, powered by SystemTap</li><li>GNU Autotools CDT additions</li><li>plugins bridging the CDT's hover help functionality with the</li><li>various open source API documentation formats; called libhover</li><li>Valgrind integration for memcheck, massif, and cachegrind</li><li>a tool to help building and packaging Eclipse plugins as RPMs named RPM Stubby</li><li>ChangeLog management tools</li><li>an editor, launcher, and data visualizer for Systemtap scripts</li></ul><h2 id="New_in_0.4">New in 0.4</h2><ul><li>GProf integration courtesy of ST Microelectronics</li><li>a Zest (GEF)-powered C/C++ call graph integrated with the CDT, powered by SystemTap</li><li>More New and Noteworthy for 0.4:<ul><li><a href="http://www.eclipse.org/linuxtools/new-0.4/">http://www.eclipse.org/linuxtools/new-0.4/</a></li><li>(will be moved to <a href="http://www.eclipse.org/linuxtools/new">http://www.eclipse.org/linuxtools/new</a> after 0.4 is released)</li></ul></li></ul><h2 id="Non-Code_Aspects">Non-Code Aspects</h2><ul><li>0.4 contains the continued improvements in our "eclipse-build" work which aims to ease the building and packaging of the Eclipse SDK for Linux distributions.  This work is now being consumed by Fedora, Debian, and Ubuntu with other distributions hopefully joining that list in the future.</li><li>After our 0.1 release we did a series of screencasts with audio. They are still relevant and are all available via our downloads page:  <a href="http://www.eclipse.org/linuxtools/downloads.php">http://www.eclipse.org/linuxtools/downloads.php</a></li></ul><h2 id="APIs">APIs</h2><ul><li>Being a pre-1.0 release, our APIs are subject to change.</li><li>We continue to internalize unnecessarily public APIs and have done much work in this area for 0.4.</li><li>We will converge on stability – and document such stability – in our APIs well before our 1.0 release.</li></ul><h2 id="Architectural_Issues">Architectural Issues</h2><ul><li>As our focus has been to bring Eclipse technology to Linux users who would otherwise be unaware of its power, we have continued to spend less time on extensibility than on user-visible features in our 0.4 release.</li><li>As we work towards our 1.0 release, we will continue to better define our APIs while stabilizing them and documenting them.</li><li>On-going work to integrate with tracing toolkits will enable us to have more extensible frameworks with exemplary implementations.</li><li>Despite being user-focused, we have a few components which provide extension points:<ul><li>our profiling tool framework whose use is demonstrated by our OProfile and Valgrind integration plugins</li><li>our ChangeLog plugin which allows for extensible parsers, formatters, and editors. The extensibility of formatters is demonstrated by our RPM .spec editor</li><li>our libhover component. This plugin provides an extension point that defines a common documentation format for C library hover help</li></ul></li></ul><h2 id="Tool_Usability">Tool Usability</h2><ul><li>Our releases thus far have been well-received and at present have satisfied users. This 0.4 release will hopefully grow this base of satisfied users.</li><li>Due to the large number of people packaging software for RPM-based distributions, our .spec editor has become one of our more popular features.<ul><li>The in-line warnings and error checking as well as templates and completion are incredibly useful features.</li><li>This 0.4 release contains the first release of a tool to create RPM .spec files from Maven pom.xml files</li><li>Our work integrating native profiling tools like OProfile and Valgrind has been introduced to excited audiences. We aim to bring the power of these tools into the IDE while making them trivial to use.  Developers making use of our tools will be able to focus on their own projects and not on setting up the underlying tools.</li></ul></li></ul><h2 id="End-of-Life">End-of-Life</h2><ul><li>We have no end-of-life issues to discuss at this time.</li></ul><h2 id="Bugzilla">Bugzilla</h2><ul><li>For our 0.4 release we have 0 outstanding release-blocker bugs.</li><li>We have postponed a few enhancement requests until our 0.5 release.</li><li>We closed over 91 bugs during our 0.4 release cycle:</li></ul><p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Technology&amp;product=Linux+Tools&amp;target_milestone=0.4&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0">https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Technology&amp;product=Linux+Tools&amp;target_milestone=0.4&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0</a></p><h2 id="Standards">Standards</h2><ul><li>Our project conforms to the following ad-hoc standards:<ul><li>Fedora RPM packaging guidelines<ul><li><a href="http://fedoraproject.org/wiki/Packaging/Guidelines">http://fedoraproject.org/wiki/Packaging/Guidelines</a></li></ul></li><li>Informal conventions around use of the GNU Autotools</li><li>GNU ChangeLog formatting<ul><li><a href="http://www.gnu.org/prep/standards/html_node/Style-of-Change-Logs.html#Style-of-Change-Logs">http://www.gnu.org/prep/standards/html_node/Style-of-Change-Logs.html#Style-of-Change-Logs</a></li></ul></li></ul></li></ul><h2 id="UI_Usability">UI Usability</h2><ul><li>Our project aims to conform to the Eclipse user interface guidelines.</li><li>All of our user interface components support keyboard navigation.</li><li>We now support interactivity of our Valgrind BIRT-generated charts and intend on further increasing our accessibility.</li><li>All of our strings are externalized but we currently have no language packs</li></ul><h2 id="Schedule">Schedule</h2><ul><li>We plan on having our 0.5 release in late December 2009</li><li>Our project aims to release minor releases (0.5, 0.6,  etc.) every two months</li><li>We are still playing it by ear to decide when our 1.0 release will be but are planning on Q2 2010</li></ul><h2 id="Communities">Communities</h2><ul><li>Our project has a strong relationship with the various Linux distributions (Fedora, Mandriva, Debian, Ubuntu, etc.)</li><li>The majority of our project's interactions occur on IRC (#eclipse-linux) and our mailing list (linuxtools-dev@eclipse.org)</li><li>We have a centralized update site and use eclipse.org bugzilla for all of our planning and bug tracking</li><li>We make use of our newsgroup for user feedback</li><li>Our project members often speak at conferences</li><li>Our team members maintain the following blogs:<ul><li><a href="http://overholt.ca/wp/">http://overholt.ca/wp/</a> (part of Planet Eclipse)</li><li><a href="http://akurtakov.blogspot.com/">http://akurtakov.blogspot.com/</a> (part of Planet Fedora)</li><li><a href="http://picobot.org/wordpress">http://picobot.org/wordpress</a> (part of Planet Fedora)</li></ul></li><li>We interact often with the CDT project and make use of the BIRT, GEF, and CDT projects</li><li>We are growing our community of adopters</li><li>An update on our project's progress was given at EclipseCon 2009:<ul><li><a href="http://www.eclipsecon.org/2009/sessions?id=466">http://www.eclipsecon.org/2009/sessions?id=466</a></li></ul></li><li>An update on our project's progress was given at the <a href="http://www.grancanariadesktopsummit.org">Gran Canaria Desktop Summit</a> in July 2009:<ul><li><a href="http://www.grancanariadesktopsummit.org/node/194">http://www.grancanariadesktopsummit.org/node/194</a></li></ul></li><li>An update on our project's progress with respect to tracing tools was given at the <a href="http://ltt.polymtl.ca/tracingwiki/index.php/TracingMiniSummit2009">Tracing Mini-Summit</a> in July 2009.</li><li>Now that we have a standardized release process and plan, we are working to ensure that our three communities are properly nurtured at all times.</li><li>Following our recent releases we have had a number of parties come forward to express interest in using, distributing, helping, and contributing.</li></ul><h2 id="IP_Log">IP Log</h2><ul><li>Our IP log including information about all CQs, external contributions, and committers can be found here<ul><li><a href="http://www.eclipse.org/projects/ip_log.php?projectid=technology.linux-distros">http://www.eclipse.org/projects/ip_log.php?projectid=technology.linux-distros</a></li></ul></li><li>A copy of our 0.4 IP log as approved by the Eclipse Legal team is archived here:<ul><li><a href="http://www.eclipse.org/linuxtools/doc/0.4-approvedIPLog.html">http://www.eclipse.org/linuxtools/doc/0.4-approvedIPLog.html</a></li></ul></li></ul></body></html>