Blockchains have been applied in different domains to guarantee data integrity and provide a decentralized computational infrastructure for executing smart contracts. Multiple blockchain-related patterns have been summarized by academics and industry practitioners covering different aspects, such as engineering applications on top of a blockchain, structuring smart contracts, and security. The existence of these patterns is both helpful and challenging for designers. Helpful, as the existence of these patterns means that developers do not need to recreate solutions to common problems. Challenging, as the multitude of patterns leaves a designer confused about when to adopt or adapt patterns. In this paper, we propose a decision model that assists developers and architects in selecting appropriate patterns for blockchain-based applications. The selection is based on the characteristics of the use cases and trade-offs implicit in the patterns. We evaluated the proposed decision model based on expert opinion regarding its correctness and usefulness in guiding the architecture design and understanding the rationale of various design decisions.

Human-induced faults play a large role in systems reliability. In cloud platforms, system administrators may inadvertently make catastrophic mistakes, like deleting a virtual disk with important data. Providing rollback for cloud operations can reduce the severity and impact of such mistakes, by allowing to revert to a known, good state. However, in the context of cloud management this is non-trivial, since cloud consumers only have limited visibility and indirect control. In this paper, we present a scalable approach to rollback operations that change the state of a system on proprietary cloud platforms. In our previous work, we provided a system that augments cloud APIs and provides rollback operation using an AI planner. In this paper, we build upon our previous work, but parallelize the rollback plan generation based on characteristics unique to rollback scenario. Furthermore, we introduce a distributed anytime algorithm that gradually improves plan quality overtime, until either an optimal plan is found or a timeout is reached. Through experimental evaluation we show that our approach scales better than a naive approach, and effectively avoids the exponential behavior of AI planning. Further, we explore the trade-offs between the quality of rollback plans and plan generation time.

Blockchain is an emerging technology for decentralised and transactional data sharing across a large network of untrusted participants. It enables new forms of distributed software architectures, where agreement on shared states can be established without trusting a central integration point. A major difficulty for architects designing applications based on blockchain is that the technology has many configurations and variants. Since blockchains are at an early stage, there is little product data or reliable technology evaluation available to compare different blockchains. In this paper, we propose how to classify and compare blockchains and blockchain-based systems to assist with the design and assessment of their impact on software architectures. Our taxonomy captures major architectural characteristics of blockchains and the impact of their principal design decisions. This taxonomy is intended to help with important architectural considerations about the performance and quality attributes of blockchain-based systems.

Sporadic operations such as rolling upgrade or machine instance redeployment are prone to unpredictable failures in the public cloud largely because of the inherent high variability nature of public cloud. Previous dependability research has established several recovery methods for cloud failures. In this paper, we first propose eight recovery patterns for sporadic operations on public cloud. We then present the filtering process which filters applicable recovery patterns. We propose an automation mechanism to automatically generate recovery actions for those applicable recovery patterns based on our resource state transition algorithm. We also propose a methodology to evaluate the recovery actions generated for the applicable recovery patterns based on the recovery evaluation metrics of Recovery Time, Recovery Cost, and Recovery Impact. This quantitative evaluation will lead to selection of the acceptable recovery actions. We propose two recovery actions selection mechanisms: one is based on user constraints of the recovery evaluation metrics, and the other one is based on Pareto set searching algorithm. We implement a recovery service and illustrate its applicability by recovering from errors occurring in the rolling upgrade operation on AWS cloud.

Cloud-based systems get changed more frequently than traditional systems. These frequent changes involve sporadic operations such as installation and upgrade. Sporadic operations may fail due to the uncertainty of cloud platforms. Each sporadic operation manipulates a number of cloud resources. The accessibility of resources manipulated makes it possible to build an accurate process model of the correct behavior for an operation and its desired effects. This paper proposes a non-intrusive recovery approach for sporadic operations on cloud, called POD-Recovery. POD-Recovery utilizes the above-mentioned process model of the operation. When needed, it triggers recovery actions based on the model through non-intrusive means, i.e., without modifying the code which implements the sporadic operation. POD-Recovery employs an efficient artificial intelligence (AI) planning technique for generating recovery plans. We implement POD-Recovery and evaluate it by recovering from faults injected into 920 runs of five representative sporadic operations.

