SAAS Series 14: SaaS Software Development and Analysis

1 Introduction

The real question is not whether computers have the ability to think, but whether humans have the ability to think.

________ B. F. Skinner Computer Science

Unlike traditional software, the SAAs model is not only reflected in operational services, but also significantly different in software development methods and technologies.

How to Develop SaaS software and what technologies will be used to develop SaaS software are the main contents of our research.

2. Key Technologies for implementing SaaS Software

L SOA technology

SOA and SaaS, known as the Sisters of Yunsheng, are indeed not a problem. SOA and SaaS are two carriages in the field of modern software services.

Service-Oriented Architecture (SOA) was first proposed by garnter in the late 1990s S, emphasizing the importance of services. Most consumers in China gradually understand and understand it through the propaganda of the boss IBM in the SOA field.

Over time, application software development vendors have become increasingly involved in the SOA field. Now, it is no exaggeration to say that SOA is everywhere. As SaaS becomes increasingly popular and SOA continues to deepen, in December 2007, Microsoft took the lead in proposing the "software + service" (S + S) strategy in the industry, aiming to break through the "internal business integration (SOA)" strategy) + external business expansion (SAAS) + rich user experience and other multiple resources, organically combining "software" and "service" to maximize the IT value, to achieve SaaS and SOA, "have both fish and bear hands ".

According to Microsoft's definition in a technical White Paper, "software + service" is an "It umbrella", which integrates many existing IT technologies and theories, includes SaaS, SOA, and Web2.0. As different manufacturers start from different starting points, the entire IT industry is taking the umbrella of "Software + service" to the road to the future of it.

"The increasing complexity of the IT environment has led to an increasing demand for technology products. The development trend of science and technology in the next 10 years has shown that, A single, modular technical product or service cannot meet the needs of socio-economic development. The global scientific and technological ecosystem will develop healthily in a diverse, dynamic, and service direction ". Donaldferguson, an academician of Microsoft and a member of Microsoft's CTO office, believes that in the service field, users can try it out before buying it and pay for it as needed. In the software field, users have full control right-customization and one-time payment, it can be used as long as you want. If you choose a pure software or service-only approach, you actually give up on the other hand. "S + S" can solve this problem well. The "s + S" concept targets a variety of user needs. You can choose to get services, continue to own software, or both.

"SOA is also important for software vendors that launch SaaS ". Dana Gardner, chief analyst at interarbor solutions, points out that SOA can help it deliver application software more effectively. Moreover, compared with traditional packaging application software vendors, they have gained a competitive advantage in terms of price.

Dr. Li zhixiao, chief technology officer of Microsoft China, said that software and services play a complementary role in "S + S, 2008 will be an important year for Microsoft to step up its "s + S" strategy. According to Liu qinzhong, director of SAP Business bydesign, SAP will also face a big change in 2008 and expand new SaaS channels with SOA architecture products to achieve both SaaS and SOA gains.

L cloud computing technology

SAAS, as a new sales method of application software, has begun to flourish. However, as SaaS software customers grow, basic resources such as network storage and bandwidth will gradually become the bottleneck of development, for many enterprises, the performance of their computer equipment may never meet their needs. A simple approach is to purchase more and more advanced equipment, and the following is the dramatic increase in equipment costs, as profits decrease, is there a more economical and effective solution? The emergence of "cloud computing" may open a gap in the door for solving this problem.

Cloud computing is an emerging Internet-based approach to sharing infrastructure. It is usually used for some large Server clusters, including computing servers, storage servers, and broadband resources. It uses the transmission capability of the high-speed internet to move the data processing process from a personal computer or server to a server cluster on the Internet. These Server clusters are managed by a large data processing center, the data center allocates computing resources based on customer needs and connects a large system pool to provide various IT services. To achieve the same effect as that of a supercomputer. Cloud computing brings together all computing resources and is automatically managed by software without human intervention. This allows enterprises to focus more on their own business without worrying about complicated details, and is conducive to innovation.

