Pharo Changelog

What's new in Pharo 3.0

May 20, 2014

Lots of Cleanups
Lots of tuning (performance, memory)
Lots of small improvements
Closure class now standard in Pharo3 Komitter Terminal output for stderr Launcher Cleanup Source ﬁle related code AST Interpreter Font Speedup AST based Navigation in Browser ….
New Inspector Unify Inspector and Explorer Make specialised inspectors visible
Athens: Vector Graphics New API for Vector Graphics Independent of Backend For now: Cairo Balloon3D for Debugging Future: OpenGL
Athens: Demo
Opal Compiler Uses RB AST ! IRBuilder: Bytecode backend with high-level builder Much easier to change Basis for Reﬂectivity (see Pharo4 talk)
New ClassBuilder Replaces the old ClassBuilder ! Easier to understand and more ﬂexible ! Basis for Slots (see talk about Pharo4)
New Debugger Model now separate from View ! Model is scriptable ! Debugger is extensible with Commands
Command Line denker$ ./pharo Pharo.image --list! Currently installed Command Line Handlers:! Fuel Loads fuel files! config Install Configurations! save Rename the image and changes file! update Load updates! printVersion Print image version! st Loads and executes .st source files! test A command line test runner! clean Run image cleanup! eval Directly evaluates one line scripts! !

New in Pharo 2.0a (Oct 3, 2012)

New in Pharo 1.4 (Oct 3, 2012)

Changes:
New code model: Ring
Support for startUp preference script
class message is not a byte code anymore
Better union and intersection methods
Better primitive simulation
Better headless support
Better support for error at startup
Introduction of FileSystem
Less dependencies: Color, Scrollbar do not depend on Compiler anymore
Cleaning tests
Unload hostSystemsMenus
More consistent API for browser opening
No event pulling anymore
More class comments
Announcement driven system notification
Better API for sharedPool
Zinc Improvement:
New mechanism for Zinc servers start/stop handling after system startUp/shutDown
and a lot a lot and a lot more.
Tools:
Support Cherrypicking when merging
Better timeProfilerBrowser
Better MC commit error
MC handles better dependencies
Better Debugger
Better Inspector
Search in tools
New Finder tool
Cmd-Click for senders and implementors
Senders and implementors deals with class
Better tool registry
Improvements for the FlatBrowser
Better Transcripter
Faster diffBuilder
New version of OCompletion and Ecompletion that can play together and without code duplication.
UI:
Better search
MultiSelection improvements
Drag and drop in multi selection list
PluggableListMorph improvements
PluggableListMorph selection on drag
Iconic Button improvements
PharoTheme
Better CheckBox
Enhanced PluggableButtonMorph
Polymorph enhancements
Deprecate PluggableListMorphOfMany
Merged NewParagraph and MultiNewParagraph
New Widget: Ticking list and widget
LazyListMorph cleaning
NewTextMorph and TextComposer improvements
Improve behavior of MorphTreeMorph
Removing NewTextMorph and related
StringMorph
Cleaning:
Object
Old HTTP code
No references to Utilities
Removed toolbuilder
Restructure packages
Canvas hierarchy
MorphicModel
Deprecate recentMessageSet
Deprecate ImageSegment
Deprecate MessageNames
Deprecate TimeProfileBrowser
Really cleaning messageSet and subclasses
SystemChangeNotifier
Removed Project
Removed BlockContext, blue book old closure encodings
Font downloading
HandMorph
Some Fixes:
Set growth with nil
Better weak finalization
isPrime fixed
Compiler Fixes
Russian characters in editor
More class comments
Fix drawing shadow morphs
Trait support
Fixed syntax hilighting
Better pointersTo:
Speedup MethodDictionary #rehash
Compiler enhancements.
Stream should not print its contents
Progress bar
InputSensor
CombinedChar
BytexTextConverter fixes

New in Pharo 1.3 (Mar 9, 2012)

