# Patent

## Title
Proactive performance management for multi-user enterprise software systems

## Abstract

The invention provides, in some aspects, systems for proactive management of development and performance of a software application based on monitoring it (and/or one or more of its components) during the course of development or execution. Those systems signal alerts upon determining that actual or expected usage of the application (or its components) by users of like classes (or roles) is anticipated to, or does, exceed quotas, when the application is placed in production mode.

## Background
BACKGROUND OF THE INVENTION
The invention pertains to digital data processing and more particularly, by way of example, to proactively managing development and performance of digital data processing applications. The invention can be applied, by way of example, to the design and implementation of enterprise software systems.
Enterprise software systems routinely fail to process transactions quickly enough to satisfy business needs, especially as the number of users and intensity of processing increases. It has traditionally been difficult to “spec out” requirements for new software projects that would avoid these scalability and performance issues, since application development itself introduces much variability. In addition, original assumptions about the scalability of a system frequently turn out to be invalid. This is exacerbated by changing user requirements.
The end result is often that an application completed by a developer has performance and scaling characteristics that differ significantly from the customer's needs. In order to remedy this, the “completed” application can be sent back for further development—which starts a vicious cycle. Alternatively, it may be necessary to buy significantly more computer hardware to run the application and, thereby, create a conflict with the original budget.
A related problem exists after the application has moved into production. Unanticipated resource consumption by some users or system processes may result in the entire system or application becoming non-responsive.
It is a common expectation that enterprise software vendors provide performance guidelines that ensure a certain number of users can be supported on a given capacity platform. This approach offers a false sense of security, since, in reality, there is a great amount of variability in the application development process that invalidates the vendor's assumptions.
To accommodate this, customers can test the performance of applications at the end of the development process by simulating a large number of users and measuring application response. A drawback here is that, by the time a performance problem is discovered, remediation may involve significant expense, e.g., buying new hardware, sending the application back to development, redefining the specification for the project, and so forth.
It is possible to test the performance of the application concurrently with the development process. However, this requires a dedicated set of human and computer resources. It is also difficult to test the developmental application, except at certain milestones when it is stable. If the performance results are unsatisfactory, or significantly different from original assumptions, any attempts to remediate are likely to interfere with the development process and to throw development off-track.
Another approach is to perform a detailed analysis of a system's or application's behavior with a single user and then project how the system will behave as the number of users increases; see, United States Patent Publication No. 2005/0216235, entitled “Scalability Test and Analysis”). This approach suffers from the same limitations as above, e.g., it requires a completed application to measure and project performance.
In view of the foregoing, an object of this invention is to provide improved methods and apparatus for digital data processing.
A related object of the invention is to provide such methods and apparatus as facilitate the design of applications, e.g., for the enterprise.
Yet another object of the invention is to provide such methods and apparatus as facilitate the design of right-sized and appropriately scalable applications.
SUMMARY OF THE INVENTION
The foregoing are among the objects attained by the invention which provides, in some aspects, systems for proactive management of performance of a software application based on monitoring it (and/or one or more of its components) during the course of development. Those systems include a performance monitor that signals alerts upon determining that usage of the application (or its components) by users of like classes (or roles) may exceed quotas, when the application is placed in production mode.
Further aspects of the invention provide such systems in which the performance monitor signals the aforementioned alerts to software application developers and/or a centralized monitoring environment. This can be done proactively, e.g., without requiring active querying by the developers. The performance monitor can, moreover, log the alerts.
Yet further aspects of the invention provide systems as described above that include a model defining a relationship between users and resources estimated to be consumed by them during use of the application in production mode. Those resources can include processing capacity, memory capacity and/or network bandwidth of one or more digital data processors on which the application will execute.
Yet still further aspects of the invention provide such systems in which the model defines quotas for usage of the application in production mode and/or one or more components thereof by users in each of one or more classes. Related aspects provide such systems in which the model defines such quotas on the basis of individual and multiple users in such classes.
Still yet further aspects of the invention provide such systems in which the quotas include expected and/or maximum permitted usage of the application in production mode by users in each of one or more classes.
In other aspects, the invention provides systems paralleling those described above for monitoring applications executing in a production environment. Those systems signal alerts upon determining that usage of the application (or its components) by users of like classes (or roles) exceed quotas defined for those classes. Related aspects of the invention provide such systems as limit usage of the application by users if quotas for their respective classes are exceeded.
Further related aspects of the invention provide such systems that signal alerts upon determining that usage of the application (or its components) by users of like classes (or roles) are approaching quotas defined for those classes. Such systems can make those determinations by comparing actual usage of the application by users in each of one or more classes with expected usage for those respective classes.
Still yet further aspects of the invention provide such systems that include sending the alerts generated during application production mode (i.e., run-time mode) to developers and/or a centralized monitoring environment. Further related aspects of the invention include systems which log the alerts generated during application production mode.
In other aspects, the invention provides such systems that utilize performance histories in defining the aforementioned model and/or its constituent quotas.
Other aspects of the invention provide systems as described above that utilize like models during monitoring the application (and/or one or more of its components) during both development and production mode. Related aspects of the invention provide such systems that utilize differing models during those respective modes.
Still yet other aspects of the invention provide systems as described above in which the aforesaid model and/or monitoring of the application are also effected by a rules base executed on such an engine.
In yet still other aspects, the invention provides methods for proactive management of performance of software applications paralleling the operations of the systems described above. Such methods can include responding to signaling, e.g., during application development, that usage of the application (or its components) by users of like classes may exceed quotas by altering (i) implementation of the application, (ii) allocation of time for such implementation, (iii) quotas defined for the respective classes, (iv) allocation of resources to the application, and/or (v) definition of the relationships defined in the model. In related aspects of the invention, personnel responsible for development, management and/or procurement of the application can respond to such signaling by communicating with one another in regard to potential implementation of one or more such alterations. Further related aspects of the invention include modifying the model to reflect such alterations.
These and other aspects of the invention are evident in the drawings and in the description that follows.



