Styjun

What is the difference between

Rectangle origin: 5@5 extent: 40@30

and

Rectangle new origin: 5@5 extent: 40@30

Rectangle new origin: 5@5 extent: 40@30 creates a fully-initialized instance of a Rectangle (to be precise with all coordinates set to 0) and then sets its coordinates and extent with the origin:extend: accessor method.

Rectangle origin: 5@5 extent: 40@30 has the class Rectangle construct a Rectangle instance with the given attributes however it sees fit. In the case of GNU Smalltalk, it uses the basicNew message to allocate the Rectangle instance instead of new (see the source of Rectangle). That forgoes the "fully-initialized instance" state of the variant above: it skips any initialization and just allocates the memory (well, the GNU Smalltalk docs don't say so explicitly, but that is traditionally the purpose of basicNew). Then it uses the origin:extend: accessor to initialize the coordinates and extent of the new instance.

It's a matter of style. The Rectangle class provides a facility method for creating an instance, so that you can communicate directly with the class and write less code. It's also a good practice as you create the rectangle object with all it needs to work correctly (this practice is called RAII, resource acquisition is initialization). If you have a look at the source of Rectangle class>>#origin:extent: you'll find something very much like

origin: aPoint extent: anotherPoint
 ^self new origin: aPoint extent: anotherPoint

So actually sending the message directly to the class o creating it manually and then setting it is in practice the same

I think it is important to note the difference between Smalltalk and other OO languages.

In other OO languages you have a construct called a constructor. Which enables you to automatically run certain code when you call method new.

For example, in ruby you would do

# Class name 
class ConstructorExample 
 # A constructor 
 def initialize 
 puts "I'm now running constructor"
 end 
end 

# Creating Object 
ConstructorExample.new # upon which calling you will get initialized run automatically.

The output would be in your shell:

> I'm now running constructor

In Smalltalk you have to differenciate between new and basicNew. (Sometimes even new is only alias for basicNew so you have to run initialize manually
or create class method. The basicNew does not execute the initialize automatically, the new usually does (not all dialects!).

The above example could be then written as:

Object subclass:#ConstructorExample
 instanceVariableNames:''
 classVariableNames:''
 poolDictionaries:''
 category: ''

ConstructorExample>>initialize
 Transcript showCR: 'I'm now running a constructor'


"You would then instantiate"
ConstructorExample new

or

| example |
example := ConstructorExample basicNew.
example initialize "sending method initialize like any other method"

In both cases the output would be (in your Transcript):

I'm now running a constructor

The main reason for that, in my eyes, is that you can run constructor after some of your custom code if you have class method

ConstructorExample class >> run
 ^ self basicNew; Transcript showCR: 'Running before constructor'; self initialize; yourself

Then you would simply do:

ConstructorExample run

The output would be:

Running before constructor
I'm now running a constructor

Now to your example

As JayK, melkyades explained the main differences I'll give more suttle differences (details) on those:

First:

Rectangle new origin: 5@5 extent: 40@30

What it actually does it this (without the Transcript showCR:):

| myRactangle |
myRactangle := Ractangle new. "Creates an empty instance with origin: 0 @ 0 corner: 0 @ 0 and would execute initialize if there would be one." 
Transcript showCR: 'Current origin: ', origin asString, 'with corner: ', corner asString. "You should see the zeros"
myRactangle origin: 5@5 extent: 40@30
Transcript showCR: 'Current origin: ', origin asString, 'with corner: ', corner asString. "You should your custom point(s)"

What happens when you do Ractangle new?

Rectangle class >> new [
 "Answer the (0 @ 0 corner: 0 @ 0) rectangle"

 <category: 'instance creation'>
 ^self origin: 0 @ 0 corner: 0 @ 0
]

When you check the source code it sets origin: 0 @ 0 corner: 0 @ 0 (notice the difference setting it via ...corner: and not extent:).

Second:

Rectangle origin: 5@5 extent: 40@30

The source code:

Rectangle class >> origin: originPoint extent: extentPoint
 "Answer a rectangle with the given origin and size"

 <category: 'instance creation'>
 ^self basicNew origin: originPoint corner: originPoint + extentPoint

As pointed-out already there is a basicNew which prevents the any initialize constuctor to be run manually or via class method like I showed above.

What you could do it rewrite it if you needed. You would create your own rectangle class which would inherit it from Rectangle and rewrite it there.

For example:

Rectangle subclass:#ApplicationRectangle
 instanceVariableNames:''
 classVariableNames:''
 poolDictionaries:''
 category: ''

where you would define:

ApplicationRectangle class >> origin: originPoint extent: extentPoint
 "Answer a rectangle with the given origin and size"

 <category: 'instance creation'>
 ^self new origin: originPoint corner: originPoint + extentPoint

You would then call it:

ApplicationRectangle origin: 5@5 extent: 40@30