IMS Reports

Document Sample
IMS Reports Powered By Docstoc
					                79 entered              74 addressed
Auto Name       Title                   Description
Num                                                                                                                 V3 Status
ber
  202 Peter     Remove                  Why do OKI exceptions extend                          Errors identifying the error condition are used in the
      Wilkins   SharedExceptions        SharedExceptions and not OsidExceptions? It           OSID spec. In the Java binding, these errors are be
                                        seems like needless indirection.                      mapped to the Exception or RuntimeException
                                                                                              Java objects depending on the error. Other binders
                                                                                              are free to interpret these error values as
                                                                                              appropriate.
                                        Proposal: Have all OSID Exceptions that
                                        currently extend SharedException, extend
                                        OsidException instead.

 203 Peter      Repository metadata     Consider this use case. A Repository metadata         The Asset data/metadata is represented through an
     Wilkins    validation              editor provides metadata validation as one of its     AssetForm interface that defines methods to
                                        functions. This function suggests that there are      capture settable elements. The AssetForm is then
                                        validation rules that could vary among Repository     passed to the create/update() methods as desired.
                                        implementations. How does the editor provide          The form may have accompanying "metadata"
                                        rich validation functionality to the user?            methods to implemnet some validation.

                                                                                              All in all, more granularity. I haven't made heads or
                                                                                              tails of the previous validateAsset() yet.
                                        Background: Repository contains a
                                        validateAsset() method, but the only exception  A more recent request is to define a validate()
                                                                                        method defined in the admin session. Though I'm
                                        message that it provides to signal invalid data is,
                                        "Operation failed". Not very informative.       not sure how calling validate() before
                                                                                        create/update() adds value beyond calling
                                                                                        create/update() directly and burying whatever
                                                                                        validation available inside the the AssetForm, or the
                                        At a minimum another exception message should update() method.
                                        be added that addresses validation with greater
                                        granularity.



 204 Scott      wrong method name:     CourseManagement updateCourseGradeRecord               Darn, still missing from the course OSID.
     Thorne     CourseOffering.updateC
                ourseGradeType()       In CourseOffering, updateCourseGradeRecord,
                                       not updateCourseGradeType.
205 Peter     Use consistent            In the Hierarchy OSID there are arguments            Hierarchy is an OSID to provide the service of
    Wilkins   parameter name for        named "nodeType" in some methods and "type".         structuring relationships. It is also an important
              same objects              In either case, the argument is intended to be the   service that it used as a supplement to other OSIDs.
                                        same. We should pick a single name and use it
                                        consistently.                                        Hierarchy was split into two OSIDs. One is geared
                                                                                             as an assist to other OSIDs, a hierarchy of Assets
                                                                                             or Qualifiers, for example. This interface defines the
                                                                                             node as an OSID Id. The Id is managed by the
                                                                                             respective OSID.

                                                                                             The other half is geared for consumers who want to
                                                                                             manage relationships in hierarchies, maps, rings,
                                                                                             etc. This has been generalized to Topology that
                                                                                             defines both a Node and an Edge.bit. Most of the
206 Peter     HierarchyException.UNS I was browsing the Javadoc for Hierarchy                The errors have been simplified a
    Wilkins   UPPORTED_CREATION Manager and read the description for                         time the context of an error can be safely assumed
              documentation          HierarchyException.UNSUPPORTED_CREATION                 from the method invoked and corresponding error
                                     . I think this should also cover the case where a       description, so there's little need for a
                                     hierarchy does not support recursion but does           UNSUPPORTED_CREATION vs.
                                     allow multiple parents.                                 UNSUPPORTED_SOMETHINGELSE errors
                                                                                             throughout the OSIDs.

                                                                                             Instead, the create method may simply result in
                                                                                             UNSUPPORTED for this type of error.
207 Tom       Create an                 The job of the OsidLoader is to find, load, and      Currently, the OsidLoader has been defined solely
    Coppeto   OsidLoadingManager        execute OsidManagers. The OsidLoader in              as an interface and has been expanded in scope to
                                        version 2.0 assumes an OsidManager derived           include various runtime operations (renamed
                                        class is locally accessible via the CLASSPATH.       OsidRuntimeEnvironment).
                                        However, the loading mechanism is an
                                        implementation detail that should allow for a        This begs the question of where one gets this
                                        variety of schemes. Implementations may wish to      implementation. The answer is that it falls out of
                                        retrieve managers via other means that can           scope of the spec and a default impl will be shipped
                                        include retrieval from a remote OSID server.         with the kit.

                                                                                             The Installation OSID piece that deals with loading
                                                                                             OSIDs and finding resources from Provider-space
                                        As such, the OsidLoader is in itself a service       is in OsidRuntimeManager. This leaves a
                                        requiring an interface specification.                conspiracy between Installation and the
                                                                                             OsidRuntimeManager in that they both have to
                                                                                             agree on the installation location. This might mean
                                                                                             that the installation methods also should move.
209 Tom       Replace                    Applications and Implementations can conspire       properties removed from getManager() and impls
    Coppeto   additionalConfiguration    through the use of additionalProperties.            should use the Configuration service.
              with appContext from       Properties are implementation specific and as
              OsidLoader                 such should not be handled by the Application.     The flow with configuring OSID impls was flipped,
                                                                                            instead of an application knowing what properties
                                         However, it is useful to have the implementation an implementation uses (oob), the impl via the
                                         alter its behavior (which can be in the form of    OsidRuntimeManager knows the "stack" above it
                                         loading an alternate Property set) based on some (but not below) and can use this as a configuration
                                         application context. This context can simply be in key for customizing itself on a per app basis.
                                         the form of a String passed through OsidLoader().

                                         The difference here is that the Implementation
                                         drives the configuration, not the application.

210 Tom       Add Status field to the    Implementations may throw an                        compliance {mandatory, optional} added to the
    Coppeto   Specification              UNIMPLEMENTED exception to indicate that a          spec. In general, methods are grouped into
                                         method has not been implemented. The OSID           OsidSessions along the lines of compliance such
                                         consumer has no way of predicting which             that each OsidSession defined by a service is
                                         methods are required to be provided by an           optional via the manager, but each method within a
                                         Implementation to fulfill its Service contract.     session is mandatory. Many more boolean tests for
                                                                                             interoperability exist in the manager tp help a
                                      The specification should indicate which methods        consumer figure out what is supported.
                                      are mandatory to implement.
211 Tom       Iterators should have a The purpose of the various Iterators is to allow for   This was rejected.
    Coppeto   start over              implementation independent iteration through a
                                      sequence of Objects. Because of the                    Given that the same query executed at different
                                      implementation independence, Iterators do not          times may result in a different result set, by
                                      permit random access. Some Iterators may be a          resetting the iterator (now called list) gives the
                                      cover for a remote procedure or some other             impression that the results are constant.
                                      single-pass data store where random access
                                      cannot be implemented. It is currently up to the
                                      Application to retrieve and store this data if other
                                      means of access are required.

                                         In some circumstances iteration may need to be

                                         performed multiple times. This process could be
                                         made simpler without requiring the Application to
                                         manage the data.

                                         Iterators should support a restart() method.
212 Tom       Remove                  The use of AuthenticationTypes interferes with        Authentication is now responsible for Agent. The
    Coppeto   AuthenticationType      Implementation interchangeability and runs            Agent was scoped to mean "something that can
                                      contrary to proper interface design.                  take an action" which maps to something that can
                                                                                            authenticate and might appear in an Authorization.
                                                                                            In effect, the Agent maps to an authentication
                                                                                            principal and this principal is described through a
                                                                                            Type.

                                                                                            In the hole Agent left behind exists a Resource
                                                                                            service which through a type specification can
                                                                                            describe a person in much more detail.

                                                                                            Agent sometimes got used to describe "thing" (eg.
                                                                                            scheduling). The Resource is the generic noun
                                                                                            service also used to descibe "things" - person,
                                                                                            place or thing.
