Order of sending class side #initialize

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
12 messages Options
Reply | Threaded
Open this post in threaded view
|

Order of sending class side #initialize

Mariano Martinez Peck
Hi guys. I am doing some experiments with FuelPackageLoader and I have a problem with the initialization. All my unit tests pass but when trying to export/import seaside/pier/magritte, I have a problem.
What I do basically, is to ask Metacello the list of packages that I need to loaded for seaside and friends. The list is IN ORDER OF LOADING. So what I do during the import is to load each package in the correct order (the one Metacello told me). For each package I load, I initialize its classes (at the end of the load of the package). The order I initialize classes for a package is:

            ((aPackage classes select: [:each | each isBehavior])
                     sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
                         do: [:aClass |
                            Transcript show: 'Initializing class: ', aClass name; cr.
                            aClass initializeOnLoad]

and

Class >> initializeOnLoad
    (self class includesSelector: #initialize)
        ifTrue: [self initialize]


so...I am having a problem with seaside with a class and it looks like a problem of the order of the initialize. Do you think something is wrong with our approach? any idea?

thanks in advance,

--
Mariano
http://marianopeck.wordpress.com

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Dale Henrichs
Mariano,

To shed some light on the exact problem, I think that you should record the initialization order of a Metacello load and compare that to the initialization order that you are using.

While your algorithm looks like it is correct it doesn't necessarily match the actual initialization order you get when using Monticello and Metacello...

It would be interesting to find out where the differences in order are and then focus on understanding why...

Dale
 
----- Original Message -----
| From: "Mariano Martinez Peck" <[hidden email]>
| To: "Pharo Development" <[hidden email]>
| Sent: Saturday, May 19, 2012 11:25:57 AM
| Subject: [Pharo-project] Order of sending class side #initialize
|
| Hi guys. I am doing some experiments with FuelPackageLoader and I
| have a problem with the initialization. All my unit tests pass but
| when trying to export/import seaside/pier/magritte, I have a
| problem.
| What I do basically, is to ask Metacello the list of packages that I
| need to loaded for seaside and friends. The list is IN ORDER OF
| LOADING. So what I do during the import is to load each package in
| the correct order (the one Metacello told me). For each package I
| load, I initialize its classes (at the end of the load of the
| package). The order I initialize classes for a package is:
|
| ((aPackage classes select: [:each | each isBehavior])
| sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| do: [:aClass |
| Transcript show: 'Initializing class: ', aClass name; cr.
| aClass initializeOnLoad]
|
| and
|
| Class >> initializeOnLoad
| (self class includesSelector: #initialize)
| ifTrue: [self initialize]
|
|
| so...I am having a problem with seaside with a class and it looks
| like a problem of the order of the initialize. Do you think
| something is wrong with our approach? any idea?
|
| thanks in advance,
|
| --
| Mariano
| http://marianopeck.wordpress.com
|
|

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Dale Henrichs
Another data point is Lukas' build scripts for the Jenkins[1]. They use Gofer to load, but they "get the initialization correct", as does Metacello.

Dale

[1] https://github.com/renggli/builder/blob/master/scripts/seaside3.st

----- Original Message -----
| From: "Dale Henrichs" <[hidden email]>
| To: [hidden email]
| Sent: Saturday, May 19, 2012 12:01:38 PM
| Subject: Re: [Pharo-project] Order of sending class side #initialize
|
| Mariano,
|
| To shed some light on the exact problem, I think that you should
| record the initialization order of a Metacello load and compare that
| to the initialization order that you are using.
|
| While your algorithm looks like it is correct it doesn't necessarily
| match the actual initialization order you get when using Monticello
| and Metacello...
|
| It would be interesting to find out where the differences in order
| are and then focus on understanding why...
|
| Dale
|  
| ----- Original Message -----
| | From: "Mariano Martinez Peck" <[hidden email]>
| | To: "Pharo Development" <[hidden email]>
| | Sent: Saturday, May 19, 2012 11:25:57 AM
| | Subject: [Pharo-project] Order of sending class side #initialize
| |
| | Hi guys. I am doing some experiments with FuelPackageLoader and I
| | have a problem with the initialization. All my unit tests pass but
| | when trying to export/import seaside/pier/magritte, I have a
| | problem.
| | What I do basically, is to ask Metacello the list of packages that
| | I
| | need to loaded for seaside and friends. The list is IN ORDER OF
| | LOADING. So what I do during the import is to load each package in
| | the correct order (the one Metacello told me). For each package I
| | load, I initialize its classes (at the end of the load of the
| | package). The order I initialize classes for a package is:
| |
| | ((aPackage classes select: [:each | each isBehavior])
| | sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| | do: [:aClass |
| | Transcript show: 'Initializing class: ', aClass name; cr.
| | aClass initializeOnLoad]
| |
| | and
| |
| | Class >> initializeOnLoad
| | (self class includesSelector: #initialize)
| | ifTrue: [self initialize]
| |
| |
| | so...I am having a problem with seaside with a class and it looks
| | like a problem of the order of the initialize. Do you think
| | something is wrong with our approach? any idea?
| |
| | thanks in advance,
| |
| | --
| | Mariano
| | http://marianopeck.wordpress.com
| |
| |
|
|

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Mariano Martinez Peck
In reply to this post by Dale Henrichs


On Sat, May 19, 2012 at 9:01 PM, Dale Henrichs <[hidden email]> wrote:
Mariano,

To shed some light on the exact problem, I think that you should record the initialization order of a Metacello load and compare that to the initialization order that you are using.

While your algorithm looks like it is correct it doesn't necessarily match the actual initialization order you get when using Monticello and Metacello...

It would be interesting to find out where the differences in order are and then focus on understanding why...

Hi Dale. Well, I did that. I noticed 2 differences:

1) If the class already exist and the #initialize is the same, it is not re-executed. In my case, I execute it always. I know, this is a problem I have. Nevertheless, the only classes that already exist in the image I am loading is Zinc...and the problem does not seem related to that. 

2) The order of the classes/methods inside a package is different. I mean, I load the packages in order, but inside, for each package, the order I send #initialize is not the same as Monticello. Example:

My code:

Initializing class: WAKeyGenerator class
Initializing class: WAUrlEncoder class
Initializing class: WAServerManager class
Initializing class: WALocale class
Initializing class: WAResponse class
Initializing class: WAXmlEncoder class
Initializing class: WASystemConfiguration class
Initializing class: WASharedConfiguration class
Initializing class: WAAbstractFileLibrary class

Monticello:

Initialize class: (Seaside-Core-Libraries) -- WAAbstractFileLibrary
Initialize class: (Seaside-Core-Configuration) -- WASystemConfiguration
Initialize class: (Seaside-Core-Configuration) -- WASharedConfiguration
Initialize class: (Seaside-Core-Document) -- WAUrlEncoder
Initialize class: (Seaside-Core-Document) -- WAXmlEncoder
Initialize class: (Seaside-Core-Utilities) -- WAKeyGenerator
Initialize class: (Seaside-Core-HTTP) -- WALocale
Initialize class: (Seaside-Core-HTTP) -- WAResponse
Initialize class: (Seaside-Core-Server) -- WAServerManager

So...maybe this is the reason?  what I am thinking now that maybe the problem is not in the initialization but instead of export? I mean, maybe Monticello exports methods/classes with certain order and that's why it works?   because when exporting I am not using any order at all.

Thanks


 

Dale

----- Original Message -----
| From: "Mariano Martinez Peck" <[hidden email]>
| To: "Pharo Development" <[hidden email]>
| Sent: Saturday, May 19, 2012 11:25:57 AM
| Subject: [Pharo-project] Order of sending class side #initialize
|
| Hi guys. I am doing some experiments with FuelPackageLoader and I
| have a problem with the initialization. All my unit tests pass but
| when trying to export/import seaside/pier/magritte, I have a
| problem.
| What I do basically, is to ask Metacello the list of packages that I
| need to loaded for seaside and friends. The list is IN ORDER OF
| LOADING. So what I do during the import is to load each package in
| the correct order (the one Metacello told me). For each package I
| load, I initialize its classes (at the end of the load of the
| package). The order I initialize classes for a package is:
|
| ((aPackage classes select: [:each | each isBehavior])
| sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| do: [:aClass |
| Transcript show: 'Initializing class: ', aClass name; cr.
| aClass initializeOnLoad]
|
| and
|
| Class >> initializeOnLoad
| (self class includesSelector: #initialize)
| ifTrue: [self initialize]
|
|
| so...I am having a problem with seaside with a class and it looks
| like a problem of the order of the initialize. Do you think
| something is wrong with our approach? any idea?
|
| thanks in advance,
|
| --
| Mariano
| http://marianopeck.wordpress.com
|
|




--
Mariano
http://marianopeck.wordpress.com

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Mariano Martinez Peck
Here are the output of both scenarios.  Notice that my experiment finishes in WAWalkbackErrorHandler because there is where I have the error.

Thanks for any help.

On Sat, May 19, 2012 at 11:20 PM, Mariano Martinez Peck <[hidden email]> wrote:


On Sat, May 19, 2012 at 9:01 PM, Dale Henrichs <[hidden email]> wrote:
Mariano,

To shed some light on the exact problem, I think that you should record the initialization order of a Metacello load and compare that to the initialization order that you are using.

While your algorithm looks like it is correct it doesn't necessarily match the actual initialization order you get when using Monticello and Metacello...

It would be interesting to find out where the differences in order are and then focus on understanding why...

Hi Dale. Well, I did that. I noticed 2 differences:

1) If the class already exist and the #initialize is the same, it is not re-executed. In my case, I execute it always. I know, this is a problem I have. Nevertheless, the only classes that already exist in the image I am loading is Zinc...and the problem does not seem related to that. 

2) The order of the classes/methods inside a package is different. I mean, I load the packages in order, but inside, for each package, the order I send #initialize is not the same as Monticello. Example:

My code:

Initializing class: WAKeyGenerator class
Initializing class: WAUrlEncoder class
Initializing class: WAServerManager class
Initializing class: WALocale class
Initializing class: WAResponse class
Initializing class: WAXmlEncoder class
Initializing class: WASystemConfiguration class
Initializing class: WASharedConfiguration class
Initializing class: WAAbstractFileLibrary class

Monticello:

Initialize class: (Seaside-Core-Libraries) -- WAAbstractFileLibrary
Initialize class: (Seaside-Core-Configuration) -- WASystemConfiguration
Initialize class: (Seaside-Core-Configuration) -- WASharedConfiguration
Initialize class: (Seaside-Core-Document) -- WAUrlEncoder
Initialize class: (Seaside-Core-Document) -- WAXmlEncoder
Initialize class: (Seaside-Core-Utilities) -- WAKeyGenerator
Initialize class: (Seaside-Core-HTTP) -- WALocale
Initialize class: (Seaside-Core-HTTP) -- WAResponse
Initialize class: (Seaside-Core-Server) -- WAServerManager

So...maybe this is the reason?  what I am thinking now that maybe the problem is not in the initialization but instead of export? I mean, maybe Monticello exports methods/classes with certain order and that's why it works?   because when exporting I am not using any order at all.

Thanks


 

Dale

----- Original Message -----
| From: "Mariano Martinez Peck" <[hidden email]>
| To: "Pharo Development" <[hidden email]>
| Sent: Saturday, May 19, 2012 11:25:57 AM
| Subject: [Pharo-project] Order of sending class side #initialize
|
| Hi guys. I am doing some experiments with FuelPackageLoader and I
| have a problem with the initialization. All my unit tests pass but
| when trying to export/import seaside/pier/magritte, I have a
| problem.
| What I do basically, is to ask Metacello the list of packages that I
| need to loaded for seaside and friends. The list is IN ORDER OF
| LOADING. So what I do during the import is to load each package in
| the correct order (the one Metacello told me). For each package I
| load, I initialize its classes (at the end of the load of the
| package). The order I initialize classes for a package is:
|
| ((aPackage classes select: [:each | each isBehavior])
| sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| do: [:aClass |
| Transcript show: 'Initializing class: ', aClass name; cr.
| aClass initializeOnLoad]
|
| and
|
| Class >> initializeOnLoad
| (self class includesSelector: #initialize)
| ifTrue: [self initialize]
|
|
| so...I am having a problem with seaside with a class and it looks
| like a problem of the order of the initialize. Do you think
| something is wrong with our approach? any idea?
|
| thanks in advance,
|
| --
| Mariano
| http://marianopeck.wordpress.com
|
|




--
Mariano
http://marianopeck.wordpress.com




--
Mariano
http://marianopeck.wordpress.com


monticello.txt (4K) Download Attachment
myExperiment.rtf (3K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Dale Henrichs
In reply to this post by Mariano Martinez Peck
Okay,

Are you loading all of the classes (for all packages) before you run the initializers? ... I'm pretty sure that some of the initializations need to be run before subclasses are _loaded_.

Next, you should try to force your initialization order to match that of Metacello, if that doesn't help then something else is the root cause of your problems...

Dale

----- Original Message -----
| From: "Mariano Martinez Peck" <[hidden email]>
| To: [hidden email]
| Sent: Saturday, May 19, 2012 2:20:14 PM
| Subject: Re: [Pharo-project] Order of sending class side #initialize
|
|
|
|
| On Sat, May 19, 2012 at 9:01 PM, Dale Henrichs < [hidden email]
| > wrote:
|
|
| Mariano,
|
| To shed some light on the exact problem, I think that you should
| record the initialization order of a Metacello load and compare that
| to the initialization order that you are using.
|
| While your algorithm looks like it is correct it doesn't necessarily
| match the actual initialization order you get when using Monticello
| and Metacello...
|
| It would be interesting to find out where the differences in order
| are and then focus on understanding why...
|
|
| Hi Dale. Well, I did that. I noticed 2 differences:
|
| 1) If the class already exist and the #initialize is the same, it is
| not re-executed. In my case, I execute it always. I know, this is a
| problem I have. Nevertheless, the only classes that already exist in
| the image I am loading is Zinc...and the problem does not seem
| related to that.
|
| 2) The order of the classes/methods inside a package is different. I
| mean, I load the packages in order, but inside, for each package,
| the order I send #initialize is not the same as Monticello. Example:
|
| My code:
|
| Initializing class: WAKeyGenerator class
| Initializing class: WAUrlEncoder class
| Initializing class: WAServerManager class
| Initializing class: WALocale class
| Initializing class: WAResponse class
| Initializing class: WAXmlEncoder class
| Initializing class: WASystemConfiguration class
| Initializing class: WASharedConfiguration class
| Initializing class: WAAbstractFileLibrary class
|
| Monticello:
|
| Initialize class: (Seaside-Core-Libraries) -- WAAbstractFileLibrary
| Initialize class: (Seaside-Core-Configuration) --
| WASystemConfiguration
| Initialize class: (Seaside-Core-Configuration) --
| WASharedConfiguration
| Initialize class: (Seaside-Core-Document) -- WAUrlEncoder
| Initialize class: (Seaside-Core-Document) -- WAXmlEncoder
| Initialize class: (Seaside-Core-Utilities) -- WAKeyGenerator
| Initialize class: (Seaside-Core-HTTP) -- WALocale
| Initialize class: (Seaside-Core-HTTP) -- WAResponse
| Initialize class: (Seaside-Core-Server) -- WAServerManager
|
| So...maybe this is the reason? what I am thinking now that maybe the
| problem is not in the initialization but instead of export? I mean,
| maybe Monticello exports methods/classes with certain order and
| that's why it works? because when exporting I am not using any order
| at all.
|
| Thanks
|
|
|
|
|
| Dale
|
|
|
| ----- Original Message -----
| | From: "Mariano Martinez Peck" < [hidden email] >
| | To: "Pharo Development" < [hidden email] >
| | Sent: Saturday, May 19, 2012 11:25:57 AM
| | Subject: [Pharo-project] Order of sending class side #initialize
| |
| | Hi guys. I am doing some experiments with FuelPackageLoader and I
| | have a problem with the initialization. All my unit tests pass but
| | when trying to export/import seaside/pier/magritte, I have a
| | problem.
| | What I do basically, is to ask Metacello the list of packages that
| | I
| | need to loaded for seaside and friends. The list is IN ORDER OF
| | LOADING. So what I do during the import is to load each package in
| | the correct order (the one Metacello told me). For each package I
| | load, I initialize its classes (at the end of the load of the
| | package). The order I initialize classes for a package is:
| |
| | ((aPackage classes select: [:each | each isBehavior])
| | sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| | do: [:aClass |
| | Transcript show: 'Initializing class: ', aClass name; cr.
| | aClass initializeOnLoad]
| |
| | and
| |
| | Class >> initializeOnLoad
| | (self class includesSelector: #initialize)
| | ifTrue: [self initialize]
| |
| |
| | so...I am having a problem with seaside with a class and it looks
| | like a problem of the order of the initialize. Do you think
| | something is wrong with our approach? any idea?
| |
| | thanks in advance,
| |
| | --
| | Mariano
| | http://marianopeck.wordpress.com
| |
| |
|
|
|
|
| --
| Mariano
| http://marianopeck.wordpress.com
|
|

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Mariano Martinez Peck


On Sat, May 19, 2012 at 11:30 PM, Dale Henrichs <[hidden email]> wrote:
Okay,

Are you loading all of the classes (for all packages) before you run the initializers? ... I'm pretty sure that some of the initializations need to be run before subclasses are _loaded_.

Next, you should try to force your initialization order to match that of Metacello, if that doesn't help then something else is the root cause of your problems...



heheheheh I should stop sending crap emails to the mailing list. Once again, sorry for the noise. I was a problem in my own code. A default flag has the incorrect value and I was initializing twice...once after each packages and then once they all finished...

anyway, now it works :)

Thanks Dale for your patient

 
Dale

----- Original Message -----
| From: "Mariano Martinez Peck" <[hidden email]>
| To: [hidden email]
| Sent: Saturday, May 19, 2012 2:20:14 PM
| Subject: Re: [Pharo-project] Order of sending class side #initialize
|
|
|
|
| On Sat, May 19, 2012 at 9:01 PM, Dale Henrichs < [hidden email]
| > wrote:
|
|
| Mariano,
|
| To shed some light on the exact problem, I think that you should
| record the initialization order of a Metacello load and compare that
| to the initialization order that you are using.
|
| While your algorithm looks like it is correct it doesn't necessarily
| match the actual initialization order you get when using Monticello
| and Metacello...
|
| It would be interesting to find out where the differences in order
| are and then focus on understanding why...
|
|
| Hi Dale. Well, I did that. I noticed 2 differences:
|
| 1) If the class already exist and the #initialize is the same, it is
| not re-executed. In my case, I execute it always. I know, this is a
| problem I have. Nevertheless, the only classes that already exist in
| the image I am loading is Zinc...and the problem does not seem
| related to that.
|
| 2) The order of the classes/methods inside a package is different. I
| mean, I load the packages in order, but inside, for each package,
| the order I send #initialize is not the same as Monticello. Example:
|
| My code:
|
| Initializing class: WAKeyGenerator class
| Initializing class: WAUrlEncoder class
| Initializing class: WAServerManager class
| Initializing class: WALocale class
| Initializing class: WAResponse class
| Initializing class: WAXmlEncoder class
| Initializing class: WASystemConfiguration class
| Initializing class: WASharedConfiguration class
| Initializing class: WAAbstractFileLibrary class
|
| Monticello:
|
| Initialize class: (Seaside-Core-Libraries) -- WAAbstractFileLibrary
| Initialize class: (Seaside-Core-Configuration) --
| WASystemConfiguration
| Initialize class: (Seaside-Core-Configuration) --
| WASharedConfiguration
| Initialize class: (Seaside-Core-Document) -- WAUrlEncoder
| Initialize class: (Seaside-Core-Document) -- WAXmlEncoder
| Initialize class: (Seaside-Core-Utilities) -- WAKeyGenerator
| Initialize class: (Seaside-Core-HTTP) -- WALocale
| Initialize class: (Seaside-Core-HTTP) -- WAResponse
| Initialize class: (Seaside-Core-Server) -- WAServerManager
|
| So...maybe this is the reason? what I am thinking now that maybe the
| problem is not in the initialization but instead of export? I mean,
| maybe Monticello exports methods/classes with certain order and
| that's why it works? because when exporting I am not using any order
| at all.
|
| Thanks
|
|
|
|
|
| Dale
|
|
|
| ----- Original Message -----
| | From: "Mariano Martinez Peck" < [hidden email] >
| | To: "Pharo Development" < [hidden email] >
| | Sent: Saturday, May 19, 2012 11:25:57 AM
| | Subject: [Pharo-project] Order of sending class side #initialize
| |
| | Hi guys. I am doing some experiments with FuelPackageLoader and I
| | have a problem with the initialization. All my unit tests pass but
| | when trying to export/import seaside/pier/magritte, I have a
| | problem.
| | What I do basically, is to ask Metacello the list of packages that
| | I
| | need to loaded for seaside and friends. The list is IN ORDER OF
| | LOADING. So what I do during the import is to load each package in
| | the correct order (the one Metacello told me). For each package I
| | load, I initialize its classes (at the end of the load of the
| | package). The order I initialize classes for a package is:
| |
| | ((aPackage classes select: [:each | each isBehavior])
| | sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| | do: [:aClass |
| | Transcript show: 'Initializing class: ', aClass name; cr.
| | aClass initializeOnLoad]
| |
| | and
| |
| | Class >> initializeOnLoad
| | (self class includesSelector: #initialize)
| | ifTrue: [self initialize]
| |
| |
| | so...I am having a problem with seaside with a class and it looks
| | like a problem of the order of the initialize. Do you think
| | something is wrong with our approach? any idea?
| |
| | thanks in advance,
| |
| | --
| | Mariano
| | http://marianopeck.wordpress.com
| |
| |
|
|
|
|
| --
| Mariano
| http://marianopeck.wordpress.com
|
|




--
Mariano
http://marianopeck.wordpress.com

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Ben Coman
In reply to this post by Mariano Martinez Peck
Mariano Martinez Peck wrote:

> Hi guys. I am doing some experiments with FuelPackageLoader and I have a
> problem with the initialization. All my unit tests pass but when trying to
> export/import seaside/pier/magritte, I have a problem.
> What I do basically, is to ask Metacello the list of packages that I need
> to loaded for seaside and friends. The list is IN ORDER OF LOADING. So what
> I do during the import is to load each package in the correct order (the
> one Metacello told me). For each package I load, I initialize its classes
> (at the end of the load of the package). The order I initialize classes for
> a package is:
>
>             ((aPackage classes select: [:each | each isBehavior])
>                      sort: [:a :b | a allSuperclasses size < b
> allSuperclasses size ])
>                          do: [:aClass |
>                             Transcript show: 'Initializing class: ', aClass
> name; cr.
>                             aClass initializeOnLoad]
>
> and
>
> Class >> initializeOnLoad
>     (self class includesSelector: #initialize)
>         ifTrue: [self initialize]
>
>
> so...I am having a problem with seaside with a class and it looks like a
> problem of the order of the initialize. Do you think something is wrong
> with our approach? any idea?
>
> thanks in advance,
>
>  
I guess if you have two inheritance paths A <-- B --< C and A <-- B <--
D and C depends on D then an #initialize order of A, B, C, D is
problematic. Some naive musings...
1. Have a mechanism to lazily invoke #initialize only when the class is
first referenced.  One way may be to load classes into a holding area in
the image but install a proxy class that when referenced replaces itself
with the one from the holding area.  Your above code will ensure this
happens for each loaded class by the end of the package load.
2. Parse the #initialize of C and D to determine dependency graph - but
perhaps this is not statically defined.
3. Specify a requirement for #initialize code to hardcode a call to
#initialize for any class it depends on.
4. Require packages to implement something like #initializeDependent to
make them compatible with Fuel.
I imagine the bootstrapping project has to solve a similar issue and
pehaps share an approach.

cheers -ben



Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Dale Henrichs
In reply to this post by Mariano Martinez Peck
Mariano,

No problem, man! Sometimes you've got to "talk out loud" to figure out what you are doing wrong, I know that I do that often enough myself ...

Dale

----- Original Message -----
| From: "Mariano Martinez Peck" <[hidden email]>
| To: [hidden email]
| Sent: Saturday, May 19, 2012 2:43:35 PM
| Subject: Re: [Pharo-project] Order of sending class side #initialize
|
|
|
|
| On Sat, May 19, 2012 at 11:30 PM, Dale Henrichs < [hidden email]
| > wrote:
|
|
| Okay,
|
| Are you loading all of the classes (for all packages) before you run
| the initializers? ... I'm pretty sure that some of the
| initializations need to be run before subclasses are _loaded_.
|
| Next, you should try to force your initialization order to match that
| of Metacello, if that doesn't help then something else is the root
| cause of your problems...
|
|
|
|
|
| heheheheh I should stop sending crap emails to the mailing list. Once
| again, sorry for the noise. I was a problem in my own code. A
| default flag has the incorrect value and I was initializing
| twice...once after each packages and then once they all finished...
|
| anyway, now it works :)
|
| Thanks Dale for your patient
|
|
|
|
| Dale
|
| ----- Original Message -----
| | From: "Mariano Martinez Peck" < [hidden email] >
|
|
| | To: [hidden email]
| | Sent: Saturday, May 19, 2012 2:20:14 PM
| | Subject: Re: [Pharo-project] Order of sending class side
| | #initialize
| |
| |
| |
| |
| | On Sat, May 19, 2012 at 9:01 PM, Dale Henrichs <
| | [hidden email]
| | > wrote:
| |
| |
| | Mariano,
| |
| | To shed some light on the exact problem, I think that you should
| | record the initialization order of a Metacello load and compare
| | that
| | to the initialization order that you are using.
| |
| | While your algorithm looks like it is correct it doesn't
| | necessarily
| | match the actual initialization order you get when using Monticello
| | and Metacello...
| |
| | It would be interesting to find out where the differences in order
| | are and then focus on understanding why...
| |
| |
| | Hi Dale. Well, I did that. I noticed 2 differences:
| |
| | 1) If the class already exist and the #initialize is the same, it
| | is
| | not re-executed. In my case, I execute it always. I know, this is a
| | problem I have. Nevertheless, the only classes that already exist
| | in
| | the image I am loading is Zinc...and the problem does not seem
| | related to that.
| |
| | 2) The order of the classes/methods inside a package is different.
| | I
| | mean, I load the packages in order, but inside, for each package,
| | the order I send #initialize is not the same as Monticello.
| | Example:
| |
| | My code:
| |
| | Initializing class: WAKeyGenerator class
| | Initializing class: WAUrlEncoder class
| | Initializing class: WAServerManager class
| | Initializing class: WALocale class
| | Initializing class: WAResponse class
| | Initializing class: WAXmlEncoder class
| | Initializing class: WASystemConfiguration class
| | Initializing class: WASharedConfiguration class
| | Initializing class: WAAbstractFileLibrary class
| |
| | Monticello:
| |
| | Initialize class: (Seaside-Core-Libraries) -- WAAbstractFileLibrary
| | Initialize class: (Seaside-Core-Configuration) --
| | WASystemConfiguration
| | Initialize class: (Seaside-Core-Configuration) --
| | WASharedConfiguration
| | Initialize class: (Seaside-Core-Document) -- WAUrlEncoder
| | Initialize class: (Seaside-Core-Document) -- WAXmlEncoder
| | Initialize class: (Seaside-Core-Utilities) -- WAKeyGenerator
| | Initialize class: (Seaside-Core-HTTP) -- WALocale
| | Initialize class: (Seaside-Core-HTTP) -- WAResponse
| | Initialize class: (Seaside-Core-Server) -- WAServerManager
| |
| | So...maybe this is the reason? what I am thinking now that maybe
| | the
| | problem is not in the initialization but instead of export? I mean,
| | maybe Monticello exports methods/classes with certain order and
| | that's why it works? because when exporting I am not using any
| | order
| | at all.
| |
| | Thanks
| |
| |
| |
| |
| |
| | Dale
| |
| |
| |
| | ----- Original Message -----
| | | From: "Mariano Martinez Peck" < [hidden email] >
| | | To: "Pharo Development" < [hidden email] >
| | | Sent: Saturday, May 19, 2012 11:25:57 AM
| | | Subject: [Pharo-project] Order of sending class side #initialize
| | |
| | | Hi guys. I am doing some experiments with FuelPackageLoader and I
| | | have a problem with the initialization. All my unit tests pass
| | | but
| | | when trying to export/import seaside/pier/magritte, I have a
| | | problem.
| | | What I do basically, is to ask Metacello the list of packages
| | | that
| | | I
| | | need to loaded for seaside and friends. The list is IN ORDER OF
| | | LOADING. So what I do during the import is to load each package
| | | in
| | | the correct order (the one Metacello told me). For each package I
| | | load, I initialize its classes (at the end of the load of the
| | | package). The order I initialize classes for a package is:
| | |
| | | ((aPackage classes select: [:each | each isBehavior])
| | | sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
| | | do: [:aClass |
| | | Transcript show: 'Initializing class: ', aClass name; cr.
| | | aClass initializeOnLoad]
| | |
| | | and
| | |
| | | Class >> initializeOnLoad
| | | (self class includesSelector: #initialize)
| | | ifTrue: [self initialize]
| | |
| | |
| | | so...I am having a problem with seaside with a class and it looks
| | | like a problem of the order of the initialize. Do you think
| | | something is wrong with our approach? any idea?
| | |
| | | thanks in advance,
| | |
| | | --
| | | Mariano
| | | http://marianopeck.wordpress.com
| | |
| | |
| |
| |
| |
| |
| | --
| | Mariano
| | http://marianopeck.wordpress.com
| |
| |
|
|
|
|
| --
| Mariano
| http://marianopeck.wordpress.com
|
|

Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Stéphane Ducasse
In reply to this post by Mariano Martinez Peck
so now that this is working: what is the process you follow?
Initialize after each package?

Stef
On May 19, 2012, at 8:25 PM, Mariano Martinez Peck wrote:

> Hi guys. I am doing some experiments with FuelPackageLoader and I have a problem with the initialization. All my unit tests pass but when trying to export/import seaside/pier/magritte, I have a problem.
> What I do basically, is to ask Metacello the list of packages that I need to loaded for seaside and friends. The list is IN ORDER OF LOADING. So what I do during the import is to load each package in the correct order (the one Metacello told me). For each package I load, I initialize its classes (at the end of the load of the package). The order I initialize classes for a package is:
>
>             ((aPackage classes select: [:each | each isBehavior])
>                      sort: [:a :b | a allSuperclasses size < b allSuperclasses size ])
>                          do: [:aClass |
>                             Transcript show: 'Initializing class: ', aClass name; cr.
>                             aClass initializeOnLoad]
>
> and
>
> Class >> initializeOnLoad
>     (self class includesSelector: #initialize)
>         ifTrue: [self initialize]
>
>
> so...I am having a problem with seaside with a class and it looks like a problem of the order of the initialize. Do you think something is wrong with our approach? any idea?
>
> thanks in advance,
>
> --
> Mariano
> http://marianopeck.wordpress.com
>


Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Edgar De Cleene
In reply to this post by Mariano Martinez Peck
Re: [Pharo-project] Order of sending class side #initialize


On 5/19/12 6:20 PM, "Mariano Martinez Peck" <[hidden email]> wrote:

because when exporting I am not using any order at all.


Hey Mariano:

IMHO you SHOULD use a exporting order and this could be the same when you export a plain .cs.

All you working on Fuel and Injectorare doing a great job !!!


Edgar
Reply | Threaded
Open this post in threaded view
|

Re: Order of sending class side #initialize

Mariano Martinez Peck


On Sun, May 20, 2012 at 1:51 PM, Edgar J. De Cleene <[hidden email]> wrote:



On 5/19/12 6:20 PM, "Mariano Martinez Peck" <[hidden email]> wrote:

because when exporting I am not using any order at all.


Hey Mariano:

IMHO you SHOULD use a exporting order and this could be the same when you export a plain .cs.

All you working on Fuel and Injectorare doing a great job !!!


Hi. Answering to both you and Stef. What I found that works (at least with Seaside/Pier/Magritte) is to LOAD ALL packages first, and then send #initialize to classes, ordered by package.

Example, Metacello told me the order of packages to load/initialize are  PackageA, PackageC, PackageB.
So, when I import I do:

load PackageA
load PackageC
load PackageB
send #initialize to classes of PackageA.
send #initialize to classes of PackageC.
send #initialize to classes of PackageB.


If I do, instead,

load PackageA
send #initialize to classes of PackageA.
load PackageC
send #initialize to classes of PackageC.
load PackageB
send #initialize to classes of PackageB.

it does not work. I guess this is because of what Dale said.

Cheers

--
Mariano
http://marianopeck.wordpress.com