Generally, SaaS providers are more focused on software development, and their network resource management capabilities are weak, which often wastes a lot of money to purchase servers, bandwidth, and other infrastructure, however, the user load provided is still limited, while cloud computing provides a simple and efficient mechanism for managing network resources, such as allocating computing tasks, re-balancing workloads, and dynamically allocating resources, it can help SaaS providers provide unimaginable huge resources to massive users. SaaS providers can no longer waste their resources on servers, bandwidth, and other infrastructure, focus on specific software development and applications to achieve a win-win situation for end users, SAAS, and cloud computing.

It can be seen that cloud computing has considerable potential in the enterprise software market and is also an opportunity for SaaS providers. They can choose a cloud computing platform and use the cloud computing infrastructure, it provides stable, fast, and secure applications and services for a large number of users at a low cost.

To quickly grasp the concept of cloud computing, we can use the concept of the cloud on the network architecture diagram and so on. In the network architecture diagram, the online architecture of the Internet is usually hidden by the cloud, so that you do not need to understand the complexity of the online architecture, but can communicate with the simplified concept; the concept of cloud computing, the complexity of the computing system should be hidden so that developers do not have to understand the system architecture that provides computing resources. As long as the computing data is thrown into the system, the system will return the result.

Cloud technology can be regarded as a sub-set of grid technology. The two share the same purpose. They all need to hide the complexity of the system so that users can use it without having to understand how the system works.

L Ajax technology

Ajax (Asynchronous JavaScript and XML) is a group of technologies used to develop Web applications. It integrates JavaScript, XML, DHTML, Dom, and other programming technologies, developers can build Ajax-based web applications and break the Convention of using page overloading. It allows the browser to provide users with a more natural browsing experience. Whenever an update is required, modifications to the client web page are asynchronous and gradually added. In this way, Ajax significantly increases the speed of the user interface when submitting web page content. In Ajax-based applications, there is no need to wait for a long time to refresh the entire page. The part of the page that needs to be updated is changed. If possible, the update is done locally and asynchronous. Users can enjoy SaaS application services while refreshing pages. browser-based B/S software is just as familiar and fluent as traditional C/S software. Applications such as Ajax are constantly being used in the software industry through SAAS.

L WebService technology

Web Service is a lightweight transmission protocol based on soap, XML-based Data encapsulation standard, and HTTP-based component integration technology.