214 Tom       Change                  The assignConfiguration() method of the               The OsidRuntimeManagert (207) is required to
    Coppeto   assignConfiguration()   OsidManager is the means by which the                 invoke OsidManager.initialize() after instantiation.
              to initialize() in      OsidLoader hands the OsidManager its
              OsidManager, make       properties. This allows the OsidLoader to be
              public                  responsible for the location of OSID properties
                                      but this public method also opens the door for
              getConfiguration() in
                                      Applictions to assign properties to
              OsidLoader()
                                      Implementations.

                                      Also, the constructor in most Implementations are
                                      unable to do any initailization of the manager
                                      because the properties are not assigned until
                                      after the manager has been instantiated.. Any
                                      initialization has to be performed at the time
                                      assignConfiguration() is invoked, or initialization
                                      needs to be checked inside the Implementation
                                      methods.

                                      Change the assignConfiguration() method to a
                                      more generic initialize() method which will be
                                      responsible for downlaoding the properties
                                      information from the OsidLoader, if it desires.
215 Tom       OsidLoader.getManager The OsidContext is a controversial object since it      OsidContext didn't survive. Providers can make use
    Coppeto   () should permit null permits the shuttling of out-of-band information        of a Configuration service (new) for stuff that it
              OsidContext           around the Interface. However, it can be                needs. The Configuration is available from the
                                    necessary for Implementations to be able to             OsidRuntimeManager such that it is possible to
                                    share certain information and currently there is        provide configuration keys that vary based on the
                                    not a better agreed upon way to accomplish this.        consuming stack so that context-sensitive impls
                                                                                            can be provided without having the consumer get
                                        On the other hand, it should never be necessary     its hands on the configuration specifics.
                                        for an Application to make use of the
                                        OsidContext. While certain out-of-band
                                        couplings, although undesirable, may exist
                                        between Implementations, the Application needs
                                        to be independent of any Implemnetation.

                                        In the mean time, the Application shouldn't be
216 Tom       Add                       responsibleway creating the OsidContext.
                                        There's no for to definitively fulfill the          See 212. Agent is essentially an authentication
    Coppeto   getAgentByPrincipalNa     Authentication.getAgentId() contract once the       principal. Agents can be mapped to people through
              me() to AgentManager      user has authenticated. There needs to be a         a Resource OSID. This allows a one to many
                                        means to map the authenticated principal name       relationship between authentication identities and
                                        available in the Authentication Implementation to   real identities.
                                        an Agent Id. The AgentManager is necessary to
                                        perform this lookup but the only lookup methods
                                        available require an Id or perform a search that
                                        may return multiple results.
217 Tom       Properties interface      Properties is an Interface defined in               The administrative sessions provide access to an
    Coppeto                             org.osid.shared. Some methods, such as              interface to manage the creation or update or OSID
                                        Agent.createAgent(), require a Properties object.   objects. These interfaces define methods to set
                                                                                            various object elements directly without needing to
                                        An application needs to understand which            identify and traverse properties.
                                        Properties implementation to use and assume
                                        the OsidManager implementation will know how
                                        to use it.

                                        There needs to be a way to abstract the
                                        Properties impl from the application, or bag the
                                        Properties interface entirely. One possible
                                        workaround is to have the OsidManager return
218 Tom       Properties (2)            Properties (big P) is a collection of 0 or more      OsidObjects include aninterface extension
    Coppeto                             properties (small p). Each (small p) property is a   mechanism that provides a means of defining a
                                        simple name/value pair.                              Type through an interface specification.

                                        This simple pair should also include an identifier   Properties remain as a light-weight alternative to
                                        to help uniquely identify the property for the       browsing some object elements that do not require
                                        purposes of developing a standard set that can       knowledge of any particular type (eg: SearchParty
                                        be used across implementations.                      app). Because the "pressure" is off Properties to
                                                                                             deliver the contract of a type specification, they
                                        There may be other considerations, such as a         have been simplified to displayable string/string
                                        semantic definition (syntax), domain and an          pairrs accessible via a simple OsidList.
                                        authority to go with this identifier.
219 Tom       a group is not an agent A Group is not an Agent. A Hierarchy may be a          Generally, most methods that took an Agent now
    Coppeto                           form of a Group, but Group should not be a             require a Resource. The grammar is: Agent does
                                      subclass of Agent.                                     something to a Resource.

                                        Bite the bullet and make separate methods        A Group is a collection of Resources.
                                        where both an Agent and Group are acceptable.
220 Tom       Types                     We should endeavor to get Types out of the spec. The Type mechanism has been scoped to indicate
    Coppeto                                                                              the type of extension interface available in an
                                        Having said that, we have them. We should have object.
                                        a means of uniquely identifying them and
                                        attempting standardization of the Types in use.  The Type contains an indentifier and a display
                                                                                         name to assist with managing Type definitions.
                                        The keyword Type really isn't a keyword. It is a
                                        key. We should call it that.

                                        We should add a getDisplayName to Type so we
                                        don't have to display the key in applications.

                                        There's some synergy between the properties
                                        and Types that can be explored.
221 Tom       Verifying accessibility   Particularly with the 'administrative' like methods   pre-authorization methods added to the OSIDs. A
    Coppeto   of "administrative"       (createAsset(), deleteAgent(), etc) there is no       provider may or may not really perform an
              methods                   way for an application to make a guess whether        authorization, but this provides a means for an
                                        or not these functions are accessible to the user     application to know not to display a function that is
                                        without actually invoking the method.                 not accessible.

                                        From a UI standpoint, I'd like not to display       canCreateAssets();
                                        functions the user is not permitted to perform, are
                                        unimplemented, or have some other detectable
                                        problem. I'd like a means of asking the manager
                                        whether or not specified methods will *not*
                                        succeed, at least from an authorization or
                                        implementation standpoint. I don't think it's
                                        possible to determine if the method will succeed
                                        Several OSIDs invoking it.
                                        without actually shuttle Properties. In some
222 Tom       Directory Service                                                             striike 2
    Coppeto                             enterprises, the Properties for Agent,
                                        CourseManagement, Group (if this is separated
                                        from Agent) all come from the same place.

                                        It would be helpful to describe a Directory Service
                                        to update and retrieve these Properties that can
                                        serve as a service provider to the various OSIDs
                                        requiring Properties management.
223 Tom       Authorization             Authorization is too complex.                         Authorization methods have been sorted among
    Coppeto   simplification                                                                  multiple sessions making the basic service much
                                                                                              easier to understand. The basic session defines a
                                                                                              single method.

                                                                                              In general, the complexity of the OSID shifted from
                                                                                              looking at a pile of methods to looking at sessions
                                                                                              as a whole which, in turn, define a small set of
                                                                                              related methods. The managers as a result define a
                                                                                               variety of ways a consumer can use a service.
224 Catherine   Remove subclassing   In striving for a non-language specific          The Grouping function simply moved from Agent
    Iannuzzo    from Agent OSID      specification, we need to remove the subclassing (which now is defined in Authentication) to
                                     of Agent by Group. Not all languages can support Resource. Details to follow.
                                     sub-classing.

                                     I propose the modification of the Agent OSID and
                                     the creation of a Group OSID. I have a document
                                     describing this proposal in detail.




229 Scott       Grading change       GradableObject:                                    versioning support?
    Thorne      proposal
                                     Add Method: updateGradeWeight /* this can be
                                     changed without effecting integrity */


                                     /* Add versioning support as in other OSIDs */

                                     longvalueIterator = ge
