On 2012-07-06 07:02 , David Karger wrote:
>
> On 7/6/2012 3:51 AM, Ryan Lee wrote:
>> On 2012-07-05 17:47 , David Karger wrote:
>>> Here's another question/issue. The current e3 approach of associating
>>> everything with events does a nice job of keeping everything
>>> independent, but what if that's not what we want? For example, there's
>>> a "registerStaticComponents" event that gets triggered when it is time
>>> for static components to be registered. But since we then leave it up to
>>> the individual static components to register themselves, there's no way
>>> for my library to say "I want to run after all the static components are
>>> registered" (which I think is what I want to do).
>> I would say there's an event missing, something like
>> registerStaticComponentsFinished. If that's something you need or if
>> there's some other piece of the events picture that seems incomplete,
>> I'm happy to look into it.
> 1. I'm not sure the name registerStaticComponentsFinished captures the
> semantics of "the entire exhibit codebase is now initialized, and we are
> now ready to do anything with exhibit that does on rely on information
> specific to this page". Whether you stick with events or implement
> specific stages, I think it would help to define some higher level event
> names. In particular if a new initialization stage with new event names
> is added in the future, it would be nice not to have to modify too much
> code to listen for a different event. You've already got an implied
> set of higher-level events in the headings of the scripted event api.
So come up with some abstract names you think are worthwhile and point
out where they seem to fit best. Your phrasing makes it sound like this
is entirely on me; if you've got something you want to accomplish, I'm
probably not going to be able to guess how to get there correctly.
> 2. Since static components are currently registered based on their
> listening for a "registerStaticComponents.exhibit" event, and you have
> no way of knowing who is listening, how are you going to know that
> registrations are complete in order to trigger the proposed new event?
> Since we impose no contract on the listeners, it's possible that some of
> them are asynchronous and are not finished when
> trigger("registerStaticComponents.exhibit") returns. I suggested phases
> as a way to require that every component provide both an "I am starting
> registration" and "I am finished registration" indicator.
Static component registration is, for Exhibit's initializing purposes,
effectively instant. The code is both loaded and evaluated by the time
the signal goes out, and registration is simply informing Exhibit that
those static classes exist. In your paradigm, it would be calling start
immediately followed by end. Exhibit has no need to do anything with
the static components after they've registered, which is why there's no
signal for it and no design around that occurrence.
I did consider the exact drawback you're hammering on, and given what I
just described, it seemed reasonable to let it be. If you have some
specific case for me to look at that illustrates that it could be
better, by all means, let's see if some events are better made to be
blocking and synchronous instead of reinventing everything.
>>> An alternative would be to define a set of clear "stages" in exhibit,
>>> such as loading, initialization, configuration, and user interaction,
>>> allow a given module to indicate that a certain function should run
>>> during a certain stage, and then declare that stage over after all
>>> functions allocated to it have finished. This does yoke components
>>> together more closely, but perhaps that is a good thing?
>> If you think this is a good thing, I'm also happy to look over a pull
>> request. I've already made what I consider a good choice for making
>> Exhibit accessible to other code - one of the worst parts of Exhibit 2
>> was trying to hook into its behavior without simply overwriting every
>> available function, which is fragile and ended up being the way it had
>> to be - but if you've got something you think is better, write it up so
>> we can make a comparison.
> This proposed design change would obviously require a lot of code
> changes. So I figured it would be worth deciding whether it would be a
> good idea *before* making all the changes. Pull request are a great way
> to propose small code changes but not such a great way to propose
> high-level design changes.
There is certainly a risk involved in investing effort into a branch
that doesn't ultimately get adopted.
Let me be more clear: the time for these design discussions was a rather
long time ago. If you want to revisit them, that's your experiment to
undertake. Convince me with code your ideas are worth following or
settle down and help improve what's already there. It seems to me that
it's quite possible it doesn't need to be thrown away wholesale for an
entirely new branch.
>>> On 7/5/2012 6:02 PM, Ryan Lee wrote:
>>>> As a follow on, I've already pushed an experiment using the <link>
>>>> method I discussed. We're currently considering other libraries to
>>>> help
>>>> manage dependencies, too (cf., RequireJS).
>>>>
>>>> On 2012-06-05 14:31 , David Karger wrote:
>>>>> Ryan, of the scenarios you propose, I'd advocate the principle that
>>>>> the
>>>>> user should never need to write js just to load extensions. I don't
>>>>> know enough about labjs to be sure but I think this rules out
>>>>> direct use
>>>>> of labjs, and possibly the exhibt-specific version. On the other
>>>>> hand,
>>>>> if there were a way to use labjs "invisibly", embedding its
>>>>> invocations
>>>>> inside the exhibit api and extensinos, it would be great.
>>>> LABjs has been in use within the Exhibit 3 codebase since it was
>>>> started. The problem with merely embedding it in Exhibit and then
>>>> allowing the specifying of extensions outside of that scheme is [see
>>>> all
>>>> of previous message].
>>>>
>>>>> An option you didn't mention would be to incorporate a "just in time"
>>>>> approach to the extensions. As you say, exhibit runs into problems
>>>>> when
>>>>> if it starts running before all extensions have loaded. But more
>>>>> specifically, the problem only occurs when it tries to use the
>>>>> functionality offered by the extension. Canonical examples include
>>>>> trying to generate a view provided by an extension that hasn't loaded
>>>>> yet, or to import data using an importer that hasn't loaded yet. What
>>>>> if exhibit were designed such that, if it got into that situation, it
>>>>> simply registered a callback to be invoked when the necessary
>>>>> functionality was available? e.g., view rendering could be gated by a
>>>>> "require" method that wouldn't run its argument until a corresponding
>>>>> "provide" method was called. I think this is the kind of
>>>>> functionality
>>>>> offered by labjs, right? So as long as extension authors followed the
>>>>> right design pattern, invoking labjs at the right moment, we'd be ok.
>>>> No, not at all. LABjs documentation is brief and readily available, I
>>>> suggest you read it before making suggestions on how it might be
>>>> applied.
>>>>
>>>> Making a UI seem responsive even if it isn't all there is a great
>>>> way to
>>>> design things, but what was under discussion was load ordering - not
>>>> load transport delays. Comparing loading Exhibit, loading extensions,
>>>> loading data, and parsing data, network costs of loading extensions is
>>>> highly unlikely to be the reason the UI is blocked. It may interfere
>>>> due to indeterminate ordering; it is far less likely that it interferes
>>>> due to transport matters.
>>>>
>>>> Still, if you want to redesign all of Exhibit along those lines, I'm
>>>> happy to look over a pull request. Making Exhibit initialization as
>>>> asynchronous as possible is a worthwhile goal.
>>>>
>>>>> Of course, you'd want to handle the case of the necessary element
>>>>> *never* being provided---but I think the page's load event, which
>>>>> tells
>>>>> you all scripts are loaded, could be used to trigger a "timeout" that
>>>>> would signal an error if some necessary functionality were still
>>>>> missing
>>>>> at that point.
>>>> This isn't related to the general topic, but as it pertains to Exhibit,
>>>> "the page's load event" does not tell you all the scripts are loaded.
>>>> Exhibit's capacity to load additional scripts means the page load event
>>>> (which specific one you're referring to is unclear) is definitely not a
>>>> reliable indicator of completion. Exhibit itself (now reliably) fires
>>>> its own scripts loaded event.
>>>>
>>>>> I agree with you that it's premature to rely on "async" loading, and
>>>>> that inline-extensions would be come a parameter management nightmare.
>>>>>
>>>>> An alternative to abusing link tags is abusing script tags. One could
>>>>> add an attribute <script ex:role="extension" src=...>; exhibit could
>>>>> find such tags and use them to detect scripts it should wait for
>>>>> (using
>>>>> onload events) before running. On the other hand, for fastest
>>>>> response
>>>>> it would be better to use the just in time approach discussed before,
>>>>> since that would allow exhibit to quickly render its initial view even
>>>>> if other views in the viewpanel require specific extensions.
>>>> Using script tags just comes back to the original problem that brought
>>>> us here, of browsers handling how they load scripts differently. If
>>>> you
>>>> want Exhibit to get to the tags before the browsers themselves do, you
>>>> go back to the bad days of working with each browser's DOM ready event
>>>> and DOM manipulation inconsistencies to find them.
>>>>
>>>>> On 05/11/2012 03:08 PM, Ryan Lee wrote:
>>>>>> Hi all,
>>>>>>
>>>>>> We've traced this down to a problem with the current extension
>>>>>> loading
>>>>>> mechanism. In an attempt to keep things from shifting too much
>>>>>> between
>>>>>> Exhibit 2 and Exhibit 3, I tried to allow for the form:
>>>>>>
>>>>>> <script src="exhibit-api.js">
>>>>>> <script src="extensions/map-extension.js">
>>>>>>
>>>>>> But, with the varied ways released browsers now handle the script
>>>>>> tag,
>>>>>> this introduces a potential network delay in loading everything in
>>>>>> the
>>>>>> right order; sometimes the map code gets loaded after Exhibit's
>>>>>> started
>>>>>> to initialize itself, which is too late.
>>>>>>
>>>>>> You probably weren't expecting design proposals to your question,
>>>>>> but it
>>>>>> seems an opportune time to share what I've been kicking around the
>>>>>> past
>>>>>> couple of days, each with its own strengths and weaknesses.
>>>>>>
>>>>>> * Use LABjs
>>>>>>
>>>>>> In this scenario, the only script src tag will be to load the LABjs
>>>>>> library, then use its loading framework inline to bring everything
>>>>>> related to Exhibit, including extensions, in in an orderly fashion.
>>>>>> The
>>>>>> major drawback here is that it forces users who don't necessarily
>>>>>> care
>>>>>> at all about code to pay attention to the actual scripting. For
>>>>>> those
>>>>>> who do pay attention, it makes things a bit easier to incorporate
>>>>>> extra-Exhibit material into the loading process.
>>>>>>
>>>>>> A related scenario would be to mask LABjs entirely with an
>>>>>> Exhibit-specific mechanism, but this only really adds a layer that
>>>>>> might
>>>>>> allow an easier departure from LABjs if needed in the future.
>>>>>>
>>>>>> * Use async / defer
>>>>>>
>>>>>> HTML 5 introduces attributes to the script tag that allow the page
>>>>>> author to give hints to the browser about whether some scripts can
>>>>>> load
>>>>>> without dependency on one another and whether some need to be run in
>>>>>> the
>>>>>> order they appear in. But support is not universal across browsers.
>>>>>>
>>>>>> * Abuse link rel
>>>>>>
>>>>>> Instead of listing extensions (or other scripts) as actual script
>>>>>> tags,
>>>>>> just point to them with
>>>>>>
>>>>>> <link rel="exhibit-extension" href="...">
>>>>>>
>>>>>> and let Exhibit pick out and load extensions itself during its
>>>>>> loading
>>>>>> process. Other than the fact that I've never seen anybody
>>>>>> use<link> in
>>>>>> this way, this might be the simplest and least obtrusive solution I
>>>>>> could think of. It does tend to make it even harder for those who
>>>>>> don't
>>>>>> control the<head> of a document to get Exhibit in.
>>>>>>
>>>>>> * Cram in more parameters
>>>>>>
>>>>>> Instead of listing each extension separately, they could also be
>>>>>> set as
>>>>>> additional parameters to the core of Exhibit
>>>>>>
>>>>>> <script
>>>>>> src="exhibit-api.js?extension=extensions/map-extension.js">
>>>>>>
>>>>>> which (aside from taking some steps backwards into Exhibit's
>>>>>> history) is
>>>>>> not as dubious as the prior proposal but makes that one line
>>>>>> difficult
>>>>>> to read and assemble and additionally makes it difficult for the
>>>>>> extensions themselves to extract any of their own parameters; it
>>>>>> would
>>>>>> probably require an ad hoc solution for adding extension-only
>>>>>> parameters.
>>>>>>
>>>>>>
>>>>>>
>>>>>> If you have any other ideas or feedback on the above, I'd love to
>>>>>> hear
>>>>>> from you (or get a pull request from you on GitHub ;).
>>>>>>
>>>>>> As for the Tile view issue, it had to do with paging and
>>>>>> localization;
>>>>>> that's been fixed in trunk [1]. Perhaps we can make a new release
>>>>>> candidate in the near future bundling some of these fixes together.
>>>>>>
>>>>>> 1.
>>>>>> https://github.com/zepheira/exhibit3/commit/0814c0b3695bb96e79272c2b00de8b3c17d1f784
>>>>>>
>>>>>>
>>>
>>
>
>
--
You received this message because you are subscribed to the Google Groups
"SIMILE Widgets" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/simile-widgets?hl=en.