Web Service is an interface proposed to enable communication and sharing between isolated sites. Web services use uniform and open standards on the Internet, so Web services can be used in any environment that supports these standards (Windows, Linux. Its design goal is simplicity and scalability, which facilitates the interoperability between a large number of heterogeneous programs and platforms, so that existing applications can be accessed by a wide range of users.

Soap technology is the core of Web Service. It encapsulates data packets in XML standard format. The encapsulated communication information is expressed in text format and follows standard encapsulation rules. This means that any component model, development tool, programming language, and application system can use this technology smoothly as long as it supports data in XML and text formats. Currently, all component models, development tools, programming languages, application systems, and operating systems support XML and text formats. Of course, soap is fully supported.

In SaaS software, Web Service provides a mechanism for communication between components. The Web Service technology will greatly improve the scalability of the system, so that the application systems of different platforms and different development tools can be seamlessly integrated. At the same time, as the core of Web Service technology, soap is an open standard protocol. It not only breaks through application barriers, but also integrates enterprise firewalls and internal information systems, it also provides a secure and integrated application environment, allowing enterprises to encapsulate any custom information without modifying the source code of the application system, providing powerful system elasticity.

L Single Sign-On Technology

One of the basic requirements for the ease of use of modern network applications, at least within our system, we need a user to log on once to access all subsystems that he or she has the right to access.

Single sing on (Single Sign-On) is to implement all authorized application software systems that are automatically accessed through one login, so as to improve overall security, and there is no need to remember multiple login processes, IDs or passwords.

In the WebService environment, Single Sign-On plays a very important role. In the WebService environment, various systems need to communicate with each other, but it is impractical to require each system to maintain an access control list between them. Users also need a better experience to use different systems involved in a business process without complicated multiple logins and authentication. In the single-point logon environment of WebService, there are also such systems that have their own authentication and authorization implementation. Therefore, you need to resolve the problem of ing users' trust among different systems, in addition, once a user is deleted, the user cannot access all participating systems.

SAML is a standard for encoding authentication and authorization information in XML format. A Web Service can therefore request from a SAML-compatible authentication and authorization service, receive SAML assertions, and authenticate and authorize a service requestor accordingly. SAML can be used to transmit trust among multiple systems, and therefore is used in single-point logon.

3. Product Line Production in the software factory

By applying important new methods, we can overcome the economic and technical problems that impede the transformation from technology to production. These methods have taken a new approach in dealing with complexity and changes. These new methods also exist now, while showing significant potential in commercial products, although most of them are not yet mature. There are four main aspects: Reuse of systems, assembly and development, model-driven development, and process framework. Let's consider it one by one.

L reuse of the system

One of the most important new methods in software development is to define software product families. Their members are changing, but they share many common features. Like parnas, such a family provides an environment for collective member issues. By identifying and distinguishing features, these features are more or less present in multiple products and those changes, and we can reuse them using a systematic approach. A software product family consists of components or the entire product. For example, a family should contain different application investment management, including different user management frameworks, which are used by Application investment management and user relationship management applications.

The software product family is developed by the System Integrator (SIS) to port applications from a user to a user, or improve existing applications to create new applications. They also develop software product families through independent software vendors. multi-application programs in the development area are like CRM, or multi-version applications are maintained and improved. They also use IT organizations to develop software product families, improve existing applications, develop multi-link applications, or multi-version applications through maintenance and improvement.

L software production line practices

Develop software product families in the software production line. by identifying common characteristics and entering tables with changes in special fields, the development of software product family members becomes faster, cheaper, and less risky. Instead of sending hope for temporary reuse, their system captures how to develop the knowledge of family members, making reuse of assets possible, and exploiting those assets during family member development. As a family product development, You can reuse requirements, architectures, frameworks, components, tests, and other assets.

Of course, developing a production line requires costs. In other words, the production line represents a classic cost-balance of interests. Benefits on the one side of the equation cannot increase profits by producing many backups in the market that supports limited release, but can increase profits by producing many related and unique products, as described in many cases [cn01]. Using software production lines is the first step towards software industrialization. The second step is to make their creation and operation cheaper. Figure 1 describes the execution, production, and utilization of main tasks on a production line.

Figure 1 software production line

Production Line developers use application development assets to develop software family members, just as platform developers create device drivers and operating systems for use by application developers. An important step to develop product assets is to develop one or more regional models that describe the common problem features provided by the production line and different tables. These models jointly define the scope of the production line and are used to limit the expected software family members. The requirement of software members is derived from these models, it provides a way to link demand changes with architecture, implementation, execution, development process, project environment, and other changes in the software life cycle.

L model-driven development

It is an important process to improve the level of abstraction. It reduces the scope of abstraction and reduces developer control during implementation. The loss of control is an increase in power. Most commercial application developers, for example, prefer to use a higher level of abstraction like these using C # And. Net frameworks, rather than assembly languages and system calls. Higher levels of abstraction produce many benefits, including higher productivity, fewer defects, and easier maintenance and improvement.

Unfortunately, we see that improving the Abstraction Level and tools are very expensive. If we can find some ways to make it faster, cheaper, and easier, but we can provide a higher level of automation for small problem domains. This is the goal of model-driven development (MDD. Model-driven development uses the model drive to capture high-level information, usually informal expressions, automatic implementation, or model compilation for execution, or manual development for execution. This is important because information is not found in the lower-layer artifacts, such as source code files, which are difficult to track, maintain, and continuously improve.

Some development activities, such as building, configuration, and debugging, are currently partially or completely automated by capturing information from source code files and other implementation artifacts. With the information captured through the model, MDD can also provide more scalable automation activities and more automated optimization tables, such as model debugging and automated configuration tools. Here are some examples:

2. daily tasks, such as producing another task from one thing, are usually fully automated. For example, a test tool can be automatically created from a user interface model to convert pages to simulate user activity.

2. Other tasks, such as solving the difference between artifacts, can be partially automated. For example, the column and form fields in the table may be full of problems to be solved by the user, and then the user determines to automatically perform correction.

2. adapters, such as Web Service wrappers, can be automatically generated from model to bridge differences in implementation technology. The model can also be used for representation, Protocol configuration, and other adaptive integration mechanisms.

2. The model can be used to define the configuration of the workpiece, which consists of configuration units to automate the configuration process. The model configuration environment can be used to constrain the design so that the design can be correctly implemented.

L special domain language

For MDD, we are no longer interested in some end languages such as 4gls, nor are we interested in using a high-level language to achieve development in all aspects. The weaknesses of these strategies have been fully demonstrated. We are no longer interested in the models submitted at the meeting, and there are notes. Unfortunately, models are usually used to compile files for use by people rather than computers. These make an impression that the model is not the first type of development artifacts that use source code. We are interested in using tools to process models, and we plan to use them in the same source code method. In this way, the document design model cannot be expressed in languages. The model must be accurate and unambiguous. At the same time, to improve the abstraction level, the modeling language must focus on small areas rather than a general programming language. There are the following requirements:

2. The goals of the language design must be clearly defined so that reviewers who are familiar with the field can evaluate the language and determine whether it has achieved the goal.

2. This language must enable people working in this field to capture business concepts. The language used to develop and assemble web services must contain concepts such as Web Services, web methods, protocols, and protocol-based connections. Similarly, a language used to visualize and edit C # source code must contain concepts such as classes, members, domains, methods, attributes, events, and proxies.

2. This language must familiarize its users with the name of its concept. For example, a C # developer finds that a class model with a domain and a method is more natural than a model with attributes and operations.

2. the symbols of the language are pictures or texts and must be easily used to solve the problem. People's Daily Work must be easily expressed by concepts. For example, it must be easy to use a visual and C # source code editing language to operate on an inheritance.

2. This language must have a set of defined rules called syntax to manage expressions that comprise concepts. This makes it possible to use tools to check whether the expressions are correct and help users write concepts.

2. the semantics of each expression must be well defined so that users can create models that others understand. Tools can generate legal implementations from models, meta from the model can be used to process tasks as expected, such as configuring servers.

Languages that meet these standards are called domain-specific language (DSL) and should be modeled for those special domain concepts. DSL is more rigorous than general modeling languages. Like a programming language, it also has text or image symbols. Sq and HTML are two examples of DSL, namely relational data definition and web page definition service.

Figure 2 shows two examples of DSL diagrams, a screen of Microsoft Visual Studio 2005 team system. The DSL on the left describes components, such as web services. It is used to automate component development and configuration. The dsl on the right describes the logical service type of the data center. It is used to design and implement data center configurations. Web Service Development is to drag service components to the Logic Server. The difference between resource requirements and availability on the Logic Server is full of validation errors and diagrams.

Figure 2 domain-specific languages

L incremental code generation

The key to efficient code generation is to reduce the conceptual differences between generation and generation. In this way, tools can be used to implement centralized, efficient, and platform features. One way to increase code generation is to make the model closer to the platform, as shown in 3. For example, a special programming language defined by a programming language type system can achieve more real modeling than a modeling language defined by a type system. This model is now a Code view. The developer's graphical operating program structure is the same as the operation class and method definition. This tool reflects the relationships and dependencies that are hard to see in the code, saving time and effort for generating code for the program structure. It enables programming styles like relationship-based collection, or provides advanced features like reproduction and Pattern Construction, application, and evaluation.

Figure 3 SaaS Operation Human Relation Group

Of course, by limiting the abstraction on available platforms, this weakens the role of modeling, or does not play much role in programming style. So how do we work on a higher abstraction layer? We use a more abstract model to make the platform and model closer through the framework or transformation, as shown in figure 4. Let's take a look at these.

Figure 4 Programming Language Modeling

Use high-level abstraction

2. We can use the framework to implement high-level abstraction in the module, and use these modules to generate small pieces of code at the framework extension points. On the contrary, the model helps users complete the extension of the framework by visualizing the framework concept and intuitively. It is difficult to use Microsoft's operating system, for example, to build a graphic application. Subsequently, Microsoft Visual Basic makes it easier to apply graphics through forms and controls.

2. We can create a lower-level DSL Description Language instead of the architecture or model language. To lead this revolutionary revolution, we can also use more than two DSL descriptive languages to span a wider span. The model described in the highest level DSL language can be refined and converted into executable softwares, 4. This explains how the compiler works, how to convert high-level languages like C # and Java into intermediate code like bytes or IL, and compile the code into the binary format of the target platform through JIT.

L composition mechanism

Of course, the handwritten code must usually be combined with the Framework Code to generate a complete executable program. Some different mechanisms can be used to do these things. The important difference between them is to help set the time.

Figure 5 composition of design time

The two advantages of runtime binding are the combination of handwritten code and framework code through interfaces, allowing dynamic configuration through object replacement. Meanwhile, the delegate class allows handwritten code to be regenerated for protection. A small drawback is that the running time is often called by methods. In the component programming model, some runtime-based binding mechanisms are very popular, as shown in figure 6. They are very successful in large-scale commercial products.

2. Before compilation, the design time in the same workpiece is mainly the time for handwriting code and framework code, as shown in Figure 5. This includes constraints to prevent users from modifying the framework code editing experience (for example, using the editor in the read-only area ). In other tools, you can add handwritten code in a special window. Through asynchronous callback, You can bind and merge the handwritten code and framework code at runtime. A proxy-based runtime binding mechanism is described by designing a model, for example, from gamma, et. al.: Events (observer), adapters (adapter), policy objects (Strategy), factories (Abstract Factory), Orchestration (mediator), wrappers (decorator), proxies (proxy ), commands (command )? And? Filters (chain of responsibility) [ghjv95]. The two advantages of runtime binding are the combination of handwritten code and framework code through interfaces, allowing dynamic configuration through object replacement. Meanwhile, the delegate class allows handwritten code to be regenerated for protection. A small drawback is that the running time is often called by methods. In the component programming model, some runtime-based binding mechanisms are very popular, as shown in figure 6. They are very successful in large-scale commercial products.

2. handwritten sub class. Users provide handwritten code in the sub class in the framework. The abstract method in the Framework Code defines the display overwrites. For example, a user writes a subset of framework Entities and uses the template method mode to reference handwritten code and highlight function calls.

2. Framework sub class. You provide handwritten code in the parent class of the Framework Code. An abstract method of handwritten code is overwritten in the Framework Code. For example, a framework entity domain introduces a parent class function call for handwritten code, and highlights the function call.

2. handwritten entrusting class. The user adds and writes code in the delegate class. For example, a framework object calls a handwritten entity at the formulation stage before or after setting the attribute value. It is actually a proxy server mode.

2. Framework delegate class. The user adds handwritten code to obtain the Framework Service. For example, a handwritten code entity calls the framework entity to set or obtain the attribute value.

Figure 6 runtime Components

2. Bind and merge handwritten code and framework code during compilation, as shown in figure 9. It is a good method to merge some specifications during compilation. In Visual Studio 2005, Visual Basic and C # are structured during compilation.

Figure 7 SaaS Operation Human Relation Group

L assembly and development

Important innovations in the platform-independent protocol field include self-describing, variable encapsulation, process assembly, and architecture-driven development.

L platform-independent protocol

When the Web Service technology succeeds, the early component assembly technology fails to separate components used for specific and Assembly from the implementation technology. Because XML is a technology for information management, rather than a technology for building components, Web services use encapsulation to map web method calls to local method calls, based on the following component implementation technology. Although CORBA tries to use a similar strategy, its complexity requires a large investment from platform vendors, which limits its scope of use. Simple XML-based protocols significantly reduce implementation difficulties and ensure their universality. By coding remote method call requests like XML, they prevent collaboration issues caused by Special Remote Call coding and parameter aggregation on the platform. At the same time, they have designed the collaboration capability of the platform from the very beginning by gaining broad recognition of industrial standards.

L self-description

By improving component packaging, we can make inferences, dependencies, behaviors, resource consumption, and obvious performance and proof. Self-descriptions reduce architecture mismatch. It provides metadata that can be used to automatically discover, select, license, obtain, install, adjust, assemble, test, configure, deploy, control, and manage components.

The most important form of self-description is used to describe component inference, dependencies, and actions. Therefore, developers can launch interactions between components before tools can verify assembly. In object-oriented systems, the wide range of spec sheets are class and interface declarations. They define the behavior provided by the class. However, by naming other classes and interfaces in the method signature, only important inferences and dependencies are described. A contract is a variety of specifications. A contract manages the interaction between components. It does not know when to call a component. A contract describes the interaction sequence and invalid response protocols and other unpredictable conditions.

Of course, the contract is useless unless it is forced. There are two ways to force a contract.

2. Assemble components without mismatched contracts

2. Provide the adapter with the information provided by the contract. This adapter enables direct interaction between components or coordinates interaction between them.

Garlan recommends the use of standard adaptation technology recipes and tools for packaging and data conversion [gar96]. One of the most promising adaptation strategies is to release some components that can be completed during assembly by encapsulating various aspects that provide the code needed for assembly. This policy is called variable encapsulation and is described as follows.

Another important aspect of self-description is proof. If a component can prove that it only has a specified dependency, consumes the specified resources, has specific functional features under certain conditions, or has some public vulnerabilities, it can infer the functional and operational features of the software assembled from these components. This has been studied at the Institute of software engineering at Carnegie Mellon University and is considered a predictable assembly (PACC) that guarantees components ).

L variable Encapsulation

We have seen that static encapsulation reduces this possibility-a component can be used for specific assembly by statically binding its functional aspects or internal aspects that do not have functionality or are associated up or down. Variable encapsulation reduces the mismatch between architectures by releasing components encapsulated in part. These components use their functional aspects to select and compile appropriate non-functional aspects, to adapt to the new context, as shown in figure 8. The component form in a specific assembly can be determined by the context at its position. Flexibility can be improved by making the component boundary more elastic and reducing the mismatch between architectures. By removing non-functional assumptions, you can allow conversion of functional parts on the component boundary. Effective adjustments can be pre-identified. In some examples, they can be automatically completed using tools.

Figure 8 variable Encapsulation

Variable encapsulation is a rewrite (AOP) for Aspect-Oriented Programming ). AOP is a method of separating and combining different aspects of the system [klm97]. Variables are encapsulated in three different ways than AOP.

