Prior art for Graphical Instance Instantiation

Question

Microsoft filed US20120227028 Graphical programming object population user interface autogeneration, which describes the automatic generation of GUIs to instantiate objects. I vaguely recall seeing a implementation of this concept in Java somewhere. Are there any other examples of prior art, or is my memory just bad? Here is the claim 1:

A computer-readable non-transitory storage medium configured with data and with instructions that when executed by at least one processor causes the processor(s) to perform a process for utilizing an instance of an object type in a graphical programming environment, the instance having at least one field defined by the object type, each field of the instance having a name and capable of being assigned a value, the process comprising the steps of:

• receiving a selection that identifies the instance of the object type;
• automatically determining what fields are defined for the object type instance;
• automatically generating an instance data population user interface in the graphical programming environment;
• and displaying at least the following in the user interface:
  • the name of each field that is defined for the object type instance,
  • and a currently assigned value for each field that currently has an assigned value.

Answer 1

Sounds like Naked Objects. Apache Isis is mentioned in the Wikipedia article. I remember running something similar for C++ in the late 90's.

Answer 2

Well, a good place to look would be the NetBeans release notes:

http://netbeans.org/community/releases/old.html

NetBeans is a Java IDE that's rougly the Java equivalent a Visual Studio. Seeing that Microsoft's patent was issued in 2012 and NetBeans has been around for a while, you might find something there.

Answer 3

Would something like Glade count?

What is Glade?

Glade is a RAD tool to enable quick & easy development of user interfaces for the GTK+
toolkit and the GNOME desktop environment.

The user interfaces designed in Glade are saved as XML, and by using the GtkBuilder GTK+
object these can be loaded by applications dynamically as needed. 

Answer 4

Interface Builder from NeXTStep through to versions shipped with Xcode 4.x carries out the process of interface design and the resultant files are instantiated into GUI objects as described in the patent application. See the discussion at http://en.wikipedia.org/wiki/Interface_Builder this shows that Interface Builder dates from 1988 according to the wikipedia article. Interface builder has been available under OSX since first release and does indeed provide user interface object instantiation at run time from text file definitions. Glade provides similar mechanisms for constructing interfaces using a GUI. The files are instantiated into GUI objects see http://en.wikipedia.org/wiki/Glade_Interface_Designer this dates from 1998.

Answer 5

I think that many of the claims there looked like it was describing original Smalltalk implementation at the Palo Alto Research Center (early '70s), or code that would be trivial to have implemented on that system.

Answer 6

This is a very common pattern and should absolutely not be patentable.

I can refute the root claim from this patent by demonstrating two prior arts: Microsoft's own Visual C++ debugger and the game file editor for my own open-source video game. I present both because they accomplish the claims of this patent in two different ways.

• VS Debugger Example Image from Visual C++ 6.0 (circa 1998). Discussion refers to the "Watch 1" panel.
• Image from my game editor and its source code, published 2010

A computer-readable non-transitory storage medium configured with data and with instructions that when executed by at least one processor causes the processor(s) to perform a process for

This is filler text to say that it runs on a computer that saves its data & code on a hard drive.

utilizing an instance of an object type in a graphical programming environment

It should be obvious that the debugger has instances of object types in its GUI. In the game editor screenshot, you see the objects listed on the left in bold, with their properties indented. Properties in both examples can be other objects.

the instance having at least one field defined by the object type, each field of the instance having a name and capable of being assigned a value,

All fields in the debugger are defined by the object type. The "Name" and "Value" columns declare the name and value of a field (row) within an object. In the game editor, the name is to the left on a line with white background, and its value is to the right in gray text.

the process comprising the steps of receiving a selection that identifies the instance of the object type;

Clicking the object accomplishes this in both examples. By expanding an object, you select the instance of the object type whose fields you want to examine or edit.

automatically determining what fields are defined for the object type instance;

The debugger does this using metadata from the compiler ("program database", aka PDB files). Alternatively, the game editor does this using a mechanism in the source code itself. Each object has a standard interface to query for its defined fields. Details of the implementation can be found in the open-source code.

automatically generating an instance data population user interface in the graphical programming environment;

The debugger populates the "Locals" list view with variables automatically when a breakpoint is hit by the executing program. The game editor populates its list on program start. It takes a static root object, queries for its sub-objects, and adds those into the list. It repeats the process for each of the objects it just added until it reaches objects with no sub-objects.

and displaying at least the following in the user interface: the name of each field that is defined for the object type instance, and a currently assigned value for each field that currently has an assigned value.

This is again the "Name" and "Value" columns in the Visual C++ debugger, where each row is a field and an expandable block with a + next to it is an object type instance. In the game editor, the expandable blocks with a + on the left are object type instances, and the fields are either other object type instances or white lines. The white lines are again left-aligned bold text for the name, and right-aligned truncated gray text for the value.

Conclusion

There are, in fact, many more examples of visual debuggers other than Visual C++ that can counter these claims equally, but I chose Visual C++ because it was a Microsoft product, and presumably the Inventors would have been quite aware of it.

I believe all claims could all be easily invalidated by these two examples of prior art.

Answer 7

LabVIEW (National Instruments) has methods to create user interface components directly out of the programming environment. You can right click on any data wire and create a user interface component that correspond to the data object.

Answer 8

Someone has already mentioned Java NetBeans. I too came across this, using the following search in a software prior-art database (named CodeClaim) that I'm building:

((instance or instantiate) w/100 object w/100 (generate or autogen or builder or ide) w/100 fields w/100 (display or gui or show or ui))

The first hit was in this file:

Java\jdk1.7.0_09\lib\visualvm\profiler\modules\org-netbeans-modules-profiler-heapwalker.jar -> org\netbeans\modules\profiler\heapwalk\ui\FieldsBrowserControllerUI.class

Which also contains InstancesControllerUI. So from this quick check, it sounds like the following would be promising:

Netbeans Profiler Heapwalk

Copyright date in the source code is 1997-2007, and there are 2008 file dates for versions on the web, e.g.:

http://www.java2s.com/Open-Source/Java/IDE-Netbeans/profiler/org/netbeans/modules/profiler/heapwalk/ui/Catalogui.htm

Andrew

Answer 9

My reading of this is that it's not talking about a UI design tool (like Interface Builder or Glade), but rather about a GUI for editing objects: you click on an object, and it displays an editable list of all the properties associated with that object. Which is precisely what every graphical database front end in the world does. Or, if you interpret it more as "automatically generating a GUI for editing data", Ruby on Rails or something similar would be an appropriate precedent.

Answer 10

They just described property pages as in the Windows shell.