230 Chuck     change              Current:                                            ROMI was removed.
    Shubert   OsidRomiManager()
              parameter list.     public java.io.Serializable
                                  invoke(java.io.Serializable object,

                                        java.lang.String methodname,
                                  java.lang.String[] argTypes,

                                       java.io.Serializable[] args) throws
                                  org.osid.OsidException;

                                  Proposed:

                                    public java.io.Serializable
                                  invoke(java.io.Serializable object,

                                        java.lang.String methodname,
                                  java.io.Serializable[] argTypes,

                                       java.io.Serializable[] args) throws
                                  org.osid.OsidException;

                                  Problem:

                                  The argTypes parameter is currently an array of
                                  java.lang.String that represents method signature
                                  Type (i.e. Class) names. The intent in Java is to
                                  allow the conversion of these argType Class
                                  names back into argType Classes with the
                                  Class.forName method. Unfortunately, this is not
                                  possible when an argType parameter is itself an
                                  array.

                                  Reasoning:

                                  In an earlier version of Romi the argTypes
                                  parameter was an array of java.lang.Class. In
                                  the proposed version of Romi the argTypes
231 Jeff Kahn   Add exception message I propose we add a defined exception message           ALREADY_EXISTS added and is generally used to
                ALREADY_EXISTS        for "already exists".                                  indicate an error from a create() method.

                                           This might show up in several places in several
                                           OSIDs. I found the need in
                                           RepositoryManager.createRepository. I know we
                                           have an "already added" in Agent.