BRIEF DESCRIPTION OF THE ILLUSTRATED EMBODIMENT
A more complete understanding of the invention may be attained by reference to the drawings, in which:
FIG. 1 depicts a digital data processing system and environment according to one practice of the invention;
FIG. 2 depicts a flow diagram illustrating a development mode operation of a digital data processing system according to one practice of the invention; and
FIG. 3 depicts a flow diagram illustrating a production mode operation of a digital data processing system according to one practice of the invention.



DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
Architecture
FIG. 1 depicts a system 10 and environment for proactively managing performance of a software application 34, particularly, for example, a multi-user enterprise application, according to one practice of the invention. In the illustrated embodiment, system 10 executes on exemplary digital data processor 12, which may be a personal computer, workstation, mainframe, or other digital data processing apparatus of the type known in the art capable of executing applications, programs and/or processes.
Illustrated digital data processor 12 executes in a network environment of the type typical in a business enterprise, e.g., one including further digital data processors 20-30—which themselves may comprise personal computers, workstations, mainframes, or other digital data processing apparatus. In other embodiments, digital data processor 12 may operate alone or in other environments, networked or otherwise. In any event, illustrated digital data processors 20-30 are coupled to digital data processor 12 via a network 32, such as the Internet, a local-area network (LAN), wide-area network (WAN), or otherwise, that may be public, private, IP-based, etc.
In a typical embodiment, illustrated here, data processors 20-24 are used in development mode, e.g., by software engineers, test engineers, systems administrators, etc. (collectively, “developers”) to develop, test and maintain/or software application 34. Likewise, data processors 26-30 are employed by users to execute instantiations of the application 34. In the discussion that follows, digital data processor 12 assumes both roles for sake of simplicity of discussion—i.e., it is treated as if used by developers to develop, test and maintain the application, as well as by users to execute the application. Moreover, it is also assumed for sake of simplicity of discussion that application 34 executes on a single digital data processor; however, in practice, the application 34 may execute on or over multiple digital data processors (e.g., in client-server mode, peer-to-peer mode, etc.).
Illustrated digital data processor 12 includes rules base 40 constructed and accessed in the conventional manner known in the art of rules bases. The digitally encoded rules 41 that it contains are likewise formatted and stored in the conventional manner known in the art. An example of the structure, operation and use of the rules base 40 and rules 41 is provided in commonly assigned U.S. Pat. No. 5,826,250, entitled “Rules Bases and Methods of Access Thereof” and U.S. patent application Ser. No. 11/368,360, filed Mar. 3, 2006, entitled “Rules Base Systems and Methods with Circumstance Translation,” the teachings of both of which are incorporated herein by reference.
Illustrated digital data processor 12 also includes rules engine 42 of the type conventionally known in the art for use in processing rules, e.g., retrieved from a rules base 40, in order to respond to (or otherwise handle) events signaled to and/or detected by the engine 42.
Illustrated digital data processor 12 further includes a software development environment (SDE) 51 that facilitates development of rules-based (or other) applications, e.g., application 34. This may include a text editor, an interpreter/compiler, libraries, or otherwise—all of the type known in the art—as adapted in accord with the teachings hereof. The SDE 51 may, itself, be comprised of rules 52 that execute on engine 42, or otherwise.
With continued reference to FIG. 1, system 10 includes a resource model (or simply “model”) 44 and a performance monitor 36. Resource model 44, which in the illustrated embodiment executes on rules engine 42, comprises a set of rules 45 which, by way of non-limiting example, defines and models relationships between users (given their respective roles, as described herein) and resources estimated to be consumed by them (as well, optionally, as those actually consumed by them) during use of the application 34 in production mode.
Though, in the illustrated embodiment, model 44 comprises rules 45 that are executed on engine 42, in other embodiments the model 44 may be defined and/or executed otherwise. In instances, such as the illustrated embodiment, where the model 44 is defined by rules 45, those rules can provide functionality attributed to the model below (and elsewhere herein), though, in other embodiments, that functionality can be incorporated in other elements of the system (e.g., the performance monitor 36). Consistent with the remarks above, though model 44 is shown as executing on digital data processor 12, it will be appreciated that, like application 34, it may execute on or over multiple digital data processors.
Performance monitor 36, also executing on rules engine 42, comprises a set of rules 55, which are in communications coupling with the application 34 (e.g., via RPC or otherwise) and which monitor the application in order to, inter alia, (i) signal alerts if predicted (or actual) usage of the application or its components by users of like classes may (or does) exceed quotas, and/or (ii) limit usage of the application or its components by users if quotas for their respective classes are approached, met or exceeded. In the illustrated embodiment, such monitoring is performed in real-time and persistently, so as to afford developers, users and others (e.g., system administrators) proactive and immediate feedback regarding expected or actual, application performance. In other embodiments, such proactive and up-to-date feedback is achieved by monitoring the application after-the-fact, e.g., following each compilation, build and/or run of the application 34, at the end of each work day, et cetera.
As used herein, the phrase “monitoring the application” refers to monitoring not only the application 24 in development and/or production modes, but also monitoring resources (e.g., processor capacity, network bandwidth, disk storage, etc.) impacted by the application. In this manner, the performance monitor 36 helps insure that performance of the application will meet or exceed expectations/specifications.
As above, in the illustrated embodiment, performance monitor 36 is defined by rules 55 that are executed on engine 42, though, in other embodiments the monitor 36 may be defined and/or executed otherwise. Moreover, though performance monitor 36 is shown as executing on digital data processor 12, it will be appreciated that, like application 34, it may execute on or over multiple digital data processors.
Illustrated application 34, also executing on the rules engine 42, comprises a set of rules 53 defining one or more software applications written, tested and revised by developers and executed by users. By way of non-limiting example, such a software application 34 can be a multi-user enterprise software system (e.g., business process management application), and the like. Moreover, the application 34 can comprise one or more components, modules, systems, and so forth (collectively, “components”), as is common in the art. Though, in the illustrated embodiment, application 34 is defined by rules 53 that are executed on engine 42, in other embodiments the application 34 may be defined and/or executed otherwise.
As used herein, activity by developers with respect to an application (e.g., in writing, testing and revising the application) is referred to as “development mode.” Activity by users (e.g., in running the application) is referred to as “production mode.” Although, in the typical application, development mode precedes production mode in the application life cycle, the term development mode can include subsequent activity—as where developers revise an application to fix “bugs,” add new functionality, etc.
Resource Model
As noted, resource model 44 models a relationship between users (given their respective roles) and their estimated (and, optionally, actual) consumption of resources in connection with application 34. It is used with the performance monitor 36 to gauge expected or actual resource consumption during development and production modes of the application 34—and, specifically, to insure that consumption falls within defined quotas—and, thereby to insure adequate performance.
To this end, illustrated model 44 defines user roles or classes for anticipated (or actual) application users. These can include, for example, general classes, like “power user” and “limited user,” and/or specific classes, like “sales executive,” “phone operator,” and so forth. The model can, further, assign actual or expected users to specific ones of these classes. The model 44 may be supplemented or supplanted in each of these functions by other elements of the system 10, digital data processor 12, or otherwise. Thus, for example, the model can define user roles/classes and assign specific users to those classes based on look-up tables contained elsewhere on the digital data processor (e.g., operating system user tables).
Illustrated model 44 further defines, on the basis of user roles, consumption quotas 46, 47 for use of resources by application 34. Those resources can include, by way of example, processor, memory, input/output, communications, network or other resources of the digital data processor 12 and/or network (or other) environment on which the application 34 operates. In the illustrated embodiment, the quotas 46, 47 can include both maximum and expected figures. More particularly, for example, the quotas 46, 47 can include, for each of at least selected resources, (1) maximum system resource consumption 46 for a user (or users) in a given role/class, and/or (2) expected system resource consumption 47 for a user (or users) in a given role/class.
As an example, maximum resource consumption quotas 46 can indicate that (i) an individual user of the limited class is permitted to consume no more than 0.2 percent of the processor capacity, peak, and (ii) 200 kbytes/sec on the network, peak, during use of the application. Alternatively, or in addition, maximum quotas 46 can indicate that (i) all simultaneous users of the limited class are permitted to consume no more than 15 percent of processor capacity, peak, and (ii) 3 Mbytes/sec on the network, peak, during use of the application.
Similarly, by way of example, expected resource consumption quotas 47 can indicate that (i) an individual user of the limited class is permitted to consume no more than 0.1 percent of processor capacity, on average, and (ii) 10 kbytes/sec on the network, on average, during use of the application. Alternatively, or in addition, quotas 46 can indicate that (i) all simultaneous users of the limited class are permitted to consume 5 percent of processor capacity, on average, and (ii) 1 Mbytes/sec on the network, on average, during use of the application.
Typically, the expected system resource consumption quota 47 is lower than quota 46, and is utilized to alert developers, system administrators, etc., that an execution or interaction by a given user or developer is approaching the respective user role's maximum allowed resource consumption quota 47. This two-tier quota system is used in the illustrated embodiment, for example, to give developers advanced warning of possible performance deterioration, thereby giving them ample opportunity to address the problem (e.g., changing the implementation). Though only two quotas per resource—maximum 46 and expected 47—are discussed here, in alternative embodiments, a lesser or greater number of quotas may be employed.
The model further defines quotas 48, 49 for the numbers of users of each class that are simultaneously permitted to use the application itself and/or its components (collectively, “application,” unless indicated otherwise). As above, two quotas are provided in the illustrated embodiment: a maximum number 48 of users per respective class, and an expected number 49 of users per expected class. Those skilled in the art will appreciate the such quotas may be alternatively defined, e.g., the model might define that application 34 can be used by 500 simultaneous users, 20 of who can be power users. As above, though only two quotas per class—maximum 48 and expected 49—are discussed here, in alternative embodiments, a lesser or greater number of quotas may be employed
Still further, the model 44 models (e.g., predicts) how use of the application 34 and its components by users, e.g., of given classes, relates to resource consumption. In this regard, a simple model 44 might define the following “user consumption relationships”:

    
    
        each user (regardless of class) executing the application consumes 0.1 percent of the processor capacity and transmits 10 kbytes/sec on the network
        execution of subsystem X of the application by a user of the “limited” class additionally consumes 0.3 percent of the processor capacity and transmits 30 kbytes/sec on the network
        execution of subsystem X of the application by user of the “power” class additionally consumes 0.5 percent of the processor capacity and transmits 40 kbytes/sec on the network
        execution of subsystem Y of the application by a user of the “limited” class additionally consumes 0.35 percent of the processor capacity and transmits 100 kbytes/sec on the network
        execution of subsystem Y of the application by user of the “power” class additionally consumes 0.6 percent of the processor capacity and transmits 150 kbytes/sec on the network.
    
    


