text:
|Publication number
|Publication type
|Application number
|Publication date
|Mar 14, 2000
|Filing date
|Dec 16, 1994
|Priority date
|Dec 16, 1994
|Fee status
|Publication number
|ChungHen Chow, James William Fountain, Jr., Rene Lim Llames
|Original Assignee
|International Business Machines Corporation
|Export Citation
|BiBTeX, EndNote, RefMan
|Patent Citations (21), Non-Patent Citations (16), Referenced by (100), Classifications (6), Legal Events (4)
|External Links: USPTO, USPTO Assignment, Espacenet
The present application is related to U.S. patent application Ser. No. 08/357,834, entitled "SYSTEM AND METHOD FOR PROVIDING A VISUAL APPLICATION BUILDER FRAMEWORK", filed on Dec. 16, 1994, which is herein incorporated by reference.
This invention generally relates to computerized object-oriented technology and, more particularly, to improve interactive user interface development systems and methods.
Prior to the development of object-oriented programming, a form of programming was developed known as structured programming, which is still used extensively. In this technique, various functions are first defined, and the program then consists of calling such defined functions at appropriate times to effect the overall objective of the application program. Structured programming provided the opportunity of a modularized approach--a significant improvement over "spaghetti code" which was difficult to debug and maintain. Nevertheless, several drawbacks to structured programming remain, such as the "semantic gap" between the concepts and entities in the world being modeled by the program and the concepts in the programming language, the textual nature of the program code, and limitations on reusability of code modules.
Eventually, a new programming paradigm was developed, referred to as object-oriented programming. In this technique, instead of defining functions, "objects" are defined (by defining their "class"). Only the external interfaces of the objects and what can be done with the objects are specified for the end-user, as opposed to the internals of they are constructed.
As a simplistic example of this technique of describing the external "appearance" of an object without the necessity of describing what it "looks like" or "does" inside, and in order to illustrate the significant benefits of such object-oriented programming, one might imagine, by analogy, a common household toaster, which could be modeled by the object-oriented approach. The external "interface" would consist of the knob, which essentially represents a parameter for adjusting the desired lightness or darkness of the toast, the slot into which the bread is inserted, and a lever for effecting the insertion and activating the toaster. The important concept is that the end-user of such an appliance does not need to know the "internals" of the toaster in order to use it, e.g. whether heat is provided by electricity, or by chemical or other means. All the user would have to do is interface properly with these externals.
The beauty of this evolution in programming is that, continuing with the analogy, the designer of the object, which might be a module of programming code modeling a toaster, may focus on improving the internals of the toaster, making it more efficient, for example, without affecting the user's ability to use the object, inasmuch as the internals are transparent to the user. Thus, more abstractly, object-oriented technology may be seen essentially as providing the advantage of separation of the interface of an object from it implementation. In a software context, the internals of the object may thereby be rewritten and improved without the necessity of rewriting the entire application program, as long as the external "knobs" etc, and their expected behavior have not changed.
The foregoing illustrates one of two important characteristics of object-oriented technology, namely, that of "encapsulation". The other characteristic is "inheritance", whereby, broadly speaking, an object may "inherit" (or acquire) all or some of its interface or implementation from another similar object, thereby avoiding the need to duplicate the descriptions of such common characteristics. For example, a "WheeledCarrier" class of objects may be defined, having the generic characteristics and definitions of having wheels and being able to carry passengers. A "Car" class of objects can then be defined, which inherits part of its description from "WheeledCarrier". Similarly, an "Airplane" class of objects can also be defined, which inherits from "WheeledCarrier". (In object-oriented terminology, the "Car" class is a subclass of the "WheeledCarrier" class, "Airplane" is a subclass of "WheeledCarrier", and "WheeledCarrier" is a superclass of "Car" and of "Airplane". Of course, cars are different from airplanes and their full descriptions will reflect the differences, but because of the use of inheritance, redundant description of their common characteristics of having wheels and being able to carry passengers is avoided.
For further general background regarding object technology to facilitate a better understanding of the invention, reference should be made to "Object Oriented Technology--A Manager's Guide", by David A. Taylor, copyright 1990, Servio Corporation.
With the development of object-oriented programming, several "object models" were further refined and developed, which specified the manner in which one was to define objects and their external interfaces, such various object models providing the aforementioned characteristics of encapsulation and inheritance among others. At an appropriately high level, these various object models are very similar, examples of which are the System Object Model (SOM), Common Lisp Object System (CLOS), Smalltalk, and C++. In essence, these various object models are simply a body of rules answering the question of what an object is, each offering slightly different answers when examined at lower levels. For example, various object models differ in their language syntax, and in how encapsulation and inheritance work.
As a direct result of these differences, one problem presented by the availability of different object-oriented languages and object models was that problems in interlanguage operability appeared, e.g. object programs could not be written with a mixture of such languages, thereby adversely impacting one of the major promises of object technology, namely reusability of code. In an effort to address this problem plaguing the industry, a Common Object Request Broker Architecture (CORBA) was arrived at by committee, which included a standardized Interface Definition Language (IDL). There was in essence an agreement in the industry as to how interfaces of an object would be specified, i.e. a standard for defining object interfaces so that objects defined by one vendor could be utilized by another. Thus, with CORBA, the effort was started to facilitate uniform definitions across languages of what an object was to "look like" in order to facilitate implementation of applications in multiple languages.
The aforementioned System Object Model (SOM) is one object model which conforms to CORBA and IDL. Conformance means that SOM objects follow CORBA semantics, and SOM objects are defined in IDL syntax. The significance of the foregoing will become readily apparent hereinafter in a more detailed description of the invention but is provided at this point for background.
We will now turn more specifically to an application of this object technology, in particular, to problems associated therewith which have plagued the industry and been successfully addressed by the subject invention. One important use of object technology is in implementing an improved "visual builder" environment for visual programming. A visual builder is essentially an application writing tool permitting the "writing" of programs visually (instead of by the more traditional method of writing textual code). Particular utility for such tools arises with respect to the writing of programs having graphical user interfaces ("GUIs"). As will be hereinafter seen, the invention provides such a program-writing tool which is itself visually based as well.
It is a characteristic of current programming technique that a great deal of the time is spent in coding the actual graphical user interface or "GUI" presented to the user (as opposed to the underlying code and functionality to which the GUI interfaces), and the present invention is directed in part to simplifying these tasks. To be more clear as to what is meant by a "visual builder", put simplistically, it is a tool which facilitates the writing of programs by the creation, movement, and interconnection of icons, e.g., through a user interface or GUI as opposed to through conventional textual programming.
A simple example of such a visual builder may be seen in the product "Visual Basic" by Microsoft Corporation in which the user interfaces, such as various windows, pull-down menus, buttons, scroll bars, and the like are created visually. A visual builder system arranges for the actual functioning interface to appear when the built application is executed, thereby relieving the programmer of the task of writing a textual program to implement the interface. As will become more apparent hereinafter, there is an increasing need to facilitate the ability to efficiently program applications visually, e.g. by "visual programmers" who do not have the detailed knowledge of computer programming languages and the like associated with the more traditional notion of a computer programmer. This need has been fueled in part by the phenomenal increase in multimedia. The invention is intended to address in part the problems associated with this concept of visual programming.
A major task of implementing a useful visual builder is to provide the function of a visual editor of the tree or graph structure of FIG. 4 (although as will hereinafter be seen it will necessarily have additional requirements, such as providing the ability to edit properties associated with the objects, etc.).
In order to more fully understand the invention, again, by way of background, a general description of the requirements for such a visual builder will now be provided.
Referring first to FIG. 2, a representative user interface 40 is shown which might appear on the monitor 38 of FIG. 1 during the process of a user visually programming a desired application. The purpose of the interface is to provide a dialog and interface between the computer and the programmer by means of visual items such as sliders, buttons, etc. whereby the programmer may proceed to structure, build, and define an end-user application. The application itself may also include graphical user interfaces employing items similar to those shown in the application build tool screen of FIG. 2, e.g., sliders, buttons, windows and the like.
More specifically, a representative interface 40 might include various icons such as slider bars 42, 46 (with associated slider "thumbs", 43, 49; end buttons 41, 45, 47, 48); buttons 50, 58; icons such as speaker icon 44; windows 52, 56; and pull-down menus 54.
One aspect of the interface 40 of FIG. 2 not intuitively obvious is that although these various items appear "flat", "under the covers" they would reveal an associated nested hierarchy of visual objects such as depicted in FIGS. 3 and 4. Thus, comparing FIGS. 2 and 3, it will be seen for example that button 58, rather than being merely a "flat" arrangement as a control, exhibits a nested relationship whereby button 58 is, hierarchically speaking, in box 56 which is in turn in box 52 and in turn in box 49.
A conventional way in the art to represent a nesting or containment relationship, such as that embodied in a GUI and the corresponding programming code implementing it, is by means of a data structure commonly known as a "tree" or graph shown in FIG. 4, which obviously more readily visually depicts the hierarchy. Each of the icons, slider bars, and the like are shown in FIG. 4 as a node or circle representing an "object" within the meaning of the object-oriented technology hereinbefore described.
In a conventional approach to writing user interface programs, trees similar to FIG. 4 are programmed textually. The various nodes, children to nodes, and children of children to nodes, etc. shown by the objects of FIG. 4 are typically implemented in building up the tree of FIG. 4 by coding in a high level language such as C, C++, or the like. As has already been pointed out, this process is extremely tedious, involving all of drawbacks of even high level languages including statements requiring precise arguments, syntax, semantics and the like.
Because of the foregoing, it became desirable to provide for the aforementioned "visual builders" whereby a program could be constructed which would in essence build the desired runtime trees of FIG. 4 by means of interactively creating, moving, and interconnecting various icons and the like (such as those depicted in FIG. 2) inasmuch as it is far easier to do so by this means rather than by writing C programs, for example.
Thus, in response to this need, vendors set upon the task of providing visual builders to interactively build up these containment structures or trees.
It should be noted that interacting with the various items of FIG. 2 would not necessarily impact the runtime tree of FIG. 4. For example, clicking on button 58 would not necessarily alter the tree structure of FIG. 4. However, moving button 58 out of box 56 to location 60 would change the hierarchical structure of this object, as may be seen in FIG. 4. Object 58A which extended from object 56A (corresponding to button 58 being contained within box 56) would, after the button 58 was moved to location 60, be reflected in the tree as object 60A now extending from object 52A (thereby reflecting the new hierarchy in which button 58 at location 60 is contained by box 52). Thus, in general, it may be seen that manipulating the items in the interface FIG. 2 may alter the corresponding object tree of FIG. 4.
A major task of implementing a useful visual builder is to provide the function of a visual editor of the tree or graph structure of FIG. 4 (although as will hereinafter be seen it will necessarily have additional requirements, such as providing the ability to edit properties associated with the objects, etc.).
Continuing with the general background discussion regarding the requirements of implementing visual builders and user interfaces, textual programming of GUI applications, for example, with the C language and some library such as X and OSF/Motif, or the Presentation Manager library of the OS/2 operating system shows that several further tasks are required beyond the building of the initial tree. The initial properties of the various nodes in the tree must be set, or, in general, the programmer must decide, for each available property, whether to specify its initial value or to accept the default initial value. (Examples of properties of the nodes in the interface of FIG. 2 would be the color of box 49, initial position of a slider thumb 43, contents of a pull-down menu 54, etc.). In addition to the task of setting or defaulting such properties of objects, there is the further task of making connections between the objects, thereby specifying the actions to be performed when certain events occur. For example, if the user were to depress button 50, the desired action might be, for example, a beeping of speaker 44. If the position of slider 43 changed, the desired action might be for some window to scroll appropriately.
Finally, after the tree has been built, the various object properties have been set, and the actions to be performed on specified events have been specified, the last task that a GUI application (either built by a visual builder or textually programmed) must do is to enter an event loop at runtime. If an event occurs, the program will perform the corresponding action, and then wait for occurrence of the next event. The typical desired behavior is for the application program to be running in an infinite event loop, responding to events such as the activation of button 50, etc.
From the foregoing, it will be readily appreciated, in summary, that a user interface application may be represented by a tree such as that of FIG. 4 which in turn represents a hierarchy of objects, and that the construction of such a tree textually is an extremely tedious matter, giving rise to the development of visual builders. However, even with the presence of visual builders, several serious problems nevertheless persisted.
First, these objects themselves (such as those shown at the nodes in FIG. 4), are typically written in accordance with more traditional programming techniques wherein the objects might never have been intended to be manipulated in a visual builder environment, but rather, intended to be part of a low level object-oriented toolkit library. Consequently, usability of these objects for higher level visual programmers may not have been a prime consideration or even a consideration at all in implementing these objects, and accordingly the properties thereof, prior to the invention, might not appear intuitive to a visual programmer.
A problem is that, in present systems, the interfaces of the runtime objects presented to the visual programmer are constrained to be those specified by the object definition. Thus present systems are limited to presenting to the visual programmer exactly the same interface (e.g., Smalltalk methods, CLOS generic functions, and by extension to CORBA, IDL attributes and operations specified by the definition of the object). Such interface may include, for example, unwieldy attribute or operation names, and attributes or operations which are at such a low level as to seriously impair the user friendliness of a visual builder.
The invention disclosed is our co-pending patent application Ser. No. 08/357,834, entitled "SYSTEM AND METHOD FOR PROVIDING A VISUAL APPLICATION BUILDER FRAMEWORK" filed on Dec. 16, 1994, solved these problems and provided a visual builder wherein the object's interface as seen by a builder user could be decoupled from that specified by the object model interface.
More particularly, it provided for an arbitrary mapping of more intuitive properties and operations of objects to the attributes and operations of runtime objects dictated by the particular object model. More control was provided in the manner in which editable properties and operations of runtime objects were presented to the visual builder user to avoid overwhelming the visual programming with unnecessary object detailing. The invention facilitated the definition of new properties of objects at higher levels of abstraction presented to the visual builder user, thereby making the editable runtime objects more intuitive.
The foregoing was accomplished by providing "proxy objects" and a system and method for visually constructing and editing a proxy object tree. Each such proxy object in the proxy object tree at build time corresponded to a correlative target object in a corresponding run time target object tree.
The proxy object interfaces, as seen by the visual builder, were "decoupled" from the interface specified by the particular object model of the target objects. In this manner, since the proxy object could be customized, the visual builder system was not forced to present to the user the exact attributes and operations of the target objects dictated by a given object model.
These proxy objects each required a great deal of information such as the class of the target object corresponding to the proxy object, presentation information on how the proxy object should present itself to the user, properties of the particular proxy object and how they are mapped to IDL attributes, and the like, all of which are further described herein.
A serious problem presented in implementing a visual builder employing the thus-described proxy object concept was how to efficiently and effectively store and access this large volume of proxy object information.
One approach was to hardcode in the implementation of the actual of the proxy itself all the necessary information for each proxy object.
Whereas this has the specific performance advantages typically associated with hardcoding, several serious disadvantages were nevertheless present as well, also associated with the nature of hardcoding.
One such disadvantage is that alteration in these proxy objects required altering the source code implementing the proxy object, which required a programmer well versed in the intricacies of writing program code.
Yet another significant disadvantage was that these changes to source code necessitated resultant recompilation of the source code.
It is therefore an object of the invention to provide a visual builder which is easy to maintain and alter.
It is a further object of the invention to provide such a visual builder which could be maintained without necessitating the alteration or rewriting of source code.
Yet a further object of the invention was to provide an improved visual builder based upon an object model implementation employing proxy objects, wherein modifications to such proxy objects was facilitated.
Still another object of the invention was to provide for such an object-based visual builder wherein modifications to such proxy objects could be effected easily by someone without detailed programming skills.
Still a further object of the invention was to provide for such a visual builder wherein modifications could be effected to the proxy objects without necessitating recompilation of source code of such proxy objects.
An object model-based visual builder is provided which includes proxy objects at build time, each corresponding to a target object at runtime. Each such proxy object has associated therewith several items of information, including the class of the target object corresponding to the proxy object, presentation information, properties and how they are mapped to IDL attributes and operations, events available on the target object, and operations supported by the target object. A portion of such information is stored in an Interface Repository, such as the System Object Model (SOM) Interface Repository, in easily changeable form, with the necessary knowledge for retrieving such information from the Interface Repository being contained in the proxy object itself. The information stored in the Interface Repository may be changed without altering or recompiling the source code which implements the proxy object itself. Interface declarations for proxy objects are provided in corresponding IDL files stored in the Interface Repository. Implementation statements in the files permit modifiers which encode the easily editable portions of the proxy object information.
These and other objects have been provided by the invention, a more detailed description of which follows hereinafter and may be more fully understood with the accompanying drawings wherein:
FIG. 1 is a block diagram of a personal computer system for use in implementing the subject invention;
FIG. 2 is an illustration of a graphic user interface portion of a program which may be implemented with the invention;
FIG. 3 is an illustration of components of the user interface of FIG. 2 illustrating their hierarchical nature;
FIG. 4 is an illustrative runtime target object hierarchy tree of the invention corresponding to FIG. 3;
FIG. 5 is a create/edit/build proxy object tree in accordance with the invention corresponding to the tree of FIG. 4.
FIG. 6 is a graph illustrating improvements in real memory usage in accordance with the invention;
FIG. 7 illustrates the storage of selected proxy object information in an Interface Repository;
FIG. 8 illustrates an example of a particular form of a proxy object and associated IDL file stored in an Interface Repository as illustrated in the FIG. 7.
From the background of the invention, the general benefits to a visual builder or interactive user interface development system should now be readily apparent. Before describing in more detail aspects of the subject invention, additional detail will be provided in relation to the requirements for a visual builder generally.
As previously described, the first task of such a builder is to perform the function of a tree editor and make building a tree such as that shown in FIG. 4 considerably easier than in the case of writing textual code, which would typically require code to create each node and attach it to the appropriate parent. With the advent of visual builder environments, the visual programmer may simply drag a desired object such as button 58 of FIG. 2 to location 60. Internally, the visual builder code would automatically understand how to alter the corresponding object tree, thereby producing a new tree as shown in FIG. 4.
As touched on in the Background of the Invention, a second task to be provided by a visual builder in accordance with the invention is to facilitate the setting of properties of the runtime objects such as those of FIG. 4, i.e., the visual builder must be a property editor. This means that the builder must provide for the editing of initial properties of objects interactively without the necessity of the programmer writing code. For example, the programmer should be able to click on an object, such as one of the pushbuttons shown in FIG. 2, and be shown a list of properties of that button object in order to set them. Such properties might include the foreground and background color, as an example.
A third function to be performed by a visual editor in accordance with the invention is to facilitate the user's ability to specify actions to be performed. Thus, a connection model will accordingly be provided, an example of which is as follows. The user might desire, for example, upon clicking on the button 50 of FIG. 2 with an appropriate pointing device, that a sound occur such as that represented by the speaker 44. A desirable implementation of a system for specifying actions to be performed, using this example, would enable the user to drag a cursor after clicking on the button 50 to the desired object such as the speaker 44. An arrow 62 might then be presented signifying that an operation will be performed on the target object 44 to be specified. Desirably a dialog box may then appear when editing this connection, shown by arrow 62, to enable the visual programmer to specify the event on button 50 which would cause some specified operation on speaker 44 to be invoked. Possible events which could be associated with the button might be a "click" event, (occurring when the button is pressed), an "expose" event (occurring when the button first appears or when a window covering it is moved), or a "resize" event (occurring when the button is resized, if it is resizable).
As another example of objects having events for which the visual builder must be able to specify actions, consider slider object 42 in FIG. 2. In the case of such a slider, a typical event might be a "changed" event if the position of the thumb 43 or 49 changed, thereby requiring the action of scrolling a window. In like manner, clicking by a pointer device on the end buttons 41, 45, 47, or 48 might, in response to this "click" event, cause scrolling by a page in a window.
From the foregoing, it will be seen that a way may thus be provided for interactively specifying actions to be performed when an event occurs. In summary, then, a desired implementation of a visual builder in accordance with the invention builds an object tree associated with an interface, facilitates setting the properties of the objects, and then further facilitates specifying the actions to be performed when certain events occur.
Detail will now be provided of how a particular visual builder framework in accordance with the present invention operates.
It will be noted that FIG. 4 is labelled a "Runtime Target Object Hierarchy Tree". Nodes shown in the Figure such as 72, are representations of actual objects which are desired to be created when the end-user application executes. At realization, an application built with the visual builder of the invention will, at runtime, create such a "runtime" object tree of FIG. 4. Secondly, it will be recalled that the various properties of the nodes or target objects shown in FIG. 4 will be set, and finally all of the linkages such as those shown by arrows 84 will be effected (specifying that if an event occurs on a given object, this will in turn call an operation of another (possibly several) object). FIG. 4 is thus labelled "Runtime" because it illustrates the objects which the application must create when it runs.
It is important to make a distinction between this runtime and "build time" during which the visual builder is not actually creating the objects of FIG. 4. It is an important feature of the invention that "proxy" objects are created by the visual builder during this "build time" (shown in FIG. 5), and that these editable proxy "source" objects map to corresponding runtime "target" objects shown in FIG. 4.
By analogy, in standard textual programming, at "build time", when an end-user application is being written, the programmer is editing source code text which is not (usually) the actual executable form of the program. Thus, in the case of the visual builder of the invention, the visual builder, in part, may be thought of as a "source code" editor performing a function similar to the text-based source code editor in the more conventional process of editing in standard textual programming. The distinction is that the "source" being edited by the visual builder is not a stream of ASCII text characters, but rather a tree of these "proxy" objects, as shown in FIG. 5.
Whereas at runtime (FIG. 4), the goal is for the visual builder to build the tree of "target objects", at build time (FIG. 5) it is desirable for the visual builder to create, edit, and build a tree of corresponding proxy objects. A comparison of FIGS. 4 and 5 will reveal a similar pattern between the target objects and proxy objects visually illustrating their one-to-one correspondence and the similarity in structure between the proxy object tree and the target object tree.
Thus, the visual builder of the invention may be seen in reality to be, in part, a proxy tree or graph editor, with the proxy objects being the "source" which is manipulated and edited by the visual programmer at build time. The reason why a proxy tree of FIG. 5 is required is that the proxy objects differ from the target objects in important respects which will be hereinafter detailed.
As previously described, each of the target objects shown in FIG. 4 (70, 72, etc.) represent the final actual runtime objects which are desired to be built, such as the scroll bar, window, form, etc., objects. Although the examples discussed have focused on visual runtime objects, note that runtime objects may also be nonvisual, e.g., they may not necessarily have a visible representation at runtime. In contrast, the objects represented by the circles or nodes in FIG. 5 are "stand-in" or "proxy" objects (which may also be thought of variously as "surrogate" or "shadow" objects) in the sense that each one has a corresponding target object at runtime. This explains the numbering convention of "70" for the target object and "70A" for the proxy object, as an example.
Now that the notion of a "proxy" object has been introduced as a fundamental concept of the present invention, it is necessary to detail the functions it must be capable of performing. They are as follows:
Representative Proxy Functions
1. Present itself at build time.
2. Provide storage for, and access to, property values.
3. Provide information on the events available on corresponding target object.
4. Provide information on the operations available on corresponding target object.
5. Save itself on, and restore itself from, a persistent medium.
6. Copy itself.
7. Realize itself, and subsequently detach itself from the realized target object tree, and destroy itself.
As to the first function of all such proxy objects, e.g., presenting itself at build time, this means that each proxy object must be able to display on the appropriate monitor 38 of FIG. 1, a visual manifestation of itself to enable interactive manipulation. Thus, as an illustration, a function of the proxy object for a button 58 of FIG. 2 must be to present a visual image in a user interface so as to suggest to the visual programmer that there exists a button target object in the target object tree being built.
Regarding function 2 of proxy objects, it will be recalled from the foregoing that a visual builder of the invention serves as a property editor, i.e., it provides the facility for editing the various properties of proxy objects. Accordingly, it should be evident that it is necessary to provide some facility for keeping track of these properties, e.g., what names and current values are. As an example, a pushbutton target object and corresponding proxy object might have, as properties, the foreground and background colors thereof, height, width of the button, and the position of the upper-left corner thereof. A corresponding proxy object would therefore store this property information associated with the target button object. In other words, the button proxy object, as an example, will "know", (i.e., be capable of storing and accessing) the aforementioned properties and what their current values.
Regarding functions 3 and 4 of the proxy objects, if the visual builder of the invention is going to include the facility of making interconnections between proxy objects, there must be facility for knowing the events and operations which are available. For example, if proxy object 74A corresponds to a pushbutton target object 74, then an additional function of the proxy object 74A is to have information on the events which can occur on it, such as the "click" event. In other words, the proxy object must know the events available so that the programmer may select the appropriate one to which to attach a desired action. Actions are usually invocations of operations on other objects. Therefore, a proxy object must have information on the operations supported by its corresponding target object so that the programmer may select and properly call the appropriate one in response to an event. For example, if it is desired to call an operation on the "speaker" object, then the speaker proxy object should know that its corresponding target object supports a "beep" operation.
Regarding function 5 of proxy objects, in the course of visual programming of an application, it may be desirable to suspend creation of the program. This proxy object function simply means that each proxy object must be able to save its corresponding proxy tree information and associated data. In other words, proxy objects must be provided with the ability to save themselves to, and later restore themselves from, some persistent medium such as a file system when visual programming of the particular application is resumed. This function is analogous to the ability of most text editors to save and later resume editing of textual source code.
Regarding function 6 of proxy objects, such proxy objects must be capable of replicating themselves. This facility is required for convenience in visual programming, i.e. to make it possible to create copies of objects at build time.
Finally, function 7 of proxy objects means that proxy objects be capable of realizing themselves, and subsequently detaching themselves from the realized target object tree, and destroying themselves. Proxy objects may be thought of as "delegates" which essentially are standing-in for their corresponding target objects. At some point, it will be desired to execute the program being built, and it will therefore be necessary to create and initialize the runtime tree, such as the example tree shown in FIG. 4. The collection of proxy objects has the necessary information to effect the running of the program inasmuch as it is essentially the "blueprint" or "source code" (FIG. 5) for the corresponding application (FIG. 4). The term "realize" simply means that the proxy objects must be capable of creating their associated target objects.
There are numerous benefits to providing a visual builder of proxy objects and the proxy object tree of FIG. 5 which may not be readily apparent and will thus be hereinafter described in greater detail. The description of these benefits will, in turn, further dictate the manner in which such proxy objects and the corresponding visual builder will be implemented in accordance with the invention.
A first major benefit of the visual builder implementation currently being described, which provides a significant distinction over visual builders of the prior art, is that by provision of such proxy objects, the proxy objects' interfaces as seen by the visual builder user are thereby decoupled from the interface specified by the target object definition.
The target objects of FIG. 4 are defined in a particular object model such as SOM, in the case of the implementation of the invention being presently described. As such, these target objects have an IDL definition which define what the attributes and operations of the particular target object are.
Because, in constructing the visual builder, it has been implemented so that the various proxy objects may be pre-defined and customized, the invention's system is not forced to present to the user of the visual builder the exact attributes and operations of the target objects of FIG. 4. Rather, the flexibility to define a different set is provided.
An example of the foregoing will be helpful in understanding its significance. Operations associated with a target object such as object 72 of FIG. 4, as dictated by the IDL, may be extremely low level. In like manner, attributes of such target objects 72 may have long and rather difficult names to read. Because the invention provides the facility for proxy objects, a different set of properties may be presented to the visual programmer which map to corresponding attributes on the target object. As an example, let us suppose that target object 72 has these attributes, namely "red", "green", and "blue", which are components of an RGB specification of the color of some part of the object on the screen. (Each component controls the amount of the associated primary color.)
At the visual builder level, it is undesirable to present to the visual programmer the information that this particular target object has three properties of "red", "green", and "blue". It would be much more desirable to simply communicate to the programmer that object 72 has a "color" property whose values may take on those listed such as pink, purple, orange, etc. These colors would then be translated into the necessary R, G, B components which the IDL attributes provide in order to effect the desired color.
In other words, a given target object might not provide a "color" attribute in its interface definition. Rather, it may have three separate attributes which collectively make up the color (e.g., R, G. B). To a visual programmer, this may appear as an unduly low level way in which he or she is required to specify color. It would be much more preferable to only require the visual programmer to pick the particular desired color such as orange, rather than doing so by way of specifying 100% red, 50% green, and 0% blue.
Thus, in providing for proxy objects, the invention allows a single property like "color" to be defined and presented to the programmer, and the proxy object possesses the information to translate this user-specified "orange" color value into the attributes of the target object, namely 100% red, 50% green, and 0% blue. For relatively high level users, the invention has facilitated the ability to define new object properties which will then be translated (transparently to the user) into the necessary target attributes. The attributes of the target objects can therefore be rendered more intuitive to the visual programmer by means of such proxy objects.
Stated another way, proxy objects provide a mechanism for introducing abstraction in an object's properties and for mapping the abstractions onto the actual defined interface. If we thus were to define a button's "color" property in the corresponding button proxy object, this proxy object will contain the information necessary to know how to set the corresponding appropriate R, G, and B IDL attributes in the target object the high level "color" property. As will be hereinafter made clearer, the knowledge of how to map the high level proxy object properties to the target object attributes will be utilized at build time and at realization time, and the knowledge is built into the particular proxy object when it is designed.
The invention need not be limited to only mapping properties of proxy objects to one or more attributes (such as IDL attributes in the implementation being described). The invention specifically contemplates mapping properties of proxy objects additionally to arbitrary combinations of properties and operations.
As an example, continuing with the prior illustration, it may be desirable to specify a "color" with R, G and B components. A target object may not have not three IDL attributes R, G, B, but instead may have three IDL operations such as "setR", "setG", and "setB". We may further desire that the builder user again simply be required to set a property "color". In this case, the proxy object would contain the necessary information to translate this "color" into calls to the three operations "setR", "setG", and "setB". This is thus an example of a proxy object property such as "color", being mapped to several operations, rather than an attribute. Note that an "operation" on an object is something which is performed or invoked on an object, as distinct from an "attribute", which is data which may be set or queried, such as "color" or "speed". However, in most object models, including SOM, attributes are just a special case of operations.
From the foregoing, it should be clear that providing the ability to define proxy objects enables us to change the way an object looks to a user, and to not be constrained by the available interface of the runtime target object.
We could, in designing a proxy object for a particular target object, add, remove, or redefine properties of the target object, as long as the new set of properties can be mapped to the existing available attributes and operations.
There is yet another important benefit to having proxy objects. Specifically, provision for proxy objects facilitates the implementation of visibility or "exposure" control on properties and operations of proxy objects.
Typically a visual programmer may not desire to be overwhelmed with the need to view all available editable properties or callable operations of a runtime target object. Provision for proxy objects enables us in the design of the visual builder to present these properties or operations to a visual programmer in a more organized manner. They may be classified into related groups, and a user may be required to take an affirmative step such as clicking on a button to see the properties in a given group. This is what is meant by visibility or exposure control. The user may initially only be shown those properties which are most typically desired to be edited or selected. The proxy objects provide the mechanism to control what properties are seen and editable by a visual builder user at any time.
A point of clarification regarding terminology may be appropriate in order to avoid confusion. At some appropriately high level, the terms "property", "attribute", "characteristic", and "feature" are synonymous and may be used interchangeably. However, as a matter of convention, we use the terms "attribute" and "operation" when referring to the IDL-defined interface of a target object, and the terms "property" and "operation" when referring to the proxy-defined interface, as seen by a visual programmer.
As was explained in the Background of the Invention, if the implementer of a visual builder could control the design of the target objects and their specifications, there might not be a need for redefining the set of properties seen by a visual programmer, or for controlling their visibility. However, in practice, such ability is not present because typically the target objects are already pre-written, often by another programmer under the constraints of a different usage model.
The proxy object framework affords the visual builder implementer (or perhaps more correctly, the person enabling a given object to be used and manipulated within the visual builder), the flexibility to essentially define a new "world" to suit desired purposes and needs. Typically, one of the most important of these needs is that the visual builder be user friendly and, secondarily, exhibit desirable performance characteristics. This flexibility is provided so long as we have the facility for translating the proxy object world to the target object world. The properties of particular proxy objects which are visible to a builder user do not have to be identical to the target object IDL attributes. On the contrary, we thus have the flexibility to define a different set of properties for purposes of user friendliness, for example, so long as we can map the "virtual" properties presented by the proxy objects to the target properties.
It will be noted that the invention is not limited to the mapping of properties. We may also redefine the set of object operations as seen from within the visual builder environment. The operations seen by the visual programmer need not be identical to the operations supported by the corresponding target object. As in the case with proxy object properties, we can relax the requirement that all target object operations be shown as proxy object operations. In other words, the proxy objects may advertise a different set of operations, again as long as we provide facility for translating the new operations to the attributes and operations of the target objects. The earlier comments on visibility control of properties also apply to the operations seen by the visual programmer when specifying event-action connections between objects.
Another important aspect and advantage provided by the invention, in implementing the visual builder and proxy framework as herein described, is the detachment and destruction of the proxy tree after it has performed realization at built application runtime, thereby saving memory consumption.
To explain this feature, recall that important functions of proxy objects is that they must be capable of "realizing" themselves, i.e. creating their corresponding runtime target objects. AT application runtime, the proxy tree of FIG. 5 facilitates the building of the corresponding target object tree of FIG. 4, sets the properties of the target objects based upon the proxy object properties (since proxy objects contain all of the mapping knowledge necessary to set the attributes and call the appropriate operations on the target objects), and establishes the connections indicating, for example, that when event "E" occurs on object "X", operation "P" is to be called on object "Y", etc.
At this point, the necessary runtime object tree of FIG. 4 now exists and is read to "go", i.e., control can now enter the event loop previously described. Because the proxy tree (which, it may be recalled, may be thought of as "source" code) has performed its job and created its image, there is no more need for it to be consuming memory. Accordingly, it is a further feature of the invention to provide for the detaching and destroying of the proxy objects in real memory after they have effected the realization, at runtime, of the target object tree of FIG. 4.
Referring now to FIG. 6, during the first few moments of application runtime execution, the proxy tree (FIG. 5), is created in real memory and is needed in order to build the runtime tree of FIG. 4. However, after all target objects are built, and the appropriate attributes are set and operations called to initialize the objects' state, and the event-action connections are established, the proxy objects may be removed from memory. The graph 90 represents real memory usage of a system such as that of FIG. 1 wherein the invention is implemented. An initial spike 96 shown therein is caused by the loading of dynamic link libraries (DLLs) associated with the proxy objects into real memory and the restoration of the proxy tree at the beginning of application execution. These DLLs contain the code associated with methods of all the proxy objects. The dip after the spike at point 94 suggests the significant drop in memory usage corresponding to the destruction of the proxy object tree of FIG. 5 and the unloading of such DLLs of the proxy object tree after construction of the target object tree. In other words, the spike 96 is caused in large part by the DLLs of proxy-related code loaded in real memory as well as the proxy object tree. Upon unloading of the DLLs and destruction of the data structures of the proxy tree, which is no longer required, real memory usage drops significantly as shown at reference numeral 94.
It will be recalled that seven functions were enumerated which must be performed by proxy objects. A related consideration is what information these proxy objects must contain to carry out their functions The information may be categorized as follows:
1. The class of the target object corresponding to the proxy object.
2. Presentation information.
3. Properties and how they are mapped to IDL attributes and operations.
4. Events available on the target object.
5. Operations supported by the target object.
More specific detail will now be provided as to these items of information which proxy objects must contain.
As to the class of the target object, if, as an example, a proxy object is a representative or "proxy" for a "President" object (i.e., the class of the target object is the "President" class), the proxy object, at realization, must "know" that it must create a "president" target object corresponding to itself (the "president" proxy object).
As to the second category of information which the proxy object must contain, recall that one function of the proxy object is to present itself (i.e., display something on the screen) at build time. Therefore, a proxy object must contain the information necessary to effect this presentation. The proxy object must know what object to display to the user, and if, for example, the user has iconified an object, what icon to display.
As to the third item of information contained by proxy objects, e.g., "properties", this refers to the fact that proxy objects must know the properties which can be edited since, at build time, the visual builder user will be editing such properties. The proxy object needs to know the name of each property, the data type of property (e.g., integer, Boolean, string, etc.), the current value, and information relating to visibility control. It will be recalled that it is a feature that not all properties need be exposed to the user, and that differing levels of property or operation disclosure or grouping may be implemented. The proxy object must also include knowledge on how the properties are mapped to the IDL attributes and operations.
Fourth, the proxy object must contain information regarding events available on the target object. Using the "President" example, if a proxy object represents a "President" target object, the proxy object must know the available "events" of the target object. For example, the proxy object must know that the "President" target object has a "speak" event available.
Finally, proxy objects must contain information indicating the operations the target object supports including information on the operation name, arguments, and return values, and how they are mapped to IDL attributes and operations.
One problem in implementing a visual builder, given the need of the proxy objects to contain the aforementioned information, is how to efficiently and effectively store and access this information.
One approach is to hardcode in the (class of the) proxy object all information listed above for each class of proxy object.
An advantage to hardcoding this proxy object information is the performance benefit which is typically associated with hardcoding. However, a significant disadvantage is the lack of flexibility also typically associated with hardcoding, namely, that changes require altering the source code and recompiling, with all of the attendant drawbacks. As an example, if in the "President" proxy object it was hardcoded that the only available event was "speak", and later it was desired to add the event "eat", this would necessitate changing and recompiling the source code of the President proxy object.
Accordingly, it a feature of the invention to provide a list of events stored elsewhere and merely looked up by the proxy object. Instead of a proxy object hardcoding all of the information hereinabove listed, it is sufficient for a proxy object to know how and from where to retrieve the information. By doing so, there is no requirement to alter the proxy object code, but rather to simply alter the list of events, which is maintained separately from the proxy object code.
In general, the approach adopted by the invention is one in which some or all of the information required for a proxy object is embedded in the IDL definition of the (class of the) proxy object, which definition then appears in, and is accessible from, an Interface Repository to be hereinafter described. The knowledge of how to retrieve this information from the Interface Repository is hardcoded (in the proxy object class object).
FIG. 7, provides an illustration of the foregoing concept. An example proxy object tree such as that in FIG. 5 is shown. Also shown is a SOM Interface Repository 100. The list of events available on a particular target object is stored in the Interface Repository 100. The proxy object 76 A for a particular target object knows how to retrieve this list from the Interface Repository 100, rather than storing this information directly. In this manner, should it be necessary to alter the list of events, this may be done by simply editing the portion 106 of the Interface Repository 100 containing the list, thereby avoiding the need to recompile the proxy object code.
In general, rather than hardcoding all of the information 108 required by the proxy objects as shown by the legend 102 for each proxy object, part of this information 108 is stored as desired elsewhere in an Interface Repository 100 which may be more easily changed without the need to recompile. The information or knowledge required by the various proxy objects to locate the information in the repository 100 is what is hardcoded into the proxy objects. It will be noted that repository 100 is simply an information store which may be implemented in several ways, such as through a file system.
Considerations well known in the art will determine, for a given implementation, which of the hereinbefore listed items of information required by proxy objects will be hardcoded in the proxy objects and which will preferably be stored in the Interface Repository 100. In the specific implementation being described herein, all items of information 1-5 shown at reference numeral 108 in FIG. 7 would be provided in the repository 100 with the exception of mapping knowledge properties and operations. At one extreme, all such information could be hardcoded into the proxy object, and at the other extreme, a great deal of information could be stored in the Interface Repository 100. In the latter case, this may necessitate development of a language processor or parser. Thus, it may be readily seen that tradeoffs well known in the art present themselves regarding the decision of hardcoding versus development of sophisticated language processors. Put simplistically, in the implementation under discussion, items of information for proxy objects were placed in the Interface Repository 100 which could be represented as lists which could be easily processed, whereas other items which could be more easily hardcoded were placed in the proxy objects.
It should be pointed out that although storage in the Interface Repository 100 provides the advantage of avoidance of recompilation, for example, one disadvantage of storing a large amount of proxy object information relates to performance, e.g., I/O limitations to bulk storage devices such as DASD or the like, which would be a conventional way to implement the Interface Repository 100.
More detail will now be provided regarding specifics of how the appropriate proxy object information is stored in the Interface Repository, with a specific instance of the technique in accordance with the invention discussed with reference to FIG. 8. The technique of the invention employs SOM IDL modifiers which are the mechanism used to store information in the repository 100. Such a modifier is another syntax in SOM class definition.
FIG. 8, depicts a representative IDL file 112, wherein a "President-- Proxy" object class 110 is defined. In this example, the interface definition is in accordance with the IDL syntax previously described. Shown in the file 112 are the attributes and operations 114 of "President Proxy" objects. It will be recalled that defining an object in IDL syntax requires such attributes and operations 114 as mandated by CORBA.
It will be recalled that while SOM is IDL compliant, it goes beyond the requirements of IDL and CORBA in defining additional semantics and syntax. SOM provides for an implementation statement 118 within an interface declaration, which in turn can include arbitrary modifiers 120 such as the "events" and "operations" modifiers shown therein. The basic idea and rationale for such modifiers 120 in SOM is that it is not possible to foresee all possible things which may be desired to be declared about a class. Thus, rather than restricting SON IDL syntax to include only a limited set of forms, an "escape valve" was provided in the form of these modifiers 120 which are ignored by the SON compiler. However, the modifiers 120 are stored in the SON Interface Repository 100 by the SON compiler, and thereby made available for access by any program, even though the SON compiler itself does not know how to utilize the information.
It should be apparent that "lists" of proxy object information which are desired to be stored in the Interface Repository 100, in light of the discussion of modifiers, may be placed in an IDL file 112 as modifiers 120. The SON compiler, as part of the compilation process, places interface definitions (including the modifier information 120) in the Interface Repository 100, so as to be available to any program knowing how to access the repository 100 (which, of course, would include code effecting the access and retrieval by the appropriate proxy objects of the object's information).
While the invention has been shown and described with reference to particular embodiments thereof, it will be understood by those skilled in the art that the foregoing and other changes in form and detail may be made therein without departing from the spirit and scope of the invention.
|Cited Patent
|Filing date
|Publication date
|Feb 5, 1987
|Aug 22, 1989
|Softron, Inc.
|Computer based workstation for development of graphic representation of computer programs
|Apr 15, 1987
|Jul 24, 1990
|Cimflex Teknowledge Corporation
|Architecture for composing computational modules uniformly across diverse developmental frameworks
|Oct 1, 1990
|Nov 19, 1991
|Visystems, Inc.
|Virtual software machine which preprocesses application program to isolate execution dependencies and uses target computer processes to implement the execution dependencies
|Oct 30, 1989
|Nov 16, 1993
|Intelligent Micro Systems, Inc.
|Displaying hierarchical tree-like designs in windows
|Dec 23, 1992
|May 24, 1994
|Taligent, Inc.
|Object-oriented notification framework system
|Dec 3, 1990
|May 24, 1994
|Bachman Information Systems, Inc.
|Method and apparatus for transforming objects in data models
|Nov 19, 1992
|Aug 16, 1994
|Borland International, Inc.
|Symbol browsing in an object-oriented development system
|Nov 9, 1992
|Jan 16, 1996
|Virtual Prototypes, Inc.
|Computer modelling system and method for specifying the behavior of graphical operator interfaces
|Jan 21, 1994
|Jan 23, 1996
|Borland International, Inc.
|Development system with methods for visual inheritance and improved object reusability
|Sep 25, 1992
|Mar 5, 1996
|Bull Hn Information Systems Inc.
|Ally mechanism for interconnecting non-distributed computing environment (DCE) and DCE systems to operate in a network system
|Nov 9, 1994
|May 14, 1996
|Kahn; Kenneth M.
|Animated user interface for computer program creation, control and execution
|Oct 19, 1995
|Mar 18, 1997
|International Business Machines Corporation
|Method and apparatus for activating and executing remote objects
|Dec 16, 1994
|Jun 24, 1997
|International Business Machines Corporation
|System and method for providing a visual application builder framework
|Sep 28, 1995
|Apr 7, 1998
|Sun Microsystems, Inc.
|Method and apparatus for allowing generic stubs to marshal and unmarshal data in object reference specific data formats
|Jan 29, 1996
|Nov 24, 1998
|Digital Equipment Corporation
|Method and apparatus for forming a translation unit
|Oct 27, 1995
|Dec 8, 1998
|Unisys Corp.
|Method for generating OLE automation and IDL interfaces from metadata information
|Jul 8, 1996
|Jan 5, 1999
|Gradient Technologies, Inc.
|Web application server with secure common gateway interface
|Apr 12, 1996
|Jan 19, 1999
|Fisher-Rosemount Systems, Inc.
|Process control system using a control strategy implemented in a layered hierarchy of control modules
|Sep 27, 1996
|Jan 19, 1999
|Intermind Corporation
|Computer-based communication system and method using metadata defining a control structure
|Feb 9, 1996
|Feb 2, 1999
|Secure Computing Corporation
|System and method for securing compiled program code
|Oct 26, 1995
|Feb 16, 1999
|Viewsoft, Inc.
|Method for managing dynamic relations between objects in dynamic object-oriented languages
|"Attribute Action Objects", IBM Technical Disclosure Bulletin, vol. 37, No. 02B, Feb. 1994, p. 665.
|"Expose Connection List as Property", IBM Technical Disclosure Bulletin, vol. 37, No. 08, Aug. 1994, p. 433.
|"Lock Icon to Secure Visual Builder Controls", IBM Technical Disclosure Bulletin, vol. 37, No. 04B, Apr. 1994, p. 21.
|"PRoxy Definition Tool for Visual Builder", IBM Technical Disclosure Bulletin, vol. 37, No. 04B, Apr. 1994, p. 347.
|"User Interface for Scripts in an OO Visual Builder", IBM Technical Disclosure Bulletin, Vo. 37, No. 04B, Apr. 1994, p. 449.
|"Visual Script Action Objects", IBM Technical Disclosure Bulletin, vol. 37, No. 04A, Apr. 1994, p. 683.
|Attribute Action Objects , IBM Technical Disclosure Bulletin, vol. 37, No. 02B, Feb. 1994, p. 665.
|Dave et al, "Proxies, Application Interfaces, and Distributed Systems", Object Orientation in Operating Systems, pp. 212(10), Sep. 1992.
|Dave et al, Proxies, Application Interfaces, and Distributed Systems , Object Orientation in Operating Systems, pp. 212(10), Sep. 1992.
|Expose Connection List as Property , IBM Technical Disclosure Bulletin, vol. 37, No. 08, Aug. 1994, p. 433.
|Lau Kee et al, VPL: An Active, Declarative Visual Programming System , Visual Languages, 1991 IEEE Workshop, pp. 40(8), Oct. 1991.
|Lau-Kee et al, "VPL: An Active, Declarative Visual Programming System", Visual Languages, 1991 IEEE Workshop, pp. 40(8), Oct. 1991.
|Lock Icon to Secure Visual Builder Controls , IBM Technical Disclosure Bulletin, vol. 37, No. 04B, Apr. 1994, p. 21.
|PRoxy Definition Tool for Visual Builder , IBM Technical Disclosure Bulletin, vol. 37, No. 04B, Apr. 1994, p. 347.
|User Interface for Scripts in an OO Visual Builder , IBM Technical Disclosure Bulletin, Vo. 37, No. 04B, Apr. 1994, p. 449.
|Visual Script Action Objects , IBM Technical Disclosure Bulletin, vol. 37, No. 04A, Apr. 1994, p. 683.
|Citing Patent
|Filing date
|Publication date
|Dec 3, 1998
|Jan 1, 2002
|International Business Machines Corporation
|Framework within a data processing system for manipulating program objects
|Jun 14, 1999
|Jul 9, 2002
|International Business Machines Corporation
|Registration of object factories under multiple interface names
|Mar 16, 1999
|Feb 25, 2003
|International Business Machines Corporation
|Method for identifying calls in java packages whose targets are guaranteed to belong to the same package
|Aug 20, 1997
|May 27, 2003
|Bea Systems, Inc.
|Service interface repository application programming models
|Oct 7, 1999
|Sep 9, 2003
|Advantest Corporation
|Program production system for semiconductor tester
|Dec 3, 1998
|Oct 21, 2003
|International Business Machines Corporation
|Creating applications within data processing systems by combining program components dynamically
|Nov 22, 2000
|Aug 3, 2004
|Hyperion Solutions Corporation
|Event model using fixed-format text strings to express event actions
|Oct 30, 2001
|Oct 26, 2004
|Hewlett-Packard Development Company, L.P.
|Mechanism allowing separation of graphical display of object status from underlying data
|May 8, 2001
|May 10, 2005
|Microsoft Corporation
|Specifiable user interfaces
|Dec 7, 1999
|Jan 24, 2006
|National Instruments Corporation
|System and method for determining methods and properties to be invoked on objects in a graphical program
|Feb 20, 2001
|Aug 4, 2009
|Worldwide Objects International Limited
|Systems and methods for application programming using persistent objects
|Feb 6, 2003
|Dec 8, 2009
|Siebel Systems, Inc.
|Application instantiation based upon attributes and values stored in a meta data repository, including tiering of application layers, objects, and components
|Mar 25, 2004
|Jan 19, 2010
|Microsoft Corporation
|Proxy objects for display
|Jan 31, 2006
|Dec 28, 2010
|Microsoft Corporation
|Dynamically extensible application program framework including message and notification routing
|Mar 28, 2007
|Jan 4, 2011
|Microsoft Corporation
|.NET ribbon model for a ribbon user interface
|Sep 9, 2005
|Jul 19, 2011
|Microsoft Corporation
|Proxy assembly for simulating real assembly features on a remote device
|Dec 17, 1999
|Sep 6, 2011
|National Instruments Corporation
|System and method for creating a graphical program which invokes methods and properties of objects
|Sep 30, 2004
|Feb 14, 2012
|Microsoft Corporation
|User interface for displaying selectable software functionality controls that are contextually relevant to a selected object
|Sep 30, 2004
|Mar 27, 2012
|Microsoft Corporation
|User interface for displaying a gallery of formatting options applicable to a selected object
|Jan 4, 2011
|Jun 5, 2012
|Microsoft Corporation
|.Net ribbon model for a ribbon user interface
|Jun 29, 2007
|Jun 12, 2012
|Microsoft Corporation
|Accessing an out-space user interface for a document editor program
|Aug 30, 2005
|Aug 7, 2012
|Microsoft Corporation
|Markup based extensibility for user interfaces
|Sep 30, 2004
|Aug 28, 2012
|Microsoft Corporation
|Command user interface for displaying selectable software functionality controls
|Jun 22, 2011
|Feb 26, 2013
|International Business Machines Corporation
|Using a dynamically-generated content-level newsworthiness rating to provide content recommendations
|Jun 24, 2008
|Mar 19, 2013
|Microsoft Corporation
|Automatic conversation techniques
|Jun 27, 2008
|Jul 9, 2013
|Microsoft Corporation
|Communication between a document editor in-space user interface and a document editor out-space user interface
|Jun 3, 2011
|Oct 22, 2013
|Microsoft Corporation
|Using enterprise management application proxies for developing projects in program development tools
|Jun 1, 2006
|Dec 10, 2013
|Microsoft Corporation
|Modifying and formatting a chart using pictorially provided chart elements
|May 9, 2006
|Jan 7, 2014
|Microsoft Corporation
|Expanded search and find user interface
|Oct 6, 2009
|Jan 28, 2014
|Microsoft Corporation
|Modifying and formatting a chart using pictorially provided chart elements
|Sep 22, 2008
|Feb 4, 2014
|Microsoft Corporation
|Redirection of multiple remote devices
|Apr 10, 2006
|Apr 1, 2014
|Microsoft Corporation
|Command user interface for displaying selectable functionality controls in a database application
|Jun 27, 2008
|Jun 24, 2014
|Microsoft Corporation
|Exposing non-authoring features through document status information in an out-space user interface
|May 21, 2004
|Aug 5, 2014
|Microsoft Corporation
|Adaptive multi-line view user interface
|May 11, 2010
|Sep 16, 2014
|Microsoft Corporation
|User interface for providing task management and calendar information
|Feb 17, 2009
|Apr 21, 2015
|Microsoft Technology Licensing, Llc
|Command user interface for displaying multiple sections of software functionality controls
|Feb 15, 2011
|Apr 21, 2015
|Microsoft Corporation
|Floating command object
|May 12, 2009
|Jun 2, 2015
|Microsoft Technology Licensing, Llc
|Hierarchically-organized control galleries
|May 4, 2012
|Aug 4, 2015
|Microsoft Technology Licensing, Llc
|Accessing an out-space user interface for a document editor program
|Feb 13, 2013
|Aug 4, 2015
|Salesforce.Com, Inc.
|Validating visual components
|Feb 9, 2008
|Aug 4, 2015
|Microsoft Technology Licensing, Llc
|Side-by-side shared calendars
|Feb 7, 2011
|Aug 25, 2015
|Nec Corporation
|Program creation support apparatus, program, and information system
|Sep 27, 2011
|Sep 8, 2015
|Interactive TKO, Inc.
|System and method for live software object interaction
|Aug 27, 2012
|Dec 29, 2015
|Microsoft Technology Licensing, Llc
|Command user interface for displaying selectable software functionality controls
|Aug 23, 2006
|Jan 12, 2016
|Sonic Solutions
|User interface method and system for application programs implemented with component architectures
|Feb 18, 2013
|May 10, 2016
|Microsoft Technology Licensing, Llc
|Automatic conversation techniques
|Aug 27, 2014
|Jun 28, 2016
|Ca, Inc.
|Graphical model for test case viewing, editing, and reporting
|Aug 27, 2014
|Aug 16, 2016
|Ca, Inc.
|Graphical model for test case viewing, editing, and reporting
|Mar 14, 2015
|Sep 27, 2016
|Ca, Inc.
|Modeling and testing of interactions between components of a software system
|Dec 27, 2013
|Dec 6, 2016
|Microsoft Technology Licensing, Llc
|Expanded search and find user interface
|Mar 23, 2014
|Dec 27, 2016
|Ca, Inc.
|Virtual service automation
|Jan 13, 2006
|Jan 10, 2017
|Microsoft Technology Licensing, Llc
|Navigating messages within a thread
|Jun 24, 2013
|Apr 11, 2017
|Microsoft Technology Licensing, Llc
|Communication between a document editor in-space user interface and a document editor out-space user interface
|Jul 31, 2001
|Feb 6, 2003
|Nigel Street
|Method of collecting, visualizing and analyzing object interaction
|Oct 30, 2001
|May 22, 2003
|Inna Lauris
|Mechanism allowing separation of graphical display of object status from underlying data
|Feb 6, 2003
|Jun 26, 2003
|Siebel Systems, Inc.
|Application instantiation based upon attributes and values stored in a meta data repository, including tiering of application layers, objects, and components
|May 22, 2002
|Nov 27, 2003
|Afshin Bayrooti
|System and method for specifying a financial transaction
|May 22, 2002
|Nov 27, 2003
|Afshin Bayrooti
|Visual editor system and method for specifying a financial transaction
|May 28, 2002
|Dec 4, 2003
|Rule John Scott
|Run time method of control system interface design and device control
|Aug 15, 2002
|Feb 19, 2004
|Microsoft Corporation
|Dynamically extensible application program framework including message and notification routing
|May 21, 2004
|Jan 6, 2005
|Microsoft Corporation
|Adaptive multi-line view user interface
|Apr 30, 2004
|Jan 6, 2005
|Microsoft Corporation
|Combined content selection and display user interface
|Mar 25, 2004
|Sep 29, 2005
|Anson Horton
|Proxy objects for display
|Apr 2, 2003
|Nov 17, 2005
|Chelle Yvonne A D
|Method and device for generating software with customized execution and upgradable without computer programming
|Sep 30, 2004
|Feb 16, 2006
|Microsoft Corporation
|User interface for displaying selectable software functionality controls that are contextually relevant to a selected object
|Sep 30, 2004
|Feb 16, 2006
|Microsoft Corporation
|User interface for displaying a gallery of formatting options applicable to a selected object
|Sep 30, 2004
|Feb 16, 2006
|Microsoft Corporation
|Command user interface for displaying selectable software functionality controls
|Aug 23, 2006
|Dec 14, 2006
|Smith Jeffrey A
|User interface method and system for application programs implemented with component architectures
|Aug 30, 2005
|Mar 8, 2007
|Microsoft Corporation
|Markup based extensibility for user interfaces
|Apr 10, 2006
|Mar 8, 2007
|Microsoft Corporation
|Command user interface for displaying selectable functionality controls in a database applicaiton
|May 9, 2006
|Mar 15, 2007
|Microsoft Corporation
|Expanded search and find user interface
|Sep 9, 2005
|Mar 15, 2007
|Microsoft Corporation
|Proxy assembly for simulating real assembly features on a remote device
|Jan 13, 2006
|Mar 15, 2007
|Microsoft Corporation
|Thread navigation
|Jun 1, 2006
|Dec 6, 2007
|Microsoft Corporation
|Modifying a chart
|Jul 24, 2007
|Mar 27, 2008
|Microsoft Corporation
|Methods, Systems, and Computer-Readable Mediums for Providing Persisting and Continuously Updating Search Folders
|Sep 22, 2006
|May 29, 2008
|Avraham Leff
|Enabling multi-view applications based on a relational state machine paradigm
|Jun 29, 2007
|Jan 1, 2009
|Microsoft Corporation
|Accessing an out-space user interface for a document editor program
|Jun 27, 2008
|Mar 26, 2009
|Microsoft Corporation
|Exposing Non-Authoring Features Through Document Status Information In An Out-Space User Interface
|Feb 17, 2009
|Aug 27, 2009
|Microsoft Corporation
|Command User Interface For Displaying Multiple Sections of Software Functionality Controls
|Jun 27, 2008
|Sep 3, 2009
|Microsoft Corporation
|Communication between a document editor in-space user interface and a document editor out-space user interface
|Jun 24, 2008
|Dec 24, 2009
|Microsoft Corporation
|Automatic conversation techniques
|Jun 20, 2008
|Dec 24, 2009
|Microsoft Corporation
|Synchronized conversation-centric message list and message reading pane
|Oct 6, 2009
|Mar 11, 2010
|Microsoft Corporation
|Modifying a chart
|Sep 22, 2008
|Mar 25, 2010
|Microsoft Corporation
|Redirection of multiple remote devices
|Mar 17, 2010
|Jul 15, 2010
|Microsoft Corporation
|User Interface for Displaying Selectable Software Functionality Controls that are Relevant to a Selected Object
|Apr 29, 2010
|Aug 19, 2010
|Microsoft Corporation
|Conversation Grouping of Electronic Mail Records
|May 11, 2010
|Sep 2, 2010
|Microsoft Corporation
|User Interface for Providing Task Management and Calendar Information
|May 18, 2010
|Nov 11, 2010
|Duke University
|Inhibiting gsnor
|Nov 29, 2010
|Mar 24, 2011
|Microsoft Corporation
|Gallery User Interface Controls
|Feb 15, 2011
|Jun 9, 2011
|Microsoft Corporation
|Floating Command Object
|Jan 4, 2011
|Jun 23, 2011
|Microsoft Corporation
|.net ribbon model for a ribbon user interface
|Dec 30, 2010
|Jul 5, 2012
|International Business Machines Corporation
|System and method for capturing a state of a running application
|Feb 7, 2011
|Jan 3, 2013
|Nec Corporation
|Program creation support apparatus, program, and information system
|Nov 2, 2011
|Apr 11, 2013
|Hanhwa Solution & Consulting Co., Ltd
|Apparatus for providing service linking closed user groups based on smart television and smart set-top box
|Feb 13, 2013
|Jun 27, 2013
|Salesforce.Com, Inc.
|Validating visual components
|May 21, 2013
|Jul 3, 2014
|Concurix Corporation
|Setting Breakpoints Using an Interactive Graph Representing an Application
|May 21, 2013
|Jul 3, 2014
|Concurix Corporation
|Animated Highlights in a Graph Representing an Application
|Nov 3, 2011
|Apr 10, 2013
|Apparatus for providing service linking closed user groups
|Feb 20, 2001
|Jun 20, 2002
|Der Spuy Johannes Christia Van
|Application programming system and method of operation thereof
|Mar 1, 2006
|Sep 8, 2006
|Tira Wireless Inc.
|System and method for porting a mobile device application
|U.S. Classification
|International Classification
|Cooperative Classification
|European Classification
|Dec 16, 1994
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CHOW, CHUNGHEN;FOUNTAIN, JAMES W., JR.;LLAMES, RENE L.;REEL/FRAME:007287/0007;SIGNING DATES FROM 19941215 TO 19941216
|Jul 10, 2003
|Fee payment
Year of fee payment: 4
|Jul 13, 2007
|Fee payment
Year of fee payment: 8
|Jul 15, 2011
|Fee payment
Year of fee payment: 12


text:
I agree. Helps me improve the trigger pull. I have a ways to go.
This is a discussion on Dry Fire Practice within the Defensive Carry & Tactical Training forums, part of the Defensive Carry Discussions category; What does everybody here do for dry fire practice? I think dry fire is a great way to keep your skills up, and actually make ...
What does everybody here do for dry fire practice? I think dry fire is a great way to keep your skills up, and actually make you better.
I wrote a blog post on what I do here: http://tattooedgunner.blogspot.com/2...-practice.html
I agree. Helps me improve the trigger pull. I have a ways to go.
The problem I found with dry fire practice in the past is that it actually reinforced bad habits. If you were pulling the trigger wrong (yanking, or curling your finger or etc.) there was really no way of knowing it. You just practiced the same thing over and over again, making that bad habit a part of you.
That is why I like the OCAT System with a laser training cartridge. You can see where you are hitting, you can see how much muzzle movement there is and you can see the direction of that muzzle movement. You can set up the laser system just about anywhere and go to town. The other nice part is that because the size of the circles show the amount of movement in the muzzle, it kind of automatically forces you to shrink those circles and get a quiet gun.
Yes, has added a lot of improvement to my shooting. I dry fire practice a few nights a week - 15 or so pulls with each RH 2 hand grip, LH 2 hand grip, RH only, LH only. Really tough, but good to work on one hand practice. And every couple of sessions I'll practice draws and moving. I'm a big fan - plus its helped a lot during the ammo shortage for keeping up my skills up (plus have gotten fondle time with my guns when I wasn't able to get to the range regularly).
The stupidity of some people NEVER ceases to amaze me.
I have my dryfire regimens recorded on CD, although I hate that the MP3 compression gives me a lisp.
Right now, I'm into my second run of 1000 days of consecutive dryfire and I will be done in January 2016. I did the first about 10 years ago and it really improved my shooting and gunhandling.
Sounds like the Terminator is playing in the background....
Man, now I wanna watch Terminator! lol. That's a pretty good idea making a recording to practice to with timed beeps and all, and I like your mag change drill - I need to include that in some of my practice. I remember a few months ago I was going to my first IDPA match and did dry fire practice every night for a little over a month I believe - I surprised myself throughout most the match. I have continued ever since, just not EVERY day.
The stupidity of some people NEVER ceases to amaze me.
Taking a class and videoing yourself is a great idea.
"for God gave us a spirit not of fear but of power and love and self-control." -- Paul
To improve what one must, one must first know what or where needs to be improved.
With respect to trigger action, pull, grip etc., having a close up visible indication seems a must. Either by some sort of fine optic, ala Laser placed on target (s) so movement of the aim point can be easily noticed during the trigger pull.
I've found, follow thru is important. Right after the trigger breaks, holding solidly to that point of aim for one second helps. Then begin another trigger pull.
Having a camera hooked to a video display and focused in tight to the aim point is a real added benefit in that it shows up even minor, miniscule movements. It's not necessary I think to film a series of practice dry fired shots, other than as a base line preliminary then Thereafter, periodically… perhaps.
I'd feel it more important to video myself, or recording in tighter to my grip and action of handling and operating the pistol or revolver as a plus..
Of course one has whatever finite resources and should take advantage of whatever they may be as is pertinent.
But there is no question watching objectively how one shoots and looking closely for POA movement during the action is a great area for immediate feedback and a huge help in becoming a better shot… but live fire is the only true way to improve oneself.

subset: commoncrawl


text:
140 Hidden Meadow Drive, Sedona, AZ 86336
4 beds, 4.5 baths, 10,200 sqft
Status: Active
Property Description
SANCTUARY in SOLITUDE!1st time available & BEST opportunity ever offered in Seven Canyons! Once featured in PHX Home & Garden magazine.Architectural influences of Mexican Ranch,Old Spain,& Native American cultures combine beautifully w/an open floor plan that exudes an Elegantly Rustic style for a buyer of discriminating tastes.Ineffable custom(Phil Morris-Builder/Robert Morris-architect)boasts 11 FP's,infinity-edge pool,2 spas,casita,2 firepits,outdoor living areas,expansive veranda,sweeping views of Red Rock cliffs,surrounded by Coconino Nat'l Forest.PLUS...adjoining lot is included w/this home!Tom Weiskopf designed golf course is a welcoming sight to entrance of this prestigious gated community.Come enjoy the unlimited amenities this home and Sedona has to offer!
Listing Information for 140 Hidden Meadow Drive Sedona, AZ 86336
Seven Canyons
Private Water Service
School Information for 140 Hidden Meadow Drive Sedona, AZ 86336
Room Information for 140 Hidden Meadow Drive Sedona, AZ 86336
Family Room
Master Bedroom Walkin Closet
Pantry, Kitchen Island, Granite Counter-tops
Double Sinks,Tub with Jets,Full Bth Master Bdrm
Dual Sinks, Jetted Tub
Interior Features for 140 Hidden Meadow Drive Sedona, AZ 86336
Microwave, Refrigerator, Gas Range/Cooktop, Multiple Ovens, Dishwasher, Dryer, Washer
Tile, Wood, Stone
Gas Heat
Separate Guest House
Double Pane
Other (See Remarks), Gas Fireplace, Fireplace Master Bdr, Fireplace Living Rm, Fireplace Family Rm, Firepit, Exterior Fireplace
Fire Sprinklers, Wet Bar(s), Water Softener (Owned), Vaulted Ceiling(s)
Exterior / Lot Features for 140 Hidden Meadow Drive Sedona, AZ 86336
3 Garage Spaces, 3 Parking Spaces, Electric Door Opener
Patio, Covered
All Tile
Private Spa
Seven Canyons
Built-in BBQ, Separate Guest House, Private Yard(s)/Courtyard(s), Private Street(s), Patio, Covered Patio(s)
Community Features for 140 Hidden Meadow Drive Sedona, AZ 86336
Golf Facilities, Gated Community
On Site Guard
Sedona at Seven Cany
Driving Directions to 140 Hidden Meadow Drive Sedona, AZ 86336
West State Route 89A to Dry Creek Rd becomes Boynton Pass Rd/up to the 'T' at Long Canyon Road/turn right to the Seven Canyons Entry Gate.Guard will direct you to property.
Financial Considerations for 140 Hidden Meadow Drive Sedona, AZ 86336
Listing Price History for MLS#: 5396215
Sedona AZ Real Estate and Sedona AZ Homes for Sale
Sedona is located in the state of Arizona. The zip code of 86336 has a population of 10,388. The median age of people living in Sedona, AZ 86336, is 58 years.
Click on the tabs below to see more details for the 86336 zip code in Sedona, Arizona.
Loading nearby sales and history ...
Ask a Question?
Start a no spam email conversation
Nearby homes for sale
Nearby Communities
Sedona Real Estate
000 - Out Of Area school district


text:
China's Alibaba Group Holding Limited is stepping up its efforts to take on Amazon Web Services and Microsoft Azure in the cloud with a new multi-billion dollar partnership with Nvidia Corp. that will see the chipmaker's silicon power its new Big Data and deep learning systems.
The plan, reported by the South China Morning Post, will see Alibaba's AliCloud adopt Nvidia's chips to run the new services, which will be offered from all of its data centers, including those located in the U.S.
"The Big Data Platform fulfills our vision of sharing our vast data troves that will create immense value to our users," Simon Hu, AliCloud's president, said to reporters. "What we want to do at Alibaba is turn the data-processing capacity and data-security capabilities that we've accumulated over the last decade into a product, so that data becomes a resource and a service that we can provide our clients."
Compared to AWS and Microsoft Azure, AliCloud is still something of a runt, but it's clear that Hu is looking to change that. He announced plans to hire more than 1,000 new data engineers to help get the new services up and running.
The announcement follows Nvidia CEO Jen-Hsun Huang's statement last November that the company has gone "all-in" on deep learning. She then promptly unveiled the company's new 'big iron' GPU computer chips, together with a credit card-sized "supercomputer" for running smaller systems.
It's those same GPU chips that Nvidia will now provide to AliCloud, in order to accelerate its new computing services.
While AWS and Microsoft are unlikely to be too concerned just yet, they will surely start keeping tabs on AliCloud and other Chinese players that might be eyeing up their markets, if they aren't doing so already.
One problem for AliCloud is that it's entering the cloud market at a time when competition is intenser than ever, with both AWS and Microsoft recently announcing big price cuts on a variety of their cloud computing services. AliCloud might have gained an edge with its deep learning capabilities, but the smart money says that the competition will likely make its own moves in this area before too long.


text:
This is a discussion on Another PDO refugee (from Virginia) within the New Members Introduce Yourself forums, part of the Welcome To DefensiveCarry.com category; I've been lurking for awhile here.......seems to be a little more civil than PDO has been. Hopefully I've found a new 'homepage'. --c green p.s. ...
I've been lurking for awhile here.......seems to be a little more civil than PDO has been. Hopefully I've found a new 'homepage'.
--c green
p.s. I carry whatever's loaded......Glock23, Sig 239, Kimber Pro Carry II, SA 1911, TTi Caspian 1911
Welcome to CC
Chris - P95
NRA Certified Instructor & NRA Life Member.
"To own a gun and assume that you are armed
is like owning a piano and assuming that you are a musician!."
http://www.rkba-2a.com/ - a portal for 2A links, articles and some videos.
Welcome to the forum.
Two things are infinite: the universe and human stupidity; and I'm not sure about the universe. Albert Einstein
Hello Goawayfarm, from a fellow PDO refugee, I still visit PDO
But here is more polite
quis custodiet ipsos custodes?
eschew obfuscation
The only thing that stops bad guys with guns is good guys with guns. SgtD
Welcome goawayfarm-
How about telling us about the TTi Caspian? I've handled some of Trapper's guns but never fired one or read a report from an owner.
Sic Semper Tyrannis
or handled one. That is because I have serial #1. Trapper built it for me, I have just about finished breaking it in (only had it 2 weeks). It is by FAR the best 1911 I have. Next time you go by Trapper's let him show the target I brought in. I'm not the best shot it the world, just competent. But this gun makes me look great.
He has built some other race guns, but this one is a weapon that will primarily be a carry gun. It has Caspian slide & frame, Storm Lake barrel, Ergo grips & ambi-safety (I'm a southpaw). Drop me a line sometime & I'll let you see it.
Cura ut valeas
Welcome from another Virginian. I joined yesterday. It's nice here.
"You can get more with a kind word and a gun than you can with a kind word alone." - Al Capone
The second amendment is the reset button of our Constitution.
Welcome -
"To disarm the people is the best and most effective way to enslave them."
George Mason
"Gun control is a job-safety program for criminals."
John R. Lott
You'll see many familiar names here. CC.com seems much more civil.
Got Gun?
I certainly will. Thanks. I'm waiting on a carry/duty Caspian Super .38 from Dave Sams:Originally Posted by goawayfarm
When it's done we can have "Show & Tell"
Sic Semper Tyrannis
Welcome to the forum.
EOD - Initial success or total failure
goawayfarm - Glad you're here... Welcome!
Eric Howland
Savannah, GA.


text:
Navy throw with an outer space pattern from premium bedding designers Catherine Lansfield. Crafted from warm fleecy polyester, the blanket features a multi-coloured star print and fits in with the rest of the Catherine Lansfield Outer Space range. – A.D.
Dimensions: 120 x 150cm
|Size / Fit:
Please remember to add postal time (2-3 working days) to obtain a complete estimate of delivery to your door.
You will receive an email to confirm when your item has been sent.
You can also check the status of your order and individual items by accessing My Account details and following the prompts.
Please allow 10 working days from dispatch of your order before notifying us of any late deliveries.
It may be advisable to check with your neighbours to see if a parcel has been left with them, check any outhouses you might have where it may be left if it cannot fit through your letterbox and contact your local sorting office to see if the item has been returned to the depot as undelivered and awaiting collection.
Please see our returns policy.
There are currently no reviews.


text:
When the White Sox have wrapped up their daily game and the players depart the clubhouse, that's when Omar Narvaez breaks out his homework.
As a catcher who has just 60 games of major-league experience, he knows there's still a lot of information he needs to help the Sox, who had a day off Thursday before opening a four-game series at home against the Tigers with a doubleheader Friday.
"I take a half an hour watching videos and watching reports, and then the next day I have everything on my mind," Narvaez said. "Whatever (pitching coach Don Cooper) tells us, I know, and we're basically on the same page."
When veteran...


text:
Main Menu
Make an Appointment Now
Book Online Now
(Select UH Physicians)
Request an Appointment Online
More Ways to Schedule
Host Chef Michael Symon and the nation's top chefs and vintners return on Saturday, June 24 for Five Star Sensation, the premier benefit for UH Seidman Cancer Center.
Learn more
Find out at one of our free stroke screenings held in May.
Find a date and location near you.
The earlier it's caught, the better your odds for beating breast cancer. That's why getting an annual mammogram is so important.
Download our free guide.
In a new series, we take a closer look at the emergency personnel who save lives every day. Learn more about these heroes.
Outpatient hip arthroscopy is a promising way to treat hip pain.
Here are some ways you can tell.
View All Health Articles
Find your best path to optimal health.
Learn more about holistic health and well-being
From its humble beginnings in a two-story wooden house in Cleveland, University Hospitals has grown into a health system that touches people worldwide. Learn about the journey of the last 150 years in a new documentary premiering this May on WVIZ.
A message from University Hospitals Chief Executive Officer Thomas F. Zenty lll
Read the State of the System Address
Wed, 24 May 2017 14:21:00 EST
Read More
Thu, 18 May 2017 13:30:00 EST
Wed, 17 May 2017 09:58:00 EST
Latest News Releases
Enter Newsroom
News Media Login. Not a member? Register Now.
Join our patient feedback community.
Sign Up
For appointments/referrals:
For general information:
216-844-8447 or 888-844-8447
Telephone Directory
Contact Us Online
Financial Assistance
UH Newsroom


text:
Our mission at Thanks-Giving Square is rooted in human spirituality and love of the diverse. Our mission is: To offer a place for all people to give thanks to God, and to witness, to celebrate, and to promote the value and spirit of thanksgiving for both sacred and secular cultures throughout the world. This mission is carried out by programs of education and research. Thanks-Giving Square serves as a common ground, a sanctuary, where there can be a confluence of faiths and traditions in discussion of shared concerns. In Dallas, where it is located, Thanks-Giving Square is a central meeting place where the diverse people of the city can use thanksgiving as a way to heal divisions, and enhance mutual understanding.
Dallas, Texas
United States
International outreach as a longtime United Nations Non-Governmental Organization (NGO)
Mr. Chris Slaughter
Gratitude, Thanksgiving, Multifaith, Interfaith, Cooperate, Understanding, Diversity, United Nations
Also Known As
Thanks-Giving Square
Physical Address
1627 Pacific Avenue
Dallas, TX 75201
See more addresses
Main Address
PO Box 131770
Dallas, TX 75313 USA
Physical Address
1627 Pacific Avenue
Dallas, TX 75201
Interfaith Issues (X90)
Humanities Organizations (A70)
Museum & Museum Activities (A50)
IRS Filing Requirement
This organization is required to file an IRS Form 990 or 990-EZ.
How does this organization make a difference?
Self-reported by organization
What are the organization's current programs, how do they measure success, and who do the programs serve?
Program 1
Thanks-Giving Square hosts seminars on gratitude and thanksgiving, educational programs for all ages, interfaith dialogues and prayer services, and cultural/religious diversity training. We sponsor a large interfaith breakfast on U.S. National Day of Prayer each year. We work with local, national and international organizations to promote peace and understanding. We conduct school, community and visitor group tours. Our Chapel of Thanksgiving provides a sanctuary for couples to marry and for memorial services. Our gardens give working people a tranquil, green oasis in the midst of hectic city.
Program long term success
Hosted Assembly of Interfaith Religious Leaders from around the World.
Program success monitored by
Not available
Program success examples
Not available
Population(s) Served
Program 2
Interfaith Council
The Interfaith Council's mission is to explore harmony and diversity among all faith traditions, as we unite in gratitude. The Council is made up of 26 faith denominations, covering almost every major continent of the world. Programs include a speaker series, visits to local congregations, special prayer vigils on major concerns and regular monthly meetings. Highlight events include honoring of veterans, service days, support of National Day of Prayer, and the Festival of Faiths, celebrating the seasons of holidays.
Program long term success
Not available
Program success monitored by
Not available
Program success examples
Not available
Population(s) Served
General Public/Unspecified
Ethnic/Racial Minorities -- General
The people, governance practices, and partners that make the organization tick.
Mr. Chris Slaughter
Jennifer Altabef
GuideStar worked with BoardSource, the national leader in nonprofit board leadership and governance, to create this section, which enables organizations and donors to transparently share information about essential board leadership practices. Self-reported by organization
Does the board conduct a formal orientation for new board members and require all board members to sign a written agreement regarding their roles, responsibilities, and expectations?
Has the board conducted a formal, written assessment of the chief executive within the past year?
Have the board and senior staff reviewed the conflict-of-interest policy and completed and signed disclosure statements in the past year?
Does the board ensure an inclusive board member recruitment process that results in diversity of thought and leadership?
Has the board conducted a formal, written self-assessment of its performance within the past three years?
In order to support nonprofits and gain valuable insight for the sector, GuideStar worked with D5—a five-year initiative to advance diversity, equity, and inclusion in philanthropy—in creating a questionnaire. This section is a voluntary questionnaire that empowers organizations to share information on the demographics of who works in and leads organizations. To protect the identity of individuals, we do not display sexual orientation or disability information for organizations with fewer than 15 staff. Any values displayed in this section are percentages of the total number of individuals in each category (e.g. 20% of all Board members for X organization are female).
This organization reports that it does not collect this information.
This organization reports that it does not collect this information.


text:
+31 (0)10 - 265 50 70
Meanwell has over 5000 standard models that are widely used in automation, communication, LED lighting, medical, moving sign and office automation fields.
Lavastica International supplies a wide range of Meanwell Batteries and other equipment. Due to our worldwide network and large stock, we are able to deliver the equipment in a short period of time against competitive prices.
Please find more information about the Meanwell product range on the right.