2. variables are encapsulated into encapsulation. However, as a common practice, AOP is compiled into non-encapsulated code lines. For non-encapsulation, the same problem occurs when poorly assembled component packages are called architecture mismatch and unpredictable. Indeed, aspect-based source code compilation tends more to these problems than component assembly, because components have at least descriptive behavior and some packaging that prevents dependency-free. Lack of AOP packaging makes it difficult for developers to infer compatibility and functional features of the program, or to execute the result features, making it almost impossible to compile the program using tool checks.

2. AOP compilation during component development, but variable encapsulation compilation is later than them, such as during component assembly or configuration. This is important because the context of a component may not be known until it is published. In fact, to support assembly and development, as described in the article, the third part must be able to predict assembly and deployment of development components without dependency. This requires a formal way to split, encapsulate, and describe and package. Variable encapsulation can also be progressive, which can occur at different stages. For example, we can bind some aspects during assembly, some aspects during development, and some aspects during running.

2. Variable encapsulation is Framework-driven, but AOP is not. These aspects separated from the functional kernel must be clearly defined through interfaces, abstract classes, WSDL files, or other forms of contracts.

L Process Management assembly

If there is a sufficient contract mechanism, the service can manage the order of information exchanged between them through the process management engine, such as Microsoft BizTalk Server, as shown in figure 9. Process Management Assembly makes assembly and Development easier, because there are far fewer dependencies between services than binary components. Unlike classes, they do not need to reside in the same execution. Unlike components, platform-specific protocols are required, which can be assembled through platform boundaries. If the contract between them is compatible, the two services can interact with each other. They can be developed and deployed separately, and then assembled through process management. If appropriate interception services are available, they can even reside in different management and organizational areas. In other words, process management Assembly eliminates the design, compilation, and deployment time dependencies between different components.