Rolling upgrade consists of upgrading progressively the servers of a distributed system to reduce service downtime.Upgrading a subset of servers requires a well-engineered cluster membership protocol to maintain, in the meantime, the availability of the system state. Existing cluster membership reconfigurations, like CoreOS etcd, rely on a primary not only for reconfiguration but also for storing information. At any moment, there can be at most one primary, whose replacement induces disruption. We propose Rollup, a non-disruptive rolling upgrade protocol with a fast consensus-based reconfiguration. Rollup relies on a candidate leader only for the reconfiguration and scalable biquorums for service requests. While Rollup implements a non-disruptive cluster membership protocol, it does not offer a full-fledged coordination service. We analyzed Rollup theoretically and experimentally on an isolated network of 26 physical machines and an Amazon EC2 cluster of 59 virtual machines. Our results show an 8-fold speedup compared to a rolling upgrade based on a primary for reconfiguration.

Users expect cloud applications to be highly available with minimum service disruption. Some of the cloud applications also have Quality of Service (QoS) requirements. The High Availability (HA) module needs to consider QoS requirements while placing or failing over the application, application's components and its replicas. In this paper we propose a new QoS module in the SDN controller. This module creates QoS queues with certain minimum bandwidth on Open Flow based switches on the route between components requiring certain minimum network bandwidth. Our approach is similar to 'Aggregation of RSVP for IPv4 and IPv6 Reservations' (RFC 3175). DiffServ based approaches reserve bandwidth for an entire class of flows and do not cater for requirements from individual applications. Our approach reserves bandwidth on a per-flow basis while overcoming the well-known scalability problem of IntServ. Also, the QoS queues are dynamically configured based on the current requirements of the applications. The QoS module is also responsible for ensuring QoS when topology and route changes. The HA module will interact with SDN controller (which includes our QoS module) to ensure QoS requirements of cloud applications. We also tried an intermediate approach where the QoS flows are directed to a DiffServ queue with a fixed rate (mentioned in RFC 3175) and the reservation of the queue is reconfigured only when the total reservation for the QoS flows exceed the initial reservation. We demonstrate the feasibility and performance aspect of our approach from experiments using Mininet.

Understanding the behavior of an operations process and capturing it as an abstract process model has been shown to improve dependability significantly [1]. In particular, process context can be used for error detection, diagnosis, and even automated recovery. Creating the process model is an essential step in determining process context and, consequently, improving dependability. This paper describes two systems. The first, POD-Discovery, simplifies the creation of such an abstract process model from operations logs. An activity that previously required many manual steps can now be done largely automatically and in minutes. Using the discovered model, the second system, POD-Viz, provides operators with the ability to visualize the current state of an operations process in near-real-time and to replay a set of events to understand how the process context changed over time. This allows operators to trace the progress of an operations process easily, and helps in analyzing encountered errors.

Recovering from failures of sporadic operations such as rolling upgrade or migration is complicated by the fact that the application being upgraded or migrated must continue to provide service. This means that recovery strategies for sporadic operations must include facilities for recovering from normal operations as well. As a step in deriving methods for recovering from failures in sporadic operations, we classify existing methods into four categories according to their purposes and the life cycle phase for which they are applicable. Not only does this taxonomy facilitate the research on recoverability of cloud sporadic operations but also it can help better understand the existing cloud recovery strategies.

When cloud consumers perform rolling upgrade operations on cloud applications, they may encounter failures due to cloud uncertainty, interfering operations and incorrect configurations. For example, unreliable cloud API calls can make the rolling upgrade operation fail in unpredictable ways due to a long time delay to respond to the API call. This paper proposes two recovery strategies for recovering from rolling upgrade failures. The strategies are Compensated Undo & Redo and Reparation. We evaluated our recovery strategies on Asgard-based rolling upgrade operation on Amazon Cloud based on two evaluation metrics: MTTR and Service Performance. The experiment results show that our strategies perform better than the recovery mechanisms provided by Asgard itself. We also conduct a comparison between the two recovery strategies based on the metrics.

