+* Enhanced static object inference
+* Holding per name information for builtin containers
+* Change signature for constructors
+* Adding 'rename when unsure' option
+* Enhanced returned object static object inference
+* Supporting generator functions
+* Handling ``*args`` and ``**kwds`` arguments
+* Showing pydoc for some of builtin types and functions
+* Filling paragraphs in text modes; ``M-q``
+* Repeating last command; ``C-x z``
+* Enhancing show pydoc to include docs from superclasses
+The most interesting features added in this release are related to
+rope's object inference mechanisms. I'd rather show some small
+examples than going into to much detail here.
+Enhanced static returned object inference::
+Here rope knows that the type of a_var is a `list` that holds `str`\s.
+Supporting generator functions::
+ for c in a_generator():
+Here the objects `a_var` and `c` hold are known.
+Another thing that has been added is SOI analysis (Available in
+``Edit`` menu or by using ``C-c x s``). It analyzes a module for
+finding useful object information. Currently it is used only when the
+user askes (Just like DOI), but in future that might change.
+Many kinds of information is collected during SOI like per name data
+for builtin container types::
+Here rope knowns the type of `var1` without doing anything. But for
+knowing the type of `var2` we need to analyze the items added to `l2`
+which might happen in other modules. Rope can find out that by
+running SOI analysis on this module.
+You might be wondering is there any reason for using DOI instead of
+SOI. The answer is that DOI is more accurate and handles complex and
+dynamic situations. For example in::
+SOI can no way conclude the object `a_var` holds but it is really
+trivial for DOI. What's more SOI analyzes calls only in one module
+while DOI analyzes any call that happens when running a module. That
+is for achieving the same result as DOI you might need to run SOI on
+more than one module and more than once (not considering dynamic
+situations.) One advantage of SOI is that it is much faster than DOI.
+Many enhancements to rope's object inference has been planned and till
+``0.5`` release most of them will be implemented. I'll write more
+about them in future releases.
+'Rename when unsure' option has been added to rename refactoring. This
+option tells rope to rename when it doesn't know whether it is an exact
+match or not. For example after renaming `C.a_func` when the
+'rename when unsure' option is set in::
+Note that the global `a_func` was not renamed because we are sure that
+it is not a match. But when using this option there might be some
+unexpected renames. So only use this option when the name is not
+another python defined elements.
The main motive for starting this project was the lack of good
-refactoring tools for python language. Refactoring programs like
-"bicycle repair man" aren't reliable due to type inference problems
-and they support a limited number of refactorings. *Rope* tries to
-improve these limitations.
+refactoring tools for Python programming language. Refactoring
+programs like "bicycle repair man" aren't reliable due to type
+inference problems and they support a limited number of refactorings.
+*Rope* tries to improve these limitations.
* Why an IDE and not a standalone library or program?