Figure 9 Process Management assembly

Process Management assembly is essentially an arbitration, as described in Gamma's Arbitration Model. The interaction process between arbitration management components. A single arbitration has powerful attributes. One of the functions is to filter or translate information when components interact. Another function is to control interaction and maintain the status through multiple calls if necessary. This allows arbitration to deduce interactions and, if necessary, change them through conditional logic. Arbitration can also perform some useful functions, such as logs, enhanced security policies, and connections between different technologies or different versions of the same technology. An arbitration can also become a functional part of the assembly, enhancing commercial rules or implementing commercial functions, such as reaching commercial transactions.

L architecture-driven development

When you prevent assembly of mismatched components from being too good to build illegal assembly, there is no need to improve the availability of matched components. This is the goal of the architecture. According to Shaw and Garlan, a software architecture describes component assembly, interaction between them, and acceptable composition patterns, reducing the risk of well-designed architecture mismatch and constrained design decisions.

Of course, developing software architecture is challenging. This allows many architects to spend many years mastering a limited architectural style or application field. Without significant advances in architecture practices and more trust in software architecture, assembly and development cannot be achieved on an industrial scale.

These are the goals of architecture-driven software development (ADD), including:

2. standards used to describe, repeat, and use the architecture.

2. It is used to predict the method that design determines utility.