Applications in the cloud are subject to sporadic changes due to operational activities such as upgrade, redeployment, and on-demand scaling. These operations are also subject to interferences from other simultaneous operations. Increasing the dependability of these sporadic operations is non-trivial, particularly since traditional anomaly-detection-based diagnosis techniques are less effective during sporadic operation periods. A wide range of legitimate changes confound anomaly diagnosis and make baseline establishment for "normal" operation difficult. The increasing frequency of these sporadic operations (e.g. due to continuous deployment) is exacerbating the problem. Diagnosing failures during sporadic operations relies heavily on logs, while log analysis challenges stemming from noisy, inconsistent and voluminous logs from multiple sources remain largely unsolved. In this paper, we propose Process Oriented Dependability (POD)-Diagnosis, an approach that explicitly models these sporadic operations as processes. These models allow us to (i) determine orderly execution of the process, and (ii) use the process context to filter logs, trigger assertion evaluations, visit fault trees and perform on-demand assertion evaluation for online error diagnosis and root cause analysis. We evaluated the approach on rolling upgrade operations in Amazon Web Services (A WS) while performing other simultaneous operations. During our evaluation, we correctly detected all of the 160 injected faults, as well as 46 interferences caused by concurrent operations. We did this with 91.95% precision. Of the correctly detected faults, the accuracy rate of error diagnosis is 96.55%.

Consumer-initiated sporadic operations on cloud applications, such as deployment, upgrade and reconfiguration, may fail because of the inherent uncertainty of operating in a cloud environment. For example, if a VM is not able to start, operations dependent on that VM will fail. In this paper we propose an approach for analyzing sporadic operations on cloud applications to facilitate recovery. We do this by first creating a process model of the sporadic cloud operation. The Process may not be suitable for recovery operations or the application's deployment architecture since an individual step may be at the wrong level of granularity or a failure may unnecessarily affect multiple steps. We then propose a set of process division criteria for revising an operation process to support recovery. This set of criteria contains four aspects: 1) Atomicity to support the imposition of transactions on portions of the process, 2) Idempotence to allow for re-execution of a failed portion, 3) Granularity to allow reuse of existing steps, 4) Recovery Actions Identifiable to allow proper recovery actions to be taken to recover from the errors occurring during the operation. We demonstrate the feasibility of imposing these criteria by using the rolling upgrade operation in Asgard - a popular cloud management tool for AWS EC2.

Deployment choices are critical in determining the availability of applications running in a cloud. But choosing good deployment for various software application components into virtual machines is a challenging task because of potential sharing of components among applications and potential interference from multi-tenancy. This paper presents an approach for improving the availability guarantee of software applications by optimizing the availability, performance and monetary cost trade-offs of different deployment choices. Our approach explicitly considers different classes of application requests during the decision process. The results of our experimental evaluation show that the approach can effectively improve the availability guarantees with little or negligible increase in the performance and monetary cost of the deployment choice.

Cloud consumers have a variety of deployment related techniques, such as auto-scaling policies and recovery strategies, for dealing with the uncertainties in the cloud. Uncertainties can be characterized as stochastic (such as failures, disasters, and workload spikes) and subjective (such as choice among various deployment options). Cloud consumers must consider both stochastic and subjective uncertainties. Analytic support for consumers in selecting appropriate techniques and setting the required parameters in the face of different types of uncertainty is currently limited. In this paper, we propose a set of application availability analysis models that capture subjective uncertainties in addition to stochastic uncertainties. We built and validated the models by using industry best practices on deployment, and actual commercial products for disaster recovery and live migration. Our results show that the models permit more informed and quantitative availability analysis than industry best practices under a wide range of scenarios.

A large number of cloud application failures happen during sporadic operations on cloud applications, such as upgrade, deployment reconfiguration, migration and scaling-out/in. Most of them are caused by operator and process errors [1]. From a cloud consumer's perspective, recovery from these failures relies on the limited control and visibility provided by the cloud providers. In addition, a large-scale system often has multiple operation processes happening simultaneously, which exacerbates the problem during error diagnosis and recovery. Existing built-in or infrastructure-based recovery mechanisms often assume random component failures and use checkpoint-based rollback, compensation actions [2], redundancy and rejuvenation to handle recovery [3]. These recovery mechanisms do not consider the characteristics of a specific operation process that consists of a set of steps carried out by scripts and humans interacting with fragile cloud infrastructure APIs and uncertain resources [4]. Other approaches such as FATE/DESTINI [5] look at the process implied by a system's internal protocols and rely on the built-in recovery protocol to detect and recover from bugs. The problem we target is at a different level related to the external sporadic activities operating on a hosted cloud application.