233 Chuck       fix Javadoc exception      These javadoc.exe warnings may indicate           Currently, no javadoc errors in the binding
    Shubert     message overrides          problems in the Java bindings, and should be      produced from the draft. I did have to write a few
                                           fixed:                                            taglets though.

                                           `org.osid.sql.SqlException.UNKNOWN_TYPE'
                                           hides `SharedException.UNKNOWN_TYPE'

                                           `org.osid.sql.SqlException.OPERATION_FAILED'
                                            hides `OsidException.OPERATION_FAILED'

                                           `org.osid.sql.SqlException.NO_MORE_ITERATO
                                           R_ELEMENTS' hides
                                           `SharedException.NO_MORE_ITERATOR_ELEM
                                           ENTS'

                                           `org.osid.workflow.WorkflowException.CIRCULAR
                                           _OPERATION' hides
                                           `SharedException.CIRCULAR_OPERATION'

                                         `org.osid.workflow.WorkflowException.ALREADY
234 Chuck       Extract constant strings _ADDED' hides strings from Exception classes. Exceptions are no longer part of the formal spec,
                                         Extract constant
    Shubert     from Exception classes This is for localization of the messages. It will but exception classes are defined in the language
                                         also make C++ header files work.                binder. The java binder produces exceptions a la
                                                                                         java, where it is the exception class that is caught
                                                                                         and the message content is loggable drivel.

                                                                                             There's also a new Locale service for localization
                                                                                             methods. One may simply layer it on an existing
                                                                                             Dictionary.
235 Jeff Kahn   PropertiesTypes in         There is support for property setting in some   Yes. There needed to be a more precise way to
                create methods             create methods such as createAgent.             create and update things, while preserving general
                                                                                           browsing abilities. Update/Creates are performed
                                       How do we specify multiple properties sets. I       with the use of an interface that defines methods
                                       think the whole model of setting properties needs for what can be updated or created, including some
                                       to be revisited. It is also silly to be able to set data constraints. This would generally be done in
                                       these in the create method only.                    the context of a particular type specification
                                                                                           (extension interface).
236 Chuck       Fix missing and        Here is the output of Jalopy indicating missing     The OsidRomi.java errors can be safely ignored.
    Shubert     obsolete documentation and obsolete documentation:

                                           java/org/osid/OsidManager.java:65:8: Missing
                                           Javadoc tag "@throws org.osid.OsidException",
                                           added

                                           java/org/osid/OsidManager.java:107:8: Missing
                                           Javadoc tag "@throws org.osid.OsidException",
                                           added

                                           java/org/osid/OsidRomiManager.java:33:8:
                                           Missing Javadoc tag "@param object", added

                                           java/org/osid/OsidRomiManager.java:34:8:
                                           Missing Javadoc tag "@param methodname",
                                           added

                                           java/org/osid/OsidRomiManager.java:35:8:
                                           Missing Javadoc tag "@param argTypes",
                                           added...

                                           (this list can be regenerated by running Jalopy on
237 Chuck       Modify Hierarchy to        Modify Hierarchy to eliminate constants in         constants removed
    Shubert     eliminate constants in     interface. C# interface do not support constants
                interface                  in the interfaces.
238 Catherine   No useful doc for      The method                                             supportsVersion(version) added to allow the
    Iannuzzo    osid.OsidManager.osidV osid.OsidManager.osidVersion_2_0() has no              provider of a different OSID version to support
                ersion_2_0             return value and the javadoc comments say              multiple versions of an interface.
                                       nothing under what circumstances an exception
                                       is thrown. So how does it "Verify to OsidLoader
                                       that it is loading OSID Version: 2.0 "???

                                        My Manager class has to implement that function.
                                        There is no documentation that tells me how to
239 Jeff Kahn   Rename                  We should discuss if                             The "content" is an interface extension on Asset.
                repository.Asset.getCon Asset.getContentRecordStructure() should really Asset.getType() and Asset.getInterfaceExtension().
                tentRecordStructure()   be getContentType().                             The interface extsnion may in turn define a
                                                                                         getConteht-like method for getting data, in addition
                                                                                         to speific elements available.

240 Craig     Remove                Gongqin points out that the Javadoc indicates             There's only one now.
    Counterma GradeRecord.getGradeT that there are identical methods in GradeRecord
    n         ype() method          and GradableObject:

                                           Type getGradeType()

                                            Get the GradeType associated with the
                                           GradableObject and Grade.

                                           Type getGradeType()

                                            Get the GradeType associated with the
                                           GradableObject and Grade.

                                           We believe that this is redundant: the GradeType
                                           is attached to the GradableObject and the
                                           method getGradeType() on the GradeRecord is
                                           redundant and refers to the GradableObject's
241 Jeff Kahn   Add constant to         Currently, there is a constant                          The hierarchy is traversed using parent/child
                hierarchy.Hierarchy:    TRAVERSE_LEVELS_INFINITE, which indicates               methods. The session provides a convenient place
                TRAVERSE_LEVELS_MA      that "...the traversal will proceed to the end of the   within the implementation to perform an
                XIMUM                   Hierarchy or until a circular reference returns to a    optimization by downloading the entire hierarchy
                                        Node already traversed."                                from a backend system for efficiency.

                                        Since the "levels" parameter is declared as an int There's also a means to get a piece of the tree in
                                        and there is no datatype for an infinite number,   bulk using an OsidList.
                                        perhaps a better name would be
                                        TRAVERSE_LEVELS_MAXIMUM or even
                                        TRAVERSE_MAXIMUM_LEVELS.

                                        I propose that we add this constant and
242 Jeff Kahn   Add search to
                                        deprecate thesearch for a course, offering, or
                                        Add ability to other.                             Yes. Although CourseOffering and Section have
                CourseManagement        section using criteria.                           been combined.
243 Jeff Kahn   CourseManagement.Ter    CourseManagement.Term.getSchedule() should        If course mgmt depends on scheduling to fulfill its
                m.getSchedule()         return an IdIterator and not a                    definition, then the pattern is to add both methods
                returns wrong object    ScheduleItemIterator.                             and provide access to the scheduling OSID via
                                                                                          cource mgmt.
244 Jeff Kahn   parameter error in      create function refers in the method summary      This no longer appears to be applicable.
                createXxx() methods     description to "Display Name" and should refer to displayNames are used everywhere in V2.
                                        "Reference Name".


245 Jeff Kahn   missing Javadoc for     There is no method summary description text for         ok
                Authorization methods   getFunction and getQualifer.
246 Jeff Kahn   Convention for Optional Several OSIDs' methods that have arguments we The methods have been re-factored to eliminate
                parameters              state are "optional". For example, if we have the optional parameters. We're very strongly
                                        method foo(x,y,z) and we want to require x and    discourgaing the use of nulls.
                                        make y and z optional we can do one of several
                                        things:

                                         1) Make several methods:

                                         foo(x)
                                         foo(x,y)
                                         foo(x,z)
                                         foo(x,y,z)

                                         This is not great because we proliferate methods
                                         and we can introduce ambiguity if y and z are the
                                         same data type. To resolve that, we would need
                                         new method names.

                                         2) We can document a convention that passing
                                         null implies that the implementation should ignore
                                         the argument. So for example, all these would be
                                         valid calls:

                                         foo(x,null,null)
                                         foo(x,y,null)
                                         foo(x,null,z)
                                         foo(x,y,z)

                                         This keeps us to only one method and there is no
                                         ambiguity given argument order. This is what we
                                         are doing now. The problem with this approach
                                         is that null input should be treated consistently
                                         and in most places it causes an exception to be
                                         raised.

                                         3) We can create an empty interface for the
                                         ignore argument. Better yet, we can implement a
                                         class such as:
247 Chuck     Tighten Exception   I'd like to propose that we tighten exception         see 202. NULL_PARAMETER, NOT_FOUND,
    Shubert   Handling            handling. We are beginning to get a standard set      UNSUPPOPRTED are error conditions. The binder
                                  of exceptions messages for each of the SIDs. I        for Java converts these into NotFoundException,
                                  would like to propose that we restrict each SID to    UnsupportedException, and so on. In Java, the
                                  only having enumerated messages. I think that         error is the exception itself that can be caught
                                  we can force this by requiring the constructor to     explicitly, rather than having to match strings in the
                                  have an exception number that is paired with an       specific error condition is pertinent. Another
                                  exception message. I would seem reasonable to         language binding may use strings for these errors
                                  have get accessors for both the exception             instead. The principle of "when in rome" applies
                                  number and the exception message.                     (although we're finding rome exists in multuple
                                                                                        countries).
                                  An example:

                                   public class MySidException extends
                                  OsidException {
                                     public final static int MyBad = 0;
                                     public final static int YourBad = 1;

                                      private final static String[] messages = { "I'm
                                  sorry", "You're sorry" };
                                      private Serializable source = null;
                                      private int messageNumber = Mybad;

                                      public MySidException( Serializable source,
                                  int messageNumber ) {

                                          this.source = source;
                                          if ( messageNumber == YourBad ) {
                                              this.messageNumber = YourBad;
                                          } else {
                                              this.messageNumber = MyBad;
                                          }
                                      }

                                      public String getMessage() {
                                        return messages[ messageNumber ];
                                      }
248 Jeff Kahn   Make OsidLoader an   Let's state the problem so we can see.               OsidLoader is now the OsidRuntimeManager
                interface                                                                 interface.
                                     An application wants to load an implementation
                                     of an OSID in order to call some service.

                                     The application knows the OSID interface for the
                                     Manager of the service, e.g.
                                     osid.authentication.AuthenticationManager

                                     The application knows the version of the OSID
                                     (this may be redundant if the package indicates
                                     this unambiguously)

                                     The application knows the package name of the
                                     OSID implementation, e.g.
                                     comet.osidimpl.authentication.useridpwd

                                     The application has or creates an owner (now
                                     context).

                                     The application knows the class that implements
                                     the OsidLoader interface that can do this work.
                                     This could be the same class for every service,
                                     version and implementation, but doesn't have to
                                     be.

                                     The application instantiates the loader by calling
                                     new. The application calls the load method in the
                                     loader and passes some arguments. The
                                     application gets back an instance of the correct
                                     Manager or an exception. The loader is bound at
                                     compile time or loaded at runtime with
                                     Class.forName(). The Manager can be
                                     determined at runtime.
249 Jeff Kahn   add method                In Repository.Asset, there is a method                  The Asset now does not contain a reference back
                repository.Asset that     getRepository() which returns an Id of the              to the repository from which it came. It may be the
                returns Repository        Repository that holds the Asset. We should have         case that the same asset is exposed from multiple
                object                    a separate method that returns the Repository           repositories in a many-to-many relationship.
                                          object itself. The Id is only useful if you have the
                                          Manager that holds the Repository. Sometimes            The Repository is available from certain sessions
                                          the Id is enough, but other times it is a pain to get   that are said to operate within the context of a given
                                          the object back when all you have is an Asset.          Repository. These sessions can return the
                                                                                                  Repository (as opposed to the Id).
250 Peter       Cabinet.entries() -       For version 2, an approved Proposal (#98) says          In general, getStuff() is used instead of stuff().
    Wilkins     Approved v2 change        to change Cabinet.entries() to
                order incomplete          Cabinet.getEntries(). The change was not made,
                                          the method remains unchanged in version 2.



                                        It should be made for version 3.
251 Tom         Type should be concrete Types not being a good idea aside, the Type               Type is now expressed as an interface and there is
    Coppeto                             class is abstract forcing an implementation to            a new Type service which provides the function of a
                                        define its own Type. So, we get implementations           Type registry.
                                        with tomsType and catherinesType littered
                                        through code.                                             The ability to construct a Type out of whole cloth
                                                                                                  has been relegated to an OSID utility (there's no
                                          A Type is essential an identifier constructed from      corresponding interface definition).
                                          the domain, authority and key (not the java
                                          class!). If a Type is to be used then code should
                                          shuttle these identifiers in a generic fashion,
                                          perhaps through the use of a Type factory, to
                                          mitigate some of the many portability issues
                                          surrounding their usage.

                                          I think this argues for a concrete Type class in
255 Tom         add supportsType()        org.osid.shared.
                                          Currently applications need to get a TypeIterator       supportsType() methods available in managers
    Coppeto     methods                   of Types supported by a manager and somehow             whose OSIDs rely on Types.
                                          select an appropriate Type.

                                          A useful tool would be to add "boolean
                                          supportsType(Type)" methods to all of the
                                          managers that require Type handling so that an
                                          implementation can negotiate Type compatibility
                                          under the covers.
256 Jeff Kahn   Javadoc for             Javadoc for                                     ok
                CourseManagement.Enr coursemanagement.EnrollmentRecordIterator.nex
                ollmentRecordIterator.n tEnrollmentRecord() is used for 2 objects.
                extEnrollmentRecord()
                                        Change:
                                        "Get the Id of the Agent representing a student
                                        enrolled in the CourseSection."

                                      To:
                                      "Get the Id of the Agent representing a student
                                      enrolled in the CourseOffering or CourseSection."
257 Jeff Kahn   Agent search doesn't  I noticed that search in AgentManager for Agent Searching is performed through a query interface.
                include a properties  and Groups includes parameters for criteria and
                parameter             type but not for properties.
258 Jeff Kahn   method name:          Should Agent.getPropertyTypes() be                The "property type" is inferred from the OsidObject
                getPropertyTypes() or Agent.getPropertiesTypes()?                       Type. The object type indicates a specification of an
                getPropertiesTypes()?                                                   interface, and the properties are considered a
                                                                                        glossy overview of elements defined in that
                                                                                        interface.
259 Peter       Remove                This method is usually found in classes that also ok
    Wilkins     AgentManager.getPrope contain a getProperties() method. No other osid
                rtyTypes()            manager has this method. It is not clear what it
                                      would return since both Agent and Group have
                                      properties and associate property types. Each of
                                      these classes have a getPropertyTypes() method.

                                           I propose that we remove the getPropertyTypes()
                                           method from AgentManager.

260 Peter       Type parameter order       The order of the Type constructor arguments         Type is an interface and as such the constructor is
    Wilkins     change between v1          changed from v2 to v2. The order of the first two   not available to the consumer. Types can be
                and v2                     args are switched from what they were in OSID       retrieved through the Type OSID or created via a
                                           version 1 (rc6.1).                                  type utility.

                                           (Domain, Authority, Keyword -> Authority,
                                           Domain, Keyword)

                                           It isn't mentioned in the release notes since it
                                           wasn't a proposed change. I propose we add a
                                           note to the documentation to notify developers
                                           that their rc6.1 Types are incompatible with v2
                                           Types unless converted.
261 Jeff Kahn   deprecate               The enrollment record refers to a student. There      The enrollment defines Resources (which are
                EnrollmentRecord.getSt is a getStudent method. I think a better name for      people in this context) and calls them members.
                udent(), add getAgent() the method would be getAgent and deprecate            Each Resource is paired with a Type in the record,
                                        getStudent. This allows more flexibility to include   where the Type is used toindicate the "role" of the
                                        non-student stake-holders such as faculty. The        Resource in the course offering.
                                        status type classifies the "role" of the agent.
                                        Note this is not an authorization system function.

                                           method to deprecatemethod to add

                                           EnrollmentRecord.getStudentgetAgent
                                           CourseSection.AddStudentaddAgent
                                           CourseSection.RemoveStudentremoveAgent
                                           CourseSection.ChangeStudentchangeAgent
                                           CourseOffering.AddStudentaddAgent
                                           CourseOffering.RemoveStudentremoveAgent
                                           CourseOffering.ChangeStudentchangeAgent

262 Chuck       Remove method              Remove method Connection.getSqlTypes from          sql?
    Shubert     Connection.getSqlTypes     org.osid.sql.Connection. Types are not
                ()                         referenced in sql.
263 Chuck       logging.WritableLog        logging.WritableLog should have the following      The format type is the Entry Type, and has a
    Shubert                                methods:                                           corresponding interface definition. Similar in
                                                                                              mechanics, but different articulartion.
                                           Type getCurrentPriorityType()
                                           Type getCurrentFormatType()                        The priority type is included in the Entry, not at the
                                                                                              log level.
                                           It is possible to append using the current types
                                           for these things. An app might want to know
                                           what they are.
264 Chuck     Question:             This method includes a courseSectionId, but
    Shubert   grading.GradingManage createGradeRecord does not. It looks like
              r.getGradeRecords()?  courseSectionId is associated with a
                                    GradableObject.

                                         Question:

                                         Is the intent of this method to compare the
                                         courseSectionId in the getGradeRecords
                                         argument (if it exists) with all GradableObjects in
                                         all GradeRecords and return GradeRecords
                                         where there is any GradableObject that has this
                                         courseSectionId (assuming no further filtering)?

                                         Observation:

                                     It seems odd to me to filter the GradeRecords on
                                     the basis of something that is not one of their
                                     properties. It looks like you will get back a lot
265 Chuck     ByteStore.updateReadO more GradableObjects than you are really and
                                     filing.ByteStore methods updateReadOnly()                 These didn't carry over. Though it may be the case
    Shubert   nly()/updateWritable() updateWritable() need boolean args. Unless                that someone defines them in the File Type.
              need boolean args      these are coded as toggles, I don't think that
                                     they'll do much.
266 Chuck     make use of repository I'm not sure what the correct proposal is here.           It was easier to remove PartStructure and
    Shubert   objects Description    Should it be to remove the getDescription()               RecordStructure.
              attribute consistent   methods from PartStructure and RecordStructure
                                     or add updateDescription() methods to them or
                                     do nothing?

                                      I thought that I might be able to answer that by
                                      finding the createPartStructure and
                                      createRecordStructure methods and looking at
                                      their arguments, but I don't see them anywhere. I
                                      could imagine that the descriptions might be
                                      immutable for some reason.
267 Chuck     repository.RecordStruct org.osid.repository.RecordStructure has no        It has no RecordStructure either. Asset does have a
    Shubert   ure has no              updateDescription() method.                       way to update the description.
              updateDescription()
              method.
268 Jeff Kahn   Change OsidLoader        Around line 177 is a catch statement for          Throwables are not found in the java binding. And
                thrown Exception to      Exception. This should be Throwable.              OsidLoader is no longer a concrete impl.
                Throwable
                                         The preceding lines are:

                                         manager.assignConfiguration(configuration);

                                         return manager;

                                         Given that the assignConfiguration call can raise
                                         an OsidException, we need to catch Throwable.
                                         Exception is not good enough and execution falls
                                         to the catch lower down. This masks the helpful
                                         message:
                                         ERROR_ASSIGNING_CONFIGURATION
269 Jeff Kahn   make behavior            Why does this method throw UNKNOWN_KEY            OsidContext is no longer found either. There is
                consistent when key is   while OsidContext.getContext returns null when    however a NOT_FOUND error that is used in
                not found                the key is not found. Seems inconsistent.         places where something might not be found.
270 Jeff Kahn   Is assignContext(null,   I see the osid.OsidContext.removeContext()        gone.
                null) equivalent to      method was dropped in version 2. I assume one
                removeContext()          uses assignContext and null. Are these really
                                         equivalent? I think one removes the context
                                         element and one sets it to null.
273 Catherine   change OsidLoader       the OsidLoader loaders properties files when it        A new Configuration service should provide more
    Iannuzzo    property loading        loads an OsidManager. In V2.0 it does this by          fleibility in getting configuration information in a
                                        using the getResourceAsStream method on the            variety of environments. Looking for a properties file
                                        OsidManager's class. This prepends the                 in the same directory always seemd a bi ttoo
                                        OsidManager's package name to the properties           restrictive.
                                        file, substituting "/" for ".". E.g., loading the
                                        OsidManager
                                        "edu.ivyleague.osids.hierarchy.HierarchyManager
                                        " will look for the properties file
                                        "edu/ivyleague/osids/hierarchy/hierarchy.propertie
                                        s"

                                        This causes problems when an application
                                        developer is expected to provide property
                                        settings to an OSID implementation packaged in
                                        a jar file, and especially in a web application.

                                        the proposal is to change the OsidLoader to use
                                        the OsidManager's class loader to perform the
                                        getResourceAsStream method. This will not
                                        prepend the package name and will allow more
274 Catherine   add EnterpriseName to   flexibility for working with application developers.
                                        The Agent class should add a property, the             Agent and Resource have been separated, so one
    Iannuzzo    Agent                   enterpriseName to the Agent object. It should not      can use the Agent display name as the enterprise
                                        be assumed that the Agent ID used by the OSID          (or principal) name. Agreed that a separate Id
                                        is the same as a username, kerberos principal, or      should be used in both cases.
                                        other type of enterprise ID commonly used to
                                        identify Agents. However, getting Agents based
                                        on this property is likely to be very important,
                                        especially if the Agent implementation federates
                                        multiple authentication authorities (which could
                                        be distinguished by Agent Type).

                                        Concerning federating Agents, it might be useful
                                        to add an explicit "AuthenticatingAuthority"
                                        property , instead of relying on Type -- an out-of-
                                        band agreement applicable only to some
275 Catherine   change OsidLoader's      OsidLoader accepts as parameters the full class     Currently, the getManager() interface accepts an
    Iannuzzo    class name generation    name of an OSID interface and the package           OSID and a string. The OSID is an enumerated
                                         name of the manager that wants to be loaded.        constant indicating the interface desired. This
                                         The name of the OsidManager class is not            clarifies the spec and avoids confusion in the usage
                                         actually specified. OsidLoader requires the name    of a double string but someone who wanted to
                                         to match the class name of the OSID interface.      create experimental OSIDs would have a little extra
                                         This is not documented anywhere, and if it is       hacking to do. We'll see how this goes.
                                         going to continue to behave this way, it should
                                         be. However, I suggest that it would be better to   The string specifies an implementation. The spec
                                         allow a fully specified class name instead of a     ends there and the implementation of getManager()
                                         package name, so that implementations can give      is outside the scope of the spec.
                                         their OsidManagers whatever names that they
                                         want.                                               A java binding of getManager() would be more
                                                                                             friendly if specified the mapping of the impl string to
                                                                                             a full class name to provide flexibility for naming
                                                                                             implementation classes (Personally I got used to
                                                                                             aligning class names to interface names but there
                                                                                             doesn't seem to be a good reason to enforce that).


276 Peter       Best Practice for        We expect each OSID implementation will have a      Given recent experiences, it's difficult to have
    Wilkins     organizing jars in web   collection of supporting jars and that a web        version management if the language platform
                app                      application is likely to use multiple OSID          doesn't support it. The ClassLoader would have to
                                         implementations. This may lead to a situation       be isolated from the rest of the JVM.
                                         where multiple versions of the same package
                                         need to be supported.                               This might be an argument for specifying versioning
                                                                                             as a parameter to the loader leaving it to the loader
                                         Perhaps it would be appropriate to document a       implementor to figure it out.
                                         "Best Practice" for packaging an OSID
                                         implementation's supporting jars for web
                                         applications.
277 Peter       order of results not     The documentation may say that there is no          An adapter can be placed on top of an OSID to
    Wilkins     guaranteed               guarantee that results will be returned in a        change ordering, or a searchType may allow for
                                         specific order. This is not true. An OBA could      specifying ordering.
                                         specify that results are ordered. What the
                                         documentation should say is that there is no
                                         _requirement_ that results will be returned in a
                                         specific order.
281 Geoff     Bug in OsidContext.java While going through the OSID Java code, I came "fixed"
    Hulette                           across what looks like an error in
                                      OsidContext.java.

                                       In assignContext(), the block:

                                        else if ((null != key) && (null == context))
                                        {
                                        if (contextInfo.get(key).equals(context))
                                        {
                                        contextInfo.remove(key);
                                        }
                                        }

                                       will never remove anything. It should probably
                                       simply be:

                                       else if ((null != key) && (null == context))
                                        {
                                        contextInfo.remove(key);
282 Catherine   need Type creation for There is an issue with Type creation for both           This was one huge can of worms. Summary:
    Iannuzzo    Hierarchy, Authorization Hierarchy and Authorization. The application is
                                         expected to provide the Type for both Nodes and       Hierarchy no longer has Types.
                                         Qualifiers. But Type is an abstract class which
                                         the application cannot instantiate. So as currently   Services that do have Types have a getTypes()
                                         distributed, an application using the OSID            method. supports/implementsType() is a preferred
                                         interfaces cannot actually assign a meaningful        means for testing interoperability.
                                         type to a Node or Qualifier.
                                                                                           There is a Type service/factory to assist providers
                                           In most other OSIDs, the OSID Manager provides in managing/localizing types.
                                           whatever relevants Types it uses to the
                                           application via some kind of "getTypes" method.
                                           But in these 2 OSIDS, the "Type" is supposed to
                                           come from the application.

                                           This is an important fix for V3. We should fix it
                                           either by having the HierarchyManager and
                                           AuthorizationManager support methods like:

                                             NodeType
                                           HierarchyManager.createNodeType(String
                                           authority, String domain, String keyword)

                                            QualifierType
                                           AuthorizationManager.createQualifierType(String
                                           authority, String domain, String keyword)

                                           OR we can fix it by creating a TypeManager (like
                                           IdManager) that creates Types. I would rather not
                                           have a dependency on another Manager, so I
                                           think I prefer adding the methods to the affected
                                           OSIDs.

                                           Note:
284 Peter       parameter name             Generating Javadoc for OsidRomiManager             "fixed"
    Wilkins     doesn't agree with         returns a warning. The problem results from a
                documentation              difference between the param name and the
                                           javadoc that references it.

                                        Either the xslt should change to use xosid:name
                                        rather than xosid:documentation to fill in the
                                        javadoc parameter tags, or the XOSID should
                                        change to make these two attributes agree.
288 Jeff Kahn   Setting Id in           There are times when it is useful to be able to set   The Id is "owned" by the provider. One provider
                org.osid.repository.Rep the Id for an Asset. One such time is when            uses GUIDS and the other a database row id.
                ository.createAsset()   migrating data from one content management            However, The Id OSID can be used in such a way
                                        system to another soley using OSID calls.             as to provide Id compatibility or mappings across
                                        Adding an Id to createAsset would address this        systems and this can be utilized through an adapter
                                        issue. Perhaps the convention would be that a         layer for asset lookups.
                                        null for this argument let's the implementation set
                                        the Id; a non-null asks the implementation to use     There may be times when in a backend system an
                                        the Id passed in.                                     identifier needs to be fudged due to some
                                                                                              administrative snag, in which case SQL could be
                                                                                              more apporpriate.

289 Jeff Kahn   getPartByPartStructureT In implementing interoperability using OSID           "fixed"
                ype                     Types, a very common issue is to get a Part
                                        whose PartStructure's Type matches a Type in
                                        an OBA. A method to do this, and one to return
                                        the Part's value would be handy.
291 Jeff Kahn   mention of Java Date    In the description for nextLongValue() in the         LongValueIterator was removed. Its only purpose
                type in javadoc         LongValueIterator in Shared, there is a mention       was to house an array of timestamps, which
                                        of date in the Returns description. Just              generally indicated an object definition was missing
                                        mentioning the long is appropriate.                   that would have more data than the timestamp.


292 Peter       Use of platform specific Review use of language-specific datatypes in         There are no free names.
    Wilkins     datatypes in OSID        OSID names. Consider alternate names that
                names                    wouldn't have language specific associations.        Given that we already overload interface names
                                         For example, using ByteIterator in a language        with impl names (at least as far as the manager
                                         that doesn't have a byte datatype, or using          goes), we've been writing impls without the use of
                                         Properties where it is synonymous with the Java      imports anyway. There are times you can get away
                                         class of the same name.                              with it, and times you can't.
294 Jeff Kahn   Clarifying the intent of
                                      Is may not be clear whether isMultivialed is          This looks like it was removed in the previous
                the isMultivalued     talking about a capability or about what is           release.
                method                currently in the Asset. If it is the former, this
                                      could help a UI by offering a multi-entry interface
                                      versus a single. If this is the later, this can be
                                      determined by walking the parts of the record. I
                                      believe the value is in the former.
297 Jeff Kahn   Format and Schema in The format and schema attributes of a                  "fixed"
                RecordStructure       RecordStructure more properly belong to the
                                      PartStructure interface. Since the Parts in a
                                      Record may hold content with different formats
                                      and schemas, a single format and schema for the
                                      whole Record has too coarse grain.
298 Jeff Kahn   Add new asset methods Thumbnails are very common in repositories. I         An interface extension can be acessed through the
                                      suggest a specific method, getPreview(). One          Asset that exposes a more specific set of methods.
                                      issue is whether the preview is a bytestream,         For example, if the asset is an image you can
                                      URL, or something else. A simple solution is a        retrieve an AssetImage object that has useful
                                      preview Type.                                         imaging methods like getWidth().

                                                                                            The problem with preview() is that thumbnail should
                                                                                            be negotiated between consumer and provider. A
                                                                                            consumer should traverse the asset equivalents
                                                                                            and find the size of the image most appropriate for
                                                                                            its display [more on this].

                                                                                            isReiszable() could be defined for images where
                                                                                            the IP restricts modifying the image.
299 Jeff Kahn   Asset methods that         We have methods that get records and parts by    "fixed"
                reference record and       id. For a consumer, these should really be by
                part -related ids          Type. I suggest we deprecate those methods
                                           and change the argument from an id to a Type.
302 Catherine   DAO persistence model see paper, "OSID V3 Proposal: DAO persistence              The update() methods have been moved into the
    Iannuzzo                          model" by Catherine Iannuzzo, 2005/9/9                     session. The interfaces for the get* and set*
                                                                                                 methods have been split into 2 separate interfaces,
                                           To be very brief, the heart of hte proposal is:       releasing the consumer from having to get an
                                                                                                 object before changing it. On the set side, the
                                           1.All business objects implement mutators of          update takes effect using an update() method in a
                                           the ìsetXyzî form to modify their attributes. These session.
                                           can exist alongside V2 ìupdateXyzî methods.
                                           Where the behavior of the ìupdateî methods is to Similar, but using a separate interface rather than
                                           perform immediate persistence operations, the         the object interface to do the same thing, which
                                           ìsetî methods would only modify the values of the covers both a DAO and transactional style. It also
                                           currently instantiated object, without persisting it. solves the problem where all the object data is not
                                                                                                 available but the user can change the parts which
                                           2.The objects acting as a DAO for the business        are without creating ambiguity for the provider (did
                                           object (usually an OsidManager, but not always, the user mean to clear those fields, or were they
                                           as some business objects create and delete            never there?)
                                           other business objects) implement an
                                           ìupdateObjectî method as a complement to the
                                           ìcreateObjectî and ìdeleteObjectî methods. The
                                           form would be:

                                           void updateObject (Object obj) throws
                                           org.osid.package.Exception

                                           îObjectî would be whatever the appropriate object
                                           name is, and ìpackageî is the appropriate
                                           package for the class. The method would update
                                           the object in the persistent store and refresh it to
                                           reflect the current state of the persistence.

                                        3.As part of the contract, the ìupdateObjectî
306 Jeff Kahn   OSID Export             Suggest we add getAssetBySearch without the               done through federation
                                        repositories array to imply all. This is a
                                        convenience for federating.
308 Jeff Kahn   Seconds vs Milliseconds In Java, dates are often converted to milliseconds        The date is a primitive that can be bound to
                since 1970              since January 1, 1970. In Objective-C the                 whatever makes sense for the language.
                                        parralel approach is seconds since January 1,
                                        1970.                                                     This solves the syntacical problem but not the
                                                                                                  consistency of resolution.
315 Additional supportsUpdate   Add supportsUpdateForAssetType()                   How about by Id? canUpdate(Id) for admin
    supportsUp extension                                                           sessions along with other similar methods to assist
    date                        We should also consider whether versioning         with create/update/delete().
    method in                   support also needs to be qualified by asset type
    Repository                  or something else
Transaction Title   Owner      Date    Suggestion                                                         V3 Response

Types               iannuzzo   ###### OKI should restrict Types to being used only when the Services      done
                                      provide them.
                                      All services that return Types should also provide a method to     This is less about a given OSID and
                                      return a specific Type when given the authority, domain and        more about creating a Type. The
                                      keyword strings                                                    "Type Factory" method is available
                                                                                                         via the TypeManager.
                                       Authorization & Hierarchy should not use Types. These objects     Types removed from Authorization *
                                       should have another attribute, such as Category which should be a Hierarchy. An Authorization Function
                                       string.                                                           may be part of a hierarchy (ontology)
                                                                                                         that indicates its "category". The
                                                                                                         Hierrarchy consumer can maintain its
                                                                                                         own categorization along with all the
                                                                                                         other data it is responsible for in the
                                                                                                         node representation.
                                       Authentication should not use Types.                              Type removed from the
                                                                                                         Authentication OSID but kept in the
                                                                                                         Agent to indicate the Type of principal
                                                                                                         represented as a way of ensuring
                                                                                                         uniqueness across all authentication

Ids                 iannuzzo   ###### This inconsistency can be addressed in one of two ways. The first
                                      would be to change the API so that applications should not supply
                                      an ID when creating Nodes, Qualifiers, or Functions. The Manager
                                      responsible for creating these objects would return an opaque ID
                                      for them, as with other OSIDS. Because this ID is opaque and not
                                      meaningful to the application, however, the Manager would have to
                                      provide lookup methods to find the object based on its business
                                      name. The DisplayName could be used for this purpose, or it could
                                      be replaced by an immutable name. It is unlikely that a mutable
                                      DisplayName and an immutable Name would both be required for
                                      the object. In any case, the lookup name would have to become a
                                      unique key for the object.


                                       The second solution is to do away with IDs altogether when
                                       referring to Nodes, Qualifiers, and Functions and completely
                                       replace their use with immutable Name strings.
                                             First, the ID-generating function of the ID Manager should be     There is a dictinct method in the Id
                                             separated from the “packaging a String as an ID Object” function. OSID for generating Ids classes.
                                             Perhaps a new service, GUIDManager, could be defined to take on
                                             the ID-generating task.                                           Id has been retained as an interface.

                                             The “string packaging” task could be handled in one of the
                                             following ways:

                                           · Allow the direct construction of ID objects with a string argument.
                                           · Distribute the ID Manager as a concrete class in org.osid.shared,
                                           enforcing the correct string packaging behavior
                                           · Do away with the ID class altogether and replace it with Strings.
                                           Strings are much easier for the application to use and do not carry
                         nwright           Should, implication that they represent some to desire Id as
                                    ###### the falsehowever, the OKI community continuekind of GUID. a             The Id object mirrors Type with a
                                           first class object, I'm in favor of adding a "source" parameter to      domain and authority added.
                                           identify were the Id was created. This would bring it into line with
                                           the GUIDs used in DOI and IEEE LOM.

                                             I think I prefer strings at this point.

Ids vs. objects as return tom       ###### lots of stuff about layering                                            More compositional schemes exist
values                                                                                                             however the Id management across
                                                                                                                   layers isn't spelled out in the spec.
                                                                                                                   There need to be more information
                                                                                                                   on this.

multi-threading and      iannuzzo   ###### Pass OsidContext on every call to an OsidManager.                       OsidContext was removed and
OsidContext                                                                                                        replaced with a more specific
                                                                                                                   Authentication object. This spells out
                                                                                                                   that the problem at hand is getting
                                                                                                                   user identity through an OSID within
                                                                                                                   an app-server enviornment. The
                                                                                                                   Authentication object is obviously
                                                                                                                   part of an OOB.

                                                                                                                   Each OSID manager has a kissing
                                                                                                                   cousin that accepts Authentication
                                                                                                                   objects for every session creation so
                                                                                                                   it can be used in a multi-user
                         mjn        ###### Session awareness and multi-threading                                   environment.
                                                                                                                   managers create sessions which in
                                                                                                                   turn perform operations within a
Iterators    mjn        ###### a Java 1.5 binding that returned typed collections, rather than         The issue is the length, whether or
                               typed iterators. Iterators are certainly the lowest common              not it is known. The LCD is an
                               denominator, but they impose a real performance and efficiency          unknown length.
                               penalty on languages that have better mechanism for handling
                        ###### Any reason why we can't have it both ways?
             nwright    ###### s part of the OSID distribution supply utilities for converting
                               between them to and from java Lists, Arrays, etc. That way
                               everyone working with the OSID will be using the same Utilities
                               and everyone will understand how they work.
             pyrotom    ###### it might be possible to add a chunked method to them. So for            Iterators (Lists) return objets in
                               instance, the TypeIterator would have :                                 chunks.

                                boolean hasNextType()                                                  Generics won't work this way though.
                                Type nextType()
                                List nextTypeList(long max)

                                This preserves the sequential nature, allows the user to specify the
                                size of the chunk to be returned, and sneaks in generics for those
                                who like angly brackets.....


Exceptions   iannuzzo   ###### Now that the OSIDs are being specified in a language-neutral            done
                               XML, we should allow the language bindings to be more "natural"
                               and optimized for the language to which they apply
                               don't subclass Thorwable                                                done
                               it might make more sense for each specific exception to be              done
                               subclass of its osid exception, so that error number and message
                               are encapsulated completely, and error handling is based on
                               exception class.
             tom        ###### One solution is to define an error such as NULL_ARGUMENT, or            done
                               OPERATION_FAILED, in the spec and leave everything else up to
                               the binding. If a language needs to map this to an integer code or
                               an exception class, fine.
                         mjn       ###### every single OSID method is defined to throw an exception, largely now only optional methods may throw
                                          so that UNIMPLMENTED can be thrown / caught. Frankly, this is      UNIMPLEMENTED. Some of the
                                          maddening to a Java programmer.                                    errors, such as UNIMPLEMENTED
                                                                                                             and others bind to an unchecked
                                                                                                             Java exception for improved sanity.

                                                                                                             The debate is still open about the
                                                                                                             name of an object should be there.
                                                                                                             On one side, we all leave a stale
                                                                                                             string in the object that is always
                                                                                                             there and never results in errors. On
                                                                                                             the other hand, if one were to keep it
                                                                                                             fresh, there needs to be an error
                         nwright   ###### I think there should be something like                             defined. OsidException &
                                                                                                             curently On ther other hand, no one
                                          org.osid.OsidException extending java.lang.Exception               OsidRuntimeException
                                          and
                                          org.osid.OsidError extending java.lang.RuntimeException

prompting for            tom       ###### One solution is to keep the prompting of such information in the   Sometimes, the provider needs to get
authentication data                       realm                                                              in the UI business or we start
                                          of the application (which may or may not be the authentication     deisgnining complicated callback
                                          comsumer), which may be multiple layers above the authentication   mechanisms :-)
                                          provider. Another is to place the prompting in the realm of the
                                          authentication provider.                                           Think UI Adapter pattern.

java.io.Serializable (and tom      ###### ROMI should not be in the interface.                               done
ROMI too)
                                           questioning utility of java.io.Serializable                       Serializable as a token no longer
                                                                                                             appears in the spec. Where a
                                                                                                             pluggable object is required the spec
                                                                                                             says "object". Object is defined in the
                                                                                                             language binder and the current
                                                                                                             implementation of the binder says
                                                                                                             "java.lang.Object". Round about way
                                                                                                             of saying "removed".
                        nwright   ###### I like the use of java.io.Serializable when used for formal       OSIDs define language-independent
                                         parameters because it tells the programmer using the interface    services. If I store something, it
                                         that this object had better conform to that restriction. This     should be persisted in such a way
                                         parameter had better be able to be sent across the wire because   that I can fetch it via the PHP binding.
                                         even if the implementation today doesn't do it tomorrow's may.    As such, the implementation must
                                                                                                           manage persistence in a platform
                                                                                                           independent way, and must
                                                                                                           understand the object passed to it
                                                                                                           (through a Type) to do this. As such,
                                                                                                           it shouldn't matter if the object
                                                                                                           passed to it from the consumer is

org.osid.shared.Properti tom      ###### Separate property identification from property labelling.         done
es                                       Add metadata to indicate typr of property value.                  done
                                         Create a property factory.                                        new Properties OSID
                        nwright   ###### Include default and possible values.                              Default and possible values can be
                                                                                                           made available inside the Properties
                                                                                                           via the request for a "blank"
                                                                                                           Properties object retrieved from the
                                                                                                           OSID for create operations.

new interface           tom       ###### payment, provisioning
considerations
                        pyrotom   ###### prefences                                                         Configuration
                        nwright   ###### admissions, classroom scheduling

Filing                  tom       ######

Repository              tom       ###### a provider presents a single repository                           A service may present all of its
                                                                                                           assets using requiring no repository
                                                                                                           navigation, or expose its assets
                                                                                                           through multiple repository objects.
                                                                                                           Both situations are handy depending
                                                                                                           on the app.
                                           an asset is a single blob with attributes                       Records and parts removed in favor
                                                                                                           of asset metadata (properties) and
                                                                                                           the ability to compose assets in a

Grading                 gladius   ######
Node suggestions   gladius   ###### Why don't nodes have an isChildOf() and isParentOf() method? It        methods added to traversal session
                                    seems a valuable but easy addition.

Scheduling         gladius   ###### My current thoughts are on the createScheduleItem() method in          The createSchedultItem() and
commitments                         SchedulingManager.                                                     addCommitment() are two separate
                                                                                                           methods. A commitment is to link a
                                     The method takes an array of Ids called agents. There are three       particular person or resource with a
                                     meanings of this, all of which are a bit problematic.                 ScheduleItem. A ScheduleItem can
                                                                                                           exist without any commitments.
                             ###### An AgentCommitment has three key pieces of information--the            Commitments can be searched by
                                    agent's Id, the status type it is associated with, and the             person or resource, so a method has
                                    ScheduleItem it is associated with.                                    been added in the commitment to get
                                                                                                           the related sscheduling item.
                                    The first two are accessible with the getAgentId() and the
                                    getStatus() method. However, there is not a good way to access
                                    the ScheduleItem.
                             ###### SchedulingItems do not have a removeAgentCommitment()                  commitments can be removed.
                                    method.
                             ###### The getCreator() puzzles me because there is no way that I know        This is supplied by the provider - the
                                    of to pass in the creator--no methods and no parameters of the         agent that created the object.
                                    constructor.

                             ###### Speaking of the createScheduleItem() method, there is no               done
                                    parameter to pass in a ScheduleItemStatusType. It may make
                                    sense to add one to be consistent with the create methods in
Properties         gladius   ###### I find the name itself problematic. Why does a class name have a       The Properties object changed
                                    plural name? It does contains lots of "property" things, so it makes   slightly and is a collection of Property
                                    some sense. But each object seems to have a lot of "Properties"        objects.
                                    objects. That is, the singular and plural of "Properties" is
                                    indistinguishable semantically. If there was a name like
                                    PropertyHolder, it would be perhaps twice easy to learn how they
                                    are dealt with and thrice as easy to explain.

                                     Next, ScheduleItem, CourseSection, CourseOffering, and                Administrative sessions sllow
                                     CanonicalCourse have no way to add properties. They might be          properties to be cerated.
                                     useful and flexible if there was a way to pas them in, but they
                                     aren't much use otherwise.
                                         What's more, it make sense to have only one Properties Object for    A consumer can get all Property
                                         those guys, so the getPropetiesTypes and getPropertiesByType         objects in a single Properties, or get
                                         are merely confusing. If getProperties() merely got one Properties   the set of Property objects
                                         object (as its name implies!) the whole thing would make way more    correspodning to a particular
                                         sense.                                                               propertiesType. A propertiesType
                                                                                                              may map to a particular schema
                                                                                                              defined elsewhere. Consumers that
                                                                                                              don't care can just get all properties
                                         Finally, if you populate any of the four classes I mentioned with    The mapping of a property to a type
                                         Properties, the PropertiesType is not passed in. If the types are    is left to the realm of the provider.
                                         part of the implementation, it seems the whole purpose of the
                                         types are defeated.

scheduling master id   tom       ###### The master identifier for scheduling items implies that the         done
                                        scheduling provider does not persist the relation, but the consumer
                                        does. Something seems upside down here given every other
                                        aspect of the service is managed by the provider.

                                         I would have provided a method in the manager to link one item to
                                         another and punted on exposing an identifier.

OSID time              gladius   ###### I think that our timestamps badly need to be synchronized. Just       This is spelled out in the V2 spec.
                                        what is the meaning of the longs we are passing around?               That being said, V3 uses a
                                                                                                              timestamp "primitive" and leaves the
                                         Wouldn't it be a blow to interoperability if my January 1st, 2010    rest up to the binding. A binding
                                         was your January 15th, 1970?                                         should support enough resolution for
                                         I feel it fair to say that we don't need more granularity than a     For some things perhaps. For
                                         second. What's more, I don't think we need records from the          simulations, system events and
                                         1960s (some things are best forgotten).                              financial transactions maybe not. If it
                                                                                                              wasn't going to be too much torture
                                                                                                              having a custom date object, I would
                                                                                                              provide a resolution of yoctoseconds.
                                                                                                              I always find language platforms
                                                                                                              short sighted here.
                                         Also, I think we could perhaps use a getCurrentDate() method in
                                         the SchedulingManager. Would a Time OSID be overkill? It may
                                         be with the various JAVA and Harmoni functions.