2. the mode or architectural style is used to organize the opinions of design experts and help designers develop component segmentation and reproduction modes.

An architectural style is a rough model that provides a group of family systems for the abstract framework. It defines a set of rules that specify different types of components. These components can be used to assemble a system. The relationships between different types of components can be used in assembly, assembly constraints, and Assembly ideas. For example, a Web service component style can be used to specify the port that the component provides. These components are defined by the web service and established through the connection port. Only two ports are compatible and can be connected for communication through HTTP using soap. Other architectural styles include data stream, layering, and MVC. An architecture style promotes division and improves design reuse by providing solutions with frequent problems.

2. The architecture elements are shared by the system based on the common architecture elements.

2. The standard architecture is defined.

2. Improve collaboration capability by defining standard communication mechanisms.

2. Improve visualization by defining standard notation.

2. Improve tool development by defining mandatory constraints.

2. Identify system highlights based on this style.

A framework description is a document that defines the software architecture. IEEE Standard 1471 is recommended to describe intensive software architectures and provides guidelines for describing architectures [ieee1471]. According to these guidelines, a system has one or more shareholders. A shareholder has special concerns and interests in some aspects of the system. To be useful to shareholders, an architecture description must require forms and structures that can be understood by shareholders. ADS is a template used to describe a system family architecture. A formal scenario defines a view that describes a part of a software product. It also provides a mode for describing, defining ranges, targets, and audience, the custom language and the method used to develop it.