Application dependability issues depend on increasingly sophisticated activities during operation time for deployment, upgrade, scaling out/in and reactions to various failures. Traditional approaches to improving application dependability focus on artifact-oriented troubleshooting and improvements. In this paper, we present an approach using process models to represent and analyze operations with considerations of exception handlings and fault-proneness. Our goal is to reduce diagnosis and repair time for application failures that occur during operation activities such as deployment and upgrade.

Size and effort estimation is a significant challenge for the management of large-scale formal verification projects. We report on an initial study of relationships between the sizes of artefacts from the development of seL4, a formally-verified embedded systems microkernel. For each API function we first determined its COSMIC Function Point (CFP) count (based on the seL4 user manual), then sliced the formal specifications and source code, and performed a normalised line count on these artefact slices. We found strong and significant relationships between the sizes of the artefact slices, but no significant relationships between them and the CFP counts. Our finding that CFP is poorly correlated with lines of code is based on just one system, but is largely consistent with prior literature. We find CFP is also poorly correlated with the size of formal specifications. Nonetheless, lines of formal specification correlate with lines of source code, and this may provide a basis for size prediction in future formal verification projects. In future work we will investigate proof sizing.

Operations costs are around 50% of the worldwide costs of Information Technology. Yet operations problems are mainly viewed as the problem of IT and not of the problem of product developers or performance engineers. I will discuss some areas where performance engineers could be of great assistance to operations and where an understanding of operations process could inform the models created by performance engineers.

This paper describes an analysis of some of the challenges facing one portion of the Electrical Smart Grid in the United States - residential Demand Response (DR) systems. The purposes of this paper are twofold: 1) to discover risks to residential DR systems and 2) to illustrate an architecture-based analysis approach to uncovering risks that span a collection of technical and social concerns. The results presented here are specific to residential DR but the approach is general and it could be applied to other systems within the Smart Grid and to other critical infrastructure domains. Our architecture-based analysis is different from most other approaches to analyzing complex systems in that it addresses multiple quality attributes simultaneously (e.g., performance, reliability, security, modifiability, usability, etc.) and it considers the architecture of a complex system from a socio-technical perspective where the actions of the people in the system are as important, from an analysis perspective, as the physical and computational elements of the system. This analysis can be done early in a system's lifetime, before substantial resources have been committed to its construction or procurement, and so it provides extremely cost-effective risk analysis.

This is the introduction of the 3rd workshop on Software Development Governance (SDG), which will take place as part of ICSE 2010. This year we have combined two successful workshops (SDG - software development governance and LMSA -- leadership and management in software architecture) since both workshops deal with decisions that are part of the development process e.g., business and organizational decisions that impact the technical decisions concerned with the product architecture and the product quality.

Requirements specifications seldom allow software and system architects to understand the business goals for a system. Architects need that information in order to design an appropriate architecture for the problem at hand. In this paper, we present a lightweight method based on goal oriented requirements engineering that begins with a canonical list of business goals and elicits specific business goals from the perspective of various stakeholders. It then interprets those business goals in terms of the quality attribute requirements that are so important to software architectures. Experience with using this method for a Boeing Air Transport System is presented.

Computer systems are constructed to satisfy some business or mission goals. This simple, and one would think obvious, statement has profound consequences in terms of how one approaches the problem of designing the computer system. Business and mission goals are rarely expressed in terms of the purpose of the system but instead they are expressed in terms of qualities the system should have-the system should be fielded quickly, it should be secure, it should perform fast, it should be modifiable, etc. This talk will take a tour that begins with business goals, goes through specification of quality attributes, discusses how quality attributes are achieved while designing, and briefly describes design and evaluation methods that are quality attribute focused. The question for CSEET attendees is: "Where in your curriculum is this material covered?" Where are students taught about business goals, where are they taught about the relation between business goals and quality attributes, where are they taught about the relation between quality attributes and design principles?

Summary form only given. Software architecture design is a matter of generate and test. That is, generate a candidate design (a hypothesis), test it to see whether it satisfies its requirements. If it does not, then generate a new hypothesis and repeat the process. Clearly, the hypothesis generation, whether for the initial hypothesis or the subsequent hypotheses is not random. If it were, then the process would never end. This session will discuss where the initial hypothesis comes from, how to test to determine the shortcomings of the current hypothesis and what techniques are available to generate a new hypothesis.

