text:
WEATHER DISCUSSION Wednesday was showery and breezy, but we will start to see a bit of a lull in the rainfall activity tonight. We are still in midst of a fairly wet time frame, as showers (or snow for higher elevations) are in the forecast every day throughout the extended period. The next system won't … Continue reading »
Wednesday Starts An Active Pattern
WEATHER DISCUSSION Tuesday morning was almost Groundhog Day when it came to the frigid temperatures. We started the day only one or two degrees warmer than Monday, meaning morning lows were once again about ten degrees below average. Temperatures will be cold again tonight, but more seasonable. These "not as cold" temperatures will be due … Continue reading »
Cool and Dry Start for the Work Week
WEATHER DISCUSSION A small ridge of high pressure has taken over the area after the cold air mass that moved into the region at the end of last week. This is allowing for clearing of the clouds overhead for the beginning of the workweek. That, in turn, brings colder temperatures overnight and warmer afternoon temperatures. … Continue reading »
Arctic Air Moving In
WEATHER DISCUSSION A deep cold air mass is moving in from the north. This cold pool of air will dip low enough to bring snow to parts of the southern states. Luckily, we are on the far western edge of the air mass, which will allow us to escape the coldest of the temperatures. That … Continue reading »
Cool Afternoon, Chilly By Saturday Night
WEATHER DISCUSSION While we were initially expecting scattered showers on Friday, most of the rainfall stayed to our north in Douglas County. Some locations saw up to three inches of rain in 24 hours. In the Cascades, Crater Lake received an additional three inches of snow, raising the snow depth on the rim to abut … Continue reading »
Showers Stick Around For Friday
WEATHER DISCUSSION Thursday night and morning, the Klamath Basin saw it's first snowfall of the season! Crater Lake received about five inches of fresh snow. Chemult saw right around three inches. Even in Klamath Falls, viewers reported about an inch of snowfall. By the afternoon, temperatures rose above freezing, and Klamath Falls even made it … Continue reading »
Rain & Winter Weather On The Way
WEATHER DISCUSSION Just offshore sits the next storm system. We have been seeing increasing cloud cover Wednesday afternoon and evening, and later tonight, we will see rain showers moving inland. Previously, a winter storm watch was in effect for northern Klamath and Lake Counties. That has since been upgraded to a winter storm warning. Also, … Continue reading »
Cold Tonight, Then Rain Arrives Wed. Eve
WEATHER DISCUSSION After a few quiet days, we are on the cusp of a very active pattern. We are watching the next storm system that will be moving through by Wednesday afternoon and evening, but in the meantime, we will see another mostly clear and cold night. A freeze warning goes into effect just after … Continue reading »
Right Back into an Active Pattern
WEATHER DISCUSSION Before the weekend arrived, models were suggesting that we would be getting a dominant ridge of high pressure and there was no end in sight. With high pressure, comes calm conditions with sunny skies. However, as is typical with forecast models. anything past a few days will likely change. So the monotonous days … Continue reading »
High Pressure Helps Weaken Next Front
WEATHER DISCUSSION A ridge of high pressure has built in over the west, and although the next storm system will weaken it, that ridge is exactly what keeps the front from making a big impact in southern Oregon and northern California. By Sunday evening, showers will drift in with the cold front from the north, … Continue reading »


text:
Ibanez rallies Mariners with 6 RBIs in 1 inning
SEATTLE (AP)—If the Minnesota Twins fall short in their quest to win the AL Central, they may remember this loss.
And if these young, upstart contenders end up winning their tight division, they may still remember it: for the levity and leadership shown after it by manager Ron Gardenhire.
Raul Ibanez had a grand slam and six RBIs—all in a wild seventh inning— and the Seattle Mariners staged their biggest comeback of a lost season to stun the Twins 11-6 on Monday night.
Ibanez set Seattle's record for RBIs in one frame, one more than Ken Griffey Jr. had in the fifth inning on April 29, 1999, at the old Kingdome.
"It's a once-in-a-lifetime deal," said Ibanez, who thought he was going to be traded to Toronto or the New York Mets last week. "I wasn't even sure it was the same inning."
Ibanez sent Minnesota out of the AL Central lead with a potentially devastating loss. The Twins, a major league-best 31-14 since June 13 entering Monday, fell a percentage point behind the Chicago White Sox in the AL Central, one day after they reached for the top for the first time in three months.
Afterward, a red-faced Gardenhire fumed about his two-faced bullpen. It is the best in the majors in home ERA (2.11) but baseball's worst away from the Metrodome, with an ERA of 6.31 after allowing six runs in Seattle's 10-run seventh-inning.
"We got nobody out in the bullpen. Just terrible pitches. Balls flying around everywhere," Gardenhire said.
"We have to have someone … step up and make pitches. Not very much fun."
Yet moments later, in the middle of a silent clubhouse with players dressing, Gardenhire playfully scolded equipment guys for ruining the road trip after just one night. Wearing a T-shirt that read "Lead. Follow. Or get the hell out of the way" on the back, Gardenhire saw one Minnesotan with a long face and joked: "Don't look sad. I'll send you home, too."
The message was clear: be angry. And then be done with this, ready to resume the long pennant race tomorrow.
Minnesota starter Glen Perkins, who cruised into the sixth with a 6-0 lead and was still comfortably up 6-1 with one out in the seventh before Ibanez hit his grand slam off him, got the message.
"I can't dwell on this. I've got to get ready for my next outing. Hopefully the guys will pick me up," Perkins said.
Perkins' trouble began with a single by Yuniesky Betancourt, a walk to Ichiro Suzuki and a single by Willie Bloomquist to load the bases with one out.
Ibanez, who thought he was going to be traded to Toronto or the New York Mets a week ago, then hit Perkins' inside fastball about six rows into the right-field bleachers. His seventh career grand slam cut the lead to 6-5—and awakened what had been another frustrated, booing crowd.
"Exactly what I was trying to avoid," Perkins said.
Perkins was stunned, staring with glazed eyes through catcher Joe Mauer as manager Ron Gardenhire replaced him with Brian Bass.
Adrian Beltre greeted Bass (3-4) with his third hit, a sharp double. Jose Lopez then blooped an RBI single to right to score Beltre with the tying run and end Bass' night as the home crowd roared.
Lopez took second with one out on a passed ball. With two outs rookie Jeff Clement, pinch-hitting for Kenji Johjima against reliever Matt Guerrier, singled in Lopez with the go-ahead run. As Lopez slid into home, the home crowd was as loud as its been all dreary season and the Mariners dugout erupted and spilled partly onto the field as if they were 26 games over .500, instead of 26 under.
"We know he's a fastball hitter—and we throw him a fastball right down the middle," Gardenhire spat out.
When asked if he knew Clement was a fastball feaster, Guerrier said: "No … I guess I know that now."
A throwing error by shortstop Brendan Harris gave Seattle two more runs.
Guerrier then loaded the bases with two walks—one intentional—for Ibanez, who lined a single to put Seattle ahead 11-6.
That was the most runs the Mariners scored in an inning in nearly five years, since Aug. 30, 2003, against Baltimore. It came just as it appeared Seattle was going to tie its season low of 28 games under .500.
Roy Corcoran (2-0) pitched a scoreless top of the seventh for the victory.
Miguel Batista allowed six runs and seven hits, with four walks, in his three-plus innings, raising the right-hander's ERA to 7.49 in his 19 starts— the worst among major leaguers with at least 15 starts.
Nick Punto hit his second home run in 167 plate appearances this season leading off the third for Minnesota.
When Francisco Liriano's first major league win since 2006 put the Twins in first place on Sunday, it was the first time since 1990 a team had gained sole possession of first place this late in a season on a pitcher's initial win of the season.

subset: commoncrawl


text:
The National Museum Institute of the History of Art, Conservation and Museology was formed and registered on January 27, 1989 under the Societies Registration Act, 1860 and was accorded the status of 'Deemed to be University' on April 28, 1989. Since its inception, the Institute has been one of the leading centres in the country for training and research in the field of art and cultural heritage. The Institute is situated within the premise of the National Museum with an objective that students can have direct exposure to the masterpieces of art and cultural heritage and have easy access to the facilities of the National Museum such as its laboratory, library, storage/reserve collection and technical support sections for a holistic learning.
Quotation Notice: For Publication of books & others
This Institute requires publication of the following:
The last date of receipt of quotation (competitive rates) on a sealed envelop is: 13-04-2015, 05:00 PM.
Click here, for details
Quotation Notice: AMC of Computers & Peripherals
Quotations are invited for Annual Maintenance Contract in respect of Computers and Peripherals and Local Area Networking connectivity in the Institute.
The last date for receipt of completed quotation is 06-04-2015.
Annual Conference: CIDOC 2015 -
The International Committee for Documentation of ICOM
The annual conference of CIDOC, the International Committee for Documentation of ICOM, will take place from 5th -10th of September 2015 in New Delhi, India. Anyone interested from museums and cultural organizations is cordially invited to participate.
The conference starts with a series of workshops on Saturday 5th and Sunday 6th of September 2015. The main conference is opened on Monday 7th of September 2015.
Parallel sessions on the different conference themes take place on the following three days (7th to 9th September). On Thursday 10th of September the attendees could join different excursions.
The main theme of the conference is "Documenting Diversity – Collections, Catalogues & Context".
Notice for cancellation of Tender Notice:
Tender under Expression of Interest to engage "Project Advisor" invited by this Institute vide advertisement appeared on 10-09-2014 in the leading news papers as well as in NMI's website i.e. www.nmi.gov.in is hereby cancelled due to some unavoidable reasons.
Home | Feedback | FAQ | Vacancies | Tender/Quotation | RTI | RFD | Downloads | Sitemap | Contact Us
Disclaimer (C) National Museum Institute, 2013
You are Visitor No.:


text: If you are looking for fantastic pizza in a cheery environment, this is the place for you. Our Tripadvisor tactic for dining during a day trip has been working a treat during this holiday. Check out the reviews. Identify three or four in different places in the area being visited that seem to... read more


text:
A method for designing software components for integration into any system without additional coding is provided. The method includes adopting a uniform application programming interface that breaks down external objects to include the characteristics of object, attribute, and method. Ideally, the characteristics include create object, delete object, read attributes, write attributes, and invoke behavior. A software tool is provided for communication between an API and a data source, the tool including a join engine adapted to provide communication between at least one view and at least one base source associated with the data source, the join engine further adapted to update the at least one base source in response to updates to the view. Ideally, the tool is further configured to support on the at least one base source operations of create object and delete object on the at least one view. The software tool is also configured to map events in the at least one base source to the at least one view, and can be configured to create virtual attributes based on the view through operations or expressions performed on the view, including, but not limited to algebraic expressions, names, strings, and functions.
1. A method in a computer system for providing an interface between at least one logical view of data and a plurality of data sources, comprising:
receiving an indication of an operation to be performed on the at least one logical view, the at least one logical view including at least one combination of data constructed from and corresponding to two or more of the plurality of data sources, the two or more of the plurality of data sources including at least one data source that is not a relational database, each of the plurality of data sources storing data;
automatically determining the corresponding plurality of data sources that were used to construct the at least one logical view; and
transparently and automatically causing the stored data in the corresponding plurality of data sources to be adjusted in accordance with the indicated operation, thereby automatically performing the indicated operation on underlying data that corresponds to the logical view.
2. The method of
3. The method of
4. The method of
5. The method of
6. The method of
retrieving from a definitions file indications of the two or more of the plurality of data sources and attributes that correspond to a join operation; and
evaluating the join operation to construct the at least one logical view.
7. The method of
evaluating each of the restriction expressions to limit which records from the associated data source are included in the logical view.
8. The method of
9. The method of
setting each of the variables to a value.
10. The method of
retrieving, from a definitions file associated with the at least one logical view, computer instructions for performing an insert operation on at least one of the corresponding plurality of data sources in accordance with the indicated operation; and
automatically causing the computer instructions to be performed to adjust the underlying data in accordance with the indicated operation.
11. The method of
12. The method of
persistently storing in a join cache linkages between the plurality of data sources and the at least one logical view.
13. The method of
determining whether data in at least one of the two or more of the plurality of data sources has changed; and
when it is determined that the data in the at least one of the of the two or more of the plurality of data sources has changed, updating the at least one logical view based on a recalculated join of the data from the two or more of the plurality of data sources; and
when it is determined that the data in the at least one of the two or more of the plurality of data sources has not changed, updating the at least one logical view based on the persistently stored linkages stored in the join cache.
14. The method of
receiving an indication of an expression that includes at least one of a mathematical expression or a function; and
evaluating the expression to generate a virtual attribute in the at least one logical view.
15. The method of
16. The method of
17. A computer-readable storage medium containing content that enables a software application in a computing device to manipulate data through logical views, by performing a method comprising:
receiving an indication of an operation to be performed on the at least one logical view, the at least one logical view including at least one combination of data constructed from and corresponding to a plurality of data sources, the plurality of data sources including at least data source that is not a relational database, each of the plurality of data sources storing data;
automatically determining the corresponding plurality of data sources that were used to construct the at least one logical view; and
transparently and automatically causing the stored data in the corresponding plurality of data sources to be adjusted in accordance with the indicated operation, thereby automatically performing the indicated operation on underlying data in the corresponding plurality of data sources that corresponds to the logical view.
18. The computer-readable storage medium of
19. The computer-readable storage medium of
20. The computer-readable storage medium of
21. A computing system for enabling a software application in a computing device to manipulate data through logical views, comprising:
a memory;
a definitions file having a plurality of sections that define a correspondence between stored data in a plurality of data sources and one or more logical views, the plurality of data sources containing at least one data source that is not a relational database, each of the plurality of data sources storing data; and
a join engine stored on the memory and configured, when executed, to automatically interface between at least one logical view and a corresponding plurality of stored data sources, including the at least one data source that is not a relational database, such that, when an operation is performed on the at least one logical view, underlying stored data is automatically manipulated in the corresponding plurality of stored data sources.
22. The computing system of
23. The computing system of
24. The computing system of
25. A computer-implemented method for generating an object according to an abstract object model for use as a reusable software component, comprising:
instantiating code for the object that corresponds to a plurality of uniform functions;
instantiating code for the object that corresponds to at least one abstraction conversion tool, the abstraction conversion tool driven by a definitions file having a plurality of sections that define a correspondence between stored data and one or more objects corresponding to at least some of the stored data such that the definitions file may be changed without recompiling code for the one or more objects; and
instantiating code for the object that implements a plurality of object behaviors including notification of a change to an attribute of the object, notification of an addition of an attribute to the object, and notification of a removal of an attribute of the object.
26. The method of
instantiating code for the object that implements functions to read an attribute of the object, write an attribute of the object, get attribute names of the object, invoke a behavior on the object, and get related objects.
27. The method of
instantiating code for the object that implements a plurality of object behaviors including notification of adding an object to a set of objects and notification of deleting an object from a set of objects.
28. The method of
instantiating code for the object the corresponds to an abstraction conversion tool that implements operations that correspond to at least one of object masquerading, object selection, object projection, object concatenation, object joins, property calculations, object bridging, object monitors, or system wrappers.
29. The method of
30. The method of
31. The method of
32. The method of
33. The method of
The present invention relates to software development and, in particular, to computer software that provides tools to create reusable software components using a uniform interface.
Interfaces are tools that allow objects of arbitrary classes to be joined into compound documents. With respect to the management of databases, such joins take place to facilitate the manipulation of data from multiple tables or databases in a new view that is a virtual representation of the �physical� base table. Updating the data in the base table through the new view is problematic because of the presence of redundant data and the difficulty of consistently updating this data.
On a larger scale, designing and implementing software solutions through a single integrated solution requires functional cooperation among a collection of disparate components. Oftentimes, these components are designed with abstractions that are application specific, and adaptation is required to cooperate with other components in the system. More particularly, functionality of the system depends on accurate and reliable communication among the components. Thus, substantial time and costs are involved in modifying the components to achieve the functionality required by the system.
The disclosed embodiments of the invention are, in one form, directed to a software tool for communication between an application program interface (API) and a data source, and in another form to a method for designing software components to be integrated into any system without additional coding.
In one embodiment, a method for designing software components for integration into any system without additional coding is provided. The method includes adopting a uniform application programming interface that breaks down external objects to include the characteristics of object, attribute, and method. Ideally, the characteristics include create object, delete object, read attributes, write attributes, and invoke behavior.
In accordance with another embodiment of the invention, a software tool is provided for providing communication between an API and a data source, the tool including a join engine adapted to provide communication between at least one view and at least one base source associated with the data source, the join engine further adapted to update the at least one base source in response to updates to the view. Ideally, the tool is further configured to support on the at least one base source operations of create object and delete object on the at least one view.
In accordance with another aspect of the foregoing embodiment, the software tool is configured to map events in the at least one base source to the at least one view. Preferably, the tool is also configured to create virtual attributes based on the view through operations or expressions performed on the view, including, but not limited to algebraic expressions, names, strings, and functions.
The features and advantages of the present invention will be more readily appreciated as the same become better understood when taken in conjunction with the following drawings, wherein:
Example embodiments of the present invention provide software design and development tools in a computer system that, in one embodiment, enable real-time viewing and managing of data in disparate databases. Data management functions can include, but are not limited to, managing events, providing calculations, and enabling updates, inserts, and deletes on aggregate views. In another embodiment, the tools of the present invention create and use a uniform interface to existing components, such as objects and databases, to manage each component's attributes, data, behavior, and relationships. The uniform interface provides a homogeneous programming abstraction to potentially heterogeneous software components, regardless of their internal and external models, thereby enabling the integration of independently developed software components into a single solution.
Representative embodiments of the invention will now be discussed in more detail, beginning with a description of a join engine for use with databases and followed by a description of adaptive object modeling using uniform interfaces. The corresponding provisional patent application filed by applicant, No. 60/261,119, along with its accompanying Appendix A, are incorporated herein by reference in their entirety in this application. Appendix A includes the source code for building uniform interfaces in accordance with the method of the invention and for building, in particular, a join engine interface.
Join Engine Description
A Join Engine is provided that simplifies the development and improves the performance of applications that interface to normalized relational databases. Database normalization is the process of deconstructing a class with many attributes into many classes, each with fewer attributes in order to eliminate redundant data and to avoid problems with inserting, updating, or deleting data. The main advantage of normalization, is defining a model that is not dependent on any single application.
In relational database terms, a view is a virtual table that joins fields from one or more data tables.
In relational databases a clear distinction is made between the base tables and view tables.
The conventional wisdom is that Joins will severely degrade the performance of a relational database especially as the number of tables involved in the Join increases beyond 5 or more. The recommended way to overcome this problem is to implement the physical database as a de-normalized set of tables. The problem with this approach is that we then discard one of the major advantages of a relational database:
Any de-normalized set of tables will be tailored to support the needs of particular set of applications.
The de-normalized tables will have redundant data, along with the associated problems of consistently updating this data.
Another set of applications will require a completely different set of de-normalized tables.
This second set of de-normalized tables will have more redundant data, along with the associated problems of consistently updating this data.
An example Join Engine works with a relational database as shown in
The Join Engine supports updates against the view tables. The Join Engine performs all the required updates on multiple base tables when a client updates a single view table.
The Join Engine also supports create object and delete object operations on the view tables. The programmer defines the create object operations that are required on base table for each create object operation on the view table.
The Join Engine also maps events in the base tables to events in the views. Applications can register for events on the view tables. The view table may join attributes from multiple base tables and the view table may restrict the number objects in the view. A client will receive a call back only if data in its current view is changed.
The following example describes the Join engine as it has been implemented with the Electric Power Research Institute (EPRI) API. It is to be understood, however, that the disclosed embodiments of the invention may be implemented with other API's, including any API that externalizes a view of data stored in a relational database. In this example, the Join Engine maps the EPRI API calls that access the views to calls that access the base tables in a relational database.
Caching and bulk read and write access to the base tables is used to enhance performance.
EPRI API Source Code Libraries
The objective of the EPRI API Source Code libraries is to provide application developers, infrastructure developers, system integrators, and end users with a head start in building EPRI API adapters for a wide variety of different data sources and middle-ware products.
The objective of the EPRI API is to provide a precisely defined programming interface so that a client component can interact with a server component. The EPRI API defines method invocations and event notifications. Programmers can use these operations to define the dynamic behavior of the system. These operations determine how the system moves from one state to the next.
The EPRI API is defined to meet the requirements that are encountered in building mission critical, high availability, real-time Energy Management Systems and Distribution Management Systems.
The EPRI API encompasses:
The EPRI API can be layered to work with different middle-ware solutions including CORBA, DCOM and JAVA JMS as well as different relational databases including Oracle, SQL Server and PowerData. The function signatures for the client are identical for all the different environments.
The EPRI API supports integrating closely coupled EMS applications with stringent real-time performance requirements as well as more loosely coupled applications and systems that operate downstream from an EMS.
The EPRI API supports the request-reply processing communication style that is typical for client server databases. A client requests information from a Data Source The client waits until the Data Source replies with a response. This is a synchronous or �pull� model of communication.
The EPRI API also supports event driven or asynchronous or �push� models of communications. The client registers for a call back when a Data Source event occurs. Upon receiving the call back, the client can query the Data Source for additional information. This event driven feature is critical for real-time systems. If this feature is not available the clients have to constantly poll the Data Source asking if there have been any changes. This provides an excessive load on the Data Source server and the network if the response times are to be kept small.
The EPRI API Source Code Libraries meet the needs four several groups of users, including:
Developers of EPRI API clients (power system specific components)�Developers of EPRI API clients need to build their software so that it can plug into different EPRI API infrastructure products. They can use the EPRI API Source Code Libraries to build their own development and test environments.
Developers of infrastructure that implements the EPRI API�These developers can use EPRI API Source Code Libraries as an interface to a generic set of infrastructure services. The infrastructure developers can be database suppliers, middle-ware suppliers and companies that have historically provided custom integration services.
System integrators�System integrators can apply the EPRI API Source Code Libraries to integrate existing legacy or new systems together for the exchange of information in a standard way. They can interface the EPRI API Source Code Libraries to existing middle-ware products that are often times dictated by corporate standards.
End users�End users can employ the EPRI API Source Code Libraries as a method of interconnecting legacy applications and systems with new applications and systems. They can add or replace systems without impacting other systems already in place and they can minimize the maintenance and training required for managing the interconnection infrastructure.
The EPRI API Source Code libraries can include the following class hierarchy:
The CDSBaseAdapter class is designed to act as a base starting point for new CDS derivative classes. One such derivative is the OracleCDS, which can be a base table wrapper for Oracle databases, as described in more detail below.
Features of the CDSBaseAdapter class include the ability to define its properties and resources on the fly with all storage based in RAM. It handles the majority of the CDS API calls in a logical fashion with respect to the RAM model created and is readily extendable so that this information can be tied into an alternate data store such as an existing database.
The implementation of the CDSBaseAdapter Class can use existing subroutines and classes. These subroutines and classes will be derived from AST Tools and the existing CDS classes. The exact classes and subroutines to be reused will be determined during the detailed software design.
AST Tools
The ASTTools C++ classes are designed primarily to simplify common coding tasks. The most commonly used functions are summarized below.
DynamicArray�a template for managing an array of any type that automatically grows to any size. This class relieves the programmer from any concern about how big an array is.
GenDB�creates a named object collection of any size and stores them for fast retrieval in a sorted list using a binary search for retrieval.
Hashtable�creates a named object collection of any size and stores them in a hash table for retrieval.
ObjectPointerArray�a template for managing a dynamic list of objects that are automatically allocated and deallocated as needed. Similar to DynamicArray, but is smart enough to create and destroy objects.
Varconf�a set of utilities for processing configuration files and command lines.
String�a class for implementing a string abstraction in C++. C and C++ don't really have a string data type, they use an array of bytes terminated by zero to represent a string. This class allows operations such as concatenation, automatic memory allocation, assignment, comparison operators, etc.
Btree�a binary tree storage facility (not a class)
Linklist�implements a linked list.
FIFO�implements a first in first out queue (not a class)
Expression�implements an expression engine class
Logger�implements logging facilities
Hexdump�dumps data buffers in a hex format . . . mostly used for debugging.
ObjectRef�implements a template for smart pointers. Smart pointers automatically clean up pointers once they aren't needed anymore.
Parse�implements a powerful parsing engine for breaking apart strings (not a class).
VarManager�implements a variable tracking and substitution class with hierarchical name spaces.
CDS Class Libraries
Embodiments of the present invention provide CDS (Common Data Source) class libraries for interfacing applications to a variety of different data sources.
The class libraries can be designed using object oriented programming (OOP) techniques. In particular the CDS class libraries take advantage of an OOP technique known as polymorphism. Polymorphism is when the same method or operator can be used on different types of objects. A real-world example is giving the command �Start your engines� to the drivers of a boat, a plane and an automobile. The same command is implemented in three very different ways.
By using polymorphism, a user application can invoke the same commands to read and write data from and to an abstract data source and different subclasses can implement these commands with different physical data sources. An abstract CDS class is used as the conduit for the subclasses.
An abstract method is not actually implemented in the abstract class. It is merely declared there. The body of the method is then implemented in sub-classes of that class. Subclasses are provided for the different physical data sources e.g., base tables, Join Engine view tables, and object data and a memory resident cache.
The CDS classes can include the following:
The XML Data Exchange Program enables a user to:
Export an XML file from a Common Data Source that is layered with the EPRI API.
Import an XML file into a Common Data Source that is layered with the EPRI API.
The XML Data Exchange Program is designed to work with the different data sources that support the EPRI Application Program Interface as shown in
By defining the functionality of the XML Data Exchange program in an abstract manner the result is a general purpose utility program that can used in a very wide range of specific applications. These applications may include examples such as:
The XML Data Exchange Program can use RDF and RDF Schema for specifying the data model.
Oracle EPRI API Adapter
A representative embodiment of an adaptor is the Oracle EPRI API Adapter described below. The Adaptor is the layer of software that allows an application written with the EPRI API function calls to interface to an Oracle database. A client application can interface directly to the Oracle database as shown in
The Oracle EPRI API Adapter translates the EPRI API function calls into Oracle C++ calls. The adapter is built by implementing specific sub-classes for the abstract classes in the EPRI API Source Code Libraries.
The EPRI API operations that can be supported by the Oracle 7 implementation include the following:
Operations for Common Data Access including create, read, update and delete.
Operations to determine EPRI API services supported by the Oracle 7 data source.
The EPRI API operations that can be supported by the Oracle 8 implementation include the following:
Operations for Common Data Access including create, read, update and delete.
Operations to determine EPRI API services supported by the Oracle 8 data source.
Operations for asynchronous notification to clients on occurrence of database events.
What follows next is a description of a representative embodiment of a PDExpressionCDS join engine.
The objective of the PDExpressionCDS join engine is to provide an abstraction layer where data that is spread across multiple locations, such as data in a normalized database, can be presented to the user as views. It uses the EPRI API as its programming interface and as a result can be combined with other EPRI API based components as needed. The implementation of this abstraction requires the solution of several complex programming problems, such as performing joins between sets of data while managing events, providing calculations, and enabling updates, inserts, and deletes on views. Preferably, this is done in a manner that doesn't introduce significant overhead or processing delays.
The PDExpressionCDS join engine accomplishes these goals. Applications can generally be written without concern as to the physical location or format of the data itself. Instead, the application can assume any set of logical objects that it desires. Each set of logical entities is known as a CDS or Common Data Source. One CDS can be thought of as a table from the relational database point of view, or as a set of objects from the object oriented point of view. Using this interface, the application developer can define their problem in terms of data that makes sense to their application. The data manipulation is done by the CDS engine, in this case the PDExpression-CDS.
This provides a powerful abstraction layer where the application is completely protected from changes in the location, format, or facility used to managed the underlying data.
The PDExpressionCDS join engine is driven through one or more join definition files. Each definition file is a plain ASCII file consisting of a number of sections delimited by brackets in the form of [SECTION_NAME].
The join file is specified as a required part of the PDExpressionCDS definition string. The format is: �PDExpressionCDS:definitionFile=filename�
An optional parameter of definitionFilePath may also be used. If this is specified then the definitionFile parameter only references the file name and doesn't specify the path. The filename is the name of a file that follows the formatting and content described here.
Each section has a section-specific set of attributes that are set using the general form of:
The use of the semi-colon at the end of each attribute statement is required. A summary of the sections and attributes is as follows:
Section Descriptions
Each section found in a definition file is described below. Some sections appear only one time while others may be repeated as many times as needed, such as the [COLUMN] section which is repeated once for each column.
The POWERDATA section is used to designate the database settings for use with a PowerData database. This section is required if TABLE sections are used, otherwise it is ignored. This section also allows a join cache to be specified. The join cache is used to store the linkages between tables persistently so that the join can be recreated with very little computation. When used, the join engine first checks to see if the data in the join columns has changed, if not the persistent linkages are used, otherwise the join is recalculated. The attributes that may be specified in the POWERDATA section are:
Type�Defines the PowerData database type where the tables will be accessed from, which is preferably one of:
Parms�Defines the parameters needed by the specified database type. The parameters expected for each type are:
CacheName�This defines the name of the cache to use for this join. If this is not specified then caching is not used. If it is specified then a table with this name will be created to cache the join linkages. It is important to make sure that this name is unique among all the joins being used. If two joins share the same name then the cache will not be used effectively. It is also possible, but very rare, that the join will be created incorrectly as a result of two joins using the same cache name.
CacheType�Defines the PowerData database type for the cache. If this is not specified then the database type for the cache will be the same as the database type for accessing the tables. See Type for a description of the different database types.
CacheParms�Defines the parameters needed by the specified cache database type. See Parms for a description of the database parameters used by each database type.
The TABLE section is repeated for each table that should be included in the join. Each table is assigned an alias that is used to reference it in other sections. A table may be assigned multiple aliases where each alias represents a different logical copy of the table.
This is useful in cases where the same table is used multiple times for different purposes within a single join. If the same table is being used but with different restrictions for each instance then each instance should have it's own TABLE section. If in doubt, create multiple TABLE sections.
The attributes for the TABLE section are:
Name�Specifies the name of the table in the database.
Alias�Specifies an alternate name for the table, usually shorter, that is used to reference this table in other sections in the join file. At least one alias is required since the table name is not usable in place of an alias. Multiple aliases can be assigned to the same table.
Restriction�Specifies a restriction to use to limit the number of visible records in the table. A restriction is created by comparing column names to each other or to constants.
Column names are written in the form of �column_name�. Strings are written in the form of �string�. Floating point numbers or integers are written as simple constants. Comparisons can use any of the following:
These sections can be connected using a logical and �&&� or a logical or �∥�. Precedence can be specified using �(�and�)�.
The CDS section is used as an alternative to the TABLE section.
The attributes used by the CDS section are:
Definition�The CDS definition. This is a string that defines a CDS type and its parameters.
Alias�The short name used to reference this CDS in the other sections. Multiple aliases can be specified for a single CDS.
Unique�This has the value of true or false. It is false by default meaning that duplicate values are OK. If set to true then duplicate values are removed.
The JOIN sections specify the way the tables or CDS's are connected together. Each JOIN section specifies a linkage between two tables in the form of alias.attribute. The alias is defined in either the TABLE or CDS section. The attribute is the name of an existing integer attribute. Multiple JOIN sections are specified, each describing a single linkage, until all of the linkages are defined.
Generally speaking, the joins can be specified in any order, however, there is one rule that is preferably followed. Except for the first JOIN, each join should specify the Table2 attribute using an alias name that was used in a previous JOIN section.
The attributes for the JOIN section are:
Table1�The first table or CDS alias and attribute in the form of alias.attribute.
Table2�The second table or CDS alias and attribute in the form of alias.attribute. The alias specified here was used in a previous JOIN section unless this is the first one.
OuterJoin�Has the value of true or false. If set to true then this will be considered an outer join. That means rows from Table2 that do not match any row in Table1 will not be removed. The default action is to remove those rows.
The ENUM sections are used to define enumerated values. This is helpful when numeric values are used internally by the database that are not clear to the end user. Enumerations can be used to convert these integers into strings.
Enumerations are converted using the enumo function which is described in the expression section. As many ENUM sections can be defined as are needed. The attributes for the ENUM section are:
Name�Specifies the name of the enumeration.
Keys�Specifies a comma seperated list of integer values.
Values�Specifies a comma seperated list of strings that correspond to the integer values.
The COLUMN sections are used to describe each column (sometimes called an attribute) that the join will represent. Columns can be created from any alias.attribute combination or from an expression (described below).
The attributes for the COLUMN section are:
Name�Specifies the name of the column. This is the name the column will appear to have to any user of this join.
Value�Specifies an expression that represents the value of this column. This can be the result of any set of supported operations (which are described below) or it can simply be an alias.attribute combination.
Update�Specifies the alias.attribute to update when data entry is performed. If this is not specified the column is not enterable.
Width�Specifies the width of this column in characters. This is used for formatting output.
Required�Has the value of either true or false (the default is false). Specifies if this column is required for adding a new object.
PK�Has the value of either true or false (the default is false). Specifies if this column represents the primary key column. This is used to help the CDS interface know if there is a unique way to identify each resource (row) in the CDS.
The INSERT section is only specified once. It defines all of the logic necessary to add a new resource (row) to the underlying tables. This section works differently than the others in that each entry is a macro function call used to manipulate other CDS's.
The insert section can be thought of as a procedure that is run each time an insert is performed on the CDS defined by this file. The caller should have already asked for the required properties and filled them in with appropriate values. Then they pass that CDS into the addResource( ) function call to add the new resource.
The CDS they pass in is available in the INSERT section as a CDS variable named _required. Once this happens control is passed to the INSERT section where all of the steps needed to insert the new logical object into the database should be implemented. In a normalized database this can require many different insert and lookup operations.
All data inside the INSERT section is managed in the form of CDS's. Variables to hold the CDS's are created implicitly and do not need to be declared. As a result, simply supplying any valid variable name to hold the return value from a function call will work.
In general an insert section performs two basic operations:
Add Records�Records are added to lower-level CDS's. In fact, in some cases the entire insert operation is delegated to a lower level CDS.
Adjust References�Many times the new records need to have foreign key references adjusted. This is done by per-forming a lookup through another CDS and using that data to update the new record. When per-forming lookups it is assumed that all required data has already be entered into the underlying database.
These operations are implemented using the following script function calls:
This function is used to load variables and their values into the factory before retrieving a CDS. This allows variables to be resolved in the underlying CDS based on the current information from the _required CDS. The parameter variableName is the name of the variable being defined and the value is the value it will be set to.
This function opens up a CDS. The resulting CDS can be used to insert new records into or to provide reference information for linkages to other CDS's. The cdsvar is a variable by any name that is used to reference the resulting CDS. The cds_definition is the CDS definition string and is dependent on the type of CDS being opened. Each type of CDS expects particular parameters to be supplied. The cache parameter is the value true or false and indicates if this CDS should be cached. If the same exact CDS will be opened often then caching is usually a good idea.
req_prop=cdsvar.getResourceRequiredProperties( );
This function returns the required properties needed to insert a new resource (row). The req_prop variable can be a variable by any name and is used to reference the returned CDS. The cdsvar variable is any CDS variable previously defined.
This function inserts a new resource (row) into an already opened CDS which is referenced by cdsvar. The parameter req_prop defines the required properties that are needed to add the new resource. The return value is a CDS with a single resource that is referenced by the variable newcds. The newcds can be used to access or set properties in the new resource. All references will be at resource id 0 since the new CDS only has a single resource.
This function is used to retrieve data from a CDS. It is usually used directly as a parameter to set-Value to set an attribute in a new CDS based on the value of an existing CDS. The cdsvar variable is a reference to the CDS from which the value is to be retrieved, the prop_name is the name of the property to fetch the data from and the res_id is the offset or id of the resource (row) to fetch the data from.
This function sets the value of a property within a CDS. The cdsvar variable is a reference to the CDS to set the value in, the prop_name is the property to change, res_id is the offset or id of the resource (row) to update and value is either a constant or a call to getValue in another CDS.
This function is always the last function in the INSERT section. It is used to terminate the procedure and to designate a key value to be used as representative of the new resource that was created.
The variable pk variable is usually the result of a previous addResource call.
Expressions provide a way to produce calculated values as well as just the data from the database. They support direct references, mathematical expressions, functions, and conditionals.
Attribute References
Attribute References refer to the direct access of data through the alias.attribute combination. The alias portion of this should have been defined in the [TABLE] or [CDS] sections. The attribute is a column name that exists for that table or CDS. This format is used to access all of the underlying information within the database.
Mathematical Expressions
Most of the basic mathematical operators are supported as defined below:
Also note that the unary minus is a tilde (�{tilde over ( )}�) symbol rather than the usual dash (�-�). Logical operators are also available as described in the Conditionals section. If used directly they evaluate to either a 1 (one) or 0 (zero).
A variety of functions are also available as described below:
Returns a string from the enumeration enum_name. This enumeration should have already been defined in the [ENUM] section. The expression should evaluate to one of the integer values defined in the enumeration.
format(�format template�[,expression . . . ])
Returns a string formatted according to the format_template. The template follows the same rules used by the printf(3) C function. Each replaceable element in the format_template should have a corresponding expression. There can be as many expression elements as needed, all separated by commas.
Returns true or 1 if the specified attribute value is NULL, otherwise false or 0 is returned.
Returns the maximum value in attribute attr for the CDS defined by cds_def.
Returns the square root of x.
Returns the length of string x.
strtok(string, �delimiters�, n)
Returns token n (where n is zero based) from string string where tokens are separated by any of the characters in the string delimiters.
Returns the string string truncated to width characters.
Conditional operations are supported in the �C� style form of:
These expressions can be nested as deep as necessary. The logical operators supported are:
Variable Substitutions
Variables can be used to allow a single join definition file to be used in different ways. For example, the join may specify a restriction based on a name in the [TABLE] section. If this name is hard-coded the join file is only useful for that specific name. An alternative is to use a variable to contain the name. A variable is defined using the form ${VARNAME}. It can be used anywhere that an expression is used or it can be part of an expression. Default initial values can also be supplied so that the join behaves normally even if the variable isn't defined by the caller. Variables with defaults are defined using the form ${VAR-NAME=default},where default is any constant.
Values for variables are set by the caller using either the CDS definition string or the factory. An example of using the CDS definition string to set the value of a variable called NAME would be:
Appendix A includes a source code listing for a Join Engine comprising the following files:
The Join Engine is but one component of a system that can be developed using the tools of the present invention for generating reusable components using a uniform calling interface. Set forth below is a description of a design and development process that uses tools described therein, including the Join Engine, operating through a uniform interface on existing components to creating a single integrated reusable component. The existing components need not share the same object abstractions because the uniform calling interface adapts to the abstractions externalized by the various components.
Adaptive Object Modeling using Uniform Interfaces (AOM/UI) is a software design and development process that significantly reduces the cost for designing, developing, deploying and maintaining software systems by using a unique approach to object abstraction.
From the AOM/UI perspective, any automated system is a collection of components that each perform a specific business function. These can be as small as a single procedure or as large as a major subsystem. Collectively these components provide all of the functionality needed for a specific automated solution. This is an iterative concept because any automated solution may be considered a component in a larger automated system.
In order to function as a single integrated solution these components should communicate with each other in a very precise and predicable manner. It is the way in which this communication is done that is at the heart of so many software system problems and is exactly the problem that AOM/UI addresses.
The AOM/UI Approach
Objects Adapt to the Component
The AOM/UI approach allows each component to assume its internal object abstractions are the standard ones. As a result, the component doesn't adapt to the object's implementation, the objects adapt to the component's implementation.
The result is a simplified component where the implementation is focused on the business logic implemented in terms of the ideal object abstractions. There is also no need for coordination between component developers since each component can use it's own object abstractions regardless of what other components are using.
This adaptive capability is a unique concept since conventional wisdom would say that the object model is the part of the equation that should be kept constant. It is also very difficult to do unless tools can be used to assist with the adaptation.
Uniform Interfaces
The tools require that the objects all be implemented with a uniform object interface. Having a uniform interface does not mean that each object has uniformity in terms of what it represents, only that the calling interface is uniform.
Having a uniform calling interface is a similar concept to a relational database engine. A relational database can be set up to store information on just about anything, however, the calling interface used by application developers is always the same, regardless of the specific information being managed.
In the AOM/UI methodology all objects are modeled the same, regardless of what they represent. Each object has attributes, behavior and relationships.
Object Interface Requirements
A programming interface is used that allows at least the following interactions with each abstracted object:
A full scale implementation would most likely enhance these operations to include specific attribute data types, object identification and other convenient operations to make the interface more complete. However, it is important that the interface stay as compact as possible and uniform across all objects. This means there can not be any extensions to the interface based on the object being abstracted. As long as that rule is met the interface can be as robust as needed.
In addition, the interface should also allow objects to be managed in sets. These sets should be defined in an opaque manner, not by queries that are coded into the application. This is important because any query mechanisms would necessarily introduce assumptions and dependencies about how the objects are stored and organized, when in fact the application should not be aware of this or much of the critical abstraction between the logical view and actual object implementation is lost.
Describing Object Sets
To address this problem, a set of objects is defined uniquely by a complex name which is similar in concept to a URL. The complex name is provided to the component during run time or through a configuration mechanism and can be exchanged for the actual set of objects it represents by using the uniform object interface.
Abstraction Conversion Tools
Once this uniformity is established, tools can be used to assist with creating the derived abstractions needed by each component. The tools implement a set of operations that allow attributes and behavior from objects presented in one abstraction to be part of objects presented in another. They can the thought of as abstraction conversion tools that implement operations that include, but are not limited to, the following:
Object masquerading�this is the ability to change the names of attributes or behavior
Object selection�this is the ability to reduce the number of objects in a set
Object projection�this is the ability to reduce the number of attributes or behaviors available on an object
Object concatenation�this is the ability to combine sets of like objects together to form a single set
Object joins�this allows the creation of derived objects based on relationships between existing objects
Property calculations�this is the ability to create calculated properties for an object
Object bridging�this is the ability to utilize a communications system (any middleware, messaging or networking technology) to make objects available across different physical machines
Object monitors�wrappers that provide security, logging, journaling or other services that are transparent to the object implementation
System wrappers�wrappers that take information and functionality from existing systems and make it available through this interface. For example, this could be used to provide access to an Oracle database or an existing proprietary system.
These operations can be chained together as needed since the input to any operation is one or more AOM/UI objects and the output is always a AOM/UI object. This means that they implement closure, allowing a great deal of flexibility in how the operations are used to gain the exact object abstractions needed.
Object Behavior
Components that implement objects should provide the following behaviors as a minimum when ever possible:
Attribute change notification�this informs an interested component each time an attribute changes value
Attribute addition notification�this informs an interested component each time an object adds an attribute
Attribute removal notification�this informs an interested component each time an object removes an attribute
Object addition notification�this informs an interested component each time an object is added to a set
Object removal notification�this informs an interested component each time an object is removed from a set
Other behavior can also be provided as needed. The system allows for any type of custom behavior to be provided as is necessary. Like the attributes, these behaviors can be abstracted to allow complete independence between components.
This means that the behavior implementor may have a different name and different parameters than the caller is using. These mis-matches are resolved using the abstraction conversion tools.
Checking for Behavior at Run-Time
Components can check to see if which behaviors exist, allowing the component to modify its processing based on the object's capabilities. This addresses the situation where the ideal case can be utilized when possible, however, any object can be processed even if it's implementation is more primitive (less functional).
Relational Modeling
The last piece of the AOM/UI puzzle is the relational object model. The relational object model is not required and in fact would be overkill in a simple system, however, if implemented it ensures the ability for the system to grow as large as necessary and reduces the complexity that would otherwise be introduced as components from different domains are integrated together.
The relational object model is a normalized representation of the core entities that make up the system. It is not required for any component to utilize this model directly, only that all views used by the components can be derived from it. As new components are added the relational object model can be expanded to encompass the normalized forms of the new objects and attributes that they define.
This relational model helps manage the complexity because it defines clearly how to start from a view in one domain and cross over to another. For example, how a customer relates to a credit in the accounting system. These are two views of two objects that have a relationship due to a sale, but without good data modeling these relationships would be difficult to manage.
The AOM/UI approach offers the following benefits:
Components are built around the object model that suites them the best.
Components can be built independently without requiring communication between groups.
The system can be scaled without limitation.
Integration technologies can be applied as needed without requiring any modification to the workings of the components themselves.
The system is not limited by location, platform or language.
Developers of complex systems are faced with a very difficult dilemma every time they set out to solve a problem: How can existing tools and technologies be best utilized to arrive at the most effective implementation of the solution. Picking the wrong approach at this critical juncture could mean the difference between a solution that stands the test of time and one that simply gets forgotten as technology evolves. It can also mean the difference between a solution that can be reused in a variety of situations or a solution that exists primarily stand-alone.
Traditionally this has been a very difficult decision process to go through, requiring considerations of which database, which operating system, which hardware, what kind of middleware, and what type of user interface. It is at this point that the solution to the problem being solved starts to be imbedded into a specific set of technology, eventually becoming indistinguishable from that technology. Each assumption made at this stage becomes a dependency, each dependency becomes a barrier that limits deployment, hinders future integration, creates potential maintenance, and devalues the resulting solution. In addition, the solution ages and grows out of date as the technology it depends on grows out of date, regardless of the robustness and the applicability of the algorithm itself.
Having dependencies of this type are often viewed as such a severe constraint that many researchers and vendors choose to build their own environment as well as their own applications. This too has pitfalls. A complete and mature set of infrastructure is very expensive and time consuming to build. It can tie up valuable resources and forces developers to become experts in many areas when their passion is really focused in a few specific areas. More often than not the result is a compromised set of infrastructure, built to the minimum specifications needed by the supported applications and not robust enough to allow the true potential of the primary work to be realized.
The following example presents an alternative approach, using abstract object modeling in accordance with one embodiment of the invention, that allows a developer to build applications that can take advantage of other technologies without depending on them. It allows applications to be combined in ways never imagined by their authors and it insulates the investment in the solution from the specific technologies available at the time of its implementation.
In order to illustrate this process we will examine the development for a linear powerflow application. First examining an implementation based on a more traditional approach, followed by an examination of that same implementation based on the abstract object modeling approach. It is important to remember that the linear powerflow application is chosen as an example because it provides an expedient illustration of these principles; however, any component in a system can be designed this way, including the user interface and database systems.
Powerflow Requirements
The linear powerflow application is expected to run continuously, reacting to any change in the system conditions by calculating the branch flows and angles. It will do this by examining each island in the system one at a time. If the island is energized, it will examine each bus in the island to find out the total load and total generation on that bus. Then each branch will be examined to find out the impedance and reactance. From this all the bus angles will be calculated along with the branch flows. These results will be stored in a way that they can be viewed and utilized by other applications.
One very common traditional approach is to use text files to pass the data in and out of the application. This is a convenient and appropriate approach in many situations, especially where batch oriented processing is acceptable. However, we are attempting to raise the level of integration for this example application so that it can immediately react to system changes and is able to process only the changes that it needs rather than starting over every time. This requires us to integrate the application more tightly and does not permit the text file approach.
The resulting powerflow application has the basic interface as shown in
Using a traditional approach, the powerflow application will need to integrate tightly with the system containing the real-time information. This will require the developer to answer some important questions:
The powerflow application from
In addition, if the application needed to be integrated on another system using another model, the amount of integration work must all be repeated, there is no carryover benefit gained after the first integration. Since this integration effort is usually expensive and time consuming it is unlikely that others with different environments will reuse this application without a very compelling reason.
Abstract Object Modeling Approach
Abstract Object Modeling takes a different approach, it is based on the idea that the application developer can assume the application is interfacing to sets of virtual objects. These virtual objects can have any definition in terms of behavior and attributes that the developer chooses. What objects really exist in the system and where they exist is not really important and is resolved later.
This may sound rather extreme until one compares this approach to the already very popular practice of using text files for data exchange. It is not very unusual for an application to specify a file format for input, how that file is generated is of no consequence to the application, just as long as it meets the format requirements. The developer may also share results through one or more output files, the format of which is assumed by the application developer, again leaving unanswered how that output file will be blended into the overall operation of the system. As long as these files are clearly documented this is usually an acceptable practice.
Text files can also be very successful in representing a set of objects in a very simplified manner, just imagine a text file for specifying the busses for the powerflow application, which could be formatted as:
This simple comma separated value file could be seen as a set of two bus objects. Of course, these bus objects don't have any behavior, only state. However, this is still a very useful representation.
It is also easy to imagine that this representation could be generated by tools from any system where a powerflow application was needed. In other words, it is perfectly reasonable for the developer to simply assume that these objects can be produced as specified without needing to know any detail about the target system ahead of time.
Another aspect of using text files is that nearly every computer language on any platform can read or write a text file that can be used by any other language on any other platform. This type of consistency is very important because it means that no special tools or facilities are being assumed by the developer that can become out of date or unavailable as the application is moved from system to system. There are other issues, such as 16 bit character sets versus 8 bit, but in general these practices work without any hitches.
Looking at this another way, the text file approach allows an application to use a simple, consistent API across any system from any language to represent any type of object. This is an interesting observation when compared to object oriented systems such as CORBA or COM where each class of object is expected to implement a different API.
Each class having its own API is quite informative when studying the interface, however, this creates a lack of consistency which prevents the construction of tools that filter, re-map and dynamically generate objects. Where systems constructed around a consistent API can do this quite naturally. This becomes a significant point that is a key component in the theory behind abstract object modeling. Using text files as an example of this principle, there are any number of generic tools and utilities that can filter, parse, read or write the bus objects stored in the simple comma separated value file that was presented above. The API for abstract object model based applications preserves this same principle.
In most respects text files seem like a viable answer to our plug and play interface. However, as useful as they are there are still significant limitations that make many implementations difficult, such as asynchronous events, shared access, locking, high-speed access, and lack of object behavior.
This is where the abstract object modeling approach helps take these concepts to another level. In much the same way that a text file can describe a set of virtual or abstract objects, the abstract object modeling API can as well. However, the abstract object modeling API goes much further, allowing access to individual attributes, creation and destruction of objects, event notification, introspection and access to behavior. These operations are all performed through an API that never changes regardless of the makeup of the objects.
The benefit is that the application can rely on only one API and assume one data model regardless of how and where it is being integrated. These logical views doesn't change, no matter what middleware, persistent storage system or data model is being used in the target system. Instead, these views are mapped to the target system during integration using tools and utilities that are external to the application.
When designing a system using abstract object modeling, the first step for the application developer is to define the sets of objects that will be required by the application. These are the only external objects that exist from the application's point of view. For the powerflow application, the classes Busses and Branches as described below:
The Busses class attributes are:
The Branches class attributes are:
The next step is to implement the powerflow assuming that these classes exist just as we described them.
Another important aspect of this approach is that no part of this implementation will need to be changed as a result of changes to another part of the system, even if the database, middleware and data model were all replaced. This assumption is proven by the fact that the design for the interface does not take the database API, middleware API or data model into account. Instead, only the logical or abstract view of the objects and the AOM API are significant to the application.
At this point the application developer is finished and the application is ready to be integrated into a variety of systems.
Abstract Object Model Integration
Integration of abstract object model based applications may seem like a difficult task, but it turns out to be quite reasonable. Somehow the abstract objects used by the application must be mapped into the real objects managed by the target system. In order for this to happen the integrator must ask some important questions:
In fact, this list is exactly the same list that the application developer had to ask in the on the Traditional Approach. If the same issues still need to be addressed, then what is the benefit of the abstract object modeling approach?
The primary benefit is that the application is now independent from any implementation technology except for the language it is written in. The application developer is able to focus only on the core application functionality, without any concern for future deployment issues, yet the resulting application is able to be integrated into any conceivable system.
The application integrator has the advantage of a well defined API and should receive documentation of the abstract objects assumed by the application from the application's author. The API is an important aspect because it is the same no matter which objects are being represented. This is a similar idea to a relational database. The database API is the same no matter what type of information is logically represented in the tables.
The primary difference between a relational database and the abstract object model approach is that instead of tables the abstract object model API interacts with fully functional objects, including behavior as well as attributes. However, the principle remains the same.
The integrator can approach the integration of a specific abstract object model based application in a number of ways:
The integrator also has an economy of scale situation, in that the target system interfaces only need to be resolved a single time. For example, if the target system uses Oracle then only one Oracle abstract object model wrapper is needed regardless of the number of applications being integrated.
Existing Abstract Object Model Applications
At this time a number of applications, databases, and user interfaces have either been developed using abstract object modeling or adapted using a wrapper so they can participate in an abstract object modeling system. This work is on-going and the list continues to grow rapidly.
User Interfaces:
Databases and Persistent Storage:
Communications (provides a transparent bridge so that an application running on one machine can access objects on another):
Conversion Utilities (provides re-mapping services to dynamically convert objects from one representation to another):
Miscellaneous Utilities:
The primary objective of an application developer or researcher is to transfer their knowledge in a particular area into an automated form. If this automated result is well packaged and without dependencies it can be reused as part of an ever increasing basic infrastructure that is available to others. However, this objective is rarely realized do to the difficulty in building truly plug & play complex applications.
The abstract object modeling approach is a methodology that overcomes this difficulty, separating the integration problem from the application development problem, resulting in truly re-usable and greatly simplified applications. It is a methodology that applies equally well to user interfaces, database systems, communication systems and application engines. It is also not limited by platform or implementation language. As a result, systems become a collection of building blocks, each provided by different experts without any prior coordination. The system integrator is able to mix and match these blocks to create a system that meets their needs.
While several embodiments and examples of the invention have been illustrated and described, it is to be understood that various changes may be made therein without departing from the spirit and scope of the invention. Hence, the invention is to be limited only by the scope of the following claims and the equivalents thereof.
The various embodiments described above can be combined to provide further embodiments. All of the U.S. patents, U.S. patent application publications, U.S. patent applications, foreign patents, foreign patent applications and non-patent publications referred to in this specification and/or listed in the Application Data Sheet, including but not limited to U.S. Provisional Patent Application No. 60/261,119, entitled �A METHOD AND SYSTEM FOR CREATING REUSABLE SOFTWARE COMPONENTS THROUGH A UNIFORM INTERFACE,� filed Jan. 14, 2001; U.S. patent application Ser. No. 10/047,457, entitled �METHOD AND SYSTEM FOR CREATING REUSABLE SOFTWARE COMPONENTS THROUGH A UNIFORM INTERFACE,� filed Jan. 14, 2002; and U.S. patent application Ser. No. 11/398,847, entitled �METHOD AND SYSTEM FOR CREATING REUSABLE SOFTWARE COMPONENTS THROUGH A UNIFORM INTERFACE,� filed Apr. 5, 2006, are incorporated herein by reference, in their entirety. Aspects of the embodiments can be modified, if necessary to employ concepts of the various patents, applications and publications to provide yet further embodiments.
From the foregoing it will be appreciated that, although specific embodiments of the invention have been described herein for purposes of illustration, various modifications may be made without deviating from the spirit and scope of the invention. Accordingly, the invention is not limited except as by the appended claims.
Patent Citations
Referenced by
Original Image


text:
Wide receivers: Are the top guys first-round worthy?
In our quarterbacks preview, I gave you statistical reasons to believe elite quarterbacks could be considered on the fantasy upswing relative to just-less-than-elite running backs. The gist of that argument: As opposed to nine of the 10 seasons prior, in 2007 two quarterbacks (Tom Brady and Tony Romo) placed in the top five in VBD points ("Value-Based Drafting," in which a player's fantasy points are compared to the fantasy points of the baseline player at his position). That means having Brady in '07 was like having Steve Young in 1994 or Brett Favre in 1996: the best player in the NFL in terms of how far above his position mates he was. It's that thinking which leads ESPN.com to rank Brady sixth overall for 2008.
But what about wide receiver? Are the elite wide receivers on the upswing, too? After all, in '07 Randy Moss ranked third in VBD points, Terrell Owens ranked sixth and Braylon Edwards ranked seventh. That sure sounds like a convincing case for the top receivers being taken well before middling rushers, doesn't it? Yes, but here's the thing: That argument has been valid for a few seasons now. Check out this chart, which indicates the number of running backs, quarterbacks and receivers who've finished inside the VBD-points top 10 over the last six seasons:
|Top 10 in VBD points by position (2002-07)
While the best quarterbacks seem to be outdistancing their average counterparts by more in recent years, the best wide receivers seem to have been doing this for the better part of a decade. And while it's not always easy to ascertain which receivers will be the absolute elite, and thus worthy of first- or second-round consideration, it's very much worth trying. Let's take a closer look at wide receivers, top to bottom.
Wide receiver rankings (by tier)
Randy Moss is the king of the receiver position, and his "VBD value" suggests he's a first-round talent, too.
Tier 1
1. Randy Moss, Patriots
2. Terrell Owens, Cowboys
3. Reggie Wayne, Colts
4. Braylon Edwards, Browns
5. Andre Johnson, Texans
6. Larry Fitzgerald, Cardinals
7. T.J. Houshmandzadeh, Bengals
8. Marques Colston, Saints
9. Plaxico Burress, Giants
10. Torry Holt, Rams
11. Chad Johnson, Bengals
12. Steve Smith, Panthers
Tier 2
13. Santonio Holmes, Steelers
14. Anquan Boldin, Cardinals
15. Brandon Marshall, Broncos
16. Calvin Johnson, Lions
17. Roy Williams, Lions
18. Roddy White, Falcons
19. Greg Jennings, Packers
20. Wes Welker, Patriots
Tier 3
21. Lee Evans, Bills
22. Dwayne Bowe, Chiefs
23. Jerricho Cotchery, Jets
24. Marvin Harrison, Colts
25. Hines Ward, Steelers
26. Donald Driver, Packers
27. Santana Moss, Redskins
Tier 4
28. Joey Galloway, Buccaneers
29. Laveranues Coles, Jets
30. Chris Chambers, Chargers
31. Patrick Crayton, Cowboys
32. Anthony Gonzalez, Colts
33. Bernard Berrian, Vikings
34. Donte' Stallworth, Browns
35. Nate Burleson, Seahawks
36. Reggie Brown, Eagles
37. Reggie Williams, Jaguars
38. Sidney Rice, Vikings
39. Ted Ginn Jr., Dolphins
40. Isaac Bruce, 49ers
Tier 5
41. Derrick Mason, Ravens
42. Javon Walker, Raiders
43. Ronald Curry, Raiders
44. Vincent Jackson, Chargers
45. Bobby Engram, Seahawks
46. Josh Morgan, 49ers
47. Antwaan Randle El, Redskins
48. Amani Toomer, Giants
49. Jabar Gaffney, Patriots
50. Bryant Johnson, 49ers
51. Drew Bennett, Rams
52. D.J. Hackett, Panthers
53. Devin Hester, Bears
54. Jerry Porter, Jaguars
55. Justin Gage, Titans
56. Mark Clayton, Ravens
57. Courtney Taylor, Seahawks
58. Eddie Royal, Broncos
59. James Hardy, Bills
60. Muhsin Muhammad, Panthers
61. Arnaz Battle, 49ers
62. Kevin Curtis, Eagles
63. Hank Baskett, Eagles
64. Chris Henry, Bengals
65. DeSean Jackson, Eagles
66. Kevin Walter, Texans
67. Shaun McDonald, Lions
68. Brandon Stokley, Broncos
69. David Patten, Saints
70. James Jones, Packers
In 2007, Wes Welker might have turned in the greatest fantasy season a slot receiver has ever produced: He tied for the league lead in receptions, scored eight touchdowns and amassed 1,175 receiving yards. No second-banana receiver benefits more from the presence of his team's top threat. Opposing defenses must pay so much attention to Moss that Welker can often stride across the middle of the field uncontested. He might not be a top-10 receiver again, but Welker should be about as steady as they come in '08. Anquan Boldin got 13 red zone targets in '07 and scored nine times, making him the perfect complement to deep threat Larry Fitzgerald in Arizona. Boldin wants a new contract (since Fitzgerald just got a $30 million extension) but isn't likely to be paid like a franchise receiver by the Cardinals. As long as he goes to training camp and doesn't make waves, though, and as long as he doesn't have a recurrence of the hip and toe problems that sidelined him in '07, Boldin is one of the game's best possession receivers. Jerricho Cotchery won't set any speed records, but he has terrific hands and isn't afraid to go over the middle. He topped 1,000 yards for the first time in his career in '07, and figures to top his two scores from last season (he registered six touchdowns in '06). If the Jets can get their quarterback situation settled, Cotchery can be a reliable starter in deeper fantasy leagues. Derrick Mason outlasted his old buddy Steve McNair in the NFL, and now will have to catch passes in Baltimore from a younger, presumably worse quarterback. Still, considering McNair had grown gun-shy over the past couple seasons, Mason -- like the other men on this list, he's mostly a possession receiver -- might actually benefit. He should catch a lot of balls, which makes him an intriguing option in point-per-reception leagues.
Calvin Johnson entered the league to trumpets blaring, but he was underwhelmed during his first season in Detroit. The Lions said a bad back was at fault, but Johnson occasionally flashed shaky hands, too, and now that Mike Martz is gone, there'll certainly be fewer targets to go around. Still, Roy Williams is entering the final year of his contract, and at the moment doesn't figure to get a big-time deal from the Lions. That means the franchise should be invested in making Johnson a focal point, which gives him a chance to become the stud we all hoped he'd be in '07. Whatever success the Vikings achieve in '08 figures to be based on a great rushing game and a good defense, so expecting too much out of free-agent signee Bernard Berrian is risky. Still, considering Tarvaris Jackson struggled so badly in '07, opposing defenses figure to load up the box to stop Adrian Peterson, and make the Vikes' aerial game beat them. Berrian has yet to eclipse six touchdowns or 1,000 yards receiving in a season, but he's a burner who can make game-breaking plays, and was pretty darned productive with mediocre quarterbacks throwing it to him in Chicago. If Marvin Harrison can't get healthy or has lost a step, Anthony Gonzalez would get a crack at playing second fiddle in the Colts' receiving game, a valuable role, indeed. He's short, but fast and even out of the slot can be a viable fantasy bye-week contributor. But if he wins a starting job in Indy, he'd be a very nice complement to Reggie Wayne, and an option in even shallow fantasy leagues. D.J. Hackett is turning into a perpetual tease: He's big, with good hands and a nice head for finding open spaces in a zone, but he hasn't been able to stay healthy. After signing with Carolina to play opposite one of the NFL's true elite deep threats in Steve Smith, Hackett has the world at his fingertips. If he stays healthy and develops some chemistry with Jake Delhomme, he could be a 100-catch receiver. Donte' Stallworth is another new signee who should benefit from the attention that opposing defenses pay to the star opposite him. While Braylon Edwards sees defensive backs roll his way, someone should be open on the other side. Now, Kellen Winslow was often that guy in '07, and Stallworth had a chance to be a super-productive No. 2 opposite Randy Moss in New England last season, and wound up losing his starting job. But at least he has a shot to be single-covered nearly every down. Mike Martz has moved his high-octane offensive-coordinator skills to San Francisco, which instantly makes the Niners' receiving corps relevant for fantasy leagues. Isaac Bruce is clearly someone with whom Martz is familiar with from his St. Louis days, and for as long as Bruce's hammies stay healthy, he'd figure to be the top pass-catcher by the Bay. But it's very much worth keeping your eye on guys like Bryant Johnson, Arnaz Battle, Jason Hill and even (gulp!) Ashley Lelie, because if Martz can make fantasy studs out of Mike Furrey and Shaun McDonald, he can do it with these guys, too.
The Bengals have the kind of high-octane aerial game that helps win fantasy championships, but with so much dissension among the starters (and with the third-stringer banished from the league for the first four weeks of the 2008 season for bad behavior), it's tough to know what'll happen. T.J. Houshmandzadeh tied for the NFL lead in catches with 112 last season, and was second in targets with 168. He's a great possession receiver, and a tough red zone threat, but he's just about as unhappy with his contract as Chad Johnson is, even though he has made far less noise about it. Dwayne Bowe was unexpectedly the most productive rookie receiver from '07, and even though he tailed off as the year progressed, he wound up with 70 catches, 995 yards and five scores. He's a big guy who's tough to tackle and can make the acrobatic catch, and in another situation, he'd look like a sure candidate for the top 20. But Brodie Croyle is the Chiefs' quarterback, the offensive line is weak, and there isn't much quality on the opposite side. If the Chiefs suddenly discover their offense, though, Bowe could be a star. The Cowboys finally cut ties with Terry Glenn earlier this summer, meaning Patrick Crayton resumes his starting role on the high-powered Dallas offense. Meanwhile, Glenn might sign with the Dolphins, and if healthy, would probably slide into a starting role in the Miami offense immediately. Reggie Williams put together a shockingly good fantasy season in '07, highlighted by a career-high 10 touchdowns on just 38 catches, but then the Jags went out and signed Jerry Porter, muddying the waters in Jacksonville. These guys have overlapping skill sets (they're big and not necessarily fast, do good work in the middle and can score in the red zone), and might wind up canceling out one another, unless Porter's May hamstring surgery lingers and relegates his role. Williams had knee surgery early in training camp, making things even murkier. The Chargers tired of waiting for Vincent Jackson to be a viable complement to Antonio Gates, so they traded for Chris Chambers early in the '07 season. Jackson does enter training camp as the team's No. 2 receiver, but he's far less of a fantasy darling, and he could have to fend off Eric Parker, Craig Davis and Legedu Naanee for meaningful snaps. The split end gig in New England, alongside Randy Moss and Wes Welker, figures to be a valuable spot if one man can hold it down all season. With Donte' Stallworth gone, Jabar Gaffney is the early favorite, but he'll have challenges from Chad Jackson and Kelley Washington.
One person's sleeper is another's starter, depending on league size, so let's look beyond the top 60 for guys with upside. Antonio Bryant has had a terrible attitude seemingly from the moment he joined the NFL, but he finds himself in a good situation this summer. He signed with Tampa for the league minimum, but outside of Joey Galloway, there just aren't many great receiving options for the Bucs. Meanwhile, Bryant has good speed and runs good routes. There's a chance he gets cut, but there's also a chance he winds up starting. Chad Jackson reportedly looked very sharp in New England's passing minicamp this spring, which gives him a little juice heading into training camp. An early second-rounder a couple years ago, Jackson has fought knee injuries and indifferent practice habits, and he hasn't contributed anything to the Patriots. But with Donte' Stallworth gone and Wes Welker operating out of the slot, Jackson could find himself manning an outside position. The Saints have a ton of receivers, so last year's first-rounder, Robert Meachem, will have nothing handed to him. But after showing up out of shape for last year's camp and then hurting his knee, Meachem drew raves from New Orleans coaches this spring in minicamp. David Patten looks like a better bet to start opposite Marques Colston, but the Saints use a lot of three-receiver sets, and Meachem has loads of physical tools. You'll probably be making a mistake if you rely too heavily on the Atlanta offense in '08, but Roddy White turned in a fantastic season in '07, and it's not outside the realm of possibility that Laurent Robinson could take a big step this year. Robinson is 6-foot-2 and runs a 4.38, and if defenses focus on White, he could make some big plays. Logan Payne spent his rookie year on Seattle's practice squad, but reportedly this summer he has impressed coaches with his good hands and route-running so much that he's starting to be looked at as an option for an outside-receiver role in three-receiver sets. Considering how often the Seahawks run three-receiver sets, that could make Payne a contributor.
Now, if you're in a league in which you know everyone's going to take their rushers first and second, it's probably a good idea to follow suit; otherwise, you're left with table scraps in your fantasy backfield. But all things being equal, Moss really should be a late first-rounder, while Terrell Owens, Reggie Wayne and maybe even Braylon Edwards, Andre Johnson and/or Larry Fitzgerald should go in the second round.
If you don't take a receiver with either of your first two picks, it's imperative you get one with your third, and probably your fourth (since if you've waited to take a quarterback beyond the second round, you'd might as well wait until the fifth). After filling in my starters, my tendency is to lean heavily in the direction of "flyer" running backs, but I'll mix in a "flyer" receiver or two if I think I'm getting some good upside. My logic is that whereas a "flyer" receiver's upside is probably that he becomes a starter and posts a couple decent games, a "flyer" rusher's upside is that he takes over as a starter and becomes a stud, a la Ryan Grant.
In accordance with the laws of supply and demand, wide receiver stars tend to go for a bit less money than their counterparts at quarterback and running back. Still, you'll probably have to spend on the order of $30 to $35 to get your No. 1 receiver. In general, I'll budget around $60 (in leagues where you've got $200 to spend) for my entire wide receiver stable, which means my No. 2 receiver (and in leagues that have them, the No. 3 receiver) might go for between $15 to $25, and everyone else will be straight from the bargain bin. If you try a "studs and duds" strategy, you'd better be darned sure about the guys you've earmarked as your studs, because dud receivers often contribute absolutely nothing. It's worth noting that because there are so many decent receivers with upside in the NFL, this position tends to be a favorite for "hiding" a player, and hoping no one nominates him in your auction until most of the money is gone. It feels pretty good when you get a guy like James Jones for a buck.
Christopher Harris is a fantasy baseball, football and racing analyst for ESPN.com. He is a six-time Fantasy Sports Writing Association award winner across all three of those sports. You can e-mail him here.
Christopher Harris | emailFantasy
- Senior writer for ESPN.com
- Six-time Fantasy Sports Writing Association award winner
- Author of "The Big Clear," a noir thriller


text:
Tricky but yummy dinner!
Myvirginkitchen is a blog about an English chap called Barry with limited cooking ability filming his attempts to learn the arts of fine food & drink. Recipe suggestions welcome!
Twitter - twitter.com/myvirginkitchen
Facebook -facebook.com/pages/MyVirginKitchencom/260097476270?ref=ts
Website - myvirginkitchen.com
YouTube - youtube.com/user/myvirginkitchen
Loading more stuff…
Hmm…it looks like things are taking a while to load. Try again?