These highlighted elements are used to describe a specific scenario, including:

2. An identifier and other introductory information (such as the author, date, reference file, and so on ).

2. Interests of the scenario.

2. customs, language, and scenario-based methods used to generate views.

2. Check the view consistency and complete the test.

A view describes a software product from a given scenario. A view is semantically close, meaning that it describes a software product from that scenario. A view contains one or more artifacts, each of which is developed based on scenario requirements. A view is an example of a scenario. To better form a view, it must be consistent with the scenario. A view follows the web design scenario. For example, you should describe the webpage layout of special software products, and use the symbols defined in the scenario to describe the webpage layout. These highlighted elements are used to describe a view in detail, including:

2. An identifier and other introductory information (such as the author, date, reference file, and so on ).

2. The scenario identifier that the view complies.

2. Software Product Description constructed by means of customs, language, and scenario definition.

To understand the differences between a view and its scenarios, consider designing a logical database for commercial applications. Logical Data

Library Design is a view of the application. More specifically, it is a view that forms components. The application and language used to describe it are all defined in the logic database design scenario. Many different commercial applications can define different views by using the same scenario. Each view describes a logical database for some commercial applications. These views can describe the same aspect in the same language, but they have different content, so each content describes a different application. An assembly view can be used to extract the views of each component from the same scenario.