An organization is architecturally competent if it has the ability to acquire, use and sustain the skills and knowledge necessary to carry out architecture-related practices that lead to systems that serve the organization's business goals. This paper presents some principles of architecture competence, based on four models that aid in explaining, measuring, and improving the architecture competence of an individual or an organization with respect to these principles, The principles are based on a set of fundamental beliefs about software architecture.

Extensive instructional materials have been developed and used for courses in specific software architecture topics offered at the Software Engineering Institute (SEI) at Carnegie Mellon University, to support the instructional goals laid out by the creators of the SEI's professional education program and the designers of the individual courses. However, to date, these courses have lacked any assessment component, certification for the course being granted solely on attendance. For an assessment component to be meaningful, it must derive from and support these instructional goals, determine which goals must be assessed and how to assess them, and determine how best to assess whether those goals have been achieved through application of the instructional materials, lectures, and activities which are included in each two-day course. In order to ensure that the course assessments target the intended learning goals, we developed content for low-stakes assessment components grounded in education theory, combining current knowledge of educational psychology and the software engineering domain to create evaluations that will effectively determine whether participants in this course have learned what the curriculum developers and the instructors intend them to learn.

The Architecture Expert (ArchE) is a software architecture design assistant under development at the Software Engineering Institute (SEI). It embodies knowledge of quality attributes and the relation between the achievement of quality attribute requirements and architecture design. In this paper, we describe the use of ArchE in a graduate level software architecture class at Clemson University. The discussion combines aspects of using ArchE as a tool to produce architectures and using ArchE to teach about architecting. The students were positive about the use of ArchE although critical of ArchE's immaturity. The instructor was also positive about the use of ArchE.

The ability of an organization to successfully carry out its tasks depends on the appropriate combination of organizational structure, processes, and communication and coordination mechanisms. In this paper, we present four case studies that exemplify coordination breakdown problems in global software development. Our analysis showed those problems took place even in the presence of a collection of processes, organizational mechanisms and communication tools established to increases the ability of the teams to perform their tasks. Finally, we discuss possible solutions to overcome the identified problems.

It has been well documented that there is a correlation between the structure of an architecture and the organization that produces it. More concretely there is a correlation between task interdependencies and coordination among the people or teams realizing these tasks. The amount of coordination needed among teams is related to the nature of these task interdependencies. As the scale and complexity of organization and systems grow it is not uncommon to have factors such as geographic boundaries, organization boundaries, cultural differences, and so forth impede the ability of certain individuals or teams to coordinate effectively. While there is some understanding of the factors that impede the ability of teams to coordinate, the factors that cause task interdependence in software systems is less well understood. The current view is that it is the interactions across module boundaries (assuming a module is assigned as a task or work item to a single team) that cause task interdependence; we have found that this view is not sufficient. In this paper we present three cases where additional architectural mechanisms created task interdependencies that the organizations were unable to accommodate. We go on to discuss the implications of these findings and suggest future research activities.

Summary form only given. Software architecture has become a widely-accepted conceptual basis for the development of non-trivial software in all application areas and by organizations of all sizes. Effectively evaluating architecture is as important as crafting it in order to have assurance that it successfully addresses the target system qualities, which in turn, help fulfill the business goals of the system. We present the Architecture Tradeoff Analysis Method (ATAM), a practical and comprehensive approach for evaluating software architectures that is based on the principles of quality attributes and architectural tactics. We have gained experience with the approach by analyzing the architecture of several systems, and the ATAM is now a standard practice in many large companies.

The output of 18 software architecture evaluations are analyzed to find patterns in the risk themes identified in the evaluations. The major results are: i) A categorization of risk themes ii) The observation that twice as many risk themes are risks of "omission " as are risks of "commission ". iii) A failure to find a relationship between the business and mission goals of a system and the risk themes from an evaluation of that system. iv) A failure to find a relationship between the domain of a system being evaluated and the risk themes associated with the development of that system. The results of this investigation have application to practitioners by suggesting activities on which developers should put greater focus. They also have application to researchers by suggesting further areas of investigation.

