yes but we are focusing on bootstrap and we cannot do deep first :)
Doing a pass on systemnavigation will help.
And having the dependencies in the right order would help too.

Le 10/9/15 23:01, Tudor Girba a écrit :
I think SystemNavigation should essentially dissolve in the near future. Moose used to have one of these some 10 years ago, and now all queries are implemented as fluent APIs distributed throughout the model classes. I would want the Pharo code model should move in the same direction.

Doru

On Thu, Sep 10, 2015 at 8:29 PM, stepharo <steph...@free.fr <mailto:steph...@free.fr>> wrote:

    Pragma should not depend on SystemNavigation. The inverse


    Le 10/9/15 19:44, Ben Coman a écrit :

        On Fri, Sep 11, 2015 at 12:43 AM, Max Leske
        <maxle...@gmail.com <mailto:maxle...@gmail.com>> wrote:

                On 10 Sep 2015, at 17:22, Ben Coman
                <b...@openinworld.com> wrote:

                The bootstrap-dependency graph and report [1] mark
                dependency
                System-Announcements --> PragmaCollector for pruning.
                This is due to...

                    SystemAnnouncer>>restoreAllNotifications
                        | collector |
                        self reset.
                        collector := PragmaCollector filter: [ :pragma |
                             pragma keyword = #systemEventRegistration ].
                        collector reset.
                        collector do: [ :pragma |
                             pragma methodClass theNonMetaClass
                perform: pragma selector ]

                Browsing around I came to understand that
                PragmaCollector is useful as
                a pragma cache, but here the collector is thrown away,
                so that
                facility is not needed. A key part is "collector
                reset" which does...
                    self class allSystemPragmas
                        do: [:pragma | self addPragma: pragma]

                where the #addPragma: evaluates the initialize'd
                #filter: block. Now
                it seems that #allSystemPragmas might fit nicely on
                Pragma rather than
                PragmaCollector
                such that the following should be equivalent...

                    SystemAnnouncer>>restoreAllNotifications
                        | systemPragmas |
                        self reset.
                        systemPragmas := Pragma allSystemPragmas
                collect: [ :pragma |
                              pragma keyword = #systemEventRegistration ].
                        systemPragmas do: [ :pragma |
                              pragma methodClass theNonMetaClass
                perform: pragma selector

            Cool. I like that better.

                However #allSystemPragmas depends on SystemNavigation,
                so is it be
                okay for Pragma to depend on SystemNavigation?

            Spontaneously I’d say that SystemNavigation should depend
            on Pragma or PragmaCollector for looking up pragmas, not
            the other way around.

        So you mean something like...

             SystemAnnouncer>>restoreAllNotifications
                 self reset.
                 SystemNavigation allPragmasNamed:
        #systemEventRegistration do:
        [ :pragma |
                       pragma methodClass theNonMetaClass perform:
        pragma selector ].

        where...

             SystemNavigation>>allPragmasNamed: symbol do: aBlock
                 | systemPragmas |
                 systemPragmas :=
                      self allSystemPragmas collect: [ :pragma |
        pragma keyword
        = symbol ].
                 systemPragmas do: [ :pragma |
                       pragma methodClass theNonMetaClass perform:
        pragma selector

             SystemNavigation>>allSystemPragmas
                 ^ (Array
                     streamContents: [:stream |
                         self allBehaviorsDo: [:behavior |
                             Pragma
                                 withPragmasIn: behavior
                                 do: [:pragma | stream nextPut: pragma]]])

        cheers -ben


                Actually, class side of Pragma has several #named:in:
                like methods, so
                something like the following would be neat...
                    SystemAnnouncer>>restoreAllNotifications
                        self reset.
                        Pragma allNamed: #systemEventRegistration do:
                [ :pragma |
                              pragma methodClass theNonMetaClass
                perform: pragma selector ].







--
www.tudorgirba.com <http://www.tudorgirba.com>

"Every thing has its own flow"

Reply via email to