In view of the foregoing, it will be appreciated that the model can predict—given specifics of the application 34 (e.g., number of remote calls made, disk usage, memory requirements, etc.)—whether the resource consumption quotas (and, therefore, expected performance) will be exceeded when the application is executed by, individual, expected and/or maximum numbers of users in each class. During development mode of the application 34, the performance monitor 46 can make use of this to gather application specifics, apply them to the model 44 and report quota violations to the developer, e.g., by the alert mechanism discussed below.
During production mode, the predicative capabilities of the model 44 need not be used (though, they may be, in some embodiments). Rather, in that mode, the performance monitor 46 can gather actual statistics about resource consumption and compare them against quotas maintained in the model, again, reporting, violations to the developer, system administrator, etc.—or, limiting execution of the application to specific numbers/types of users.
In the illustrated embodiment, the quotas 46-49 form part of the rules base 45 defined by the developer, his/her project manager and/or other persons involved in defining the requirements for application 34 (collectively, the “project manager”). To facilitate this, particularly, in regard to development work on new versions and/or modifications of application 34, the model 44 can utilize and/or incorporate performance histories that are, for example, gathered by the performance monitor 36 during production mode (e.g., in connection with the alerts discussed below) and/or collected from logs on the digital data processor 12, networking system, or otherwise. This can be achieved, for example, by execution of rules in the rules base 45 that periodically, on demand, or otherwise, identify those logs and extract relevant records for storage, e.g., in the model, and display or permit query by the project manager when new quotas are being defined. In preferred embodiments, the model utilizes the historical performance information to update the rules 45 that reflect “user consumption relationships.”
Operation
FIG. 2 is a flow diagram depicting the operation of system 10 in development mode. In step 200, developers create, test and/or revise software application 34 in the conventional manner, e.g., using SDE 51. In the illustrated embodiment, rules engine 42 executes rules 53 defining the application 34, and developers modify those rules 53 (or add new rules) within the SDE 51 (e.g., via a text editor or other component of the SDE 51) in order, for example, to alter the functionality and/or performance characteristics of application 34.
In step 210, the performance monitor 36 monitors the SDE 51, e.g., in real-time (for example, while the developer enters lines of code, issue commands for validation and/or compilation of modules, and/or save modules to disk or a software repository) or responds to direct invocation by the developers, to test the application-in-development against the model 44 to ensure that performance will meet or exceed expectations/specifications when it is deployed (i.e., enters production mode).
To this end, the performance monitor 36 obtains from the SDE 51 specifics of the application 34 (e.g., as noted above, number of remote calls made, disk usage, memory requirements, etc.) and applies them to the model by way of function calls or otherwise. The model 44 and, more particularly, the rules 45 that represent it, execute on the rules engine 30 and determine whether the resource consumption quotas will be exceeded (and, therefore, expected performance not achieved), given the specifics provided.
As reflected in steps 220-280, the model 44 can report quota violations to the SDE 51 which, in turn, can alert the developer. In other embodiments, the model 44 generates results directly to the developer. Regardless, the reported quota violations can include identification of quota violated, measure of expected violations, etc., and, thereby, facilitate correction of the application by the developer and/or modification of quotas by the project manager, as reflected in steps 270, 280.
Alternatively, or additionally, the developer and/or product manager can respond to such alerts by (i) allocating additional time for implementation of the application (or fixes thereto), (ii) allocating additional resources to the application, and/or (iii) refining the “user consumption relationships” defined by the model. Additionally, such alerts can motivate personnel responsible for development, management and/or procurement of the application to communicate in regard to potential implementation and/or alteration of the application, the model, or otherwise.
As illustrated in steps 220, 240, when the model detects violation of a maximum resource quota 46, the performance monitor 36 signals the developer with a high-priority alert or warning (e.g., a “red light” warning). This can take the form of, for example, a pop-up window on a developer's screen/terminal 20-24, an email to a developer, and so forth. Alternatively, as illustrated in steps 230, 250, when the model detects violation of an expected resource quota 47, the performance monitor 36 signals the developer with a low-priority alert or warning (e.g., a “yellow light” warning). Again, this can take the form of, for example, a pop-up window on a developer's screen/terminal 20-24, an email to a developer, and so forth. In the illustrated embodiment, alert categories (e.g., high-priority, low-priority, etc.) are associated with the alerts to reflect the importance of the anticipated quota violation; in other embodiments additional and/or other categories may be used. Likewise, alerts may be signaled by other and/or additional mechanisms to those mentioned above.
In preferred embodiments, alerts are sent to are signals not only to developers but also to a log and/or a centralized monitoring environment, e.g., a database maintained by project manager(s) or other personnel responsible for development of application 34. This facilitates identifying and categorizing alerts, e.g., to improve overall developer and application performance.
Operation of system 10 in production mode (i.e., run-time execution of application 34) parallels that of operation during development mode. Generally, the rules engine 42, resource model 44, and performance monitor 36 operate in the manner described above, e.g., in connection with FIG. 2. In production mode, however, application 34 has “gone live,” and the predictive capabilities of the model 44 need not be used. Rather, the performance monitor 36 monitors actual use of the application 34 and resource consumed by it. Thus, the “specifics” applied to the model 44 by the monitor 36 in production mode are actual statistics about resource consumption by actual users.
FIG. 3 is a flow diagram illustrating operation of system 10 during production mode. Steps 300-350 parallel steps 200-250 in FIG. 2. For example, in step 340 and 350, the monitor 36 sends “red light” and/or “yellow light” alert(s) 38 to developers, project managers, systems administrators, or other personnel (and, where appropriate, to end-users) depending on whether actual usage violates a maximum quota 46, 48 or an expected quota 47, 49. Note, that the violations in production mode can (unlike development mode) include violations of the expected and maximum user quotas 48, 49. As above, the alerts 38 can also be logged to the centralized monitoring environment. Also as noted, the resource model 44 (or performance monitor 36, etc.) may utilize performance histories to facilitate entry of quotas and definition of rules defining “user consumption relationships.” To this end, the alerts can be logged for access by the model 44 and/or they can effect logging of detailed performance statistics which may also be accessed by the model.
In production mode, unlike development mode, the monitor 36 can limit usage of the application 34 by one or more users upon determining that usage (individual or collective) violates one or more quotas (typically, maximum consumption quotas 46). This can be effected, e.g., when a red light warning condition has been signaled, by preventing additional users from executing the application and/or by terminating the processes of one or more offending users. See step 360.
Described herein are methods and systems meeting the objects set forth above, among others. It will be appreciated that the illustrated embodiment and those otherwise discussed herein are merely examples of the invention and that other embodiments, incorporating changes thereto, fall within the scope of the invention.