Summary form only given. In this article, the author describes the principles involved in the design of software architecture. The premise is that the design of software architecture is determined by the quality attributes requirements for a system. The quality attributes that we have focused on are: availability, modifiability, performance, security, and usability. The author discusses why quality attributes are important, how to specify quality attribute requirements in a common form, design primitives to support the achievement of each quality attribute and how these can be applied to the design and evaluation of software architectures

The SPLC doctoral symposium provides a platform for young researchers to present their work to an international audience and discuss it with each other and with experts in the field. The symposium addresses research activities in the field of Software Product Lines Topics of Interest include all aspects of the development phases, management, evaluation, reuse, and maintenance of software product lines.

Design patterns have been claimed to facilitate modification and improve understanding in software design. A controlled experiment was performed to assess the usefulness of portions of a usability-supporting architectural pattern (USAP) in modifying the design of software architectures to support a specific usability concern. Software engineering and information technology graduate students received different subsets of a USAP supporting cancellation functionality. They then studied a software architecture design and made modifications to add the ability to cancel commands. Results showed that participants who received a usability scenario, a list of general responsibilities, and a sample solution thought of significantly more key issues than participants who saw only the scenario. Implications for software development are that usability concerns can be included at architecture design time, and that USAPs can significantly help software architects to consider responsibilities inherent from usability concerns.

This paper presents a technique developed at the Software Engineering Institute (SEI) for encapsulating quality attribute knowledge for use in the design and validation of software architectures. A reasoning framework, our encapsulation mechanism, can be used by nonexperts to analyze a specific quality (e.g., performance, modifiability, availability) of a system.

This is a report of a working session on quality in the Working International Conference on Software Architecture, 2005

Software architects have techniques to deal with many quality attributes such as performance, reliability, and maintainability. Usability, however, has traditionally been concerned primarily with presentation and not been a concern of software architects beyond separating the user interface from the remainder of the application. In this paper, we present usability-supporting architectural patterns. Each pattern describes a usability concern that is not supported by separation alone. For each concern, a usability-supporting architectural pattern provides the forces from the characteristics of the task and environment, the human, and the state of the software to motivate an implementation independent solution cast in terms of the responsibilities that must be fulfilled to satisfy the forces. Furthermore, each pattern includes a sample solution implemented in the context of an overriding separation based pattern such as J2EE Model View Controller.

ArchE (Architecture Expert) is an rule based system that contains a model of modifiability. The model plus modifiability scenarios that characterize expected change enable ArchE to collaborate with an architect to produce a design of the architecture that supports the expected change. ArchE has been used with real requirements from a manufacturer. This paper describes the model used in ArchE and how the architect and ArchE interact in order to produce a design.

The First International Workshop on the Relationships between Software Engineering and Human-Computer Interaction was held on May 3-4, 2003 as part of the 2003 International Conference on Software Engineering, in Portland, OR, U.S.A. This workshop was motivated by a perception among researchers, practitioners, and educators that the fields of Human-Computer Interaction and Software Engineering were largely ignoring each other and that they needed to work together more closely and to understand each other better. This paper describes the motivation, goals, organization, and outputs of the workshop.

The role of software architecture with respect to usability has evolved over the past 20 years. The architectures of the 1980s and early 1990s assumed that usability was primarily a property of the presentation of information. Therefore, simply separating the presentation from the dialogue and application made it easy to modify that presentation after user testing. A more popular belief in the 1990s was that usability concerns greatly affected system functionality as well as the presentation. This emphasis took attention away from architectural support (beyond separation). Achieving the correct functionality for a given system became paramount. It is our observation that even if presentation and functionality of a system are well designed, the usability of a system can be greatly compromised if the underlying architecture does not support human concerns beyond modifiability. This paper will present a new role for software architecture in usability, preliminary research and practice stemming from this role and a research agenda for the future.

The design process used to produce an innovative computer system is presented.The computer system that resulted from the process uses a circular motif both for the user interface and the input device.The input device is a dial and the user interface is visually organized around the concept of a circle.The design process itself proceeded in the presence of a great many constraints and we discuss these constraints and how an innovative design was achieved in spite of the constraints.

