IE memory leaks solution for AJAX enabled components.
Tuesday 31 July 2007
First Part. Short Intro.
First of all , I must say that probably you already know about problem with memory leaks in IE. And also we have a lot of pages on different sites where people were discussed the patterns of memory leaks in IE.Just try to google on memory leaks in IE, or something like that - and you'll see.
Main part. The problem.
But I want to share with you the solution to a problem with memory leaks in IE.
I want to describe you a problem, If you'll made your own AJAX-enabled component with a lot of javascript on the client-side, you may get the situation when memory allocated by IE will grow after each(or may be not each) component refresh with AJAX or whole page refresh probably.
You could see such behavior , if you assign( by javascript ) to your AJAX enabled component any custom(means non-standard :) ) events or some specific functions, in which you'll get reference to that component.This is very popular way to do such things.
And if you'll take your AJAX enabled component and will try to refresh(not one time - let's say 1000 times) whole component or just it's part via AJAX - you will see in Task Manager that memory that was allocated by IE was grew up.
Final Part. The Solution.
The solution is to "clean" all custom javascript object(in javascript functions is also objects) that were "attached" to your component. By "clean" you can read - just assign null values. It will break all circular references, and possible closures.
And memory allocated by IE will not grow. Why? Because before that any DOM element that can be already null, but has any custom javascript objects attached to it, could not be collected by Garbage Collector.
But from now IE will "understand" that such elements can be collected by Garbage Collector, because there would not be any references from that objects to another one.
Below, I give you a short javascript function that I saw on this blog.
/*!
@fn MetaWrap.Page.Element.scrub = function(p_element)
@param p_element A reference to the element we want to scrub
@return void
@brief Nulls element references that commonly cause circular references.
@author James Mc Parlane
@date 23 October 2005
Called for every Element that is garbage collected by
MetaWrap.Page.garbageCollectListeners() or by the teardown code
MetaWrap.Page.deleteListeners()
As a generic leak pattern cleanup, this solution is only
effective for elements have had a listener added via
MetaWrap.Page.Element.addEventListener
Works by nulling event listeners and custom expanded members.
This will only work if you use the following naming standard
for your custom expansions of the element object.
m_XXX eg. m_flipover
$XXX eg. $flipover
*/
MetaWrap.Page.Element.scrub = function(p_element)
{
// For each member of the element
for(var l_member in p_element)
{
// If its an event listener or one of my user assigned
// members m_XXX, $XXX (self imposed naming standard)
if ((l_member.indexOf("on") == 0) ||
(l_member.indexOf("m_") == 0) ||
(l_member.indexOf("$") == 0))
{
// Break the potential circular reference
p_element[l_member] = null;
}
}
}
If you'll call this function for all elements and it's childNodes that were replaced by AJAX request-response, you'll "clean all unnecessary".
Hope it will help.
Posted byEugene at 05:17 2 comments
QuipuKit 1.2 Is Available Now!
Sunday 29 July 2007
QuipuKit is a JSF components library. I wrote about it in my past posts.
I've tried it in two of my projects. Web applications that was made - working under Tomcat server, so I wasn't boring about Quipukit's compatibility with other servers. Now as was written in press release , QuipuKit library works under Jboss server, WebShpere server and support JBoss Seam framework.
Other features are pretty good. Mainly I was using it's TreeTable and DataTable components.In version 1.2 Quipukit library now has SuggestionField component.As I saw in it's demo - it's kind an AutoComplete component.
You can take a look by your own on the demo of QuipuKit library.
$450 for per developer license - it's great price for library like that.
Posted byEugene at 08:35 0 comments
JSF 1.2 - Apache MyFaces 1.2.0 released
Wednesday 18 July 2007
The Apache MyFaces team is pleased to announce the release of Apache MyFaces Core 1.2.0.
MyFaces Core 1.2.x is a JavaServer(tm) Faces 1.2 implementation as specified by JSR-252. MyFaces Core has passed Sun's JSR-252 TCK and is 100% compliant with the JSR-252 specification.
MyFaces Core 1.2.0 is available in both binary and source distributions.
* http://myfaces.apache.org/download.html
MyFaces Core is also available in the central Maven repository under
Group ID "org.apache.myfaces.core".
Release notes are available.
From the editor: It's as yet unclear whether Tomahawk, which extends JSF with new components and converters, is compatible with MyFaces Core 1.2.0, as Tomahawk is specified as a JSF 1.1 library. Likewise with the other MyFaces subprojects, such as Tobago (more user interface components and theming), Trinidad (dialog management and page flow scope), and Orchestra (which combines JSF with a persistence layer). They should be compatible, however: is anyone willing to confirm?
Post from TheServerSide.COM
Posted byEugene at 07:36 0 comments
JCR 2.0 under public review
The next major revision of the Java Content Repository (JSR-283) has entered public review status on the JCP web site. Most of the visible changes revolve around querying a repository for content, with the SQL and XPath query languages being deprecated.
JCR is gaining acceptance in the market, with open source vendors like Alfresco, Apache, Magnolia as well as commercial vendors such as Day, and Percussions available. (Note: this is very far from an exhaustive list, although it'd be nice to have an exhaustive list somewhere...)
The revision to the specification is an excellent step forward.
Posted byEugene at 01:44 0 comments
WebGalileo Faces releases components as open source
JSCAPE and SoftAspects today announced that their popular WebGalileo Faces component suite will be released as open-source under the Apache License. The decision to go open-source was made in an effort to expand the user base while continuing to offer commercial support options. JSCAPE and SoftAspects will continue to offer support to current licensed customers as well as provide community user forums and paid commercial support options for the newly released open-source version.
WebGalileo Faces is a suite of Ajax-enabled Java Server Faces (JSF) components for streamlined development of Rich Internet Applications. Using WebGalileo Faces, developers can create web based applications in a fraction of the time required and with fewer errors. This time savings allows developers to deploy applications much faster and focus more of their efforts on the business logic of the application versus the technical details of writing software.
Components include containers, panels, dual lists, menus, date and time components, and a flow chart component.
WebGalileo Faces has built-in support for several IDE including Sun Java Studio CreatorTM, IBM Rational Application DeveloperTM, Oracle JDeveloperTM and EclipseTM.
For more information or to download WebGalileo Faces go to http://www.javawebcomponents.com
This message on TheServerSide.COM
Posted byEugene at 01:42 3 comments
Aspect Orientation for Mashups using OpenESB by Gopalan Suresh Raj
Saturday 14 July 2007
Modularity and Encapsulation have always been cornerstones of good software engineering. Modularizing concerns is an important way to ensure that there is very little overlap in functionality between software services. Concerns that defy encapsulation are termed Cross-cutting concerns. Cross-cutting concerns make a clear separation of concerns difficult to achieve since they may cut across many modules within a software application. Some examples of such cross-cutting concerns are logging which cross-cuts all logged classes and operations, or caching which cross-cuts all cached objects, or alerting, or message tracking, or auto-reconnect, or queuing, et aliae.
Aspects help to encapsulate cross-cutting expressions in one place. By applying an Advice, at various points in an application called Join-Points, Aspects can alter the behavior of the non-aspect parts of a software application.
The Java Business Integration (JBI) specification, JSR-208, provides a loosely coupled integration model for distributed services within a Service-Oriented Architecture (SOA). The architecture allows dynamic deployment of JBI components and JBI service assemblies that can be used as Aspect and Advice mechanisms to alter the behavior of other services. Once these Aspect and Advice mechanisms are "plugged" in on-the-fly between a Consuming Service and a Provisioning Service through a Service Facade, the architecture provides a mechanism to dynamically define, verify, audit, track, enable, and enforce these cross-cutting concerns.
More information is available on the GlassFish wiki.
By Java.net
Posted byEugene at 05:00 0 comments
Java EE 6, OSGi & Sun on different wavelength's
Friday 13 July 2007
Java EE 6 is on the drawing board, but the opinions are already starting to diverge. Rod Johnson -- of Spring fame -- thinks Java EE 6 is on the right track, see the discussion on Rod Johnson: "Java EE 6 Gets it Right" . However, this is not the same tone adopted by some OSGi proponents.
Peter Kriens over at OSGi writes: "Can someone tell Sun about OSGi", going onto say :
Someone just sent me a mail linking JSR 316. A JSR that will specify Java Enterprise Edition 6, the successor of Java EE 5, which was defined in JSR 244.
Now before we take a look, lets just investigate some recent trends in the Enterprise computing world. Hmm, BEA moved their micro Service Architecture on top of OSGi, IBM Websphere 6.1 seems to have chosen OSGi, Jonas is an EE framework build on OSGi from day one, and the JBoss Microcontainer is modified to support OSGi. On top of that, we have one product that made many people re-think Java EE: Spring. Now this product fell in love with OSGi. The market clearly says one size does not fit all. One would expect that these trends have some influence on Java EE 6? Sigh, think again.
Alex Blewitt, continues with his post "Sun submits JSR 316, still doesn't get OSGi", saying :
What's really interesting is that this approach (of combining lots of individual elements to one big package) mirrors what Sun's trying to do with the Java language. Instead of breaking units down into smaller and smaller levels (or bundles), they're going the opposite way and defining larger and larger chunks.
What are your thoughts on Java EE 6 ? Are the OSGi claims unfounded ? Or are they on the mark ?
Full post from Peter : http://www.osgi.org/blog/2007/07/can-someone-tell-sun-about-osgi.html
Full post from Alex :
http://www.eclipsezone.com/eclipse/forums/t98330.rhtml
This article was posted by TheServerSide.COM
Posted byEugene at 04:42 0 comments
Interoperability between the Java platform and Windows Communication Foundation (WCF)
Project Tango develops and evolves the codebase for Web
Services Interoperability Technologies (WSIT) that enable
interoperability between the Java platform and Windows Communication
Foundation (WCF) (aka Indigo).
Project Tango's WSIT tecnology is bundled inside GlassFish v2. It is also
possible to download a more recent version of WSIT and install into
GlassFish or Tomcat.
Project Tango uses JAX-WS and
JAXB as a foundation upon which
to build plugins to provide web services features such as
bootstrapping communication, optimizing communication, reliable
messaging, atomic transactions, security and trust.
One of the main goals of Project Tango is to provide
interoperability with Windows Communication Foundation,
the Web services stack bundled with the .NET 3.0 platform.
The two main value propositions of Project Tango are the following:
● An implementation of the key WS-* specifications
● Interoperability with .NET 3.0 framework
Tango provides an implementation of the key enterprise Web services technologies, commonly known as WS-*, with a focus to provide interoperability with Windows Communication Foundation, which is a component of .the NET 3.0 framework that provides Microsoft's unified framework to build distributed applications.
For any Web service communication, there is a Client that invokes an Endpoint. The Endpoint advertises its capabilities as metadata which the Client uses to bootstrap communication with the Endpoint. This metadata indicates which of the capabilities―Security, Reliability, and Transactions―are supported at the Endpoint. The figure shows a pair of Client and Endpoint, one using Metro and the other using .NET 3.0. The Metro Client and Endpoint can be deployed on any of the GlassFish V2 supported platforms. The .NET 3.0 Client and Endpoint can be deployed on any of the .NET 3.0 supported platforms.
Posted byEugene at 02:00 0 comments
Seam and Flex by Shashank Tiwari
Wednesday 11 July 2007
JBoss Seam and Adobe Flex are two promising technologies. Seam makes it easy to build stateful web applications. It integrates the Java EE frameworks together. Flex is a great rich application development framework. The question is can they and should they be used together?
Seam till its 1.x versions used JSF as the main UI framework. This implied that it was built around a server side UI model. Flex on the contrary is a client side UI framework. Oops! so we have a big disconnect right away! Not really, there possibly are some viable options to make them work together. In the latest version of Seam 2.0.0 BETA the coupling with JSF has been loosened. Also, in the past its been demonstrated that JavaScript UIs (built on frameworks like DOJO or any other) could directly remote to Seam server side components. Remember though that JavaScript runs within the browser whereas Flex applications runs within the Flash VM. Does that matter?One option is to have Flex as the front end and make Flex components remote to Seam? Technically this is a possibility and may be good in situations where Flex is used as a pure view description technology. In fact has anybody wondered writing a JSF render kit for Flex? That would be one nice looking but ugly under the hood hack. The state and event management would be all mixed up and one would end up writing more wiring to save the two together than use in isolation. I know some of you may oppose this thought and may cite cases where you have used Applets as a face for Servlets or similar server side technologies. Yes it works, is it elegant though? And what were the big wins of making them work together anyway? This the same question I ask when I read articles that claim that Spring MVC can work smoothly with Flex and Java Portlets can work effortlessly with Flex. Is it better to make complicated applications by spending more time and energy as opposed to building clean applications faster? In other words is it better to do the right thing or focus on making everyone happy?
So what does it mean in the context of our main exploration of making Seam and Flex work together? We have looked at the dry option of remoting a Flex face to a Seam server side. We could possibly liven it up by managing state on both sides - client and server - and introduce something that could be called a State Transfer Object (STO) to transfer the state information back and forth. Doesn’t sound good! It reminds me of the pain of using DTOs. Is there any other option? My answer is that I don’t know of one yet. I am trying to write a bridge between the two, following the principle of delegation and inclusion of common contexts wherever possible and ofcourse cheating (oh sorry! drawing inspiration) from the JavaScript remoting integration and the GWT integration in the Seam code base. If and when its ready, it would show up as an open source tool for everybody to play with and I will annouce its arrival. BTW, if anyone else here is interested in hacking that with me, you are most welcome to join in. In the meanwhile I would certainly like to hear your experiences in making these two work together. Both real life experiences and armchair musing are welcome.
Before I end this post, it may be important to discuss the “should they be used together” part of the question. Seam integrates the parts that make up Java EE very well. EJB3 components and POJOs are available as transactional components within stateful contexts. The programming model is simplified with the use of annotations. Integration with persistence architectures is really cool - I wish like with JSF, I could validate my form input on the Flex screen using Hibernate Validators or directly bind Flex component and control properties or instances to EJB3 entity beans.
With Seam there are lesser number of those XML files and template configurations to handle, as opposed to others, say Spring, where they are in abundance. Plus the biggest benefit is that you don’t have to learn a new framework really, most of what Seam uses is standard Java EE - EJB3, expression language, annotations, etc…..
Flex creates really elegant user interfaces. The best part is one can create them really quickly. Last week I hacked a fairly functional prototype for a reporting and charting application in 2 days - I can never do that with any other technology - not even with Ruby on Rails. Even if I can it would never look so nice and be functional. Part of the speed is surely attributed to the FlexBuilder eclipse plugin and it takes a lot more effort before such an application can go to production.
To summarize, both are great technologies. Also, though they overlap in many places they clearly have their strengths in different areas.
Theoretically bringing them together implies a beautiful face and smooth controls to a powerful engine — Tell me who would not want to drive such a machine?
Posted on O'Reilly Blog
Posted byEugene at 02:08 0 comments
Remind about OSGi.
Sunday 8 July 2007
OSGi is a specification of a Java based service platform targeted for use by systems that require long running times, dynamic updates, and minimal disruptions to the running environment.. The Eclipse Equinox project provides one of many available implementations of this specification (EclipseZone recently featured a podcast with Equinox project lead Jeff MacAffer) and serves as the reference implementation of the latest OSGi R4 specification. Initially, OSGi was targeted at home automation and residential gateway devices. More recently, it has found use in everything from mobile phones to cars.
The OSGi specification breaks software up into units of functionality called bundles. As a result this makes OSGi an idea base for applications such as IDE and application servers that often have numerous "modules" that may or may not need to be started at runtime or after the application has been started. The Eclipse IDE has made use of OSGi as its base since version 3.0. More recently other applications have started leveraging OSGi.
One recent use of the Eclipse Equinox technology is to bundle servlets and JSP's in Eclipse style plugins for dynamic WAR deployment. The Apache Tuscany SOA project has recently started exploring OSGi. Websphere 6.1 and JOnAS 5 are also being reworked as OSGi applications. A case study published by Adobe details how they made use of OSGi in their Adobe Creative Suite 2 application:
... [team members] found that reusing Adobe Creative Suite 2 components in an Equinox environment was as simple as writing a thin compatibility layer.Developing plug-ins to deliver new functionality in the past had presented significant challenges. Since it was difficult to validate dependencies, Version Cue had not been able to make the most efficient use of system resources by loading exactly what was needed. Using Equinox and the Eclipse plug-in model, resolving plug-in dependency is simple, and they have been able to achieve true dynamic loading and unloading of plug-ins on demand. The result is a smarter, leaner and faster application that provides a better user experience.
Developers in the trenches are also starting to notice OSGi. Xerto's Imagery application is built on Swing but uses OSGi for its plugins layer. Blogger Werner Schuster recently commented:
if you want to write any kind of nontrivial program where you want a clean seperation of the individual modules. If you do that, you can spend ages writing a runtime system that tediously reimplements all the OSGi features,.. or you can just use OSGi. And it will pay off… OSGi isn‘t a new kid on the block… it‘s now up to version 4, not to mention that Eclipse has used it now for about 3 years and provided lots of feedback. I became really convinced of OSGi usefulness when I had some class loading issues while writing EclipseShell… I already feared having to mess with the classloaders (not much fun if you‘re using JVM based dynamic languages which might or might not pack their own class loading tricks). But no! The solution to my problems was … adding a line to the Manifest.MF ... et voila! (If you‘re curious, google for “Buddy-Classloading”)...So… screw Sun‘s NotInventedHere syndrome, screw Dolphin, screw waiting for JSR-277 to be shoved into existence. The future is here right now and it‘s tried, tested and easy to use in the form of OSGi, Eclipse for development, and Equinox for the runtime.
It will be interesting to see how the Java community makes use of OSGi which is available today versus Sun's "super-packages" (JSR 294) and Java Modules (JSR 277) initiatives scheduled for Java 7. A blog post by Sun's Alexis Moussine-Pouchkine described the two JSR's:
JSR 294 is development-time and language driven while JSR 277 is all about deploy-time ... one of JSR 294's goal is to enable "separate compilation", i.e. compile against an interface without needing the actual implementation. Most of JSR 277 has to do with annotating JSR 294 modules. Pretty much like moving archive manifest information to Java annotations.
Read original article on InfoQ
Posted byEugene at 05:08 0 comments
JSF 2.0. When & What ?
I think most of web developers on java, know that JSR 314is in the review ballot phase.
This JSR is all about JavaServerFaces 2.0
By next year when the specification is ready for release we would see a lot of goodies in JSF, some of them being -
- better view decription technology - somewhat like facelets or maybe better.
- application modification and deployment at runtime
- tighter integration with Ajax. perhaps support for a small JavaScript library contract specification.
- better and maybe centralized error handling
- minimization of “xml hell”, use of annotations instead
- possibility of RESTful urls and use of GETs
- skinning and themeing
- reduction of effort required for creating custom components
You can view the requirements scratchpad for this JSR.
Posted byEugene at 05:08 0 comments
OSGi , Spring OSGi and the server-side. Part 4
Now , I want to tell you about server-side of OSGi technology.
Nowadays, better support of server-side gives Eclipse Equinox OSGi framework.
From a code point of view, Equinox is an implementation of the OSGi
R4 core framework specification, a set of bundles that implement various optional OSGi services and other infrastructure for running OSGi-based systems.
More generally, the goal of the Equinox project is to be a first class OSGi community and foster the vision of Eclipse as a landscape of bundles. As part of this, it is responsible for developing and delivering the OSGi framework implementation used for all of Eclipse. In addition. the project is open to:
- Implementation of all aspects of the OSGi specification (including the MEG and VEG work)
- Investigation and research related to future versions of OSGi specifications and related runtime issues
- Development of non-standard infrastructure deemed to be essential to the running and management of OSGi-based systems
- Implementation of key framework services and extensions needed for running Eclipse (e.g., the Eclipse Adaptor, Extension registry) and deemed generally useful to people using OSGi.
Server-Side Equinox
Equinox can be used on the server to serve up static content and to run servlets or JSPs. In each of these cases you need to setup an HTTP server and then configure it with the appropriate content. There are two basic ways of running an HTTP server in Equinox;
Follow the steps for the configuration best suited to your scenario then return here to write your bundle based web application.
HintEmbed a server in Equinox is the easiest configuration to setup and run. This will allow you to do all your development and debugging. Only when you go to production or in special circumstances will you need to embed Equinox in an existing servlet container.
Posted byEugene at 05:01 1 comments
Rethinking JSF - The Real Problem. By Joseph Ottinger
Saturday 7 July 2007
This article is worth to look at. The main problem that discussed there is that JSF, for a component framework, has so few components.
It is hard to disagree with that.
"So... where are the login box components? Where are the search box components? Where are the data input components? Where's the ability to manage "pretty URLs?" ("Pretty URLs" are also known as bookmarkable URLs, or search-engine-friendly URLs.) Where is the data flow? Where's the conversational state?
There's absolutely nothing in JSF that prevents these things from being made, and some groups (vendors, open source groups) have already made some of them - frameworks and implementations like Seam, IceFaces, RichFaces, Tomahawk, NetAdvantage, and others. For others, code is readily available in books like "JSF: The Complete Reference" (Schalk, Burns), "JSF In Action" (Mann), and "Core JSF" (Geary). Some elements are even available on the web (for example, how to manage pretty URLs). There are also sites with lots of JSF information: IBM developerWorks, Java.sun.com, www.jsfcentral.com, www.jsftutorials.net, and TheServerSide itself. "
"Advice for new component authors: stop reinventing the wheel! Everyone has a tab panel, a menu component, a spinner, a drag-and-drop mechanism. It's been done. While perhaps newer and better ways to do things will always be welcomed, aiming for a "me-too" implementation doesn't help propagate the technology in any real way. What JSF needs is a set of components that use interfaces as models, along with a "standard implementation" of those interfaces that can be replaced at runtime with specific functionality. Along with this set of components, documentation that addresses the learning curve would be welcomed."
Full article
Posted byEugene at 06:55 1 comments
Ajax Experience: What's interesting for Java developers?
"The Ajax Experience, scheduled for July 25-27 2007 in San Francisco, has a lot of great sessions of interest to Java developers - whether you're following JSF, GWT, Struts, or even hand-coding your client-side UIs yourself. The Ajax Experience caters to the technology behind Web 2.0 - you should check it out.
Topical tracks include architecture, performance, design and effects, and specific frameworks. Speakers include framework developers like Brad Neuberg (Dojo), Patrick Lightbody (Struts2), Joe Walker (DWR), and more. Specific sessions of interest to Java developers include "Flash: Strengths vs. Weaknesses and How to Best Utilize it in Projects," by Geoff Stearns, a Youtube engineer; Advanced Prototype usage (Prototype is the underlying toolkit used by many Ajax frameworks); Continuations in Javascript; Advanced Web Security with Joe Walker, and more.
Of course, these are only the tip of the iceberg for Ajax developers.
So what makes this conference useful? Well, consider: for most users and applications, the web interface is the primary (or even only) point of contact. The back end may be elegant, incredibly fast, amazingly efficient, but with a clunky interface, nobody will care. The killer applications today tend to focus on the user experience: useful menus, dynamic behavior that caters to the way users want to use the application.
With a few rare exceptions, the way people make their application interfaces sing today is with Ajax, rich client interfaces that offer interactivity and rapid response to users.
The Ajax Experience is a great way for Java developers to leverage this technology, whether as experts or as people needing introduction to the concepts, whether you need to understand how the basic architecture works or if you need to optimize how your application already leverages the technology.
What stands out to you in the Ajax Experience?"
By TheServerSide.COM
Posted byEugene at 06:53 0 comments
JSR-275 - Units and Measures for Java 7 - draft terminates soon
Friday 6 July 2007
I really interested in what it would be? And how it would be implemented?
This is what they say:
"Java developers who work with physical quantities (such as developers in the scientific, engineering, medical, and manufacturing domains) need to be able to handle measurements of these quantities in their programs. Inadequate models of physical measurements can lead to significant programmatic
errors. In particular, the practice of modeling a measure as a simple number with no regard to the units it represents creates fragile code. Another developer or another part of the code may misinterpret the number as representing a different unit of measurement. For example, it may be unclear whether a person's weight is expressed in pounds, kilograms, or stones.
Developers must either use inadequate models of measurements, or must create their own solutions. A common solution can be safer and can save development time for domain-specific work. This JSR proposes to establish safe and useful methods for modeling physical quantities."
JSR-275 "Measures and Units" Early Draft Public Review terminates soon (July 8). Your comments/feedback are important to us (the latest version 0.8 is available here).
The JSR-275 should be a major enhancement for Java 7 by providing "strong" typing (through class parameterization) and easy internationalization of Java programs (preventing conversion errors). The reference implementation is provided by the JScience project under BSD License.
Let's wait and will take a look when all will be done.
Posted byEugene at 00:57 0 comments
WhoDoes, free web-based project management software
Monday 2 July 2007
GotThingsDone.comhas released WhoDoes, a new intuitive web-based project management software developed with Ruby on Rails.
Whodoesis suitable both for firms and professionals that have to plan and manage various projects of diverse complexity, where a lot of people, united or distributed anywhere, have to be coordinated and have to collaborate with tracking the advancement of the developed activities.
WhoDoes is designed to assist Project Managers and team members in the planning and management of projects with varying complexities.
It makes managing of complex projects easy, and facilitates the convenient planning of short-term small activities.
The major hitch in project management is making all the team members aware of what they have to do daily, so a successful project management tool must first of all answer the following question: What do I have to do today?
WhoDoesis designed to manage activities and share real time information with all the team members, whether they are in the same office or distributed all over the World.
Among its key features:
- Web-based: WhoDoesis usable from every computer connected to the Internet. No installation is required, it's totally cross-platform and cross-browser.
- Easy to use: A simple and easy web application helps to reduce the time spent on project planning.
- Team co-ordination: WhoDoes has a control panel to communicate and collaborate with all team members anywhere, filling the communication gap between who plans and who works.
- Roles division: Roles and permissions are divided for each project user.
- Easy time tracking: Gives detailed real-time informations and time control on tasks, project times and delays, allowing project managers to manage delays at the right moment.
- Repository: A shared archive for project documentation, a common space where all the team members could share materials and find the last official version of the project documents.
WhoDoesis completely free to use. All the features included in this version will remain free even when chargeable versions come out in the future.Follow this link to register for a new WhoDoes account.
Posted byEugene at 01:18 1 comments