According to ieee1471, an architecture describes the scenarios that must be identified and the principles of these scenarios. Ads, as a special target, can be defined by listing a set of scenarios it uses. For example, a consumer's ads for commercial Web applications may need a Web page layout scenario and a business data layout scenario. Every view in the architecture description must follow a scenario defined by ads.

L process framework

As the project scale, geographic distribution, or time complexity increases, the key to maturity is to maintain flexibility. Experience tells us that few structures increase flexibility by reducing the necessary workload. This principle can be applied in the software product family. It uses a process framework to manage complex products without reducing flexibility.

Some of the difficulties in the formal process are that they are too abstract. The guidance they provide is obvious to old programmers, but it is not very specific to beginners. In order to increase the value of use, it must reduce the details of the current project, because each project is unique in many aspects, and we cannot produce a process that can satisfy all projects. We know how to solve such problems, and we can customize and crop a formal process for a special product family. If there is no professional supplier, the above things cannot be successful in the market. Some suppliers usually add some useful things from other processes, such as XP, to customize the process for special users. Others, especially system integrators and ISVs, are cropping processes to adapt to special product or consulting practices. For each method, the key to efficient use of any process is to make it highly specialized for a given project so that it only contains directly available resources. The changes produced by such customization are very complex and produce very little similar results from the original process.

A highly centralized process includes detailed project information, such as tool configuration, network sharing path, developer work according to instructions, API documentation, and name of important contacts in key processes, such as cm, defect tracking and handling, team strategy on check-in, programming style and equivalent checks, and other detailed features on project and project teams. Together with other forms of system reuse, this customization is useful only when we can use it more than once. Similarly, process resources in the reuse high set increase their flexibility by eliminating work, just like other reuse resources. As Jacob son often said, the fastest way to build things is to reuse existing things, especially reusable resources that can be customized and expanded. Many things can be systematically reused, and the development process is the same.

A process framework is divided into smaller processes, which are attached to the ADs scenario. Each small process describes the need to generate a view. It can list key decision points, identify the Conversion Relationship between each decision point, describe the required and optional activities, and describe the resources and products required for each activity. Each workpiece has some constraints before it is processed, and some post conditions, which are the constant environment required when the workpiece is stable. For example, we need to get the cycle condition before the loop starts and get the end condition when exiting. We need to construct and test all the code correctly. We call this architecture a process framework because it defines the space where possible merging processes depend on the needs and environment of a given project, and there is no need to describe a process for all projects. When a process framework is defined, a small process can be combined into any workflow required by the project, including top-down, bottom-up, from the inside out, test coding and coding testing, any combination or mixed stream.

These workflows can be driven by resources and can be optimized through pert and CPM. when resources are available, the workflow can be started. Many types of resources can drive plans, including requirements and source code, developers and program managers, configuration management products or defect tracking systems, such as devices that open a port on a server or allocate storage. This is called a constraint-based plan. Constraints-based plans use a small number of architecture requirements to balance the demand for flexibility. A constraint-based plan provides guidance on adding constraints to the development artifacts rather than the prescribed process. Flexibility can be dynamically generated by a workflow in constraints to adapt to a large number of environmental variables. At the same time, the learning experience can be summarized to reduce the cost and time of knowledge discovery.

A process framework does not need to be too large or too detailed, and may contain more or less required details. This provides a way to measure the process size, depending on the environment. For example, a small and flexible group can use a small framework, which only provides some key practices, such as XP. A large organization can add many details about the build process, check the process, test the process, or share rules with components.

4. Summary

This article introduces the development mode of SAAS. By introducing the key technologies for implementing SaaS software, we can gain a purposeful understanding of this knowledge. The production of product lines in software factories comes from the traditional manufacturing industry. There are still some problems in the application of assembly lines in the software industry, but it is not impossible to implement the factory of software. When talking about development, the system architecture is indispensable. The software architecture is mainly about the software hierarchy. In this section, both. NET and J2EE use instances to describe the architecture of the software. Product R & D is not only a technical path but also a decision-making issue for enterprises. Different companies can adopt effective and optimal R & D models based on their actual situation. Establishing and accumulating your own development system helps you reuse code and greatly reduce development costs.