Building a system at the architectural level can be thought of as decomposition into components followed by a series of exercises in matching. Components must be composed with each other via matching mechanisms; matching signatures within those mechanisms ensures that data and control flows through the system; and matching semantics among the components ensures that the system meets its behavioral requirements. The standard concepts of software architecture (components, connectors, styles) have been widely used with little more than intuitive understanding of their meaning. Mechanism matching is currently an ad hoc exercise that relies on the peculiarities of programming language facilities. This paper presents a set of well-known but informally described software architectural elements used in system composition, and taxonomizes them under a basic set of characteristic features. This classification allows us to describe legal combinations of architectural elements by performing a simple matching exercise on the relevant features of the member elements. This classification also allows us to identify architectural elements that can be substituted for each other and satisfy the same mechanism matching requirements. This leads to delayed binding of architectural mechanisms, which in turns provides increased flexibility and greater opportunities for reuse of units of computation.

Forms have become widely used as a user interface for database systems. By analyzing the components of forms, a unified treatment of aggregation operators, headings, subheadings, and internal logic of a form is possible. In this paper we present a theory and a system based on that theory which allows users to easily specify displays. Displays are composed of components and the user can specify geometry of the components and grouping relationships between the components which allow for the generation of the desired display.

Two disciplines have been developed during the past few years for the study of computer software. Software physics has as its purpose the analysis of execution characteristics of programs. Basic measures of software work, time, and shortage occupancy are used to derive measures such as power, capacity usage, and storage work, with applications to the choice of processor and device speeds. Software science is related to information theory. Occurrences of operators and operands in the text of programs are counted to provide measures for a number of relationships; among them are estimates for program length, program and language level, and programming time.

Previous article Full AccessErrata: On Optimal Processor Scheduling for MultiprogrammingL. J. BassL. J. Basshttps://doi.org/10.1137/0205053PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAbout"Errata: On Optimal Processor Scheduling for Multiprogramming." SIAM Journal on Computing, 5(4), p. 758 Previous article FiguresRelatedReferencesCited ByDetails Volume 5, Issue 4| 1976SIAM Journal on Computing History Submitted:21 October 1975Published online:13 July 2006 InformationCopyright © 1976 Society for Industrial and Applied MathematicsPDF Download Article & Publication DataArticle DOI:10.1137/0205053Article page range:pp. 758-758ISSN (print):0097-5397ISSN (online):1095-7111Publisher:Society for Industrial and Applied Mathematics

The relationship between computational complexity and hierarchies of computable Functions is explored.It is shown that known results of hierarchy theory have interesting applications to the Blum theory of computational complexity and, conversely, the Blum theory has applications to hierarchy theory.For example, it is shown that the Blum Speed-up Theorem guarantees the existence of nondegenerate hierarchies of computable functions through all the Church-Kleene constructive ordinal numbers without obtaining all total recursive functions in the hierarchy.In the other direction, a theorem of Kreisel and Parikh on the nonuniqueness of hierarchies forces a number of "irregularities" in the McCreight-Meyer notion of "class-determining measured sets."A variation of the well-known Borodin-Constable Gap Theorem is presented.In toto, still more evidence is presented for the claim originally advanced by Young that it is reasonable to expect an interplay between theories of computational complexity and known results in "pure" reeursion theory.

This paper investigates the problem of scheduling a processor to optimize throughput in a multiprogramming environment. A deterministic model is used to study the scheduling of a batch of k programs residing in main memory of a system consisting of a single processor and k input–output devices in such a way as to minimize the time to complete all k jobs. It is shown that for any set of independent programs a preemptive strategy is not necessary to obtain the minimum running time for the entire batch. There is always an interrupt driven schedule which is as good as the best preemptive schedule. It is also shown that processor bound programs are easy to schedule. A lower bound on the completion time for any set of programs is observed, and it is shown that with processor bound programs the lower bound can always be obtained. An algorithm for obtaining this bound is given. These results provide some insight into the workings of the dynamic scheduling algorithms in use in many modern computer systems.

The classes of computable functions defined by a bound on the computation time are shown not to be closed under infinite descending intersection.

We consider here the problem of building transfinite hierarchies of computable functions on the basis of their difficulty of computation. Previous hierarchies of functions through the constructive ordinals have had two major problems, each apparently caused by not having techniques to restrict the classes considered at limit ordinals. These problems are, first that every function occurs at some name for ω, or some other small ordinal, and second that two names for the same constructive ordinal have two different classes of functions associated with them.