软件开发概念和设计方法大学毕业论文外文文献翻译及原文
外文译文
成都理工大学
学生毕业设计（论文）外文译文
图表1展示了FriendTracker和FriendViewer应用所包含的不同类型的组件。
体化了组件。
关于应用中每个类型的组件的数量是没有限制的，但是作为惯例，一个组件与应用有相同的名字。
常见的情况是，这里有个activity，就像在FriendViewer
图表2展示了应用FriendTracker和FriendViewer
android分配的一部分。
在每个案例中，一个组件启动与另一个的通信。
简单来说，我们调用这个内部组件通信（ICC）。
在许多时候，在Unix基础系统中，
ICC的功能除了安全规则以外，同样的是不考虑目标是否在同一个应用或者是不同的应用中。
可用的ICCaction取决于目标组件。
每个类型的组件只特定支持他的类型的交互——举个例子，当
如图表3所示，android通过两个强制机制的共同工作来保护应用和数据，
ICC层面上。
ICC的仲裁定义了核心安全架构，这也是这篇文章的核心，但是他依赖于下层的
系统提供的保障。
（正文页面不够可加页，并在正文后附外文原文，统一用A4纸张打印或手工誊写）。
外文文献JSP中英文翻译
THE TECHNIQUE DEVELOPMENT HISTORY OF JSPBy:Kathy Sierra and Bert BatesSource:Servlet&JSPThe Java Server Pages( JSP) is a kind of according to web of the script plait distance technique, similar carries the script language of Java in the server of the Netscape company of server- side JavaScript( SSJS) and the Active Server Pages(ASP) of the Microsoft. JSP compares the SSJS and ASP to have better can expand sex, and it is no more exclusive than any factory or some one particular server of Web. Though the norm of JSP is to be draw up by the Sun company of, any factory can carry out the JSP on own system.The After Sun release the JSP( the Java Server Pages) formally, the this kind of new Web application development technique very quickly caused the people's concern. JSP provided a special development environment for the Web application that establishes the high dynamic state. According to the Sun parlance, the JSP can adapt to include the Apache WebServer, IIS4.0 on the market at inside of 85% server product.This chapter will introduce the related knowledge of JSP and Databases, and JavaBean related contents, is all certainly rougher introduction among them basic contents, say perhaps to is a Guide only, if the reader needs the more detailed information, pleasing the book of consult the homologous JSP.1.1 GENERALIZEThe JSP(Java Server Pages) is from the company of Sun Microsystems initiate, the many companies the participate to the build up the together of the a kind the of dynamic the state web the page technique standard, the it have the it in the construction the of the dynamic state the web page the strong but the do not the especially of the function. JSP and the technique of ASP of the Microsoft is very alike. Both all provide the ability that mixes with a certain procedure code and is explain by the language engine to carry out the procedure code in the code of HTML. Underneath we are simple of carry on the introduction to it.JSP pages are translated into servlets. So, fundamentally, any task JSP pages can perform could also be accomplished by servlets. However, this underlying equivalence does not mean that servlets and JSP pages are equally appropriate in all scenarios. The issue is not the power of the technology, it is the convenience, productivity, and maintainability of one or the other. After all, anything you can do on a particular computer platform in the Java programming language you could also do in assembly language. But it still matters which you choose.JSP provides the following benefits over servlets alone:• It is easier to write and maintain the HTML. Your static code is ordinary HTML: no extra backslashes, no double quotes, and no lurking Java syntax.• You can use standard Web-site development tools. Even HTML tools that know nothing about JSP can be used because they simply ignore the JSP tags.• You can divide up your development team. The Java programmers can work on the dynamic code. The Web developers can concentrate on the presentation layer. On large projects, this division is very important. Depending on the size of your team and the complexity of your project, you can enforce a weaker or stronger separation between the static HTML and the dynamic content.Now, this discussion is not to say that you should stop using servlets and use only JSP instead. By no means. Almost all projects will use both. For some requests in your project, you will use servlets. For others, you will use JSP. For still others, you will combine them with the MVC architecture . You want the appropriate tool for the job, and servlets, by themselves, do not complete your toolkit.1.2 SOURCE OF JSPThe technique of JSP of the company of Sun, making the page of Web develop the personnel can use the HTML perhaps marking of XML to design to turn the end page with format. Use the perhaps small script future life of marking of JSP becomes the dynamic state on the page contents.( the contents changes according to the claim of)The Java Servlet is a technical foundation of JSP, and the large Web applies the development of the procedure to need the Java Servlet to match with with the JSP and then can complete, this name of Servlet comes from the Applet, the local translation method of now is a lot of, this book in order not to misconstruction, decide the direct adoption Servlet but don't do any translation, if reader would like to, can call it as" small service procedure". The Servlet is similar to traditional CGI, ISAPI, NSAPI etc. Web procedure development the function of the tool in fact, at use the Java Servlet hereafter, the customer need not use again the lowly method of CGI of efficiency, also need not use only the ability come to born page of Web of dynamic state in the method of API that a certain fixed Web server terrace circulate. Many servers of Web all support the Servlet, even not support the Servlet server of Web directly and can also pass the additional applied server and the mold pieces to support the Servlet. Receive benefit in the characteristic of the Java cross-platform, the Servlet is also a terrace irrelevant, actually, as long as match the norm of Java Servlet, the Servlet is complete to have nothing to do with terrace and is to have nothing to do with server of Web. Because the Java Servlet is internal to provide the service by the line distance, need not start a progressto the each claimses, and make use of the multi-threading mechanism can at the same time for several claim service, therefore the efficiency of Java Servlet is very high.But the Java Servlet also is not to has no weakness, similar to traditional CGI, ISAPI, the NSAPI method, the Java Servlet is to make use of to output the HTML language sentence to carry out the dynamic state web page of, if develop the whole website with the Java Servlet, the integration process of the dynamic state part and the static state page is an evil-foreboding dream simply. For solving this kind of weakness of the Java Servlet, the SUN released the JSP.A number of years ago, Marty was invited to attend a small 20-person industry roundtable discussion on software technology. Sitting in the seat next to Marty was James Gosling, inventor of the Java programming language. Sitting several seats away was a high-level manager from a very large software company in Redmond, Washington. During the discussion, the moderator brought up the subject of Jini, which at that time was a new Java technology. The moderator asked the manager what he thought of it, and the manager responded that it was too early to tell, but that it seemed to be an excellent idea. He went on to say that they would keep an eye on it, and if it seemed to be catching on, they would follow his company's usual "embrace and extend" strategy. At this point, Gosling lightheartedly interjected "You mean disgrace and distend."Now, the grievance that Gosling was airing was that he felt that this company would take technology from other companies and suborn it for their own purposes. But guess what? The shoe is on the other foot here. The Java community did not invent the idea of designing pages as a mixture of static HTML and dynamic code marked with special tags. For example, Cold Fusion did it years earlier. Even ASP (a product from the very software company of the aforementioned manager) popularized this approach before JSP came along and decided to jump on the bandwagon. In fact, JSP not only adopted the general idea, it even used many of the same special tags as ASP did.The JSP is an establishment at the model of Java servlets on of the expression layer technique, it makes the plait write the HTML to become more simple.Be like the SSJS, it also allows you carry the static state HTML contents and servers the script mix to put together the born dynamic state exportation. JSP the script language that the Java is the tacit approval, however, be like the ASP and can use other languages( such as JavaScript and VBScript), the norm of JSP also allows to use other languages.1.3JSP CHARACTERISTICSIs a service according to the script language in some one language of the statures system this kind of discuss, the JSP should be see make is a kind of script language.However, be a kind of script language, the JSP seemed to be too strong again, almost can use all Javas in the JSP.Be a kind of according to text originally of, take manifestation as the central development technique, the JSP provided all advantages of the Java Servlet, and, when combine with a JavaBeans together, providing a kind of make contents and manifestation that simple way that logic separate. Separate the contents and advantage of logical manifestations is, the personnel who renews the page external appearance need not know the code of Java, and renew the JavaBeans personnel also need not be design the web page of expert in hand, can use to take the page of JavaBeans JSP to define the template of Web, to build up a from have the alike external appearance of the website that page constitute. JavaBeans completes the data to provide, having no code of Java in the template thus, this means that these templates can be written the personnel by a HTML plait to support. Certainly, can also make use of the Java Servlet to control the logic of the website, adjust through the Java Servlet to use the way of the document of JSP to separate website of logic and contents.Generally speaking, in actual engine of JSP, the page of JSP is the edit and translate type while carry out, not explain the type of. Explain the dynamic state web page development tool of the type, such as ASP, PHP3 etc., because speed etc. reason, have already can't satisfy current the large electronic commerce needs appliedly, traditional development techniques are all at to edit and translate the executive way change, such as the ASP → ASP+;PHP3 → PHP4.In the JSP norm book, did not request the procedure in the JSP code part( be called the Scriptlet) and must write with the Java definitely. Actually, have some engines of JSP are adoptive other script languages such as the EMAC- Script, etc., but actually this a few script languages also are to set up on the Java, edit and translate for the Servlet to carry out of. Write according to the norm of JSP, have no Scriptlet of relation with Java also is can of, however, mainly lie in the ability and JavaBeans, the Enterprise JavaBeanses because of the JSP strong function to work together, so even is the Scriptlet part not to use the Java, edit and translate of performance code also should is related with Java.1.4JSP MECHANISMTo comprehend the JSP how unite the technical advantage that above various speak of, come to carry out various result easily, the customer must understand the differentiation of" the module develops for the web page of the center" and" the page develops for the web page of the center" first.The SSJS and ASP are all in several year ago to release, the network of that time is still very young, no one knows to still have in addition to making all business, datas and theexpression logic enter the original web page entirely heap what better solve the method. This kind of model that take page as the center studies and gets the very fast development easily. However, along with change of time, the people know that this kind of method is unwell in set up large, the Web that can upgrade applies the procedure. The expression logic write in the script environment was lock in the page, only passing to shear to slice and glue to stick then can drive heavy use. Express the logic to usually mix together with business and the data logics, when this makes be the procedure member to try to change an external appearance that applies the procedure but do not want to break with its llied business logic, apply the procedure of maintenance be like to walk the similar difficulty on the eggshell. In fact in the business enterprise, heavy use the application of the module already through very mature, no one would like to rewrite those logics for their applied procedure.HTML and sketch the designer handed over to the implement work of their design the Web plait the one who write, make they have to double work- Usually is the handicraft plait to write, because have no fit tool and can carry the script and the HTML contents knot to the server to put together. Chien but speech, apply the complexity of the procedure along with the Web to promote continuously, the development method that take page as the center limits sex to become to get up obviously.At the same time, the people always at look for the better method of build up the Web application procedure, the module spreads in customer's machine/ server the realm. JavaBeans and ActiveX were published the company to expand to apply the procedure developer for Java and Windows to use to come to develop the complicated procedure quickly by" the fast application procedure development"( RAD) tool. These techniques make the expert in the some realm be able to write the module for the perpendicular application plait in the skill area, but the developer can go fetch the usage directly but need not control the expertise of this realm.Be a kind of take module as the central development terrace, the JSP appeared. It with the JavaBeans and Enterprise JavaBeans( EJB) module includes the model of the business and the data logic for foundation, provide a great deal of label and a script terraces to use to come to show in the HTML page from the contents of JavaBeans creation or send a present in return. Because of the property that regards the module as the center of the JSP, it can drive Java and not the developer of Java uses equally. Not the developer of Java can pass the JSP label( Tags) to use the JavaBeans that the deluxe developer of Java establish. The developer of Java not only can establish and use the JavaBeans, but also can use the language of Java to come to control more accurately in the JSP page according to the expression logic of the first floor JavaBeans.See now how JSP is handle claim of HTTP. In basic claim model, a claim directly was send to JSP page in. The code of JSP controls to carry on hour of the logic processing and module of JavaBeanses' hand over with each other, and the manifestation result in dynamic state bornly, mixing with the HTML page of the static state HTML code. The Beans can be JavaBeans or module of EJBs. Moreover, the more complicated claim model can see make from is request other JSP pages of the page call sign or Java Servlets.The engine of JSP wants to chase the code of Java that the label of JSP, code of Java in the JSP page even all converts into the big piece together with the static state HTML contents actually. These codes piece was organized the Java Servlet that customer can not see to go to by the engine of JSP, then the Servlet edits and translate them automatically byte code of Java.Thus, the visitant that is the website requests a JSP page, under the condition of it is not knowing, an already born, the Servlet actual full general that prepared to edit and translate completes all works, very concealment but again and efficiently. The Servlet is to edit and translate of, so the code of JSP in the web page does not need when the every time requests that page is explain. The engine of JSP need to be edit and translate after Servlet the code end is modify only once, then this Servlet that editted and translate can be carry out. The in view of the fact JSP engine auto is born to edit and translate the Servlet also, need not procedure member begins to edit and translate the code, so the JSP can bring vivid sex that function and fast developments need that you are efficiently.Compared with the traditional CGI, the JSP has the equal advantage. First, on the speed, the traditional procedure of CGI needs to use the standard importation of the system to output the equipments to carry out the dynamic state web page born, but the JSP is direct is mutually the connection with server. And say for the CGI, each interview needs to add to add a progress to handle, the progress build up and destroy by burning constantly and will be a not small burden for calculator of be the server of Web. The next in order, the JSP is specialized to develop but design for the Web of, its purpose is for building up according to the Web applied procedure, included the norm and the tool of a the whole set. Use the technique of JSP can combine a lot of JSP pages to become a Web application procedure very expediently.JSP的技术发展历史作者：Kathy Sierra and Bert Bates来源：Servlet&JSPJava Server Pages(JSP)是一种基于web的脚本编程技术，类似于网景公司的服务器端Java脚本语言——server-side JavaScript(SSJS)和微软的Active Server Pages(ASP)。
软件工程本科毕业外文文献翻译资料
软件工程本科毕业外文文献翻译学校代码：10128本科毕业设计外文文献翻译二〇一五年一月The Test Library Management System ofFramework Based on SSHThe application system features in small or medium-sized enterprise lie in the greater flexibility and safety high performance-price ratio. Traditional J2EE framework can not adapt to these needs, but the system a pplication based on SSH(Struts+Spring+Hibernate) technology can better satisfy such needs. This paper analyses some integration theory and key technologies about SSH, and according to the integration constructs a lightweight WEB framework, which has integrated the three kinds of technology ,forming the lightweight WEB framework bas ed on SSH and gaining good effects in practical applications.IntroductionGenerally the J2EE platform[27] used in large enterprise applications, can well s olve the application of reliability, safety and stability, but its weakness is the price hig h and the constructing cycle is long. Corresponding to the small or medium enterprise applications, the replace approach is the system framework of lightweight WEB, inclu ding the more commonly used methods which are based on the Struts and Hibernate. With the wide application of Spring, the three technology combination may be a bette r choice as a lightweight WEB framework. It uses layered structure and provides a go od integrated framework for Web applications at all levels in minimizing the Interlaye r coupling and increasing the efficiency of development. This framework can solve a l ot of problems, with good maintainability and scalability. It can solve the separation o f user interface and business logic separation, the separation of business logic and data base operation and the correct procedure control logic, etc. This paper studies the tech nology and principle of Struts and Spring and Hibernate, presenting a proved lightwei ght WEB application framework for enterprise.Hierarchical Web MechanismHierarchical Web framework including the user presentation layer, business logi clayer, data persistence layer ,expansion layer etc, each layer for different function, re spectively to finish the whole application. The whole system are divided into differentlogic module with relatively independent and mutual, and each module can be imple mented according to different design. It can realize the system parallel development, r apid integration, good maintainability, scalability.Struts MVC FrameworkTo ensure the reuse and efficiency of development process, adopting J2EE techn ology to build the Web application must select a system framework which has a good performance . Only in this way can we ensure not wasting lots of time because of adju sting configuration and achieve application development efficiently and quickly. So, p rogrammers in the course of practice got some successful development pattern which proved practical, such as MVC and O/R mapping, etc; many technologies, including S truts and Hibernate frameworks, realized these pattern. However, Struts framework on ly settled the separation problem between view layer and business logic layer, control layer, did not provide a flexible support for complex data saving process. On the contr ary, Hibernate framework offered the powerful and flexible support for complex data saving process. Therefore, how to integrate two frameworks and get a flexible, low-coupling solutions project which is easy to maintain for information system, is a resea rch task which the engineering staff is studying constantly.Model-View-Controller (MVC) is a popular design pattern. It divides the interactive system in three components and each of them specializes in one task. The model contains the applica tion data and manages the core functionality. The visual display of the model and the f eedback to the users are managed by the view. The controller not only interprets the in puts from the user, but also dominates the model and the view to change appropriately . MVC separates the system functionality from the system interface so as to enhance t he system scalability and maintainability. Struts is a typical MVC frame[32], and it also contains the three aforementioned components. The model level is composed of J avaBean and EJB components. The controller is realized by action and ActionServlet, and the view layer consists of JSP files. The central controller controls the action exec ution that receives a request and redirects this request to the appropriate module contr oller. Subsequently, the module controller processes the request and returns results tothe central controller using a JavaBean object, which stores any object to be presented in the view layer by including an indication to module views that must be presented. The central controller redirects the returned JavaBean object to the main view that dis plays its information.Spring Framework technologySpring is a lightweight J2EE application development framework, which uses the model of Inversion of Control(IoC) to separate the actual application from the Config uration and dependent regulations of the application. Committed to J2EE application a t all levels of the solution, Spring is not attempting to replace the existing framework, but rather “welding” the object of J2EE application at all levels together through the P OJO management. In addition, developers are free to choose Spring framework for so me or all, since Spring modules are not totally dependent.As a major business-level detail, Spring employs the idea of delay injection to assemble code for the sake o f improving the scalability and flexibility of built systems. Thus, the systems achieve a centralized business processing and reduction of code reuse through the Spring AOP module.Hibernate Persistent FrameworkHibernate is a kind of open source framework with DAO design patterns to achie ve mapping(O/R Mapping) between object and relational database.During the Web system development, the tradition approach directly interacts wi th the database by JDBC .However, this method has not only heavy workload but also complex SQL codes of JDBC which need to revise because the business logic sli ghtly changes. So, whatever development or maintain system are inconvenient. Consi dering the large difference between the object-oriented relation of java and the structure of relational database, it is necessary to intro duce a direct mapping mechanism between the object and database, which this kind of mapping should use configuration files as soon as possibility, so that mapping files w ill need modifying rather than java source codes when the business logic changes in the future. Therefore, O/R mapping pattern emerges, which hibernate is one of the most outstanding realization of architecture.It encapsulates JDBC with lightweight , making Java programmer operate a relati onal database with the object oriented programming thinking. It is a a implementation technology in the lasting layer. Compared to other lasting layer technology such as JD BC, EJB, JDO, Hibernate is easy to grasp and more in line with the object-oriented programming thinking. Hibernate own a query language (HQL), which is full y object-oriented. The basic structure in its application as shown in figure6.1.Hibernate is a data persistence framework, and the core technology is the object / relational database mapping(ORM). Hibernate is generally considered as a bridge bet ween Java applications and the relational database, owing to providing durable data se rvices for applications and allowing developers to use an object-oriented approach to the management and manipulation of relational database. Further more, it furnishes an object-oriented query language-HQL.Responsible for the mapping between the major categories of Java and the relatio nal database, Hibernate is essentially a middle ware providing database services. It su pplies durable data services for applications by utilizing databases and several profiles , such as hibernate properties and XML Mapping etc..Web services technologiesThe introduction of annotations into Java EE 5 makes it simple to create sophisticated Web service endpoints and clients with less code and a shorter learning curve than was possible with earlier Java EE versions. Annotations — first introduced in Java SE 5 — are modifiers you can add to your code as metadata. They don't affect program semantics directly, but the compiler, development tools, and runtime libraries can process them to produce additional Java language source files, XML documents, or other artifacts and behavior that augment the code containing the annotations (see Resources). Later in the article, you'll see how you can easily turn a regular Java class into a Web service by adding simple annotations.Web application technologiesJava EE 5 welcomes two major pieces of front-end technology — JSF and JSTL — into the specification to join the existing JavaServer Pages and Servlet specifications. JSF is a set of APIs that enable a component-based approach to user-interface development. JSTL is a set of tag libraries that support embedding procedural logic, access to JavaBeans, SQL commands, localized formatting instructions, and XML processing in JSPs. The most recent releases of JSF, JSTL, and JSP support a unified expression language (EL) that allows these technologies to integrate more easily (see Resources).The cornerstone of Web services support in Java EE 5 is JAX-WS 2.0, which is a follow-on to JAX-RPC 1.1. Both of these technologies let you create RESTful and SOAP-based Web services without dealing directly with the tedium of XML processing and data binding inherent to Web services. Developers are free to continue using JAX-RPC (which is still required of Java EE 5 containers), but migrating to JAX-WS is strongly recommended. Newcomers to Java Web services might as well skip JAX-RPC and head right for JAX-WS. That said, it's good to know that both of them support SOAP 1.1 over HTTP 1.1 and so are fully compatible: a JAX-WS Web services client can access a JAX-RPC Web services endpoint, and vice versa.The advantages of JAX-WS over JAX-RPC are compelling. JAX-WS:•Supports the SOAP 1.2 standard (in addition to SOAP 1.1).•Supports XML over HTTP. You can bypass SOAP if you wish. (See the article "Use XML directly over HTTP for Web services (where appropriate)"for more information.)•Uses the Java Architecture for XML Binding (JAXB) for its data-mapping model. JAXB has complete support for XML schema and betterperformance (more on that in a moment).•Introduces a dynamic programming model for both server and client.The client model supports both a message-oriented and an asynchronous approach.•Supports Message Transmission Optimization Mechanism (MTOM), a W3C recommendation for optimizing the transmission and format of a SOAP message.•Upgrades Web services interoperability (WS-I) support. (It supports Basic Profile 1.1; JAX-WS supports only Basic Profile 1.0.)•Upgrades SOAP attachment support. (It uses the SOAP with Attachments API for Java [SAAJ] 1.3; JAX-WS supports only SAAJ 1.2.)•You can learn more about the differences by reading the article "JAX-RPC versus JAX-WS."The wsimport tool in JAX-WS automatically handles many of the mundane details of Web service development and integrates easily into a build processes in a cross-platform manner, freeing you to focus on the application logic that implements or uses a service. It generates artifacts such as services, service endpoint interfaces (SEIs), asynchronous response code, exceptions based on WSDL faults, and Java classes bound to schema types by JAXB.JAX-WS also enables high-performing Web services. See Resources for a link to an article ("Implementing High Performance Web Services Using JAX-WS 2.0") presenting a benchmark study of equivalent Web service implementations based on the new JAX-WS stack (which uses two other Web services features in Java EE 5 —JAXB and StAX) and a JAX-RPC stack available in J2EE 1.4. The study found 40% to 1000% performance increases with JAX-WS in various functional areas under different loads.ConclusionEach framework has its advantages and disadvantages .Lightweight J2EE struct ure integrates Struts and Hibernate and Spring technology, making full use the powerf ul data processing function of Struts and the management flexible of Spring and the m ature of Hibernate. According to the practice, putting forward an open-source solutions suitable for small or medium-sized enterprise application of. The application system based on this architecture tech nology development has interlayer loose coupling ,structure distinctly, short develop ment cycle, maintainability. In addition, combined with commercial project developm ent, the solution has achieved good effect. The lightweight framework makes the paral lel development and maintenance for commercial system convenience, and can push f orward become other industry business system development.Through research and practice, we can easily find that Struts / Spring / Hiberna te framework utilizes Struts maturity in the presentation layer, flexibility of Spring bu siness management and convenience of Hibernate in the serialization layer, three kind s of framework integrated into a whole so that the development and maintenance beca me more convenient and handy. This kind of approach also will play a key role if appl ying other business system. Of course ,how to optimize system performance, enhance the user's access speed, improve security ability of system framework ,all of these wor ks, are need to do for author in the further.基于SSH框架实现的试题库管理系统小型或者中型企业的应用系统具有非常好的灵活性、安全性以及高性价比，传统的J2EE架构满足不了这些需求，但是基于SSH框架实现的应用系统更好的满足了这样的需求，这篇文章分析了关于SSH的一体化理论和关键技术，通过这些集成形成了轻量级Web框架，在已经集成三种技术的基础上，伴随形成了基于SSH的轻量级Web 框架，并且在实际应用中有着重要作用。
(完整版)软件工程专业_毕业设计外文文献翻译_
（二〇一三年六月A HISTORICAL PERSPECTIVEFrom the earliest days of computers, storing and manipulating data a major application focus. The first general-purpose DBMS was designed by Charles Bachman at General Electric in the early 1960s and was called the Integrated Data Store. It formed the basis for the network data model, which was standardized by the Conference on Data Systems Languages (CODASYL) and strongly influenced database systems through the 1960s. Bachman was the fi rst recipient of ACM’s Turing Award (the computer science equivalent of a Nobel prize) for work in the database area; 1973. In the late 1960s, IBM developed the Information Management System (IMS) DBMS, used even today in many major installations. IMS formed the basis for an alternative data representation framework called the Airlines and IBM around the same time, and it allowed several people to access the same data through computer network. Interestingly, today the same SABRE system is used to power popular Web-based travel services such as Travelocity!In 1970, Edgar Codd, at IBM’s San Jose Research Laboratory, proposed a new data representation framework called the relational data model. This proved to be a watershed in the development of database systems: it sparked rapid development of several DBMSs based on the relational model, along with a rich body of theoretical results that placed the field on a firm foundation. Codd won the 1981 Turing Award for academic discipline, and the popularity of relational DBMSs changed thecommercial landscape. Their benefits were widely recognized, and the use of DBMSs for managing corporate data became standard practice.In the 1980s, the relational model consolidated its position as the dominant DBMS paradigm, and database systems continued to gain widespread use. The SQL query language for relational databases, developed as part of IBM’s System R project, is now the standard query language. SQL was standardized in the late 1980s, and the current standard, SQL-92, was adopted by the American National Standards Institute (ANSI) and International Standards Organization (ISO). Arguably, the most widely used form of concurrent programming is the concurrent execution of database programs (called transactions). Users write programs as if they are to be run by themselves, and the responsibility for running them concurrently is given to the DBMS. James Gray won the 1999 Turing award for management in a DBMS.In the late 1980s and the 1990s, advances made in many areas of database systems. Considerable research carried out into more powerful query languages and richer data models, and there a big emphasis on supporting complex analysis of data from all parts of an enterprise. Several vendors (e.g., IBM’s DB2, Oracle 8, Informix UDS) developed by numerous vendors for creating data warehouses, consolidating data from several databases, and for carrying out specialized analysis.An interesting phenomenon is the emergence of several enterprise resource planning(ERP) and management resource planning (MRP) packages, which add a substantial layer of application-oriented features on top of a DBMS. Widely used packages include systems from Baan, Oracle,PeopleSoft, SAP, and Siebel. These packages identify a set of common tasks (e.g., inventory management, resources planning, financial analysis) encountered by a large number of organizations and provide a general application layer to carry out these tasks. The data is stored in a relational DBMS, and the application layer can be customized to different companies, leading to lower Introduction to Database Systems overall costs for the companies, compared to the cost of building the application layer from scratch. Most significantly, perhaps, DBMSs of Web sites stored their data exclusively in operating systems files, the use of a DBMS to store data that is accessed through a Web browser is becoming widespread. Queries are generated through Web-accessible forms and answers are formatted using a markup language such as HTML, in order to be easily displayed in a browser. All the database vendors are adding features to their DBMS aimed at making it more suitable for deployment over the Internet. Database management continues to gain importance as more and more data is brought on-line, and made ever more accessible through computer networking. Today the field is being driven by exciting visions such as multimedia databases, interactive video, digital libraries, a genome mapping effort and NASA’s Earth Observation System project,and the desire of companies to consolidate their decision-making processes and mine their data repositories for useful information about their businesses. Commercially, database manage- ment systems represent one of the largest and most vigorous market segments. Thusthes- tudy of database systems could prove to be richly rewarding in more ways than one!INTRODUCTION TO PHYSICAL DATABASEDESIGNLike all other aspects of database design, physical design must be guided by the nature of the data and its intended use. In particular, it is important to understand the typical workload that the database must support; the workload consists of a mix of queries and updates. Users also requirements about queries or updates must run or and users’ performance requirements are the basis on which a number of decisions .To create a good physical database design and to tune the system for performance in response to evolving user requirements, the designer needs to understand the workings of a DBMS, especially the indexing and query processing techniques supported by the DBMS. If the database is expected to be accessed concurrently by many users, or is a distributed database, the task becomes more complicated, and other features of a DBMS come into play.DATABASE WORKLOADSThe key to good physical design is arriving at an accurate description of the expected workload. A workload description includes the following elements:1. A list of queries and their frequencies, as a fraction of all queries and updates.2. A list of updates and their frequencies.3. Performance goals for each type of query and update.For each query in the workload, we must identify:Which relations are accessed.Which attributes are retained (in the SELECT clause).Which attributes or join conditions expressed on them (in the WHERE clause) and the workload, we must identify:Which attributes or join conditions expressed on them (in the WHERE clause) and .For UPDATE commands, the fields that are modified by the update.Remember that queries and updates typically involves a particular account number. The values of these parameters determine selectivity of selection and join conditions.Updates benefit from a good physical design and the presence of indexes. On the other indexes on the attributes that they modify. Thus, while queries can only benefit from the presence of an index, an index may either speed up or slow down a given update. Designers should keep this trade-offer in mind when creating indexes.NEED FOR DATABASE TUNINGAccurate, detailed workload information may be of the system. Consequently, tuning a database after it designed and deployed is important—we must refine the initial design in the light of actual usage patterns to obtain the best possible performance.The distinction between database design and database tuning is somewhat arbitrary.We could consider the design process to be over once an initial conceptual schema is designed and a set of indexing and clustering decisions is made. Any subsequent changes to the conceptual schema or the indexes, say, would then be regarded as a tuning activity. Alternatively, we could consider some refinement of the conceptual schema (and physical design decisions affected by this refinement) to be part of the physical design process.Where we draw the line between design and tuning is not very important.OVERVIEW OF DATABASE TUNINGAfter the initial phase of database design, actual use of the database provides a valuable source of detailed information that can be used to refine the initial design. Many of the original assumptions about the expected workload can be replaced by observed usage patterns; in general, some of the initial workload specification will be validated, and some of it will turn out to be wrong. Initial guesses about the size of data can be replaced with actual statistics from the system catalogs (although this information will keep changing as the system evolves). Careful monitoring of queries can reveal unexpected problems; for example, the optimizer may not be using some indexes as intended to produce good plans.Continued database tuning is important to get the best possibleperformance.TUNING THE CONCEPTUAL SCHEMAIn the course of database design, we may realize that our current choice of relation schemas does not enable us meet our performance objectives for the given workload with any (feasible) set of physical design choices. If so, we may our conceptual schema (and re-examine physical design decisions that are affected by the changes that we make).We may realize that a redesign is necessary during the initial design process or later, after the system in use for a while. Once a database designed and populated with data, changing the conceptual schema requires a significant effort in terms of mapping the contents of relations that are affected. Nonetheless, it may sometimes be necessary to revise the conceptual schema in light of experience with the system. We now consider the issues involved in conceptual schema (re)design from the point of view of performance.Several options must be considered while tuning the conceptual schema:We may decide to settle for a 3NF design instead of a BCNF design.If there are two ways to decompose a given schema into 3NF or BCNF, our choice should be guided by the workload.Sometimes we might decide to further decompose a relation that is already in BCNF.In other situations we might denormalize. That is, we might choose toreplace a collection of relations obtained by a decomposition from a larger relation with the original (larger) relation, even though it suffers from some redundancy problems. Alternatively, we might choose to add some fields to certain relations to speed up some important queries, even if this leads to a redundant storage of some information (and consequently, a schema that is in neither 3NF nor BCNF).This discussion of normalization the technique of decomposition, which amounts to vertical partitioning of a relation. Another technique to consider is , which would lead to our ; rather, we want to create two distinct relations (possibly with different constraints and indexes on each).Incidentally, when we redesign the conceptual schema, especially if we are tuning an existing database schema, it is worth considering whether we should create views to mask these changes from users for whom the original schema is more natural.TUNING QUERIES AND VIEWSIf we notice that a query is running much slower than we expected, we conjunction with some index tuning, can often ?x the problem. Similar tuning may be called for if queries on some view run slower than expected.When tuning a query, the first thing to verify is that the system is using the plan that you expect it to use. It may be that the system is not finding the best plan for a variety of reasons. Some common situations that are not condition involving null values.Selection conditions involving arithmetic or string expressions orconditions using the or connective. For example, if we E.age = 2*D.age in the WHERE clause, the optimizer may correctly utilize an available index on E.age but fail to utilize an available index on D.age. Replacing the condition by E.age2=D.age would reverse the situation.Inability to recognize a sophisticated plan such as an index-only scan for an aggregation query involving a GROUP BY clause.If the optimizer is not smart enough to and the best plan (using access methods and evaluation strategies supported by the DBMS), some systems allow users to guide the choice of a plan by providing order and join method. A user who wishes to guide optimization in this manner should and the capabilities of the given DBMS.(8)OTHER TOPICSMOBILE DATABASESThe availability of portable computers and wireless communications many components of a DBMS, including the query engine, transaction manager, and recovery manager.Users are connected through a wireless link whose bandwidth is ten times less than Ethernet and 100 times less than ATM networks. Communication costs are therefore significantly proportion to IO and CPU costs.Users’ locati ons are constantly changing, and mobile computers costs is connection time and battery usage in addition to bytes transferred, and change constantly depending on location. Data is frequently replicated to minimize the cost of accessing it from different locations.As a user moves around, data could be accessed from multipledatabase servers within a single transaction. The likelihood of losing connections is also much greater than in a traditional network. Centralized transaction management may therefore be impractical, especially if some data is resident at the mobile computers. We may in fact ACID transactions and develop alternative notions of consistency for user programs.MAIN MEMORY DATABASESThe price of main memory is now low enough that we can buy enough main memory to CPUs also memory. This shift prompts a reexamination of some basic DBMS design decisions, since disk accesses no longer dominate processing time for a memory-resident database: Main memory does not survive system crashes, and so we still atomicity and durability. Log records must be written to stable storage at commit time, and this process could become a bottleneck. To minimize this problem, rather than commit each transaction as it completes, we can collect completed transactions and commit them in batches; this is called group commit. Recovery algorithms can also be optimized since pages rarely out to make room for other pages.The implementation of in-memory operations must be considered while optimizing queries, namely the amount of space required to execute a plan. It is important to minimize the space overhead because exceeding available physical memory would lead to swapping pages to disk (through the operating system’s virtual memory mechanisms), greatly slowing down execution.Page-oriented data structures become less important (since pages areno longer the unit of data retrieval), and clustering is not important (since the cost of accessing any region of main memory is uniform).（一）从历史的角度回顾从数据库的早期开始，存储和操纵数据就一直是主要的应用焦点。
软件开发毕业设计—英文论文
Struts, an open-source MVC implementationIntroductionKids in grade school put HTML pages on the Internet. However, there is a monumental difference between a grade school page and a professionally developed Web site. The page designer (or HTML developer) must understand colors, the customer, product flow, page layout, browser compatibility, image creation, JavaScript, and more. Putting a great looking site together takes a lot of work, and most Java developers are more interested in creating a great looking object interface than a user interface. JavaServer Pages (JSP) technology provides the glue between the page designer and the Java developer.If you have worked on a large-scale Web application, you understand theterm change. Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface from business logic and data. Struts is an MVC implementation that uses Servlets 2.2 and JSP 1.1 tags, from the J2EE specifications, as part of the implementation. You may never implement a system with Struts, but looking at Struts may give you some ideas on your future Servlets and JSP implementations.In this article, I will begin with a JSP file that uses elements you may be familiar with and discuss the pros and cons of such a page. I will then cover Struts and how it can control change in your Web project and promote specialization. Finally, I willre-develop the simple JSP file with the page designer and change in mind.A JSP file is a Java servletA JavaServer Page (JSP) file is nothing more than another way to view a servlet. The concept of a JSP file is to allow us to see a Java servlet as an HTML page. This view eliminates all of the ugly print() statements that normally show up in Java code. The JSP file is pre-processed into a .java file, then compiled into a .class. If you are using Tomcat, you can view your pre-processed.java files in the work directory. Other containers may store the .java and .class files elsewhere; the location is container specific. Figure 1 demonstrates the JSP file-to-servlet flow.Figure 1. JSP file-to-servlet flow(This is significantly different from a Microsoft Active Server Page (ASP). An ASP is compiled into memory, not into a separate file.)The simple self-contained JSP fileIn a small JSP application, it is common to see the data, business logic, and the user interface combined into one module of code. In addition, the application generally contains the logic that controls the flow of the application. Listing 1 and Figure 2 demonstrate a simple JSP file that allows a user to join a mailing list.Listing 1. join.jsp -- a simple request and response JSP file<%@ page language="java" %><%@ page import="business.util.Validation" %><%@ page import="business.db.MailingList" %><%String error = "";String email = request.getParameter("email");// do we have an email addressif( email!=null ) {// validate input...if( business.util.Validation.isValidEmail(email) ) {// store input...try {business.db.MailingList.AddEmail(email);} catch (Exception e) {error = "Error adding email address to system. " + e;}if( error.length()==0 ) {%>// redirect to welcome page...<jsp:forward page="welcome.html"/><%}} else {// set error message and redisplay pageerror = email + " is not a valid email address, please try again.";Figure 2. In a simple request and response, the JSP file sets the data, controls the flow to the next page, and creates the HTMLThe mailing list JSP file is a self-contained, do-it-all module. The only things not contained in the JSP file are the actual code for validation that is containedin isValidEmail() and the code that puts the e-mail address in the database. (Separating theisValidEmail() method into reusable code might seem like an obvious thing to do, but I have seen the code for isValidEmail()embedded directly into the page.) The advantage of the single-page approach is that it is easy to understand and initially easy to build. In addition, with all the graphical development tools, it is easy to get started.Activities of join.jsp1.Display opening input page.2.Read the email value from the form parameter.3.Validate the email address.4.If email address is valid:o Add the address to the database.o Redirect to the next page.5.If email address is invalid:o Set an error message.o Redisplay join.jsp with the error message.Consequences of the single-page approach∙Heavy HTML and Java couplingThe coder of the JSP file must be both a page designer and a Java developer.The result is often either terrible Java code or an ugly page, or sometimesboth.∙Java and JavaScript blurAs the pages become larger, there can be a tendency to implement someJavaScript. When the JavaScript appears in a page, the script can get confused with the Java code. An example of a possible point of confusion is usingclient-side JavaScript to validate the email field.∙Embedded flow logicTo understand the entire flow of the application, you have to navigate all ofthe pages. Imagine the spaghetti logic on a 100-page Web site.∙Debugging difficultiesIn addition to being ugly to look at, HTML tags, Java code, and JavaScript code all in one page makes it difficult to debug problems.∙Tight couplingChanges to business logic or data means possibly touching every pageinvolved.∙AestheticsVisually, in large pages, this type of coding looks messy. When I was doingMicrosoft ASP development, I would commonly see 1000-line pages. Evenwith syntax coloring, it was still difficult to read and understand.No more Java code in my HTML, pleaseIn Listing 1, instead of having a lot of HTML in Java code, I have a lot of Java code in an HTML file. From this standpoint, I really have not accomplished much, other than permit page designers to write Java code. However, all is not lost; with JSP 1.1, we got a new feature called tags.A JSP tag is simply a way of abstracting out code from a JSP file. Some people think of JSP tags as macros for JSP files, where the code for the tag is contained in the servlet. (The macro perspective is almost true.) For the same reason I do not want to see HTML tags in Java code, I do not want to see Java code in a JSP file. The entire point of JSP technology is to allow the page designer to create servlets without being distracted with Java code. Tags allow Java programmers to extend JSP files by making Java code look like HTML. Figure 3 displays the general concept of pulling the code from the JSP page and putting into a JSP tag.Figure 3. JSP tagAn example of Struts tag capability is in Listing 2. In Listing 2, the normalHTML <form> tag is replaced with the Struts <form:form>tag. Listing 3 shows the resulting HTML that the browser receives. The browser gets the HTML <form> tag, but with additional code, such as the JavaScript. The additional JavaScript sets the focus on the email address field. The server side <form:form>tag code created the appropriate HTML and abstracts the JavaScript away from the page designer.Notes about JSP tags:∙JSP tags require a container that runs JSP 1.1 or later.∙JSP tags run on the server and are not interpreted by the client like HTML tags are.∙JSP tags provide proper code re-use.∙HTML and JavaScript can be added to pages using a JSP mechanism called include. However, developers have a tendency to create hugeJavaScript library files, and these libraries are included into the JSP file. Theresult is a much larger than necessary HTML page returned to the client. Theproper use of include is for HTML snippets for such things as page headersand footers.∙By abstracting out the Java code, JSP tags have promoted specialization of development roles.Model-View-Controller (MVC)JSP tags solved only part of our problem. We still have issues with validation, flow control, and updating the state of the application. This is where MVC comes to the rescue. MVC helps resolve some of the issues with the single module approach by dividing the problem into three categories:∙ModelThe model contains the core of the application's functionality. The modelencapsulates the state of the application. Sometimes the only functionality it contains is state. It knows nothing about the view or controller.∙ViewThe view provides the presentation of the model. It is the look of theapplication. The view can access the model getters, but it has no knowledgeof the setters. In addition, it knows nothing about the controller. The viewshould be notified when changes to the model occur.∙ControllerThe controller reacts to the user input. It creates and sets the model.MVC Model 2The Web brought some unique challenges to software developers, most notably the stateless connection between the client and the server. This stateless behavior made it difficult for the model to notify the view of changes. On the Web, thebrowser has to re-query the server to discover modification to the state of the application.Another noticeable change is that the view uses different technology for implementation than the model or controller. Of course, we could use Java (or PERL, C/C++ or what ever) code to generate HTML. There are several disadvantages to that approach:∙Java programmers should develop services, not HTML.∙Changes to layout would require changes to code.∙Customers of the service should be able to create pages to meet their specific needs.∙The page designer isn't able to have direct involvement in page development.∙HTML embedded into code is ugly.For the Web, the classical form of MVC needed to change. Figure 4 displays the Web adaptation of MVC, also commonly known as MVC Model 2 or MVC 2.Struts detailsDisplayed in Figure 6 is a stripped-down UML diagram ofthe org.apache.struts.action package. Figure 6 shows the minimal relationships among ActionServlet (Controller), ActionForm (Form State), and Action (Model Wrapper).Figure 6. UML diagram of the relationship of the Command (ActionServlet) to the Model (Action & ActionForm)The ActionServlet classDo you remember the days of function mappings? You would map some input event to a pointer to a function. If you where slick, you would place the configuration information into a file and load the file at run time. Function pointer arrays were the good old days of structured programming in C.Life is better now that we have Java technology, XML, J2EE, and all that. The Struts Controller is a servlet that maps events (an event generally being an HTTP post) to classes. And guess what -- the Controller uses a configuration file so you don_t have to hard-code the values. Life changes, but stays the same.ActionServlet is the Command part of the MVC implementation and is the core ofthe Framework. ActionServlet (Command) creates and uses Action, an ActionForm, and ActionForward. As mentioned earlier, the struts-config.xml file configures the Command. During the creation of the Web project, Action and ActionForm are extended to solve the specific problem space. Thefile struts-config.xml instructs ActionServlet on how to use the extended classes. There are several advantages to this approach:∙The entire logical flow of the application is in a hierarchical text file. This makes it easier to view and understand, especially with large applications.∙The page designer does not have to wade through Java code to understand the flow of the application.∙The Java developer does not need to recompile code when making flow changes.Command functionality can be added by extending ActionServlet.The ActionForm classActionForm maintains the session state for the Web application. ActionForm is an abstract class that is sub-classed for each input form model. When I say input form model, I am saying ActionForm represents a general concept of data that is set or updated by a HTML form. For instance, you may have a UserActionForm that is set by an HTML Form. The Struts framework will:∙Check to see if a UserActionForm exists; if not, it will create an instance of the class.∙Struts will set the state of the UserActionForm using corresponding fields from the HttpServletRequest. No more dreadfulrequest.getParameter() calls.For instance, the Struts framework will take fname from request stream andcallUserActionForm.setFname().∙The Struts framework updates the state of the UserActionForm before passing it to the business wrapper UserAction.∙Before passing it to the Action class, Struts will also conduct form state validation by calling the validation() method onUserActionForm. Note: This is not always wise to do. There might be ways of using UserActionForm in other pages or business objects, where the validation might be different. Validation of the state might be better in the UserAction class.∙The UserActionForm can be maintained at a session level.Notes:∙The struts-config.xml file controls which HTML form request maps to which ActionForm.∙Multiple requests can be mapped UserActionForm.∙UserActionForm can be mapped over multiple pages for things such as wizards.The Action classThe Action class is a wrapper around the business logic. The purpose of Action class is to translate the HttpServletRequest to the business logic. To use Action, subclass and overwrite the process() method.The ActionServlet (Command) passes the parameterized classesto ActionForm using the perform() method. Again, no moredreadful request.getParameter() calls. By the time the event gets here, the input form data (or HTML form data) has already been translated out of the request stream and into an ActionForm class.Figure 4. MVC Model 2Struts, an MVC 2 implementationStruts is a set of cooperating classes, servlets, and JSP tags that make up a reusable MVC 2 design. This definition implies that Struts is a framework, rather than a library, but Struts also contains an extensive tag library and utility classes that work independently of the framework. Figure 5 displays an overview of Struts.Figure 5. Struts overviewStruts overview∙Client browserAn HTTP request from the client browser creates an event. The Webcontainer will respond with an HTTP response.∙ControllerThe Controller receives the request from the browser, and makes thedecision where to send the request. With Struts, the Controller is a command design pattern implemented as a servlet. The struts-config.xml file configures the Controller.∙Business logicThe business logic updates the state of the model and helps control the flowof the application. With Struts this is done with an Action class as a thinwrapper to the actual business logic.∙Model stateThe model represents the state of the application. The business objectsupdate the application state. ActionForm bean represents the Model state ata session or request level, and not at a persistent level. The JSP file readsinformation from the ActionForm bean using JSP tags.∙ViewThe view is simply a JSP file. There is no flow logic, no business logic, and nomodel information -- just tags. Tags are one of the things that make Strutsunique compared to other frameworks like Velocity.Note: "Think thin" when extending the Action class. The Action class should control the flow and not the logic of the application. By placing the business logic in a separate package or EJB, we allow flexibility and reuse.Another way of thinking about Action class is as the Adapter design pattern. The purpose of the Action is to "Convert the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn_t otherwise because of incompatibility interface" (from Design Patterns - Elements of Reusable OO Software by Gof). The client in this instance is theActionServlet that knows nothing about our specific business class interface. Therefore, Struts provides a business interface it does understand, Action. By extending the Action, we make our business interface compatible with Struts business interface. (An interesting observation is that Action is a class and not an interface. Action started as an interface and changed into a class over time. Nothing's perfect.)The Error classesThe UML diagram (Figure 6) alsoincluded ActionError and ActionErrors. ActionError encapsulates an individual error message. ActionErrors is a container of ActionError classes that the View can access using tags. ActionErrors is Struts way of keeping up with a list of errors.Figure 7. UML diagram of the relationship of the Command (ActionServlet) to the Model (Action)The ActionMapping classAn incoming event is normally in the form of an HTTP request, which the servlet Container turns into an HttpServletRequest. The Controller looks at the incoming event and dispatches the request to an Action class.The struts-config.xml determines whatAction class the Controller calls.The struts-config.xml configuration information is translated into a setof ActionMapping, which are put into container of ActionMappings. (If you have not noticed it, classes that end with s are containers)The ActionMapping contains the knowledge of how a specific event maps to specific Actions. The ActionServlet (Command) passes the ActionMapping tothe Action class via the perform() method. This allows Action to access the information to control flow.ActionMappingsActionMappings is a collection of ActionMapping objects.Struts，MVC 的一种开放源码实现简介小学生也可以在因特网上发布 HTML 网页。
软件开发中英文对照外文翻译文献
软件开发中英文对照外文翻译文献(文档含英文原文和中文翻译)译文：仿真软件开发低大型复杂腔基于UG的二次开发摘要---射击和弹跳射线(SBR)二次开发的基础软件是由国标库(UG)。
射线跟踪的核心算法是基于优化的非均匀有理b样(NURBS)曲线表面相交算法建立在UG,导致非常高的射线路径跟踪的准确性没有啮合从而保持原有的空腔模型的准确性。
它也是有效的避免同任何复杂的蛀牙,因为即使工作屏蔽的过程。
两腔的几何建模及其散射模拟成一个统一的平台,形成一个易用的综合和环球环境电磁建模复杂的蛀牙。
在本文开发的软件对复杂腔散射建模引入了一些数值结果显示的准确性和效率关键词--电大型复杂cavit; 雷达截面; UG的二次开发; 射击和弹跳射线(SBR); 射线跟踪I.介绍雷达截面(RCS)的分析电等大型复杂洞进口或出口,双面或三面角反射器等,是计算电磁学中最重要的主题之一。
低大型复杂的空腔结构,只有基于高频方法如射击和弹跳射线(SBR)[1][2][3]是合适的。
传统上,为三步骤采用SBR首先,模型腔的CAD软件和网格表面的内墙,然后出口信息网格的结果;其次发现表面上的光线的反射点ray-surface十字路口和屏蔽计算;最后计算RCS即将离任的射线从腔。
虽然这些网基于射线跟踪可用于任意形状的蛀牙从理论上讲,它有不准确的缺点路径建立在复杂的蛀牙导致贫穷的RCS计算精度。
电大型复杂的蛀牙,射线跟踪的效率很低,由于分离腔建模与RCS计算复杂的仿真过程。
为了解决这些问题, 一个强大的CAD软件,模拟电大型复杂腔并计算其RCS在同一平台。
开发的软件具有以下优势: 1)腔建模和RCS计算在UG集成,因此仿真过程大大简化。
2)表面啮合没有必要而射线可以追踪精度高和效率在任何任意形状的空腔。
3)开发的软件是通用的电磁散射的凹面反射镜结构,如蛀牙和角落。
小说射线追踪方法的新的先进的软件是基于UG的二次开发将讨论下一步,和RCS仿真结果。
软件系统开发中英文对照外文翻译文献
软件系统开发中英文对照外文翻译文献(文档含英文原文和中文翻译)软件工程中的过程处理模型斯卡基沃尔特摘要软件系统从起初的开发，维护，再到一个版本升级到另一个版本，经历了一系列阶段。
这篇文章归纳和整理了一些描述如何开发软件系统的方法。
从传统的软件生命周期的背景和定义出发，即大多数教科书所讨论的，并且目前的软件开发实践所遵循的软件生命周期，接着讨论作为目前软件工程技术基石的更全面的软件开发模型。
关键词：软件生命周期；模型；原型1 前言软件业的发展最早可追溯到开发大型软件项目的显式模型，那是在二十世纪五十年代和六十年代间。
总体而言，这些早期的软件生命周期模型的唯一目的就是提供一个合理的概念计划来管理软件系统的开发。
因此，这种计划可以作为一个基础规划，组织，人员配备，协调，预算编制，并指导软件开发活动。
自20世纪60年代，出现了许多经典的软件生命周期的描述（例如，霍西尔1961年，劳斯莱斯1970年，1976年博伊姆，迪斯塔索1980年，1984年斯卡基，萨默维尔1999年）。
罗伊斯（1970）使用现在生活中熟悉的“瀑布”图表，提出了周期的概念，这个图表概括了开发大型软件系统是多么的困难，因为它涉及复杂的工程任务，而这些任务在完成之前可能需要不断地返工。
这些图表也通常在介绍性发言中被采用，主要针对开发大型软件系统的人们（例如，定制软件的客户），他们可能不熟悉各种各样的技术问题但还是要必须解决这些问题。
这些经典的软件生命周期模型通常包括以下活动一些内容：系统启动/规划：系统从何而来？在大多数情况下，不论是现有的信息处理机制以前是自动的，手工的，还是非正式的，新系统都会取代或补充它们。
● 需求分析和说明书：阐述一个新的软件系统将要开发的问题：其业务能力，其所达到的性能特点，支持系统运行和维护所需的条件。
● 功能或原型说明：潜在确定计算的对象，它们的属性和关系，改变这些对象的操作，约束系统行为的限制等。
●划分与选择：给出需求和功能说明书，将系统分为可管理的模块，它们是逻辑子系统的标志，然后确定是否有对应于这些模块的新的，现有的，或可重复使用的软件系统可以复用。
计算机 软件工程 外文翻译 外文文献 英文文献
一、外文资料译文：Java开发2.0：使用Hibernate Shards 进行切分横向扩展的关系数据库Andrew Glover，作者兼开发人员，Beacon50摘要：Sharding并不适合所有网站，但它是一种能够满足大数据的需求方法。
对于一些商店来说，切分意味着可以保持一个受信任的RDBMS，同时不牺牲数据可伸缩性和系统性能。
在Java 开发 2.0系列的这一部分中，您可以了解到切分何时起作用，以及何时不起作用，然后开始着手对一个可以处理数TB 数据的简单应用程序进行切分。
日期：2010年8月31日级别：中级PDF格式：A4和信（64KB的15页）取得Adobe®Reader®软件当关系数据库试图在一个单一表中存储数TB 的数据时，总体性能通常会降低。
索引所有的数据读取，显然是很耗时的，而且其中有可能是写入，也可能是读出。
因为NoSQL 数据商店尤其适合存储大型数据，但是NoSQL 是一种非关系数据库方法。
对于倾向于使用ACID-ity 和实体结构关系数据库的开发人员及需要这种结构的项目来说，切分是一个令人振奋的选方法。
切分一个数据库分区的分支，不是在本机上的数据库技术，它发生在应用场面上。
在各种切分实现，Hibernate Shards 可能是Java™ 技术世界中最流行的。
这个漂亮的项目可以让您使用映射至逻辑数据库的POJO 对切分数据集进行几乎无缝操作。
当你使用Hibernate Shards 时，您不需要将你的POJO 特别映射至切分。
您可以像使用Hibernate 方法对任何常见关系数据库进行映射时一样对其进行映射。
Hibernate Shards 可以为您管理低级别的切分任务。
迄今为止，在这个系列，我用一个比赛和参赛者类推关系的简单域表现出不同的数据存储技术比喻为基础。
这个月，我将使用这个熟悉的例子，介绍一个实际的切分策略，然后在Hibernate实现它的碎片。
软件工程外文翻译文献
软件工程外文翻译文献(文档含中英文对照即英文原文和中文翻译)Software engineeringSoftware engineering is the study of the use of engineering methods to build and maintain effective, practical and high-quality software disciplines. It involves the programming language, database, software development tools, system platform, standards, design patterns and so on.In modern society, the software used in many ways. Typical software such as email, embedded systems, human-machine interface, office packages, operating systems, compilers, databases, games. Meanwhile, almost all the various sectors of computer software applications, such as industry, agriculture, banking, aviation and government departments. These applications facilitate the economic and social development,improve people's working efficiency, while improving the quality of life. Software engineers is to create software applications of people collectively, according to which software engineers can be divided into different areas of system analysts, software designers, system architects, programmers, testers and so on. It is also often used to refer to a variety of software engineers, programmers.OriginIn view of difficulties encountered in software development, North Atlantic Treaty Organization (NATO) in 1968 organized the first Conference on Software Engineering, and will be presented at the "software engineering" to define the knowledge required for software development, and suggested that "software development the activities of similar projects should be. " Software Engineering has formally proposed since 1968, this time to accumulate a large number of research results, widely lot of technical practice, academia and industry through the joint efforts of software engineering is gradually developing into a professional discipline.Definitioncreation and use of sound engineering principles in order to obtain reliable and economically efficient software.application of systematic, follow the principle can be measured approach to development, operation and maintenance of software; that is to beapplied to software engineering.The development, management and updating software products related to theories, methods and tools.A knowledge or discipline (discipline), aims to produce good quality, punctual delivery, within budget and meet users need software.the practical application of scientific knowledge in the design, build computer programs, and the accompanying documents produced, and the subsequent operation and maintenance.Use systematic production and maintenance of software products related to technology and management expertise to enable software development and changes in the limited time and under cost.Construction team of engineers developed the knowledge of large software systems disciplines.the software analysis, design, implementation and maintenance of a systematic method.the systematic application of tools and techniques in the development of computer-based applications.Software Engineering and Computer ScienceSoftware development in the end is a science or an engineering, this is a question to be debated for a long time. In fact, both the two characteristics of software development. But this does not mean that they can be confused with each other. Many people think that softwareengineering, computer science and information science-based as in the traditional sense of the physical and chemical engineering as. In the U.S., about 40% of software engineers with a degree in computer science. Elsewhere in the world, this ratio is also similar. They will not necessarily use every day knowledge of computer science, but every day they use the software engineering knowledge.For example, Peter McBreen that software "engineering" means higher degree of rigor and proven processes, not suitable for all types of software development stage. Peter McBreen in the book "Software Craftsmanship: The New Imperative" put forward the so-called "craftsmanship" of the argument, consider that a key factor in the success of software development, is to develop the skills, not "manufacturing" software process.Software engineering and computer programmingSoftware engineering exists in a variety of applications exist in all aspects of software development. The program design typically include program design and coding of the iterative process, it is a stage of software development.Software engineering, software project seeks to provide guidance in all aspects, from feasibility analysis software until the software after completion of maintenance work. Software engineering that software development and marketing activities are closely related. Such assoftware sales, user training, hardware and software associated with installation. Software engineering methodology that should not be an independent programmer from the team and to develop, and the program of preparation can not be divorced from the software requirements, design, and customer interests.Software engineering design of industrial development is the embodiment of a computer program.Software crisisSoftware engineering, rooted in the 20th century to the rise of 60,70 and 80 years of software crisis. At that time, many of the software have been a tragic final outcome. Many of the software development time significantly beyond the planned schedule. Some projects led to the loss of property, and even some of the software led to casualties. While software developers have found it increasingly difficult for software development.OS 360 operating system is considered to be a typical case. Until now, it is still used in the IBM360 series host. This experience for decades, even extremely complex software projects do not have a set of programs included in the original design of work systems. OS 360 is the first large software project, which uses about 1,000 programmers. Fred Brooks in his subsequent masterpiece, "The Mythical Man Month" (The Mythical Man-Month) in the once admitted that in his management of theproject, he made a million dollar mistake.Property losses: software error may result in significant property damage. European Ariane rocket explosion is one of the most painful lesson.Casualties: As computer software is widely used, including hospitals and other industries closely related to life. Therefore, the software error might also result in personal injury or death.Was used extensively in software engineering is the Therac-25 case of accidents. In 1985 between June and January 1987, six known medical errors from the Therac-25 to exceed the dose leads to death or severe radiation burns.In industry, some embedded systems do not lead to the normal operation of the machine, which will push some people into the woods. MethodologyThere are many ways software engineering aspects of meaning. Including project management, analysis, design, program preparation, testing and quality control.Software design methods can be distinguished as the heavyweight and lightweight methods. Heavyweight methods produce large amounts of official documentation.Heavyweight development methodologies, including the famous ISO 9000, CMM, and the Unified Process (RUP).Lightweight development process is not an official document of the large number of requirements. Lightweight methods, including well-known Extreme Programming (XP) and agile process (Agile Processes).According to the "new methodology" in this article, heavyweight method presented is a "defensive" posture. In the application of the "heavyweight methods" software organizations, due to a software project manager with little or no involvement in program design, can not grasp the item from the details of the progress of the project which will have a "fear", constantly had to ask the programmer to write a lot of "software development documentation." The lightweight methods are presented "aggressive" attitude, which is from the XP method is particularly emphasized four criteria - "communication, simplicity, feedback and courage" to be reflected on. There are some people that the "heavyweight method" is suitable for large software team (dozens or more) use, and "lightweight methods" for small software team (a few people, a dozen people) to use. Of course, on the heavyweight and lightweight method of approach has many advantages and disadvantages of debate, and various methods are constantly evolving.Some methodologists think that people should be strictly followed in the development and implementation of these methods. But some people do not have the conditions to implement these methods. In fact, themethod by which software development depends on many factors, but subject to environmental constraints.Software development processSoftware development process, with the subsequent development of technology evolution and improvement. From the early waterfall (Waterfall) development model to the subsequent emergence of the spiral iterative (Spiral) development, which recently began the rise of agile development methodologies (Agile), they showed a different era in the development process for software industry different awareness and understanding of different types of projects for the method.Note distinction between software development process and software process improvement important difference between. Such as ISO 15504, ISO 9000, CMM, CMMI such terms are elaborated in the framework of software process improvement, they provide a series of standards and policies to guide software organizations how to improve the quality of the software development process, the ability of software organizations, and not give a specific definition of the development process.Development of software engineering"Agile Development" (Agile Development) is considered an important software engineering development. It stressed that software development should be able to possible future changes and uncertaintiesof a comprehensive response.Agile development is considered a "lightweight" approach. In the lightweight approach should be the most prestigious "Extreme Programming" (Extreme Programming, referred to as XP).Correspond with the lightweight approach is the "heavyweight method" exists. Heavyweight approach emphasizes the development process as the center, rather than people-centered. Examples of methods such as heavyweight CMM / PSP / TSP.Aspect-oriented programming (Aspect Oriented Programming, referred to as the AOP) is considered to software engineering in recent years, another important development. This aspect refers to the completion of a function of a collection of objects and functions. In this regard the contents related to generic programming (Generic Programming) and templates.软件工程软件工程是一门研究用工程化方法构建和维护有效的、实用的和高质量的软件的学科。
软件工程专业毕业设计外文文献翻译
软件工程专业毕业设计外文文献翻译1000字本文将就软件工程专业毕业设计的外文文献进行翻译，能够为相关考生提供一定的参考。
外文文献1: Software Engineering Practices in Industry: A Case StudyAbstractThis paper reports a case study of software engineering practices in industry. The study was conducted with a large US software development company that produces software for aerospace and medical applications. The study investigated the company’s software development process, practices, and techniques that lead to the production of quality software. The software engineering practices were identified through a survey questionnaire and a series of interviews with the company’s software development managers, software engineers, and testers. The research found that the company has a well-defined software development process, which is based on the Capability Maturity Model Integration (CMMI). The company follows a set of software engineering practices that ensure quality, reliability, and maintainability of the software products. The findings of this study provide a valuable insight into the software engineering practices used in industry and can be used to guide software engineering education and practice in academia.IntroductionSoftware engineering is the discipline of designing, developing, testing, and maintaining software products. There are a number of software engineering practices that are used in industry to ensure that software products are of high quality, reliable, and maintainable. These practices include software development processes, software configuration management, software testing, requirements engineering, and project management. Software engineeringpractices have evolved over the years as a result of the growth of the software industry and the increasing demands for high-quality software products. The software industry has developed a number of software development models, such as the Capability Maturity Model Integration (CMMI), which provides a framework for software development organizations to improve their software development processes and practices.This paper reports a case study of software engineering practices in industry. The study was conducted with a large US software development company that produces software for aerospace and medical applications. The objective of the study was to identify the software engineering practices used by the company and to investigate how these practices contribute to the production of quality software.Research MethodologyThe case study was conducted with a large US software development company that produces software for aerospace and medical applications. The study was conducted over a period of six months, during which a survey questionnaire was administered to the company’s software development managers, software engineers, and testers. In addition, a series of interviews were conducted with the company’s software development managers, software engineers, and testers to gain a deeper understanding of the software engineering practices used by the company. The survey questionnaire and the interview questions were designed to investigate the software engineering practices used by the company in relation to software development processes, software configuration management, software testing, requirements engineering, and project management.FindingsThe research found that the company has a well-defined software development process, which is based on the Capability Maturity Model Integration (CMMI). The company’s software development process consists of five levels of maturity, starting with an ad hoc process (Level 1) and progressing to a fully defined and optimized process (Level 5). The company has achieved Level 3 maturity in its software development process. The company follows a set of software engineering practices that ensure quality, reliability, and maintainability of the software products. The software engineering practices used by the company include:Software Configuration Management (SCM): The company uses SCM tools to manage software code, documentation, and other artifacts. The company follows a branching and merging strategy to manage changes to the software code.Software Testing: The company has adopted a formal testing approach that includes unit testing, integration testing, system testing, and acceptance testing. The testing process is automated where possible, and the company uses a range of testing tools.Requirements Engineering: The company has a well-defined requirements engineering process, which includes requirements capture, analysis, specification, and validation. The company uses a range of tools, including use case modeling, to capture and analyze requirements.Project Management: The company has a well-defined project management process that includes project planning, scheduling, monitoring, and control. The company uses a range of tools to support project management, including project management software, which is used to track project progress.ConclusionThis paper has reported a case study of software engineering practices in industry. The study was conducted with a large US software development company that produces software for aerospace and medical applications. The study investigated the company’s software development process,practices, and techniques that lead to the production of quality software. The research found that the company has a well-defined software development process, which is based on the Capability Maturity Model Integration (CMMI). The company uses a set of software engineering practices that ensure quality, reliability, and maintainability of the software products. The findings of this study provide a valuable insight into the software engineering practices used in industry and can be used to guide software engineering education and practice in academia.外文文献2: Agile Software Development: Principles, Patterns, and PracticesAbstractAgile software development is a set of values, principles, and practices for developing software. The Agile Manifesto represents the values and principles of the agile approach. The manifesto emphasizes the importance of individuals and interactions, working software, customer collaboration, and responding to change. Agile software development practices include iterative development, test-driven development, continuous integration, and frequent releases. This paper presents an overview of agile software development, including its principles, patterns, and practices. The paper also discusses the benefits and challenges of agile software development.IntroductionAgile software development is a set of values, principles, and practices for developing software. Agile software development is based on the Agile Manifesto, which represents the values and principles of the agile approach. The manifesto emphasizes the importance of individuals and interactions, working software, customer collaboration, and responding to change. Agile software development practices include iterative development, test-driven development, continuous integration, and frequent releases.Agile Software Development PrinciplesAgile software development is based on a set of principles. These principles are:Customer satisfaction through early and continuous delivery of useful software.Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.Deliver working software frequently, with a preference for the shorter timescale.Collaboration between the business stakeholders and developers throughout the project.Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.Working software is the primary measure of progress.Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.Continuous attention to technical excellence and good design enhances agility.Simplicity – the art of maximizing the amount of work not done – is essential.The best architectures, requirements, and designs emerge from self-organizing teams.Agile Software Development PatternsAgile software development patterns are reusable solutions to common software development problems. The following are some typical agile software development patterns:The Single Responsibility Principle (SRP)The Open/Closed Principle (OCP)The Liskov Substitution Principle (LSP)The Dependency Inversion Principle (DIP)The Interface Segregation Principle (ISP)The Model-View-Controller (MVC) PatternThe Observer PatternThe Strategy PatternThe Factory Method PatternAgile Software Development PracticesAgile software development practices are a set ofactivities and techniques used in agile software development. The following are some typical agile software development practices:Iterative DevelopmentTest-Driven Development (TDD)Continuous IntegrationRefactoringPair ProgrammingAgile Software Development Benefits and ChallengesAgile software development has many benefits, including:Increased customer satisfactionIncreased qualityIncreased productivityIncreased flexibilityIncreased visibilityReduced riskAgile software development also has some challenges, including:Requires discipline and trainingRequires an experienced teamRequires good communicationRequires a supportive management cultureConclusionAgile software development is a set of values, principles, and practices for developing software. Agile software development is based on the Agile Manifesto, which represents the values and principles of the agile approach. Agile software development practices include iterative development, test-driven development, continuous integration, and frequent releases. Agile software development has many benefits, including increased customer satisfaction, increased quality, increased productivity, increased flexibility, increased visibility, and reduced risk. Agile software development also has some challenges, including the requirement for discipline and training, the requirement for an experienced team, the requirement for good communication, and the requirement for a supportive management culture.。
软件工程毕业论文文献翻译中英文对照
软件工程毕业论文文献翻译中英文对照学生毕业设计(论文)外文译文学生姓名: 学号专业名称:软件工程译文标题(中英文):Qt Creator白皮书(Qt Creator Whitepaper)译文出处:Qt network 指导教师审阅签名: 外文译文正文:Qt Creator白皮书Qt Creator是一个完整的集成开发环境(IDE)，用于创建Qt应用程序框架的应用。
Qt是专为应用程序和用户界面，一次开发和部署跨多个桌面和移动操作系统。
本文提供了一个推出的Qt Creator和提供Qt开发人员在应用开发生命周期的特点。
Qt Creator的简介Qt Creator的主要优点之一是它允许一个开发团队共享一个项目不同的开发平台(微软Windows?的Mac OS X?和Linux?)共同为开发和调试工具。
Qt Creator的主要目标是满足Qt开发人员正在寻找简单，易用性，生产力，可扩展性和开放的发展需要，而旨在降低进入新来乍到Qt的屏障。
Qt Creator 的主要功能，让开发商完成以下任务: , 快速，轻松地开始使用Qt应用开发项目向导，快速访问最近的项目和会议。
, 设计Qt物件为基础的应用与集成的编辑器的用户界面，Qt Designer中。
, 开发与应用的先进的C + +代码编辑器，提供新的强大的功能完成的代码片段，重构代码，查看文件的轮廓(即，象征着一个文件层次)。
, 建立，运行和部署Qt项目，目标多个桌面和移动平台，如微软Windows，Mac OS X中，Linux的，诺基亚的MeeGo，和Maemo。
, GNU和CDB使用Qt类结构的认识，增加了图形用户界面的调试器的调试。
, 使用代码分析工具，以检查你的应用程序中的内存管理问题。
, 应用程序部署到移动设备的MeeGo，为Symbian和Maemo设备创建应用程序安装包，可以在Ovi商店和其他渠道发布的。
, 轻松地访问信息集成的上下文敏感的Qt帮助系统。
软件开发概念和设计中英文对照外文翻译文献
中英文对照外文翻译外文资料原文Software Development Concepts and DesignMethodologiesDuring the 1960s, ma inframes and higher level programming languages were applied to man y problems including human resource s yste ms,reservation s yste ms, and manufacturing s yste ms. Computers and software were seen as the cure all for man y bu siness issues were sometimes applied blindly. S yste ms sometimes failed to solve the problem for which the y were designed for man y reasons including:•Inability to sufficiently understand complex problems•Not sufficiently taking into account end-u ser needs, the organizational environ ment, and performance tradeoffs•Inability to accurately estimate development time and operational costs •Lack of framework for consistent and regular customer commun ications At this time, the concept of structured programming, top-down design, stepwise refinement，and modularity e merged. Structured programming is still the most dominant approach to software engineering and is still evo lving. These failures led to the c oncept of "software engineering" based upon the idea that an engineering-like discipline could be applied to software design and develop ment.Software design is a process where the software designer applies techniques and principles to produce a conceptual model that de scribes and defines a solution to a problem. In the beginning, this design process has not been well structured and the model does not alwa ys accurately represent theproblem of software development. However,design methodologies have been evolving to accommo date changes in technolog y coupled with our increased understanding of development processes.Whereas early desig n methods addressed specific aspects of the develop ment process, current methods atte mpt to address the entire scope of software development. Software design methods are often classified in reference to the period in which the y were introduced and the problems at that time. Driven b y coding and testing problems, tools and methods were developed. Early methods focused on modularit y a nd top-down development, and information hiding through abstraction. This led to the development of structured languages, structured analysis, and data flow analysis.In the last decade or so, the expense involved in automation has shifted from hardware to people. Therefore, the software engineering community has been focused on object oriented (O-O) design and the concept of re-usable code in order to reduce the human cost component. Inefficient designs and develop ment methodologies have been addressed with Computer Aided Software Engineering (CASE) tools, and fourth generation design languages. This has been done in an attempt replace the traditional waterf all life c ycle process model under which most existing software has been developed.一、Software De sign FundamentalsSoftware design meth ods all aim to provide the software designer with a s yste m blueprint. This blueprint usually has three aspects: data, architectural, and procedural.•Data design refers to the data's organization, relationships, access and processing methods.•Architectural design defines the components of the sys tem a nd their relationships.•Procedural design builds on the data and architectural design phases to describe the processing details of the s yste m.Even though there are numer ous design methodologies, their basicconcepts are ver y similar-All software design methods partition the problem and software into smaller pieces in order to reduce complexity. They all strive to identif y data structures and functions, and provide measur e ments for software quality. Some of the common principles in software design include: stepwise refinement, s oftware architecture, program structure, data structure, software procedures, mo d u la r i t y,a b s tr a c t io n,a n d in f o r ma t io n h i d i n g.二、M o d e r n D e s i g n M e t h o d o l o g i e sC o n ve n t io n a l s o f t wa r e d e ve l o p me n t p r a c t ic e s c a n g e n e r a l l y b ema p p e d o n to t h e tr a d i t io n a l l i f e-c y c l e p h a s e s o f a n a l ys i s,f u n c t i o n a ls p e c i f i c a t i o n,d e s i g n,i mp l e me n t a t i o n,t e s t i n g,a n d m a i n t e n a n c e.T h i st h o u g h t p r o c e s s i s i n a d e q u a t e f o r t o d a y's c o m p l e x i n f o r m a t i o n s y s t e m s.As the demand for software is growing much faster than the number of developers, adhering to conventional techniques such as the waterfall method requires too much time, too many people, and is difficult to manage. Hence, many new software development technologies have arisen. N e wl y d e ve lo p e d p r a c tic e s a n d mo d e ls d o n o t a tte mp t to s e p a r a te p h a s e s o f s o f twa r e development, such as specification and implementation, but instead focus on the concept of program transformation through stepwise refinement and iteration.1、O b j e c t-O r i e n t e d Te c h n o l o g yObject-Oriented (O-O) software design technology is fundamentally different from the traditional methods described above. With traditional methods, each module is recognized a major step in the o verall process and the process goes from one step to the next. On the other hand, O-O design is structured around a model of objects and the functions they perform.O-O programming can be traced to the simulation language SIMULA, a high level language developed in the late 60's that introduced object classes as a method to encapsulate data. Later, in the 1970s, Smalltalk was introduced as a complete graphic user interface (GUI) environment for O-O programming. Even 30 years later, Smalltalk is still the sta ndard against which all other O-O languages are measured. O-O software development methodologies have becomepopular in the last decade as O-O concepts have matured. At the same time, the software industry's focus has shifted from coding and structured pro cesses to saving labor costs, and time through design and flexibility. Flexibility has become pivotal because sys tems have become larger, more complex, and more volatile with rapidly changing requirements.With O-O, there is no real separation between anal ysis and design. During analysis, system objects are identified along with their characteristics and relationships. These objects are maintained through design and coding as detail is added to the design. This provides a common language throughout each sta ge in development. O-O is best applied with specifically designed O-O development tools, but it is important to remember that as a methodology is it not specific to any programming language. Many different programming languages can be used to implement 0-0 technology and design methodologies.Instead of procedures and functions passing data back and forth, in object oriented design, the system is viewed as a collection of objects with messages passed from object to object. Each object has its own set of ass ociated operations. Object-oriented design is based on the idea of information hiding and modularization of both data and processing. It is best used when neither data structure nor processing operations are well defined ahead of time. This is quite useful in today's business environment where requirements are always changing and not very well defined. Thus, it has become quite popular! The concept of objects performing services is a natural way of thinking for both developers and customers. This facilitate s understanding the problem domain and a more natural design. In addition, there are many benefits of object-oriented development. These include:•I n h e r i t a n c e c a p i t a l i z e s o n t h e c o m m o n a l t y o f a t t r i b u t e s a n d s e r v i c e s a l l o w i n g c o d e a n d objects to be re-used..I n f o r m a t i o n h i d i n g m a k e s s y s t e m s m o r e s t a b l e b y l o c a l i z i n g c h a n g e s t o o b j e c t s a n d t h e r e b y m a k i n g t h e m r e u s a b l e..T h e o b j e c t-o r i e n t e d d e v e l o p m e n t p r o c e s s i s c o n s i s t e n t f r o ma n a l y s i s,t h r o u g h d e s i g n, t o c o d i n g.More information on Object Oriented Programm ing principles can be found in Chapter 4-Organization of Programming Languages and Programming Concepts.2、P r o t o t y p i n gPrototyping was invented because end users participating in the development phase found it difficult to understand requirement specifica tions and conceptual models. However, when it first began being used in the 1980s, most conventional life c ycle developers considered it expensive and time consuming.S i n c e t h a t t i m e,u s e r s a n d d e v e l o p e r s h a v e u s e d p r o t o t y p e s s u c c e s s f u l l y a s a communications tool to demonstrate system requirements. After several prototype iterations, developers have a better understanding of user requirements and users have a better idea of how the s ystem will eventually work, look, and feel. Prototyping has proven to be an effective way of understanding the users' needs and problems and eliminating costly rework later in the development process due to misunderstandings in requirements. Prototyping is particularly useful for user interface development because it is sometimes impossible to represent the look and feel of a user interface in an effective way using words and diagrams. This is especially critical in today's development environment where user interface development consumes an increasing portion of overall system de velopment costs.（1）T h r o w Aw a y P r o to t yp in gThere are two va r ieties of pro to typ ing, Th row-awa y p ro to typin g and Evo lutiona r y prototyping. Throw-away prototyping is designed to validate or derive the system requirements. It may also be used to evaluate performan ce capabilities and determine design feasibility. Once the desired information has been obtained and the prototype's objective has been fulfilled, the p r o t o t y p e i s t h r o w n a w a y a n d c o n v e n t i o n a l s o f t w a r e d e s i g n c o n t i n u e s.T h r o w a w a y p r o t o t y p i n g are:•U s e d t o r e d u c e r e q u i r e m e n t s r i s k a n d f a c i l i t a t e u n d e r s t a n d i n gu s e r r e q u i r e m e n t s.•N o t c o n s i d e r e d a s a f i n a l s y s t e m,a n d i s d i s c a r d e d a f t e r u s eb ec a u s e:♦M a n y s y s t e m c h a r a c t e r i s t i c s a r e l e f t o u t♦T h e p r o t o t y p e i s w r i t t e n q u i c k l y p r i m a r i l y f o r t h e p u r p o s e o f d e m o n s t r a t i o n a n d t h e r e f o r e m a y n o t b e o p t i m a l l ys t r u c t u r e d a n d c o n s e q u e n t l y d i f f i c u l t t o m a i n t a i n With th r o w a wa y p r o to t yp in g,s o me a n a l ys ts th in k o f a p r o to t y p e a s a d e s ig n o r specifications language to be used as input to the traditional system design phase, rather than a product or system in itself.（2）Evol uti onary PrototypingR a t h e r t h a n b e i n g d e s i g n e d t o w i t h t h e i n t e n t i o n o f b e i n g t h r o w n a w a y,e v o l u t i o n a r y p r o t o t y p i n g d e l i v e r s a w o r k i n g s y s t e m t o e n d-u s e r s. T h e d e v e l o p m e n t s t a r t s w i t h t h o s e r e q u i r e me n ts t h a t a r e b e s t u n d e r s to o d. T h e n,r a th e r th a n b e in g a p r e l i mi n a r y s t e p to th e li f e c yc le m o d e l,t h e p r o t o t y p e i s t h e c e n t r a l f o c u s o f t h e p r o c e s s m o d e l.T h e p r o t o t y p e i s s c o p e d,s c h e d u l e d a n d s p e c i f i e d.I t i s t h e n i n c r e m e n t a l l y r e f i n e d a n d u p d a t e d a s t h e c e n t r a l c o m p o n e n t o f th e p r o c e s s mo d e l.T h e n u mb e r o f t i me s th e p r o to t yp e is in c r e me n t a l l y r e f in e d d e p e n d s o n h o w we l l th e u s e r r e q u i r e me n ts a n d u n d e r s t o o d.I t a ls o d e p e n d s o n th e u s e r s n e e d to a d d r e q u ir e me n ts o r c h a n g e p r e v i o u s l y s t a t e d r e q u i r e m e n t s.A f t e r e s t a b l i s h i n g a n o v e r a l l a r c h i t e c t u r e a n d f r a me w o r k, t h e s ys t e m i s d e v e l o p e d a n d d e l i v e r e d in in c r e me n ts.U s e r s ma y e x p e r i me n t w i t h a n d u s e d e l i v e r e d i n c r e me n t s w h i l e o t h e r s a r e b e i n g d e v e l o p e d.Fo r i n s t a n c e,t h e f i r s t p r o t o t yp e ma y b e d e l i v e r e d t h a t i m p l e m e n t s a c e r t a i n s c r e e n w i t h o n l y s o m e a c t i v e m e n u i t e m s.W h i l e u s e r s a r e e x p e r i me n t i n g w i t h t h i s s c r e e n a n d me n u i t e ms,o t h e r s c r e e n s a n d me n u i t e ms a r e c o n c u r r e n t l y b e in gd e v e l o p e d wh i c h la t e r w il l b e c o mb in e d w i th th e e x is t in g p r o to t yp e a s ite vo l v e s.O n c e t h e u s e r i s s a t i s f i e d t h a t t h e p r o t o t y p e m e e t s r e q u i r e m e n t s,t h ep r o t o t y p e i s t r a n s f o r me d i n to th e"s ys t e m".T h i s e ff o r t d e p e n d s o n s e v e r a l f a c to r s. I t ma y i n c lu d e a d d i n g f u n c t i o n a l i t y t h a t w a s n't i n i t i a l l y r e c o g n i z e d a s r e q u i r e d,r e p l a c i n g i n e f f i c i e n t p a r t s o f t h e p r o t o t yp e t o me e t p e r f o r ma n c e c r i t e r i a,o r a d a p t i n g t h e p r o t o t yp e t o f i t t h e u s e r's h a r d w a r e e n vi r o n me n t.P r o t o t y p i n g c a n b e g i n v e r y e a r l y, a f t e r s o m e p r e l i m i n a r y r e q u i r e m e n t s a n a l y s i s h a s d e t e r m i n e d t h e b a s i c f u n c t i o n a l i t y,s c o p e,a n d e n v i r o n m e n t o f t h e p r o p o s e d s o f t w a r e.C o n t r a r y t o t h e t r a d i t i o n a l w a t e r f a l l me t h o d,i n t h e p r o t o t yp i n g,f u n c t i o n a l s p e c i f i c a t i o n s a r e n o t f i x e d.R a t h e r,u s e r s a r e e n c o u r a g e d t o m o d i f y t h e i r r e q u i r e m e n t s a s t h e y t h e m s e l v e s b e g i n t o u n d e r s t a n d t h e m b e t t e r.T h i s i s b e c a u s e u s e r s o f t e n d o n't r e a l l y k n o w w h a t t h e y w a n t u n t i l t h e y s e e i t o n t h e s c r e e n.T h e p r o t o t yp i n g p r o c e s s o f d e mo n s t r a t i o n,r e v i e w,a n d r e f i n e me n t g e t s t h e u s e r m o r e i n v o l v e d i n t h e d e v e l o p m e n t p r o c e s s,g i v i n g t h e m a s e n s e o f o w n e r s h i p d u r i n g t h e p r o c e s s a n d a t f i n a l s y s t e m d e l i v e r y.H o w e v e r,d u e t o t h e m i n d s e t o f"p r o t o t y p e", u s e r s o f t e n f in d i t d iff ic u l t to ve r if y t h a t th e p r o to t yp e s a tis f ie s th e ir r e q u ir e me n ts. T h e r e f o r e, g u id e l in e s mu s t b e e s t a b l i s h e d t o d e te r m in e wh e n t o s to p i te r a t in g a n d th e p r o to t yp e to f in a l p r o d u c t.外文资料译文软件开发概念和设计方法在20世纪60年代，大型机和高级程序语言被用来解决包括人力资源系统、专有系统和制造系统等许多问题。
软件开发概念和设计方法-外文翻译
外文资料原文Software Development Concepts and DesignMethodologiesDuring the 1960s, ma inframes and higher level programming languages were applied to man y problems including human resource s yste ms,reservation s yste ms, and manufacturing s yste ms. Computers and software were seen as the cure all for man y bu siness issues were sometimes applied blindly. S yste ms sometimes failed to solve the problem for which the y were designed for man y reasons including:•Inability to sufficiently understand complex problems•Not sufficiently taking into account end-u ser needs, the organizational environ ment, and performance tradeoffs•Inability to accurately estimate development time and operational costs •Lack of framework for consistent and regular customer communications At this time, the concept of structured programming, top-down design, stepwise refinement，and modularity e merged. Structured programming is still the most dominant approach to software engineering and is still evo lving. These failures led to the concept of "software engineering" based upon the idea that an engineering-like discipline could be applied to software design and develop ment.Software design is a process where the software designer applies techniques and principles to produce a conceptual model that de scribes and defines a solution to a problem. In the beginning, this design process has not been well structured and the model does not alwa ys accurately represent the problem of software development. However,design methodologies have been evolving to a ccommo date changes in technolog y coupled with our increased understanding of development processes.Whereas early desig n methods addressed specific aspects of the develop ment process, current methods atte mpt to address the entire scope of software development. Software design methods are often classified inreference to the period in which the y were introduced and the problems at that time. Driven b y coding and testing problems, tools and methods were developed. Early methods focused on modularity a nd top-down development, and information hiding through abstraction. This led to the development of structured languages, structured analysis, and data flow analysis.In the last decade or so, the expense involved in automation has shifted from hardware to people.Therefore, the software engineering community has been focused on object oriented (O-O) design and the concept of re-usable code in order to reduce the human cost component. Inefficient designs and develop ment methodologies have been addressed with Comput er Aided Software Engineering (CASE) tools, and fourth generation design languages. This has been done in an attempt replace the traditional waterf all life c ycle process model under which most existing software has been developed.一、Software Design FundamentalsSoftware design meth ods all aim to provide the software designer with a s yste m blueprint. This blueprint usually has three aspects: data, architectural, and procedural.•Data design refers to the data's organization, relationships, access and processing methods.•Architectural design defines the components of the sys tem a nd their relationships.•Procedural design builds on the data and architectural design phases to describe the processing details of the s yste m.Even though there are numerous design methodologies, their basic concepts are ver y similar-All software design methods partition the problem and software into smaller pieces in order to reduce complexity. They all strive to identif y data structures and functions, and provide measur ements for software quality. Some of the common principles in software design include: stepwise refinement, s oftware architecture, program structure, data structure, software procedures, mo d u la r i t y,a b s tr a c t io n,a n d in f o r ma t io n h i d i n g.二、M o d e r n D e s i g n M e t h o d o l o g i e sC o n ve n t io n a l s o f t wa r e d e ve l o p me n t p r a c t ic e s c a n g e n e r a l l y b ema p p e d o n to t h e tr a d i t io n a l l i f e-c y c l e p h a s e s o f a n a l ys i s,f u n c t i o n a ls p e c i f i c a t i o n,d e s i g n,i mp l e me n t a t i o n,t e s t i n g,a n d m a i n t e n a n c e.T h i st h o u g h t p r o c e s s i s i n a d e q u a t e f o r t o d a y's c o m p l e x i n f o r m a t i o n s y s t e m s.As the demand for software is growing much faster than the number of developers, adhering to conventional techniques such as the waterfall method requires too much time, too many people, and is difficult to manage. Hence, many new software development technologies have arisen. N e wl y d e ve lo p e d p r a c tic e s a n d mo d e ls d o n o t a tte mp t to s e p a r a te p h a s e s o f s o f twa r e development, such as specification and implementation, but instead focus on the concept of program transformation through stepwise refin ement and iteration.1、O b j e c t-O r i e n t e d Te c h n o l o g yObject-Oriented (O-O) software design technology is fundamentally different from the traditional methods described above. With traditional methods, each module is recognized a major step in the overall proc ess and the process goes from one step to the next. On the other hand, O-O design is structured around a model of objects and the functions they perform.O-O programming can be traced to the simulation language SIMULA, a high level language developed in the late 60's that introduced object classes as a method to encapsulate data. Later, in the 1970s, Smalltalk was introduced as a complete grapgh design and coding as detail is added to the design. This provides a common language throughout each stage in deve lopment. O-O is best applied with specifically designed O-O development tools, but it is important to remember that as a methodology is it not specific to any programming language. Many different programming languages can be used to implement 0-0 technolog y and design methodologies.Instead of procedures and functions passing data back and forth, in object oriented design, the system is viewed as a collection of objects with messages passed from object to object. Each object has its own set of associated op erations.Object-oriented design is based on the idea of information hiding and modularization of both data and processing. It is best used when neither data structure nor processing operations are well defined ahead of time. This is quite useful in today's business environment where requirements are always changing and not very well defined. Thus, it has become quite popular! The concept of objects performing services is a natural way of thinking for both developers and customers. This facilitates understa nding the problem domain and a more natural design. In addition, there are many benefits of object-oriented development. These include:•I n h e r i t a n c e c a p i t a l i z e s o n t h e c o m m o n a l t y o f a t t r i b u t e s a n d s e r v i c e s a l l o w i n g c o d e a n d objects to be re-used..I n f o r m a t i o n h i d i n g m a k e s s y s t e m s m o r e s t a b l e b y l o c a l i z i n g c h a n g e s t o o b j e c t s a n d t h e r e b y m a k i n g t h e m r e u s a b l e..T h e o b j e c t-o r i e n t e d d e v e l o p m e n t p r o c e s s i s c o n s i s t e n t f r o m a n a l y s i s,t h r o u g h d e s i g n, t o c o d i n g.More information on Object Oriented Programming princi ples can be found in Chapter 4-Organization of Programming Languages and Programming Concepts.2、P r o t o t y p i n gPrototyping was invented because end users participating in the development phase found it difficult to understand requirement specifications and conceptual models. However, when it first began being used in the 1980s, most conventional life c ycle developers considered it expensive and time consuming.S i n c e t h a t t i m e,u s e r s a n d d e v e l o p e r s h a v e u s e d p r o t o t y p e s s u c c e s s f u l l y a s a communications tool to demonstrate system requirements. After several prototype iterations, developers have a better understanding of user requirements and users have a better idea of how the system will eventually work, look, and l.T h e n u mb e r o f t i me s th e p r o to t yp e is in c r e me n t a l l y r e f in e d d e p e n d s o n h o w we l l th e u s e r r e q u i r e me n ts a n d u n d e r s t o o d.I t a ls o d e p e n d s o n th e u s e r sn e e d to a d d r e q u ir e me n ts o r c h a n g e p r e v i o u s l y s t a t e d r e q u i r e m e n t s.A f t e r e s t a b l i s h i n g a n o v e r a l l a r c h i t e c t u r e a n d f r a me w o r k, t h e s ys t e m i s d e v e l o p e d a n d d e l i v e r e d in in c r e me n ts.U s e r s ma y e x p e r i me n t w i t h a n d u s e d e l i v e r e d i n c r e me n t s w h i l e o t h e r s a r e b e i n g d e v e l o p e d.Fo r i n s t a n c e,t h e f i r s t p r o t o t yp e ma y b e d e l i v e r e d t h a t i m p l e m e n t s a c e r t a i n s c r e e n w i t h o n l y s o m e a c t i v e m e n u i t e m s.W h i l e u s e r s a r e e x p e r i me n t i n g w i t h t h i s s c r e e n a n d me n u i t e ms,o t h e r s c r e e n s a n d me n u i t e ms a r e c o n c u r r e n t l y b e in gd e v e l o p e d wh i c h la t e r w il l b e c o mb in e d w i th th e e x is t in g p r o to t yp e a s ite vo l v e s.O n c e t h e u s e r i s s a t i s f i e d t h a t t h e p r o t o t y p e m e e t s r e q u i r e m e n t s,t h e p r o t o t y p e i s t r a n s f o r me d i n to th e"s ys t e m".T h i s e ff o r t d e p e n d s o n s e v e r a l f a c to r s. I t ma y i n c lu d e a d d i n g f u n c t i o n a l i t y t h a t w a s n't i n i t i a l l y r e c o g n i z e d a s r e q u i r e d,r e p l a c i n g i n e f f i c i e n t p a r t s o f t h e p r o t o t yp e t o me e t p e r f o r ma n c e c r i t e r i a,o r a d a p t i n g t h e p r o t o t yp e t o f i t t h e u s e r's h a r d w a r e e n vi r o n me n t.P r o t o t y p i n g c a n b e g i n v e r y e a r l y, a f t e r s o m e p r e l i m i n a r y r e q u i r e m e n t s a n a l y s i s h a s d e t e r m i n e d t h e b a s i c f u n c t i o n a l i t y,s c o p e,a n d e n v i r o n m e n t o f t h e p r o p o s e d s o f t w a r e.C o n t r a r y t o t h e t r a d i t i o n a l w a t e r f a l l me t h o d,i n t h e p r o t o t yp i n g,f u n c t i o n a l s p e c i f i c a t i o n s a r e n o t f i x e d.R a t h e r,u s e r s a r e e n c o u r a g e d t o m o d i f y t h e i r r e q u i r e m e n t s a s t h e y t h e m s e l v e s b e g i n t o u n d e r s t a n d t h e m b e t t e r.T h i s i s b e c a u s e u s e r s o f t e n d o n't r e a l l y k n o w w h a t t h e y w a n t u n t i l t h e y s e e i t o n t h e s c r e e n.T h e p r o t o t yp i n g p r o c e s s o f d e mo n s t r a t i o n,r e v i e w,a n d r e f i n e me n t g e t s t h e u s e r m o r e i n v o l v e d i n t h e d e v e l o p m e n t p r o c e s s,g i v i n g t h e m a s e n s e o f o w n e r s h i p d u r i n g t h e p r o c e s s a n d a t f i n a l s y s t e m d e l i v e r y.H o w e v e r,d u e t o t h e m i n d s e t o f"p r o t o t y p e", u s e r s o f t e n f in d i t d iff ic u l t to ve r if y t h a t th e p r o to t yp e s a tis f ie s th e ir r e q u ir e me n ts. T h e r e f o r e, g u id e l in e s mu s t b e e s t a b l i s h e d t o d e te r m in e wh e n t o s to p i te r a t in g a n d th e p r o to t yp e to f in a l p r o d u c t.外文资料译文软件开发概念和设计方法在20世纪60年代，大型机和高级程序语言被用来解决包括人力资源系统、专有系统和制造系统等许多问题。
大学毕业论文---软件专业外文文献中英文翻译
while Ifyou a ]. Every软件专业毕业论文外文文献中英文翻译Object landscapes and lifetimesTechnically, OOP is just about abstract data typing, inheritance, and polymorphism, but otheissues can be at least as important. The remainder of this section will cover these issues.One of the most important factors is the way objects are created and destroyed. Where is thedata for an object and how is the lifetime of the object controlled? There are different philosoat work here. C++ takes the approach that control of efficiency is the most important issue, sogivesthe programmer a choice.For maximum run-timespeed,the s torageand lifetimecan bedeterminedwhile the program isbeing written,by placingthe objectson the stack(thesearesometimes called automatic or scoped variables) or in the static storage area. This places a prion the speed of storage allocation and release, and control of these can be very valuable in somsituations. However, you sacrifice flexibility because you must know the exact quantity, lifetimand type of objectsyou're writing the program. are trying to solvemore generalproblem such as computer-aided design, warehouse management, or air-traffic control, this is toorestrictive.The second approach is to create objects dynamically in a pool of memory called the heap. Inthis approach, you don't know until run-time how many objects you need, what their lifetime is,what theirexacttypeis.Those aredeterminedatthespurof themoment whiletheprogram isrunning. If you need a new object, you simply make it on the heap at the point that you need it.Because the storage is managed dynamically, at run-time, the amount of time required to allocatestorage on the heap is significantly longer than the time to create storage on the stack. (Creatstorage on the stack is often a single assembly instruction to move the stack pointer down, andanother to move it back up.) The dynamic approach makes the generally logical assumption thatobjects tend to be complicated, so the extra overhead of finding storage and releasing that storwill not have an important impact on the creation of an object. In addition, the greater flexibiessential to solve the general programming problem.Java uses the second approach, exclusively timeyou want to create an object, you useIn you when th but any new youin C (suchthe new keyword to build a dynamic instance of that object.There's another issue, however, and that's the lifetime of an object. With languages that alobjectsto be createdon the stack,the compilerdetermineshow long the objectlastsand canautomatically destroy it. However, if you create it on the heap the compiler has no knowledge ofits lifetime.alanguage like C++,must determine programmatically to destroy theobject, which can lead to memory leaks if you don’t do it correctly (and this is a common problin C++ programs). Java provides a feature called a garbage collector that automatically discoverwhen an object is no longer in use and destroys it. A garbage collector is much more convenientbecause it reduces the number of issues that you must track and the code you must write. Moreimportant, the garbage collector provides a much higher level of insurance against the insidiousproblem of memory leaks (which has brought many a C++ project to its knees).The rest of this section looks at additional factors concerning object lifetimes and landsca1. The singly rooted hierarchyOne of the issues in OOP that has become especially prominent since the introduction of C++iswhether a llclassesshouldultimatelybe inheritedfrom a singlebase class.In Java (aswithvirtually all other OOP languages)answer is “yes” and the name of this ultimate base class issimply Object. It turns out that the benefits of the singly rooted hierarchy are many.All objectsin a singlyrootedhierarchyhave an interfacein common, so they are allultimatelythe same type.The alternative(providedby C++) is thatyou don’tknow thateverything is the same fundamental type. From a backward-compatibility standpoint this fits themodel of C betterand can be thoughtof as lessrestrictive, when you want to do full-onobject-orientedprogramming you must then buildyour own hierarchyto providethe sameconvenience that’s built into other OOP languages. And in library classacquire, someother incompatible interface will be used. It requires effort (and possibly multiple inheritancework the new interface into your design. Is the extra “flexibility” of C++ worth it? If you neit —if you have a large investment —it’s quite valuable. If you’re starting from scratch, otheralternatives such as Java can often be more productive.All objects in a singly rooted hierarchyas Java provides) can be guaranteed to havecertain functionality. You know you can perform certain basic operations on every object in yoursystem. A singly rooted hierarchy, along with creating all objects on the heap, greatly simplifitoso ’s that is a it’sargument passing (one of the more complex topics in C++).A singly rooted hierarchy makes it much easier to implement a garbage collector (which isconvenientlybuiltintoJava).The necessarysupportcan be installed the b ase class,and thegarbage collector can thus send the appropriate messages to every object in the system. Withoutsinglyrootedhierarchyand a system to manipulatean objectvia a reference,itisdifficultimplement a garbage collector.Since run-time type information is guaranteed to be in all objects, you’ll never end up withobject whose type you cannot determine. This is especially important with system level operationsuch as exception handling, and to allow greater flexibility in programming.2 .Collection libraries and support for easy collection useBecause a container is a tool that you’ll use frequently, it makes sense to have a librarycontainersthatare builtin a reusablefashion,so you can take one off the shelfBecause acontainer is a tool that you’ll use frequently, it makes sense to have a library of containersbuilt in a reusable fashion, so you can take one off the shelf and plug it into your program. Japrovides such a library, which should satisfy most needs.Downcasting vs. templates/genericsTo make thesecontainersreusable,they hold the one universaltype in Java thatwaspreviously mentioned: Object. The singly rooted hierarchy means that everything is an Object, soa container that holds Objects can hold anything. This makes containers easy to reuse.To use such a container, you simply add object references to it, and later ask for them backBut, since the container holds only Objects, when you add your object reference into the containit is upcast to Object, thus losing its identity. When you fetch it back, you get an Object refeand not a reference to the type that you put in. So how do you turn it back into something thatthe useful interface of the object that you put into the container?Here, the cast is used again, but this time you’re not casting up the inheritance hierarchymore general type, you cast down the hierarchy to a more specific type. This manner of casting icalled downcasting. With upcasting, you know, for example, that a Circle is aittype of Shapesafe to upcast, but you don’t knowObject an necessarily a Circle or so Shape hardly’t itit to get by safe to downcast unless you know that’s what you’re dealing with.It’s not completely dangerous, however, because if you downcast to the wrong thing you’llget a run-time error called an exception, which will be described shortly. When you fetch objectreferences from a container, though, you must have some way to remember exactly what they areso you can perform a proper downcast.Downcasting and the run-time checks require extra time for the running program, and extraeffort from the programmer. Wouldnmake sense tosomehow create the container so that itknows the types that it holds, eliminating the need for the downcast and a possible mistake? Thesolution is parameterized types, which are classes that the compiler can automatically customizework with particulartypes.For example,with a parameterizedcontainer,the compilercouldcustomize that container so that it would accept only Shapes and fetch only Shapes.Parameterized types are an important part of C++, partly because C++ has no singly rootedhierarchy. In C++, the keyword that implements parameterized types is “template.” Java current has no parameterized types since it is possible for —however awkwardly —using thesingly rooted hierarchy. However, a current proposal for parameterized types uses a syntax thatstrikingly similar to C++ templates.。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
毕业设计（论文）外文文献翻译文献、资料中文题目：软件开发概念和设计方法文献、资料英文题目：文献、资料来源：文献、资料发表（出版）日期：院（部）：专业：班级：姓名：学号：指导教师：翻译日期： 2017.02.14外文资料原文Software Development Concepts and DesignMethodologiesDuring the 1960s, ma inframes and higher level programming languages were applied to man y problems including human resource s yste ms,reservation s yste ms, and manufacturing s yste ms. Computers and software were seen as the cure all for man y bu siness issues were some times applied blindly. S yste ms sometimes failed to solve the problem for which the y were designed for man y reasons including:•Inability to sufficiently understand complex problems•Not sufficiently taking into account end-u ser needs, the organizational environ ment, and performance tradeoffs•Inability to accurately estimate development time and operational costs •Lack of framework for consistent and regular customer communications At this time, the concept of structured programming, top-down design, stepwise refinement，and modularity e merged. Structured programming is still the most dominant approach to software engineering and is still evo lving. These failures led to the concept of "software engineering" based upon the idea that an engineering-like discipl ine could be applied to software design and develop ment.Software design is a process where the software designer applies techniques and principles to produce a conceptual model that de scribes and defines a solution to a problem. In the beginning, this des ign process has not been well structured and the model does not alwa ys accurately represent the problem of software development. However,design methodologies have been evolving to accommo date changes in technolog y coupled with our increased understanding of development processes.Whereas early desig n methods addressed specific aspects of thedevelop ment process, current methods atte mpt to address the entire scope of software development. Software design methods are often classified in reference to the peri od in which the y were introduced and the problems at that time. Driven b y coding and testing problems, tools and methods were developed. Early methods focused on modularity a nd top-down development, and information hiding through abstraction. This led to t he development of structured languages, structured analysis, and data flow analysis.In the last decade or so, the expense involved in automation has shifted from hardware to people. Therefore, the software engineering community has been focused on object oriented (O-O) design and the concept of re-usable code in order to reduce the human cost component. Inefficient designs and develop ment methodologies have been addressed with Computer Aided Software Engineering (CASE) tools, and fourth generation design l anguages. This has been done in an attempt replace the traditional waterf all life c ycle process model under which most existing software has been developed.一、Software Design FundamentalsSoftware design meth ods all aim to provide the software designer wi th a s yste m blueprint. This blueprint usually has three aspects: data, architectural, and procedural.•Data design refers to the data's organization, relationships, access and processing methods.•Architectural design defines the components of the sys tem a nd their relationships.•Procedural design builds on the data and architectural design phases to describe the processing details of the s yste m.Even though there are numerous design methodologies, their basic concepts are ver y similar-All software design methods partition the problem and software into smaller pieces in order to reduce complexity. They all strive to identif y data structures and functions, and provide measur ements for software quality. Some of the common principles in software design include: stepwise refinement, s oftware architecture, program structure, data structure,software procedures, mo d u la r i t y,a b s tr a c t io n,a n d in f o r ma t io n h i d i n g.二、M o d e r n D e s i g n M e t h o d o l o g i e sC o n ve n t io n a l s o f t wa r e d e ve l o p me n t p r a c t ic e s c a n g e n e r a l l y b ema p p e d o n to t h e tr a d i t io n a l l i f e-c y c l e p h a s e s o f a n a l ys i s,f u n c t i o n a ls p e c i f i c a t i o n,d e s i g n,i mp l e me n t a t i o n,t e s t i n g,a n d m a i n t e n a n c e.T h i st h o u g h t p r o c e s s i s i n a d e q u a t e f o r t o d a y's c o m p l e x i n f o r m a t i o n s y s t e m s.As the demand for software is growing much faster than the number of developers, adhering to conventional techniques such as the waterfall method requires too much time, too many people, and is difficult to ma nage. Hence, many new software development technologies have arisen. N e wl y d e ve lo p e d p r a c tic e s a n d mo d e ls d o n o t a tte mp t to s e p a r a te p h a s e s o f s o f twa r e development, such as specification and implementation, but instead focus on the concept of program transformation through stepwise refinement and iteration.1、O b j e c t-O r i e n t e d Te c h n o l o g yObject-Oriented (O-O) software design technology is fundamentally different from the traditional methods described above. With traditional methods, each module is recognized a major step in the overall process and the process goes from one step to the next. On the other hand, O-O design is structured around a model of objects and the functions they perform.O-O programming can be traced to the simulation language SIMULA, a hig h level language developed in the late 60's that introduced object classes as a method to encapsulate data. Later, in the 1970s, Smalltalk was introduced as a complete grapgh design and coding as detail is added to the design. This provides a common language throughout each stage in development. O-O is best applied with specifically designed O-O development tools, but it is important to remember that as a methodology is it not specific to any programming language. Many different programming languages can be used to implement 0-0 technology and design methodologies.Instead of procedures and functions passing data back and forth, in object oriented design, the system is viewed as a collection of objects with messages passed from object to object. Each object has its own set of associated operations.Object-oriented design is based on the idea of information hiding and modularization of both data and processing. It is best used when neither data structure nor processing operations are well defined ahead of time. This is quite useful in today's business environment where requirements are always changing and not very well defined. Thus, it has become quite popular! The concept of objects performing services is a natural way of thinking for both developers and customers. This facilitates understanding the problem domain and a more natural design. In addition, there are many benefits of object-oriented development. These include:•I n h e r i t a n c e c a p i t a l i z e s o n t h e c o m m o n a l t y o f a t t r i b u t e s a n d s e r v i c e s a l l o w i n g c o d e a n d objects to be re-used..I n f o r m a t i o n h i d i n g m a k e s s y s t e m s m o r e s t a b l e b y l o c a l i z i n g c h a n g e s t o o b j e c t s a n d t h e r e b y m a k i n g t h e m r e u s a b l e..T h e o b j e c t-o r i e n t e d d e v e l o p m e n t p r o c e s s i s c o n s i s t e n t f r o m a n a l y s i s,t h r o u g h d e s i g n, t o c o d i n g.More information on Object Oriented Programming principles can be found in Chapter 4-Organization of Programming Languages and Programming Concepts.2、P r o t o t y p i n gPrototyping was invented because end users participating in the development phase found it difficult to understand requirement specifications and conceptual models. However, when it first began being used in the 1980s, most conventional life c ycle developers considered it expensive and time consuming.S i n c e t h a t t i m e,u s e r s a n d d e v e l o p e r s h a v e u s e d p r o t o t y p e s s u c c e s s f u l l y a s a communications tool to demonstrate system requirements. After several prototype iterations, developers have a better understanding of user requirements and users have a better idea of how the system will eventually work, look, and l.T h e n u mb e r o f t i me s th e p r o to t yp e is in c r e me n t a l l y r e f in e d d e p e n d s o n h o w we l l th e u s e r r e q u i r e me n ts a n d u n d e r s t o o d.I t a ls o d e p e n d s o n th e u s e r s n e e d to a d d r e q u ir e me n ts o r c h a n g e p r e v i o u s l y s t a t e d r e q u i r e m e n t s.A f t e re s t a b l i s h i n g a n o v e r a l l a r c h i t e c t u r e a n df r a me w o r k, t h e s ys t e m i s d e v e l o p e d a n d d e l i v e r e d in in c r e me n ts.U s e r s ma y e x p e r i me n t w i t h a n d u s e d e l i v e r e d i n c r e me n t s w h i l e o t h e r s a r e b e i ng d e v e l o p e d.Fo r i n s t a n c e,th e fi r s t p r o t o t yp e ma y b e d e l i v e r e d t h a t i m p l e m e n t s a c e r t a i n s c r e e n w i t h o n l y s o m e a c t i v e m e n u i t e m s.W h i l e u s e r s a r e e x p e r i me n t i n g w i t h t h i s s c r e e n a n d me n u i t e ms,o t h e r s c r e e n s a n d me n u i t e ms a r e c o n c u r r e n t l y b e in gd e v e l o p e d wh i c h la t e r w il l b e c o mb in e d w i th th e e x is t in g p r o to t yp e a s ite vo l v e s.O n c e t h e u s e r i s s a t i s f i e d t h a t t h e p r o t o t y p e m e e t s r e q u i r e m e n t s,t h e p r o t o t y p e i s t r a n s f o r me d i n to th e"s ys t e m".T h i s e ff o r t d e p e n d s o n s e v e r a l f a c to r s. I t ma y i n c lu d e a d d i n g f u n c t i o n a l i t y t h a t w a s n't i n i t i a l l y r e c o g n i z e d a s r e q u i r e d,r e p l a c i n g i n e f f i c i e n t p a r t s o f t h e p r o t o t yp e t o me e t p e r f o r ma n c e c r i t e r i a,o r a d a p t i n g t h e p r o t o t yp e t o f i t t h e u s e r's h a r d w a r e e n vi r o n me n t.P r o t o t y p i n g c a n b e g i n v e r y e a r l y, a f t e r s o m e p r e l i m i n a r y r e q u i r e m e n t s a n a l y s i s h a s d e t e r m i n e d t h e b a s i c f u n c t i o n a l i t y,s c o p e,a n d e n v i r o n m e n t o f t h e p r o p o s e d s o f t w a r e.C o n t r a r y t o t h e t r a d i t i o n a l w a t e r f a l l me t h o d,i n t h e p r o t o t yp i n g,f u n c t i o n a l s p e c i f i c a t i o n s a r e n o t f i x e d.R a t h e r,u s e r s a r e e n c o u r a g e d t o m o d i f y t h e i r r e q u i r e m e n t s a s t h e y t h e m s e l v e s b e g i n t o u n d e r s t a n d t h e m b e t t e r.T h i s i s b e c a u s e u s e r s o f t e n d o n't r e a l l y k n o w w h a t t h e y w a n t u n t i l t h e y s e e i t o n t h e s c r e e n.T h e p r o t o t yp i n g p r o c e s s o f d e mo n s t r a t i o n,r e v i e w,a n d r e f i n e me n t g e t s t h e u s e r m o r e i n v o l v e d i n t h e d e v e l o p m e n t p r o c e s s,g i v i n g t h e m a s e n s e o f o w n e r s h i p d u r i n g t h e p r o c e s s a n d a t f i n a l s y s t e m d e l i v e r y.H o w e v e r,d u e t o t h e m i n d s e t o f"p r o t o t y p e", u s e r s o f t e n f in d i t d iff ic u l t to ve r if y t h a t th e p r o to t yp e s a tis f ie s th e ir r e q u ir e me n ts. T h e r e f o r e, g u id e l in e s mu s t b e e s t a b l i s h e d t o d e te r m in e wh e n t o s to p i te r a t in g a n d th e p r o to t yp e to f in a l p r o d u c t.。