## Claims

1. A system for proactive management of performance of a software application, comprising:
A. a first digital data processor executing a software development environment,
B. a second digital data processor executing a performance monitor in communications coupling with the software development environment, wherein the first digital data processor and the second digital data processor may overlap, the performance monitor obtains a specific of an application-in-development the software development environment, and
C. the performance monitor applying the specific of the application-in-development to a model that defines one or more quotas for a user, wherein the one or more quotas are defined in accordance with a class to which the user belongs, and
D. the performance monitor signaling an alert upon determining that, based on the results obtained in step (C), execution of the application-in-development and/or a component thereof by the user and/or consumption of digital data processing resources during such execution is anticipated to exceed the one or more quotas for the user as defined by the model, wherein steps (A), (B), (C) and (D) are performed in real-time in order to provide proactive and immediate feedback regarding expected application performance.

2. The system of claim 1, wherein the performance monitor signals the alert to a developer and/or a centralized monitoring environment.

3. The system of claim 1, wherein the performance monitor estimates consumption of the one or more resources based on prior monitoring of actual consumption during execution of the application.

4. The system of claim 1, in which the model defines a relationship between (i) users in each of one or more classes and (ii) estimated consumption of resources by such users during execution of the application.

5. The system of claim 4, wherein those resources include any of processing capacity, memory capacity and/or network bandwidth.