Cleaning architectural dependencies
We clean a lot of unwanted dependencies between several packages. We applied Moose tools and we will continue to improve the architecture of the system. In particular we will identify better layers in the system. This is important to be able to change large components and to be agile and make certain hypotheses exposed.
Applying code critics to the complete system
We started to run code critics on the complete system and fix them. We will continue on this path and we will add automated code critics in the hudson build scripts. In particular we removed more than you can expect duplicated code between classes and subclasses. We plan to add Pharo specific Lint Rules and also bring rule checking for all the hosted applications on our hudson server.
Support for server and headless images
Being able to run Pharo on headless servers is important for web development as well as for building scripts. We introduced a better way of handling non interactive mode. We want to make sure that Pharo can run without UI. Ideally we would like to be able to plug a UI layer on the fly to get a real headless mode but this is clearly future. But at least you know our vision.
We improved the way the command line works. A new implementation is now available and it can support multiple extensions without conflicts.
Pharo has now a support for stdin, stdout and stderr.
More robust and better startup/shutdown
At startup and shutdown the image executes the methods startUp: and shutdown: of registered classes (registered using addToStartUpList:, addToShutDownList:, ... methods and friends). Now we improved the robstuness of actions performed at startup by introducing a two stages process. During the first stage of start up the UI manager, the default uimanager is switched to a specific non interactive ui manager (StartupUIManager). Note that this specific non interactive UIManager kills the system on any attempt to open windows and interaction. So be warned, don't use interaction in the first phase. Then all registered classes execute their start up procedures (which should not imply interactive behavior). After startup list is finished, any deferred startup actions are executed, which you can add using the method addDeferredStartupAction: method. This change is important since it structures the startup and make sure that certain actions only occurs when they can run.
Better look and feel
We copied the work done for Moose and reorganize a bit the themes. We deprecated some old ones. We will continue to improve this aspect.
Better widgets
In general we believe that the core widgets should be more powerful. We did a lot of progress there and we will continue our effort.
Better support for syntax highlighting.
Now we introduced a NullStyler to be able to have a more modular system.
Deprecation of ParagraphEditor, introduction of TextEditor
We deprecated ParagraphEditor and use the new text editor. We got a better TextMorph, with a better find/replace behavior. There is now a really powerful text selection that can show automatically all the occurrences of a selection in the complete text. This makes code changes really fast. The visual impact is excellent.
PluggableTextEditorMorph was a funky and somehow duplicated class so it got deprecated.
Better PluggableListMorph and friends
PluggableList Morph was improved in multiple fashions. Multiple selection is now supported. List items can be searched then the focus on a new item can be driven using keyboard. PluggableListMorph can now behaves like a multiple selection list. This behavior can be switched on the fly. (MultipleListOfMany, PluggableIconListMorphOfMany are now deprecated since PluggableListMorph can do the same). Benjamin van Ryseghem did an excellent job there.
MorphTreeMorph speed was improved.
Deeper merge of Polymorph.
We continued to integrate deeper Polymorph into the system and revisit also some polymorph choices.
Better GeneralScrollPane. Now it supports both spaceFill and shrinkWrap.
Cleaner and simpler Modal mode (no more thisContext usage). We remove duplicated code in addition.
MorphTreeMorph keystroke event handling now accept an event.
We removed the left over of ST-80 old and nearly unused classes.
Now menus should be created via UIManager so that they do not break the non interactive mode.
Better tools
Our goal is to be able to get models for all the tools and to rewrite all the basic tools so that we can deprecate the old hierarchy around StringHolder. We made good progress there. Benjamin van Ryseghem really helped a lot for this task.
Tools are now accessed via Smalltalk tools toolName. A tool at class side should implement #registerToolsOn: method. This method will be executed automatically for all classes, when you issue
Smalltalk resetTools. Note, that with tools registry, you are no longer need to keep (and implement) a singleton pattern per each tool class, which requires it , i.e.SomeTool default doSomething. instead, with using registry, you can register a sole tool instance (or class) to registry , and then just write Smalltalk tools someTool doSomething.
RecentMessageList, the Finder and Senders and implementors underlying widgets were totally rewritten.
Better Monticello branch encoding.
Better debugger menu context.
Huge amount of little fixes.
New time profiler.
StringHolder hierarchy got a lot of deadcode and other cleaning action.
Deferred UI messages was now better handled.
Speeding up the Help browser by 50%.
After a long discussion that started at ESUG last year, we started to remove toolbuilder dependences. We should be able to remove ToolBuilder. ToolBuilder was a good idea: a set of specification objects abstracted the common widgets and some of the existing tools were using it. It was potentially good to port the current and fixed set of tools to new UI frameworks. The current problems were that there is no new UI framework on the horizon and second the default tools could not take advantage of the new UI widgets of Polymorph. So since we would really like to get a new set of powerful widgets and since ToolBuilder did not support an existing need, we will remove it. If the need arrives, we may reimplement it.
New libraries or Enhancement
Support for more robust Announcements infrastructure is now in place and used. The problems we faced were, how can we make sure that solid and tested code can be executed when sometimes end-users code can break the loop executing system code. A typical example is announcement, event handling, ui rendering thread.
A new method on:fork: is introduced, on error it will manipulate the stack and fork a process with the part containing the error. This lets in particular the execution of non broken behavior continue to run. This changes will bring a lot of stability and robustness in the system in key core places. The logic of the UI thread will be rewritten to take advantage of it.
Weak Announcements
Announcements are important and we improved the first naive implementation. Support for weak announcements was first added. Then announcement took advantage of the on:fork: introduction. It makes sure now that all system announcement will be delivered.
WeakOrderedCollection needed for Magma has been added.
Generator was added.
Stratified Proxy
Often when you build proxy, you cannot control all the messages sent to the proxy because the proxy implementation relies on DNU and ProtoObject. We designed a new version which does not suffer such limit based on an not so well known VM hook. Ghost a proxy library is also available.
Removing Old Undo Framework
We removed the old undo framework and introduced a brand new one working really well. Thanks Alain Plantec
Now Set can contain nil.
Added lots of explicit exceptions for Collections errors (instead of just calling #error:)
Improved Smalltalk cleanUp, use it in #cleanUpForRelease.
SystemNavigation has been further enhanced to work with environments.
More class comments
Thanks to the wonderful idea of Laurent Laffont we started to systematically comment, uncommented classes!
Old Compiler
While we continued to work on OPAL and in particular its decompiler and various point between layers, we continued to integrate improvements to the old compiler.
Sync with Squeak trunk code base of old compiler
inline #whileTrue:
Cleaning FakePool usage
Old positional experiments removed from compiler
ifNotNil:, ifTrue: and friends are now added to the literal array and thus are shown when searching for "senders of".
Network
Some defined primitives were not used. Now they are.
Now we use the excellent package Zinc for the HTTP client/server for fetching packages.
Varia
Better systemVersion API
Mail support improvements.
Linux line breaking and copy and paste clipboard.
Serial plugin fixes got introduced.
We started to make sure that we can bootstrap the system. Some fixed points and hidden assumptions were identified and resolved.
We fixed all the senders of == to numbers, as == is not a test for numerical equality.
Add support for Threaded VMs in Process
Cleanup of Tests to make them usable in a continuous integration setting (e.g. remove PCCByCompilationTest)
Cleanups
The system continues to contain a lot of dead code. In the 1.3 release cycle we continued cleaning unused code. We use a combination of two strategies. For one, deprecating code (moving classes and methods to the Deprecated13 package). This allows clients to continue to use this code and slowly migrate. The second strategy is hard and radical deletion.
Cleaning of ChangeSet, ChangeSorter and related.
remove ExternalSettings. A third preferences subsystem that saved preferences in files (unused).
Deprecation of PCXReadWriter, as this format sees not much use these days.
Clean up MVC leftovers.
The removal of MVC allowed to do start a major cleanup related to the text model. Paragraph has been replaced by MultiNewParagraph everywhere, lots of unused code was removed from text and canvas classes.
We continued to clean some Etoy leftovers.
Uniclasses, which complicated the system considerably.
Imports, Tiles, random unused code.
We evaluated and cleaned the startup list and actions. We removed a lot of obsolete ones. Some should be fixed.
Duplicated code related to encoding of temps in CompiledMethods was removed. Simplifies considerably understanding (and future cleanup)
saving the image embedded in the vm executable has been removed. Simplifies image snapshot
Cursor cleaning.
Deprecated13 contains 26 classes, 786 Methods with over 5000 lines of Code.
Security
We removed the old security manager as it was not used. Better things will be added in the future.
As a start, there is a new way of dealing with plugin brings in more security and flexibility. Here are two new primitives which are added to the VM. SmalltalkImage>>loadModule: aModuleName loads a module of the given name. Fail if module cannot be found, or cannot be loaded, or failed to initialize. SmalltalkImage>>disableModuleLoading disables a new module loading mechanism for the rest of current session. This operation is not reversible. Any subsequent attempts to load either external or internal module(s) will fail.

New in Pharo 1.2 (Mar 9, 2012)

New in Pharo 1.1 (Mar 9, 2012)

Settings framework
Setting is a new Preference framework that supports modularity. No need to have a global Preference class anymore nor having the class Preference hardcoded everywhere. Settings lets you define advanced preferences without tying all the system to one class. Old preferences have been evaluated and migrated when necessary. Thanks Alain Plantec for this cool work.
New world menu
Menu items are declared using pragmas. That is, they are not hardcoded anymore and hence are easier to extend.
Core libraries
The collection hierachy has been refactored to have both Set and Dictionary a subclass of HashedCollection instead of having Dictionary a subclass of Set. Pharo now uses a better distributed identityHash for identity sets and dictionaries.
StandardFilestream now performs read-buffering, dramatically speading up some operations like "Object compileAll" (2x improvement) as well as various other operations (scanning change lists etc). This change was taken from Squeak.
A new extensible number parser hierharchy has been introduced NumberParser and its subclasses provide support for parsing and building numbers from strings and streams.
Smalltalk globals and system queries
SystemDictionary and SmalltalkImage have been refactored. Smalltalk is now an instance of SmalltalkImage, representing a facade for system-wide queries and actions. SmalltalkImage contains a global environment, an instance of SystemDictionary, which the environment used by classes. Thus, SmalltalkImage current == Smalltalk, Object environment == Smalltalk globals.
Compiler fixes and improvement
Selectors including minus are now parsed correctly. The parser was improve to reject some ill-defined expressions such as '#1' returning 1.
Cleanup and simplifications
Removal of the required/provided selectors computation code that was in the Traits package for historical reasons. This removes 17 classes with about 240 methods from PharoCore. The code is re-packaged and moved to SqueakSource.
A new general cleanup protocol has been added. The cleanUp protocol takes an optional argument to indicate whether we're doing an aggressive cleanup (which involves deleting projects, change sets, and possibly other destructive actions) or a more gentle cleanup that's only supposed to clean out transient caches. This change was taken from Squeak.
Improved modularization and smaller production image size
Many small changes in the packaging to get a better modularization (as a preparation for bootstrapping from a minimal kernel image). Repackaged methods holding icons and font definitions to produce smaller images (do "ScriptLoader new cleanUpForProduction"). The resulting image is only 6.2 MB.
Performance optimizations
Better Identity hashing, encoding conversions, collection changes, rendering speedups (e.g., through inlining a lot of common morph extensions and using Strike fonts by default)
Reading PNG images has been significantly sped up for some common cases. The improvements are in 50-200x range and heavily affect interactive uses of such files.
Exceptions
OutOfMemory has been added as a standard exception being signaled when an allocation fails, replacing the previous signaling of the low space semaphore. Improved #ensure: performance avoiding remote context manipulation (via #tempAt:put:) in the default case. This change was taken from Squeak.
SUnit
TestCase assert: show now only take booleans.
CompilerMethodFormat
We adopted the changes of Igor Stasenko to have a cleaner implementation of compiled method meta information.