Sap Ag

Sap Se

Andreas Blumenthal

Helmut Prestel

Andreas Simon Schmitt

Christian Stork

Rolf Hammer

Michael Schneider

Thomas Decker

Gerd Kluger

Markus Peter Frick

Volker Wiechers

Juergen Remmel

Kai Baumgarten

Ulrich Koch

Friederike Benjes

Rasmus Faust

Martin Runte

Karsten K Bohlmann

Stefan Bresch

Dirk Debertin

Tobias Wenner

Ralf Wendelgass

Klaus Ziegler

Christoph H K Wedler

Holger Janz

Juergen Staader

Masoud Aghadavoodi Jolfaei

Kerstin Hoeft

Bjoern Mielenhausen

Guenter Zachmann

Welf N Walter

Wolfgang G Mueller

Sigrid K Wortmann

Werner Rehm

Jens Lieberum

Mirko Luedde

Frank Bertelsmeier

Erik Sodtke

Wolf Hagen Thuemmel

Carl Philipp Staszkiewicz

Wolfgang Roeder

Thomas Becker

Wilfried Ehrensperger

Mathias Hanbuch

Thomas Manzke

Christiaan E Swanepoel

Thomas Bareiss

Jürgen Remmel

Wolfgang Baur

In one embodiment, a method includes defining a parent structure including an extension. A polymorphic structure is defined for the extension. The polymorphic structure is associated with a plurality of client specialization structures, each client specialization being associated with a client in a plurality of clients. During runtime by a computing device, the parent structure is generated with an extension to a client specialization structure associated with one of the plurality of clients where client specialization structures associated with other clients are not visible to the parent structure.

Generic boxed components for multi-client systems

A system and a method associated with a system landscape having a plurality of independent systems are provided to determine a refactoring object associated with modification of at least one code-based object and transport the refactoring object to a set of independent systems in the system landscape where each independent system is coupled to a communications network. Furthermore modifications of code-based objects are arranged to be performed at each of the set of independent systems in the system landscape.

Transportable refactoring object

According to some embodiments, a programming language in an application server may access different database server implementations, wherein the programming language accesses content of database tables via work areas derived from the database tables. A database table may be mapped to a work area such that each column in the database table is mapped to a corresponding component of the work area (having a default component type based on the column type of the associated column). It may be determined that a particular column in the database table is to store large object data content, and a new mapping to a work area may be defined such that a particular column maps to a corresponding component having a component type other than the default component type.

Systems and methods for mapping large object data content in a database table to a work area

According to some embodiments, a programming language in an application server may include access to different database server implementations, wherein the programming language accesses content of database tables via work areas derived from the database tables. A database table, having columns to store content, each column being associated with a column type, may be mapped to a work area such that, at a database server, each column in the database table is mapped to a corresponding component of the work area, the corresponding component having a default component type based on the column type of the associated column in the database table. It may be determined that a particular column in the database table is to store large object data content, and, in response to the determination, a new mapping to a work area may be defined such that the particular column maps to a corresponding component having a component type other than the default component type.

Systems and method for mapping large object data content in a database table to a work area

A system, computer program product and method of processing function calls in a distributed application environment are provided. A number of function calls for communication from a sending application to a receiving application are queued in a database. Dependencies among at least a portion of the function calls that are being queued are determined while the function calls are stored in the queues. A schedule of execution of the function calls is then generated based on the determined dependencies.

Queued asynchronous remote function call dependency management

A method and system for employing client interfaces for packages. In one embodiment, an access object associated with a service provided by a first package is located, where the service is seeking to access content residing at a second package. A client interface is then created at the second package using the access object. The client interface is used to provide access to the content by exposing the content to the service via the client interface.

Client interfaces for packages

An application system includes a first process configured to execute an application program, wherein the application program is operable to use a set of data structures. The application system also includes a second process configured to interpret a markup language document. A transformation template is configured to specify a symmetric mapping between the markup language document and the set of data structures. A transformation virtual machine runs in association with the first process and is operable to execute the transformation template. The transformation virtual machine is operable to perform a symmetric transformation between the markup language document and the set of data structures to allow the first process and the second process to exchange information.

Symmetric transformation processing system

A method and system for object generation in packages. In one embodiment, the process for generating an object in a package is initiated. The package is created and is associated with a target package. The object is generated into the package.

Object generation in packages

Methods and apparatus, including computer program products, for activating assertions and breakpoints. The techniques include establishing any number of checkpoints in a first computer program; and including each checkpoint in a checkpoint group, wherein each checkpoint group can include any number of the checkpoints regardless of where the checkpoints are in the first computer program. The checkpoints can include assertion statements and breakpoint statements. Activation variants enable checkpoint groups or compilation units or both to be managed jointly.

Activating assertions and breakpoints

A method and system for executing calls and return calls using client interfaces for packages. In one embodiment, a service at a service package is called using a client interface at a client package. The return call is then made on object using the client interface at the client package as performed by the service at the service package.

Calls and return calls using client interfaces

Methods and apparatus, including computer program products, for measuring the performance of aspects of a complex data processing system. In one aspect, a method uses a dynamic synthetic benchmark to provide performance information for a program application running on a virtual machine. The benchmark in one implementation uses a load profile that includes information about instructions that make up the application, their call frequencies, and their workloads. Microbenchmarks of individual virtual machine instructions provide performance information about the virtual machine that is used with the load profile to synthesize a performance benchmark for the application.

Measuring software system performance using benchmarks

A shared memory technology where shared objects can be used by any of multiple users, applications, or program sessions with programming language support during development and at runtime. The developer can declare shared memory behaviors at design time to cause one or more area classes to be generated for use at runtime. A shared objects memory is managed by the runtime environment. Content is stored at runtime in an area instance of an area class. Class methods to be generated that include methods for attaching and detaching a running session to and from an area instance, and for detaching a session from a change request on an area instance with a commit or a rollback. The runtime environment manages locks for area instances. There are programming language constructs for creating area instances and for creating data objects of arbitrary data type within area instances.

Programming with shared objects in a shared memory

Techniques for testing production code include providing a common source unit having production source code and test source code, the test source code having test methods for testing the production source code. Executable production code is produced based on the production source code and executable test code is produced based on the test source code. A global switch specifies whether to load the executable test code with the executable production code.

Language integrated unit testing

Methods and apparatus, including computer program products, for defining and using data types at runtime. A procedural source code program is compiled to generate a compiled program having instructions to create a runtime data type and to use the runtime data type. The runtime data type has a compound structure of referenced data types. Instructions to create a runtime data type having a compound structure are executed by creating a runtime data type definition from the compound structure of referenced data types by resolving the referenced data types bottom up into data types known at runtime. A data object having the runtime data type is created. Type checking is performed on uses of the data object at runtime according to the runtime data type.

Creating and checking runtime data types

An article of manufacture and a method includes providing a system having an interface, dividing the interface into levels, associating a dependency list with a level, associating a client with the dependency list, and marking the clients associated with a dependency list for recompilation based on a change to a global component.

Reducing recompilation frequency

Growing community of inventors

Heidelberg, Germany

Andreas Blumenthal