6. The system of claim 4, in which the model defines quotas for usage of the application and/or one or more components thereof in production mode by users in each of one or more classes.

7. The system of claim 4, in which the model defines quotas for consumption of resources during usage of the application and/or one or more components thereof in production mode by users in each of one or more classes.

8. The system of claim 4, wherein the model defines such quotas on the basis of individual and multiple users in such classes.

9. The system of claim 4, wherein the quotas include any of (i) maximum permitted usage of the application by users in each of one or more classes, and (ii) expected usage of the application by users in each of one or more classes.

10. A method for proactive management of performance of a software application, comprising:
A. obtaining, by a digital data processor, a specific of an application-in-development in a software development environment,
B. applying the specific of the application-in-development to a model that defines one or more quotas for a user, wherein the one or more quotas are defined in accordance with a class to which the user belongs,
C. signaling an alert upon determining that, based on the results obtained in step (B), execution of the application-in-development and/or a component thereof by a user and/or consumption of digital data processing resources during such execution is anticipated to exceed the one or more quotas for the user as defined by the model, wherein steps (A), (B), and (C) are performed in real-time in order to provide proactive and immediate feedback regarding expected application performance.

11. The method of claim 10, comprising signaling the alert to a developer and/or a centralized monitoring environment.

12. The method of claim 10, comprising consumption of the one or more resources based on prior monitoring of actual consumption during execution of the application.

13. The method of claim 10, wherein the model defines a relationship between (i) users in each of one or more classes and (ii) estimated consumption of resources by such users during execution of the application.

14. The method of claim 13, wherein those resources include any of processing capacity, memory capacity and/or network bandwidth of the one or more digital data processing resources.

15. The method of claim 13, in which the model defines quotas for execution of the application and/or one or more components thereof by users in each of one or more classes.

16. The method of claim 15, in which the model defines quotas for consumption of resources during execution of the application and/or one or more components thereof by users in each of one or more classes.

17. The method of claim 13, in which the model defines such quotas on the basis of individual and multiple users in such classes.

18. The method of claim 13, wherein the quotas include any of (i) maximum permitted usage of the application by users in each of one or more classes, and (ii) expected usage of the application by users in each of one or more classes.

19. The method of claim 10 comprising responding to signaling in step (C) by one or more of altering (i) implementation of the application, (ii) allocation of time for such implementation, (iii) quotas defined for the respective classes, (iv) allocation of resources to the application, and/or (v) definition of the relationships defined in the model.

20. The method of claim 19, wherein the responding step includes at least initiating communications among personnel responsible for any of development, management and/or procurement of the application in regard to potential implementation of one or more such alterations.