US20060144010A1 - Information processing applications - Google Patents

Information processing applications Download PDF

Info

Publication number
US20060144010A1
US20060144010A1 US10/533,997 US53399705A US2006144010A1 US 20060144010 A1 US20060144010 A1 US 20060144010A1 US 53399705 A US53399705 A US 53399705A US 2006144010 A1 US2006144010 A1 US 2006144010A1
Authority
US
United States
Prior art keywords
application
hierarchy
objects
inputs
application objects
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US10/533,997
Other languages
English (en)
Inventor
Dietrich Wolf
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
ORIMOS SA
Original Assignee
ORIMOS SA
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by ORIMOS SA filed Critical ORIMOS SA
Assigned to ORIMOS S.A. reassignment ORIMOS S.A. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: WOLF, DIETRICH
Publication of US20060144010A1 publication Critical patent/US20060144010A1/en
Abandoned legal-status Critical Current

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/30Creation or generation of source code
    • G06F8/36Software reuse
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/20Software design

Definitions

  • the present invention relates to information processing applications and in particular to the development and modification of such applications.
  • RAD tools can offer some improvement to coding, testing and rollout times, but offer only partial solutions to the problem of rapid and secure development of powerful and complex applications.
  • the present invention provides an application framework within which an application can be efficiently and rapidly developed, and which allows for rapid and efficient modification or enhancement of the developed application to meet changing requirements or circumstances.
  • the present invention further provides an application framework which allows applications to be modified or enhanced at runtime, and for this to be accomplished by users with no coding skills.
  • applications using the framework of the present invention are such that components making up the application can be run on different processes on one machine and/or on different machines in a network, so that the applications are processed in a distributed manner enabling better use to be made of available resources.
  • the application framework provided by the present invention effectively redefines the way applications are designed, implemented, tested and extended, and can greatly reduce time-to-development and costs involved.
  • Applications developed within the framework of the present invention also offer accessibility and flexibility to users such that they can effect modifications, without having the ability of write code, to rapidly adapt the application to their needs without having to wait for IT specialists to do this for them.
  • applications developed within the framework of the present invention are so structured that they are capable of distributed processing across different machines available on a network.
  • FIG. 1 a schematic diagram of an application object as employed in the framework of the present invention (illustrating the standard application object interface)
  • FIG. 2 a schematic diagram of a hierarchy as employed in the framework of the present invention
  • FIG. 3 a schematic diagram of data dependencies as employed in the framework of the present invention
  • FIG. 4 a schematic diagram illustrating distributed processing of an application as provided by the present invention
  • an application is constructed from building blocks which are arranged within an architectural structure which combines the building blocks to deliver the required application functionality.
  • AOs are the basic building blocks or atomic elements used by the present invention to construct and application. AOs may be complied objects which provide the speed and stability of natively complied code. Each AO takes a number of inputs and applies some processing to these inputs in order to derive, typically, a single output value. An AO's processing can be a very simple operation like adding two input values together or it can be very complex with information coming from many inputs. AOs may be provided as instances of “standard” AO's which provide commonly needed or generic processings, made available in a library, or may be specially written by software developers where special processing capabilities are needed.
  • the AO code that performs the processing can obtained from a library of compiled code which is then loaded.
  • each AO is “wrapped” in a interface having a standard structure. This means that data input and output is performed in a uniform manner, which makes it easy for AOs to communicate with one another, or with external data sources or sinks. That is, for all AOs a uniform interface structure is used which provides consistent representations of meaning or significance of the AOs inputs and output(s), and these are accessible via the framework provided by the present invention. In other words, although a user cannot “see” or manipulate what actually effects the processing provided by the AO (e.g.
  • the user through the framework provided by the present invention the user (or developer) can access and interact with the interface, taking account of the significance and type of the inputs/outputs at the interface.
  • the user can interact with the inputs/outputs of AOs, to connect or disconnect them to outputs/inputs of, for example, other AOs.
  • FIG. 1 provides a schematic illustration of a compiled code AO with its code wrapped in the standard AO interface. From the Figure it will be understood that the AO code communicates with the interface, and that the “outside world” communicates with the interface, via the interface inputs and outputs.
  • the interface structure is standardized, e.g. applies the consistent designations to the inputs and outputs of the interface which can be accessed by a user or developer. For example, the interface structure provides the user or developer with designations of the number or inputs required for the AO concerned, whether each input is mandatory (i.e. data must be presented to the input for the AO to function) or optional, and the type of data to be presented (e.g.
  • AOs have Interfaces for uniform handling of data flow.
  • This simple but powerful paradigm can be alternatively summarized as: “an object receives inputs and produces an output without having to concern itself with where the inputs come from or where the output goes;
  • the AO e.g. code
  • the code is decoupled from its data providers and consumers.
  • the code only “sees” the interface and is not concerned with what is beyond that interface.
  • objects can inserted and updated (see below), and data flow between components (e.g. Ads) can be modified without additional coding, linking or compilation.
  • the interface performs validity checks to ensure that the presented data complies with the criteria (e.g. mandatory/optional; string/numeric/boolean) set for each input.
  • the criteria e.g. mandatory/optional; string/numeric/boolean
  • the application framework provides a visual user or developer interface which displays to the user a representation of each AO together with a representation of the inputs and output(s) of the AO such that the user can understand the function performed by the AO (as a very simple example: add two numbers together) and the types (mandatory/optional; string/numeric/boolean) and connections of the inputs and output(s) of the AO,
  • the visual user interface provides that the user can create or delete connections by simple drag-and-drop or point-and-click techniques.
  • the architectural structure imposed by the application framework of the present invention comprises a hierarchy and data dependencies, as explained below.
  • a number of AOs are combined into a hierarchy.
  • AOs are primarily arranged or organised in parent/child relationships. Every AO in a hierarchy (with the exception of the “root” AO) has a parent.
  • a hierarchy can be thought of as representing a function to be performed or a problem to be solved by the application, with the individual AOs in the hierarchy providing the individual tools or functionality which can be assembled or combined together to perform the function or solve the problem.
  • a hierarchy represents a real-world object (an object that performs a function relevant to the real world situation which the application is to deal with, e.g. an object providing the function of a financial instrument, such as a bond pricing or hedge calculation instrument, or an organisational instrument, such as an optimal vehicle routing calculator), with the individual AOs of the hierarchy providing the component capabilities needed to create the real-world object.
  • the hierarchy may have a tree structure, “sub” hierarchies nested as needed.
  • the application developer or user can see the whole of the tree structure, down to individual leaf elements, i.e. AOs.
  • FIG. 2 gives a very simple illustration or the hierarchy/sub-hierarchy organisation of AOs in accordance with the present invention.
  • the complete hierarchy starting from the root AO, corresponds to a logical real world object, that is a function which the user or developer relates to the real world capability required of the application which the hierarchy represents, built up of individual AOs which provide the individual processing capabilities or atomic elements needed to perform the real world function.
  • individual sub-hierarchies may themselves also correspond to logical real world objects (i.e. real world capabilities required of the application of which the sub-hierarchy is a part).
  • the hierarchy provides all the real-world objects which the application concerned needs to fulfil its purpose.
  • the hierarchy can be seen and manipulated.
  • AOs can be additionally introduced or removed, or sub-hierarchies can be newly created or deleted.
  • an optimal vehicle route calculator may involve a hierarchy of AOs which deal with various relevant factors, such as cost of fuel. If a new cost factor arises, for example because of a new government road pricing scheme, the hierarchy can be modified by the introduction of an AO to deal with this factor in the optimal route calculation. This can be accomplished at run-time.
  • the a visual user or developer interface of the application framework displays to the user a representations of the hierarchy such that the user can understand the hierarchy and any sub-hierarchies in terms of their functions, or the real world objects they represent (e.g. optimal route calculator) and the parent/child relationships of the AOs in the hierarchy
  • the visual user interface provides that the user can manipulate the hierarchy by simple drag-and-drop or point-and-click techniques.
  • an AO may provide its output value as an input to one or more other AOs.
  • These AOs to which an output value is input are said to be dependents of the AO providing the output value.
  • the network which describes the flow of information between AOs is called the dependency graph.
  • FIG. 3 provides a very simple schematic illustration of data dependencies of AOs in accordance with the present invention.
  • Connections shown by solid lines which indicate data flow are established from external data sources to the inputs appropriate AOs (i.e. to the interface inputs of the AOs, and such data flow connections are established between outputs of the AOs and inputs of other AOs within the hierarchy or inputs of external destinations of data.
  • Feedback connections, illustrated by a dotted line, can also be established between an output and an input of the hierarchy to enable data to be updated for a subsequent iteration of the processing carried out by the hierarchy.
  • these data dependencies, or data flow connections can be readily devised and established by a developer or user, and the developer or user can readily changes them to meet changing needs of the application. For example, the developer or user can alter the connections or data flow to accommodate a new AO in an optimal route calculation hierarchy to take account a new government road pricing scheme as mentioned above. Because of the standard interface structure, the developer or user can readily ensure that appropriate connections (e.g. with regard to input/output types and designations) are correctly made.
  • the visual user or developer interface of the application framework displays to the user a representations of the data dependencies such that the user can understand the data flows involved.
  • the visual user interface provides that the user can manipulate the paths of data flow by simple drag-and-drop or point-and-click techniques.
  • AOs may provide connectivity to built-in services like data sources through to others that provide calculation capabilities and visualisation of information.
  • the connectivity between objects is easily achieved through a uniform interface that provides a consistent representation of the meanings of an object's inputs and its output. This unique quality of AO's allows the non-programmer to create the required functionality by visually connecting AOs together like Lego blocks.
  • the framework provided by (the present invention enables complex systems to be broken down into logical elements which can be developed and tested as discrete components by specialist developers, third party vendors etc.
  • the framework then allows even non-programmers to design, deploy and monitor high performance solutions based on those components by managing the connection complexity between them without having to perform any further coding or linking.
  • the present invention enables applications to be constructed which run in a distributed manner.
  • parts of the AO hierarchy e.g. a sub-hierarchy, of the application can be assigned to its own “container”.
  • This container provides the thread that executes the code of the AOs within it and also provides an messaging interface for external data sources and destinations to enable them to interact with—provide data to and accept data from—the AOs in the container.
  • Externally input data for AOs in the container are channelled as an input message queue that belongs to the container thread.
  • the AOs in the container can thus take inputs from the container input message queue as well as from other AOs within the container.
  • Data from AOs in the container can also be fed back to the container input queue (see e.g. FIG. 3 ).
  • Each container thus encapsulates a single processing queue.
  • the threads used big different containers can be executed on different machines or processes, or a machine or process can handle a number of threads or containers, to make full use of multi-processor capabilities of the machine. This enables the application to be processed in a distributed manner, with the code of different containers (or different parts of the hierarchy of AOs being run in distributed processes hierarchy relationships (e.g. parent/child relationships) and data dependencies are still maintained.
  • hierarchy relationships e.g. parent/child relationships
  • FIG. 4 provides a very simple schematic illustration of distributed processing of an application provided in accordance with the present invention.
  • a process e.g. a machine
  • External data sources communicate with AOs of the part hierarchies via input messaging queues (interfaces) of the containers.
  • AOs of the part hierarchies output data aria interfaces.
  • messaging middleware is shown as handling communications between clients of the application provided by the present invention, such clients being for example a spreadsheet client which can take data provided by the present invention into a spreadsheet representation, a graphing client and a database client.
  • the clients can send data and/or requests for data to the interfaces of the containers and thus to the AOs of the part hierarchies contained or run in the containers, and also receive data.
  • the application developer can chose different organizations as best suited to the particular application concerned.
  • the use of many containers can provide for highly parallel processing, but it should be noted that this could be time consuming if many cross-container data connections are involved, because data has to be passed between different threads.
  • the framework of the present invention provides the application developer or user with a logical view, of the structure of the application (i.e. AOs, the hierarchy and data dependencies) and the developer or user can manipulate or modify the structure based on that logical view.
  • AOs for example compiled objects
  • the framework of the present invention provides for objects or components that have uniform transparent interfaces providing normalised data flow, such that the structure in which the objects are positioned and the relationships between objects can be modified at runtime.
  • the framework provided by the present invention is designed to enable the decomposition of complex objects into simple components. Structures are created by combining simple components to build flexible real world objects, which can be extended at runtime. This enables applications to evolve to address new requirements while ensuring maximum system availability.
  • application objects used by applications in accordance with the invention can be processed in a distributed manner across different machines or processes whilst the necessary relationships and data flows between objects are maintained.
  • the framework of the present invention provides that:—
  • the framework provides a visualisation of the structure of the application
  • Each object can be visualised in terms of its inputs, outputs and functionality.
  • the hierarchy can be visualised in a logical view from the top down to its basic elements, and the data flow connections between objects of the hierarchy can be visualised.
  • the application can be manipulated.
  • Objects can be added to the hierarchy from the library, hierarchies can be modified or restructured, and data flows can be manipulated.
  • the visualisation of an application is available not only to the developer of the application, but also to a user of the application at runtime, so that the application can be manipulated not only by the developer but also the user at runtime.

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • General Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Stored Programmes (AREA)
US10/533,997 2002-11-05 2003-11-05 Information processing applications Abandoned US20060144010A1 (en)

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
EP02024665A EP1426857A1 (de) 2002-11-05 2002-11-05 Komponentenbasierte Entwicklung von Software
EP02024665.8 2002-11-05
PCT/EP2003/012351 WO2004042567A2 (en) 2002-11-05 2003-11-05 Information processing systems configured and manipulated under an application framework

Publications (1)

Publication Number Publication Date
US20060144010A1 true US20060144010A1 (en) 2006-07-06

Family

ID=32309311

Family Applications (1)

Application Number Title Priority Date Filing Date
US10/533,997 Abandoned US20060144010A1 (en) 2002-11-05 2003-11-05 Information processing applications

Country Status (4)

Country Link
US (1) US20060144010A1 (de)
EP (1) EP1426857A1 (de)
AU (1) AU2003283355A1 (de)
WO (1) WO2004042567A2 (de)

Cited By (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20060026094A1 (en) * 2004-07-28 2006-02-02 Tolga Oral Systems and methods for distributing updated information in a stateless system
US20070124006A1 (en) * 2005-11-28 2007-05-31 Ubiquity Software Corporation Service structured application development architecture
US20070276755A1 (en) * 2006-05-29 2007-11-29 Sap Ag Systems and methods for assignment generation in a value flow environment
US7418710B1 (en) * 2007-10-05 2008-08-26 Kaspersky Lab, Zao Processing data objects based on object-oriented component infrastructure
US20090204976A1 (en) * 2008-02-11 2009-08-13 International Business Machines Corporation System and method of reconstructing complex custom objects
US20100325606A1 (en) * 2004-03-15 2010-12-23 Ramco Systems Limited Component based software system
US20120291045A1 (en) * 2011-05-13 2012-11-15 Martin Jeremy D Registration and execution of highly concurrent processing tasks
US20160117237A1 (en) * 2014-10-27 2016-04-28 Software Ag Usa, Inc. Systems and/or methods for monitoring live software
US10180823B2 (en) * 2016-09-16 2019-01-15 Oracle International Corporation Systems and methods for building applications using building blocks linkable with metadata
US20200183662A1 (en) * 2017-05-16 2020-06-11 Makeblock Co., Ltd. Method and apparatus for converting building block programming into program code

Families Citing this family (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7680935B2 (en) 2004-09-30 2010-03-16 Microsoft Corporation Entity domains
AU2007240079A1 (en) * 2006-04-17 2007-10-25 Smart Technologies Ulc Enhancing software application features and content objects
GB2459682B (en) * 2008-04-30 2012-04-25 Vmware Inc A computer system and a method of deploying an application in a computer system
CN111309368B (zh) * 2020-03-12 2023-05-16 超越科技股份有限公司 一种基于b/s框架开发信息管理方法,系统,设备及可读存储介质

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6247020B1 (en) * 1997-12-17 2001-06-12 Borland Software Corporation Development system with application browser user interface
US7076763B1 (en) * 2000-04-24 2006-07-11 Degroote David Glenn Live component system

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6247020B1 (en) * 1997-12-17 2001-06-12 Borland Software Corporation Development system with application browser user interface
US7076763B1 (en) * 2000-04-24 2006-07-11 Degroote David Glenn Live component system

Cited By (24)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9009658B2 (en) * 2004-03-15 2015-04-14 Ramco Systems Limited Component based software system
US20100325606A1 (en) * 2004-03-15 2010-12-23 Ramco Systems Limited Component based software system
US20060026094A1 (en) * 2004-07-28 2006-02-02 Tolga Oral Systems and methods for distributing updated information in a stateless system
US7831958B2 (en) * 2004-07-28 2010-11-09 International Business Machines Corporation Systems and methods for distributing updated information
US8099716B2 (en) * 2005-11-28 2012-01-17 Ubiquity Software Corporation Limited Service structured application development architecture
US20070124006A1 (en) * 2005-11-28 2007-05-31 Ubiquity Software Corporation Service structured application development architecture
US20070276755A1 (en) * 2006-05-29 2007-11-29 Sap Ag Systems and methods for assignment generation in a value flow environment
US7418710B1 (en) * 2007-10-05 2008-08-26 Kaspersky Lab, Zao Processing data objects based on object-oriented component infrastructure
US8234656B1 (en) 2007-10-05 2012-07-31 Kaspersky Lab, Zao Processing data objects based on object-oriented component infrastructure
US10223108B2 (en) 2008-02-11 2019-03-05 International Business Machines Corporation System and method of reconstructing complex custom objects
US8626720B2 (en) * 2008-02-11 2014-01-07 International Business Machines Corporation System and method of reconstructing complex custom objects
US9632772B2 (en) 2008-02-11 2017-04-25 International Business Machines Corporation System and method of reconstructing complex custom objects
US20090204976A1 (en) * 2008-02-11 2009-08-13 International Business Machines Corporation System and method of reconstructing complex custom objects
US9081647B2 (en) 2008-02-11 2015-07-14 International Business Machines Corporation System and method of reconstructing complex custom objects
US8935705B2 (en) * 2011-05-13 2015-01-13 Benefitfocus.Com, Inc. Execution of highly concurrent processing tasks based on the updated dependency data structure at run-time
CN103649907A (zh) * 2011-05-13 2014-03-19 益焦.com有限公司 高度并发处理任务的记录和执行
US20120291045A1 (en) * 2011-05-13 2012-11-15 Martin Jeremy D Registration and execution of highly concurrent processing tasks
US20160117237A1 (en) * 2014-10-27 2016-04-28 Software Ag Usa, Inc. Systems and/or methods for monitoring live software
US9465723B2 (en) * 2014-10-27 2016-10-11 Software Ag Usa, Inc. Systems and/or methods for monitoring live software
US10180823B2 (en) * 2016-09-16 2019-01-15 Oracle International Corporation Systems and methods for building applications using building blocks linkable with metadata
US10552124B2 (en) 2016-09-16 2020-02-04 Oracle International Corporation Systems and methods for building applications using building blocks linkable with metadata
US10642581B2 (en) 2016-09-16 2020-05-05 Oracle International Corporation Systems and methods for building applications using building blocks linkable with metadata
US20200183662A1 (en) * 2017-05-16 2020-06-11 Makeblock Co., Ltd. Method and apparatus for converting building block programming into program code
US10929109B2 (en) * 2017-05-16 2021-02-23 Makeblock Co., Ltd. Method and apparatus for converting building block programming into program code

Also Published As

Publication number Publication date
AU2003283355A8 (en) 2004-06-07
EP1426857A1 (de) 2004-06-09
AU2003283355A1 (en) 2004-06-07
WO2004042567A3 (en) 2004-07-29
WO2004042567A2 (en) 2004-05-21

Similar Documents

Publication Publication Date Title
US11169784B2 (en) Computing expression medium, development environment, and device communication and control architecture
US8458660B1 (en) Semantic-based, service-oriented system and method of developing, programming and managing software modules and software solutions
US10324690B2 (en) Automated enterprise software development
US7266565B2 (en) Table-oriented application development environment
Mannaert et al. Towards evolvable software architectures based on systems theoretic stability
US7240328B2 (en) System and method for visual application development without programming
US20060144010A1 (en) Information processing applications
Gedik et al. A model‐based framework for building extensible, high performance stream processing middleware and programming language for IBM InfoSphere Streams
Jézéquel Model‐Driven Engineering for Software Product Lines
US11275567B1 (en) Making communication interfaces pluggable by using mechanisms comprising of exchange/broker for communication interfaces
Zdun Language support for dynamic and evolving software architectures
Neubauer Higher-order process engineering: The technical background
Yang Process library
Rath et al. Declarative specification of domain specific visual languages
Spacek Design and Implementation of a Reflective Component-Oriented Programming and Modeling Language
Song A general model for component-based software
Hamilton Software Design and Development
Lanore On Scalable Reconfigurable Component Models for High-Performance Computing
Design Language support for application framework design
Zaichenkov A Method for Consistent Non-Local Configuration of Component Interfaces
Chen A semantic anchoring infrastructure for model-integrated computing
Nechypurenko et al. Supporting Model Reusability with Pattern-based Composition Units
Baltopoulos Web Service Composition in the Grid Environment
Talevski et al. A Re-configurable Component-based Software Framework
Kersten How to Make Runtime Architectural Design Decisions

Legal Events

Date Code Title Description
AS Assignment

Owner name: ORIMOS S.A., SWITZERLAND

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:WOLF, DIETRICH;REEL/FRAME:017676/0922

Effective date: 20051114

STCB Information on status: application discontinuation

Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION