计算机专业毕业论文文献翻译资料
计算机专业外文文献及翻译
微软Visual Studio1微软Visual StudioVisual Studio 是微软公司推出的开发环境，Visual Studio可以用来创建Windows平台下的Windows应用程序和网络应用程序，也可以用来创建网络服务、智能设备应用程序和Office 插件。
Visual Studio是一个来自微软的集成开发环境IDE，它可以用来开发由微软视窗，视窗手机，Windows CE、.NET框架、.NET精简框架和微软的Silverlight支持的控制台和图形用户界面的应用程序以及Windows窗体应用程序，网站，Web应用程序和网络服务中的本地代码连同托管代码。
Visual Studio包含一个由智能感知和代码重构支持的代码编辑器。
集成的调试工作既作为一个源代码级调试器又可以作为一台机器级调试器。
其他内置工具包括一个窗体设计的GUI应用程序，网页设计师，类设计师，数据库架构设计师。
它有几乎各个层面的插件增强功能，包括增加对支持源代码控制系统（如Subversion和Visual SourceSafe）并添加新的工具集设计和可视化编辑器，如特定于域的语言或用于其他方面的软件开发生命周期的工具（例如Team Foundation Server的客户端：团队资源管理器）。
Visual Studio支持不同的编程语言的服务方式的语言，它允许代码编辑器和调试器（在不同程度上）支持几乎所有的编程语言，提供了一个语言特定服务的存在。
内置的语言中包括C/C + +中（通过Visual C++）,（通过Visual ），C＃中（通过Visual C＃）和F＃（作为Visual Studio 2010），为支持其他语言，如M,Python,和Ruby等，可通过安装单独的语言服务。
它也支持的XML/XSLT,HTML/XHTML,JavaScript和CSS.为特定用户提供服务的Visual Studio也是存在的：微软Visual Basic，Visual J＃、Visual C＃和Visual C++。
计算机专业文献翻译
毕业设计（论文）外文资料原文及译文原文出处：《Cloud Computing》作者：M ichael Miller以下为英文原文Beyond the Desktop: An Introduction to Cloud ComputingIn a world that sees new technological trends bloom and fade on almost a daily basis, one new trend promises more longevity. This trend is called cloud computing, and it will change the way you use your computer and the Internet.Cloud computing portends a major change in how we store information and run applications. Instead of running programs and data on an individual desktop computer, everything is hosted in the “cloud”—a nebulous assemblage of computers and servers accessed via the Internet. Cloud computing lets you access all your applications and documents from anywhere in the world, freeing you from the confines of the desktop and making it easier for group members in different locations to collaborate.The emergence of cloud computing is the computing equivalent of the electricity revolution of a century ago. Before the advent of electrical utilities, every farm and business produced its own electricity from freestanding generators. After the electrical grid was created, farms and businesses shut down their generators and bought electricity from the utilities, at a much lower price (and with much greater reliability) than they could produce on their own.Look for the same type of revolution to occur as cloud computing takes hold. Thedesktop-centric notion of computing that we hold today is bound to fall by the wayside as we come to expect the universal access, 24/7 reliability, and ubiquitous collaboration promised by cloud computing.It is the way of the future.Cloud Computing: What It Is—and What It Isn’tWith traditional desktop computing, you run copies of software programs on each computer you own. The documents you create are stored on the computer on which they were created. Although documents can be accessed from other computers on the network, they can’t be accessed by computers outside the network.The whole scene is PC-centric.With cloud computing, the software programs you use aren’t run from your personal computer, but are rather stored on servers accessed via the Internet. If your computer crashes, the software is still available for others to use. Same goes for the documents you create; they’re stored on a collection of servers accessed via the Internet. Anyone with permission can not only access the documents, but can also edit and collaborate on those documents in real time. Unlike traditional computing, this cloud computing model isn’t PC-centric, it’sdocument-centric. Which PC you use to access a document simply isn’t important.But that’s a simplification. Let’s look in more detail at what cloud computing is—and, just as important, what it isn’t.What Cloud Computing Isn’tFirst, cloud computing isn’t network computing. With network computing,applications/documents are hosted on a single company’s server and accessed over the company’s network. Cloud computing is a lot bigger than that. It encompasses multiple companies, multiple servers, and multiple networks. Plus, unlike network computing, cloud services and storage are accessible from anywhere in the world over an Internet connection; with network computing, access is over the company’s network only.Cloud computing also isn’t traditional outsourcing, where a company farms out (subcontracts) its computing services to an outside firm. While an outsourcing firm might host a company’s data or applications, those documents and programs are only accessible to the company’s employees via the company’s network, not to the entire world via the Internet.So, despite superficial similarities, networking computing and outsourcing are not cloud computing.What Cloud Computing IsKey to the definition of cloud computing is the “cloud”itself. For our purposes, the cloud is a large group of interconnected computers. These computers can be personal computers or network servers; they can be public or private. For example, Google hosts a cloud that consists of both smallish PCs and larger servers. Google’s cloud is a private one (that is, Google owns it) that is publicly accessible (by Google’s users).This cloud of computers extends beyond a single company or enterprise. The applications and data served by the cloud are available to broad group of users, cross-enterprise andcross-platform. Access is via the Internet. Any authorized user can access these docs and apps from any computer over any Internet connection. And, to the user, the technology and infrastructure behind the cloud is invisible. It isn’t apparent (and, in most cases doesn’t matter) whether cloud services are based on HTTP, HTML, XML, JavaScript, or other specific technologies.It might help to examine how one of the pioneers of cloud computing, Google, perceives the topic. From Google’s perspective, there are six key properties of cloud computing:·Cloud computing is user-centric.Once you as a user are connected to the cloud, whatever is stored there—documents, messages, images, applications, whatever—becomes yours. In addition, not only is the data yours, but you can also share it with others. In effect, any device that accesses your data in the cloud also becomes yours.·Cloud computing is task-centric.Instead of focusing on the application and what it can do, the focus is on what you need done and how the application can do it for you., Traditional applications—word processing, spreadsheets, email, and so on—are becoming less important than the documents they create.·Cloud computing is powerful. Connecting hundreds or thousands of computers together in a cloud creates a wealth of computing power impossible with a single desktop PC. ·Cloud computing is accessible. Because data is stored in the cloud, users can instantly retrieve more information from multiple repositories. You’re not limited to a single source of data, as you are with a desktop PC.·Cloud computing is intelligent. With all the various data stored on the computers in a cloud, data mining and analysis are necessary to access that information in an intelligent manner.·Cloud computing is programmable.Many of the tasks necessary with cloud computing must be automated. For example, to protect the integrity of the data, information stored on a single computer in the cloud must be replicated on other computers in the cloud. If that one computer goes offline, the cloud’s programming automatically redistributes that computer’s data to a new computer in the cloud.All these definitions behind us, what constitutes cloud computing in the real world?As you’ll learn throughout this book, a raft of web-hosted, Internet-accessible,group-collaborative applications are currently available, with many more on the way. Perhaps the best and most popular examples of cloud computing applications today are the Google family of applications—Google Docs & Spreadsheets, Google Calendar, Gmail, Picasa, and the like. All of these applications are hosted on Google’s servers, are accessible to any user with an Internet connection, and can be used for group collaboration from anywhere in the world.In short, cloud computing enables a shift from the computer to the user, from applications to tasks, and from isolated data to data that can be accessed from anywhere and shared with anyone. The user no longer has to take on the task of data management; he doesn’t even have to remember where the data is. All that matters is that the data is in the cloud, and thus immediately available to that user and to other authorized users.From Collaboration to the Cloud: A Short History of CloudComputingCloud computing has as its antecedents both client/server computing and peer-to-peer distributed computing. It’s all a matter of how centralized storage facilitates collaboration and how multiple computers work together to increase computing power.Client/Server Computing: Centralized Applications and StorageIn the antediluvian days of computing (pre-1980 or so), everything operated on the client/server model. All the software applications, all the data, and all the control resided on huge mainframe computers, otherwise known as servers. If a user wanted to access specific data or run a program, he had to connect to the mainframe, gain appropriate access, and then do his business while essentially “renting”the program or data from the server.Users connected to the server via a computer terminal, sometimes called a workstation or client. This computer was sometimes called a dumb terminal because it didn’t have a lot (if any!) memory, storage space, or processing power. It was merely a device that connected the user to and enabled him to use the mainframe computer.Users accessed the mainframe only when granted permission, and the information technology (IT) staff weren’t in the habit of handing out access casually. Even on a mainframe computer, processing power is limited—and the IT staff were the guardians of that power. Access was not immediate, nor could two users access the same data at the same time.Beyond that, users pretty much had to take whatever the IT staff gave them—with no variations. Want to customize a report to show only a subset of the normal information? Can’t do it. Want to create a new report to look at some new data? You can’t do it, although the IT staff can—but on their schedule, which might be weeks from now.The fact is, when multiple people are sharing a single computer, even if that computer is a huge mainframe, you have to wait your turn. Need to rerun a financial report? No problem—if you don’t mind waiting until this afternoon, or tomorrow morning. There isn’t always immediate access in a client/server environment, and seldom is there immediate gratification.So the client/server model, while providing similar centralized storage, differed from cloud computing in that it did not have a user-centric focus; with client/server computing, all the control rested with the mainframe—and with the guardians of that single computer. It was not a user-enabling environment.Peer-to-Peer Computing: Sharing ResourcesAs you can imagine, accessing a client/server system was kind of a “hurry up and wait”experience. The server part of the system also created a huge bottleneck. All communications between computers had to go through the server first, however inefficient that might be.The obvious need to connect one computer to another without first hitting the server led to the development of peer-to-peer (P2P) computing. P2P computing defines a network architecture inwhich each computer has equivalent capabilities and responsibilities. This is in contrast to the traditional client/server network architecture, in which one or more computers are dedicated to serving the others. (This relationship is sometimes characterized as a master/slave relationship, with the central server as the master and the client computer as the slave.)P2P was an equalizing concept. In the P2P environment, every computer is a client and a server; there are no masters and slaves. By recognizing all computers on the network as peers, P2P enables direct exchange of resources and services. There is no need for a central server, because any computer can function in that capacity when called on to do so.P2P was also a decentralizing concept. Control is decentralized, with all computers functioning as equals. Content is also dispersed among the various peer computers. No centralized server is assigned to host the available resources and services.Perhaps the most notable implementation of P2P computing is the Internet. Many of today’s users forget (or never knew) that the Internet was initially conceived, under its original ARPAnet guise, as a peer-to-peer system that would share computing resources across the United States. The various ARPAnet sites—and there weren’t many of them—were connected together not as clients and servers, but as equals.The P2P nature of the early Internet was best exemplified by the Usenet network. Usenet, which was created back in 1979, was a network of computers (accessed via the Internet), each of which hosted the entire contents of the network. Messages were propagated between the peer computers; users connecting to any single Usenet server had access to all (or substantially all) the messages posted to each individual server. Although the users’connection to the Usenet server was of the traditional client/server nature, the relationship between the Usenet servers was definitely P2P—and presaged the cloud computing of today.That said, not every part of the Internet is P2P in nature. With the development of the World Wide Web came a shift away from P2P back to the client/server model. On the web, each website is served up by a group of computers, and sites’visitors use client software (web browsers) to access it. Almost all content is centralized, all control is centralized, and the clients have no autonomy or control in the process.Distributed Computing: Providing More Computing PowerOne of the most important subsets of the P2P model is that of distributed computing, where idle PCs across a network or across the Internet are tapped to provide computing power for large, processor-intensive projects. It’s a simple concept, all about cycle sharing between multiple computers.A personal computer, running full-out 24 hours a day, 7 days a week, is capable of tremendous computing power. Most people don’t use their computers 24/7, however, so a good portion of a computer’s resources go unused. Distributed computing uses those resources.When a computer is enlisted for a distributed computing project, software is installed on the machine to run various processing activities during those periods when the PC is typically unused. The results of that spare-time processing are periodically uploaded to the distributedcomputing network, and combined with similar results from other PCs in the project. The result, if enough computers are involved, simulates the processing power of much larger mainframes and supercomputers—which is necessary for some very large and complex computing projects.For example, genetic research requires vast amounts of computing power. Left to traditional means, it might take years to solve essential mathematical problems. By connecting together thousands (or millions) of individual PCs, more power is applied to the problem, and the results are obtained that much sooner.Distributed computing dates back to 1973, when multiple computers were networked togetherat the Xerox PARC labs and worm software was developed to cruise through the network looking for idle resources. A more practical application of distributed computing appeared in 1988, when researchers at the DEC (Digital Equipment Corporation) System Research Center developed software that distributed the work to factor large numbers among workstations within their laboratory. By 1990, a group of about 100 users, utilizing this software, had factored a 100-digit number. By 1995, this same effort had been expanded to the web to factor a 130-digit number.It wasn’t long before distributed computing hit the Internet. The first major Internet-based distributed computing project was , launched in 1997, which employed thousands of personal computers to crack encryption codes. Even bigger was SETI@home, launched in May 1999, which linked together millions of individual computers to search for intelligent life in outer space.Many distributed computing projects are conducted within large enterprises, using traditional network connections to form the distributed computing network. Other, larger, projects utilize the computers of everyday Internet users, with the computing typically taking place offline, and then uploaded once a day via traditional consumer Internet connections.Collaborative Computing: Working as a GroupFrom the early days of client/server computing through the evolution of P2P, there has been a desire for multiple users to work simultaneously on the same computer-based project. This type of collaborative computing is the driving force behind cloud computing, but has been aroundfor more than a decade.Early group collaboration was enabled by the combination of several different P2P technologies. The goal was (and is) to enable multiple users to collaborate on group projects online, in real time.To collaborate on any project, users must first be able to talk to one another. In today’s environment, this means instant messaging for text-based communication, with optionalaudio/telephony and video capabilities for voice and picture communication. Most collaboration systems offer the complete range of audio/video options, for full-featured multiple-user video conferencing.In addition, users must be able to share files and have multiple users work on the same document simultaneously. Real-time whiteboarding is also common, especially in corporate andeducation environments.Early group collaboration systems ranged from the relatively simple (Lotus Notes and Microsoft NetMeeting) to the extremely complex (the building-block architecture of the Groove Networks system). Most were targeted at large corporations, and limited to operation over the companies’private networks.Cloud Computing: The Next Step in CollaborationWith the growth of the Internet, there was no need to limit group collaboration to asingle enterprise’s network environment. Users from multiple locations within a corporation, and from multiple organizations, desired to collaborate on projects that crossed company and geographic boundaries. To do this, projects had to be housed in the “cloud”of the Internet, and accessed from any Internet-enabled location.The concept of cloud-based documents and services took wing with the development of large server farms, such as those run by Google and other search companies. Google already had a collection of servers that it used to power its massive search engine; why not use that same computing power to drive a collection of web-based applications—and, in the process, provide a new level of Internet-based group collaboration?That’s exactly what happened, although Google wasn’t the only company offering cloud computing solutions. On the infrastructure side, IBM, Sun Systems, and other big iron providers are offering the hardware necessary to build cloud networks. On the software side, dozens of companies are developing cloud-based applications and storage services.Today, people are using cloud services and storage to create, share, find, and organize information of all different types. Tomorrow, this functionality will be available not only to computer users, but to users of any device that connects to the Internet—mobile phones, portable music players, even automobiles and home television sets.The Network Is the Computer: How Cloud Computing WorksSun Microsystems’s slogan is “The network is the computer,”and that’s as good as any to describe how cloud computing works. In essence, a network of computers functions as a single computer to serve data and applications to users over the Internet. The network exists in the “cloud”of IP addresses that we know as the Internet, offers massive computing power and storage capability, and enables widescale group collaboration.But that’s the simple explanation. Let’s take a look at how cloud computing works in more detail.Understanding Cloud ArchitectureThe key to cloud computing is the “cloud”—a massive network of servers or even individual PCs interconnected in a grid. These computers run in parallel, combining the resources of eachto generate supercomputing-like power.What, exactly, is the “cloud”? Put simply, the cloud is a collection of computers and servers that are publicly accessible via the Internet. This hardware is typically owned and operated by a third party on a consolidated basis in one or more data center locations. The machines can run any combination of operating systems; it’s the processing power of the machines that matter, not what their desktops look like.As shown in Figure 1.1, individual users connect to the cloud from their own personal computers or portable devices, over the Internet. To these individual users, the cloud is seen as a single application, device, or document. The hardware in the cloud (and the operating system that manages the hardware connections) is invisible.FIGURE 1.1How users connect to the cloud.This cloud architecture is deceptively simple, although it does require some intelligent management to connect all those computers together and assign task processing to multitudes of users. As you can see in Figure 1.2, it all starts with the front-end interface seen by individual users. This is how users select a task or service (either starting an application or opening a document). The user’s request then gets passed to the system management, which finds the correct resources and then calls the system’s appropriate provisioning services. These services carve out the necessary resources in the cloud, launch the appropriate web application, and either creates or opens the requested document. After the web application is launched, the system’s monitoring and metering functions track the usage of the cloud so that resources are apportioned and attributed to the proper user(s).FIGURE 1.2The architecture behind a cloud computing system.As you can see, key to the notion of cloud computing is the automation of many management tasks. The system isn’t a cloud if it requires human management to allocate processes to resources. What you have in this instance is merely a twenty-first-century version ofold-fashioned data center–based client/server computing. For the system to attain cloud status, manual management must be replaced by automated processes.Understanding Cloud StorageOne of the primary uses of cloud computing is for data storage. With cloudstorage, data is stored on multiple third-party servers, rather than on the dedicated servers used in traditional networked data storage.When storing data, the user sees a virtual server—that is, it appears as if the data is stored in a particular place with a specific name. But that place doesn’t exist in reality. It’s just a pseudonym used to reference virtual space carved out of the cloud. In reality, the user’s data could be stored on any one or more of the computers used to create the cloud. The actual storage location may even differ from day to day or even minute to minute, as the cloud dynamically manages available storage space. But even though the location is virtual, the user sees a “static”location for his data—and can actually manage his storage space as if it were connected to his own PC.Cloud storage has both financial and security-associated advantages.Financially, virtual resources in the cloud are typically cheaper than dedicated physical resources connected to a personal computer or network. As for security, data stored in the cloud is secure from accidental erasure or hardware crashes, because it is duplicated across multiple physical machines; since multiple copies of the data are kept continually, the cloud continues to function as normal even if one or more machines go offline. If one machine crashes, the data is duplicated on other machines in the cloud.Understanding Cloud ServicesAny web-based application or service offered via cloud computing is called a cloud service. Cloud services can include anything from calendar and contact applications to word processing and presentations. Almost all large computing companies today, from Google to Amazon to Microsoft, are developing various types of cloud services.With a cloud service, the application itself is hosted in the cloud. An individual user runs the application over the Internet, typically within a web browser. The browser accesses the cloud service and an instance of the application is opened within the browser window. Once launched, the web-based application operates and behaves like a standard desktop application. The only difference is that the application and the working documents remain on the host’s cloud servers.Cloud services offer many advantages. If the user’s PC crashes, it doesn’t affect either the host application or the open document; both remain unaffected in the cloud. In addition, an individual user can access his applications and documents from any location on any PC. He doesn’t have to have a copy of every app and file with him when he moves from office to home to remote location. Finally, because documents are hosted in the cloud, multiple users can collaborate on the same document in real time, using any available Internet connection. Documents are no longer machine-centric. Instead, they’re always available to any authorized user.Companies in the Cloud: Cloud Computing TodayWe’re currently in the early days of the cloud computing revolution. Although many cloud services are available today, more and more interesting applications are still in development. That said, cloud computing today is attracting the best and biggest companies from across the computing industry, all of whom hope to establish profitable business models based in the cloud.As discussed earlier in this chapter, perhaps the most noticeable company currently embracing the cloud computing model is Google. As you’ll see throughout this book, Google offers a powerful collection of web-based applications, all served via its cloud architecture. Whether you want cloud-based word processing (Google Docs), presentation software (Google Presentations), email (Gmail), or calendar/scheduling functionality (Google Calendar), Google has an offering. And best of all, Google is adept in getting all of its web-based applications to interface with each other; their cloud services are interconnected to the user’s benefit.Other major companies are also involved in the development of cloud services. Microsoft, for example, offers its Windows Live suite of web-based applications, as well as the Live Mesh initiative that promises to link together all types of devices, data, and applications in a common cloud-based platform. Amazon has its Elastic Compute Cloud (EC2), a web service that provides cloud-based resizable computing capacity for application developers. IBM has established a Cloud Computing Center to deliver cloud services and research to clients. And numerous smaller companies have launched their own webbased applications, primarily (but not exclusively) to exploit the collaborative nature of cloud services.As we work through this book, we’ll examine many of these companies and their offerings. All you need to know for now is that there’s a big future in cloud computing—and everybody’s jumping on the bandwagon.Why Cloud Computing MattersWhy is cloud computing important? There are many implications of cloud technology, for both developers and end users.For developers, cloud computing provides increased amounts of storage and processing power to run the applications they develop. Cloud computing also enables new ways to access information, process and analyze data, and connect people and resources from any location anywhere in the world. In essence, it takes the lid off the box; with cloud computing, developers are no longer boxed in by physical constraints.For end users, cloud computing offers all those benefits and more. A person using a web-based application isn’t physically bound to a single PC, location, or network. His applications and documents can be accessed wherever he is, whenever he wants. Gone is the fear of losing data if a computer crashes. Documents hosted in the cloud always exist, no matter what happens to the user’s machine. And then there’s the benefit of group collaboration. Users from around the world can collaborate on the same documents, applications, and projects, in real time. It’s a whole new world of collaborative computing, all enabled by the notion of cloud computing.And cloud computing does all this at lower costs, because the cloud enables more efficient sharing of resources than does traditional network computing. With cloud computing, hardware doesn’t have to be physically adjacent to a firm’s office or data center. Cloud infrastructure can be located anywhere, including and especially areas with lower real estate and electricity costs. Inaddition, IT departments don’t have to engineer for peak-load capacity, because the peak load can be spread out among the external assets in the cloud. And, because additional cloud resources are always at the ready, companies no longer have to purchase assets for infrequent intensive computing tasks. If you need more processing power, it’ s always there in the cloud—and accessible on a cost-efficient basis.。
计算机类毕业设计英文文献及翻译
外貌在环境面板上的共同标签部分包括光，云，太阳和月亮的控制器。
启用灯光--当设置后，环境面板被点亮并且物体的场景会在全天不断变化。
当此复选框被清除，在场景中所有对象不亮也不随着一天时间的变化而变化。
（该对象将仍然被视为未点亮时，他们将使用为他们定制的颜色，材料和正常的价值观）。
启用云--当设置后，一个云层的场景便设置其中。
道路工具将定出海拔类型和云层类型。
默认情况下，此值未设置。
启用太阳/月亮--当设置，太阳和月球环境的效果显示并且月亮环境的效果有助于现场场景内的任何物体的照明。
当此复选框被清除，太阳和月亮不会被显示并且月亮助手停止现场照明。
默认情况下，太阳和月亮是没有设置。
注：太阳和月亮在天空的位置和绘制使用星历模型。
太阳和月亮的位置是根据一天中的时间，日期，纬度和经度绘制的。
月亮的月球阶段也以同样的方式计算。
天空颜色在环境面板上的共同标签部分包括天空的颜色，云的颜色，周围的颜色，天气的控制，和雾。
注：彩色按钮旁边的天空，云，和环境（背景）显示你当前的颜色。
单击每个按钮来改变颜色。
云的颜色--这个颜色的按钮显示您的云层的颜色。
点击就显示颜色对话框，然后选择一个新的颜色，然后点击确定。
环境光颜色--这个颜色的彩色按钮显示您当前的周围灯光组件的颜色。
点击就显示颜色对话框，然后选择一个新的颜色，然后点击确定。
环境光元件有助于场景和物体的亮度；默认设置是应用一个小环境光线。
环境光照亮了现场或对象，当一天的时间设置为晚，对象将仍然由于环境光而可见。
环境光可以用来照亮一个带有黑暗纹理或者用IRIX电脑做出纹理的物体。
（IRIX电脑相对于WINDOWS电脑使用了不同的GAMMA设置，他使Irix计算机处理的纹理总是看上去黑暗，直到图像编辑程序纠正才能恢复正常。
）天气--此选项不使用这种版本的路径工具。
在今后的版本中，天气列表将包含环境设置预设模拟不同时间的天气事件，如日出，上午，傍晚，夜间，多云，雨，雪等。
计算机专业毕业论文外文翻译
附录（英文翻译）Rich Client Tutorial Part 1The Rich Client Platform (RCP) is an exciting new way to build Java applications that can compete with native applications on any platform. This tutorial is designed to get you started building RCP applications quickly. It has been updated for Eclipse 3.1.2By Ed Burnette, SASJuly 28, 2004Updated for 3.1.2: February 6, 2006IntroductionTry this experiment: Show Eclipse to some friends or co-workers who haven't seen it before and ask them to guess what language it is written in. Chances are, they'll guess VB, C++, or C#, because those languages are used most often for high quality client side applications. Then watch the look on their faces when you tell them it was created in Java, especially if they are Java programmers.Because of its unique open source license, you can use the technologies that went into Eclipse to create your own commercial quality programs. Before version 3.0, this was possible but difficult, especially when you wanted to heavily customize the menus, layouts, and other user interface elements. That was because the "IDE-ness" of Eclipse was hard-wired into it. Version 3.0 introduced the Rich Client Platform (RCP), which is basically a refactoring of the fundamental parts of Eclipse's UI, allowing it to be used for non-IDE applications. Version 3.1 updated RCP with new capabilities, and, most importantly, new tooling support to make it easier to create than before.If you want to cut to the chase and look at the code for this part you can find it in the accompanying zip file. Otherwise, let's take a look at how to construct an RCP application.Getting startedRCP applications are based on the familiar Eclipse plug-in architecture, (if it's not familiar to you, see the references section). Therefore, you'll need to create a plug-in to be your main program. Eclipse's Plug-in Development Environment (PDE) provides a number of wizards and editors that take some of the drudgery out of the process. PDE is included with the Eclipse SDK download so that is the package you should be using. Here are the steps you should follow to get started.First, bring up Eclipse and select File > New > Project, then expand Plug-in Development and double-click Plug-in Project to bring up the Plug-in Project wizard. On the subsequent pages, enter a Project name such as org.eclipse.ui.tutorials.rcp.part1, indicate you want a Java project, select the version of Eclipse you're targeting (at least 3.1), and enable the option to Create an OSGi bundle manifest. Then click Next >.Beginning in Eclipse 3.1 you will get best results by using the OSGi bundle manifest. In contrast to previous versions, this is now the default.In the next page of the Wizard you can change the Plug-in ID and other parameters. Of particular importance is the question, "Would you like to create a rich client application?". Select Yes. The generated plug-in class is optional but for this example just leave all the other options at their default values. Click Next > to continue.If you get a dialog asking if Eclipse can switch to the Plug-in Development Perspective click Remember my decision and select Yes (this is optional).Starting with Eclipse 3.1, several templates have been provided to make creating an RCP application a breeze. We'll use the simplest one available and see how it works. Make sure the option to Create a plug-in using one of the templates is enabled, then select the Hello RCP template. This isRCP's equivalent of "Hello, world". Click Finish to accept all the defaults and generate the project (see Figure 1). Eclipse will open the Plug-in Manifest Editor. The Plug-in Manifest editor puts a friendly face on the various configuration files that control your RCP application.Figure 1. The Hello World RCP project was created by a PDE wizard.Taking it for a spinTrying out RCP applications used to be somewhat tedious. You had to create a custom launch configuration, enter the right application name, and tweak the plug-ins that were included. Thankfully the PDE keeps track of all this now. All you have to do is click on the Launch an Eclipse Application button in the Plug-in Manifest editor's Overview page. You should see a bare-bones Workbench start up (see Figure 2).Figure 2. By using thetemplates you can be up andrunning anRCPapplication inminutes.Making it aproductIn Eclipse terms a product is everything that goes with your application, including all the other plug-ins it depends on, a command to run the application (called the native launcher), and any branding (icons, etc.) that make your application distinctive. Although as we've just seen you can run a RCP application without defining a product, having one makes it a whole lot easier to run the application outside of Eclipse. This is one of the major innovations that Eclipse 3.1 brought to RCP development.Some of the more complicated RCP templates already come with a product defined, but the Hello RCP template does not so we'll have to make one.In order to create a product, the easiest way is to add a product configuration file to the project. Right click on the plug-in project and select New > Product Configuration. Then enter a file name for this new configuration file, such as part1.product. Leave the other options at their default values. Then click Finish. The Product Configuration editor will open. This editor lets you control exactly what makes up your product including all its plug-ins and branding elements.In the Overview page, select the New... button to create a new product extension. Type in or browse to the defining plug-in(org.eclipse.ui.tutorials.rcp.part1). Enter a Product ID such as product, and for the Product Application selectorg.eclipse.ui.tutorials.rcp.part1.application. Click Finish to define the product. Back in the Overview page, type in a new Product Name, for example RCP Tutorial 1.In Eclipse 3.1.0 if you create the product before filling inthe Product Name you may see an error appear in the Problems view. The error will go away when you Synchronize (see below). This is a known bug that is fixed in newer versions. Always use the latest available maintenance release for the version of Eclipse you're targeting!Now select the Configuration tab and click Add.... Select the plug-in you just created (org.eclipse.ui.tutorials.rcp.part1) and then click on Add Required Plug-ins. Then go back to the Overview page and press Ctrl+S or File > Save to save your work.If your application needs to reference plug-ins that cannot be determined until run time (for example the tomcat plug-in), then add them manually in the Configuration tab.At this point you should test out the product to make sure it runs correctly. In the Testing section of the Overview page, click on Synchronize then click on Launch the product. If all goes well, the application should start up just like before.Plug-ins vs. featuresOn the Overview page you may have noticed an option that says the product configuration is based on either plug-ins or features. The simplest kind of configuration is one based on plug-ins, so that's what this tutorial uses. If your product needs automatic update or Java Web Start support, then eventually you should convert it to use features. But take my advice and get it working without them first.Running it outside of EclipseThe whole point of all this is to be able to deploy and run stand-alone applications without the user having to know anything about the Java and Eclipse code being used under the covers. For a real application you may want to provide a self-contained executable generated by an install program like InstallShield or NSIS. That's really beyond the scope of this article though, so we'll do something simpler.The Eclipse plug-in loader expects things to be in a certain layout so we'll need to create a simplified version of the Eclipse install directory. This directory has to contain the native launcher program, config files,and all the plug-ins required by the product. Thankfully, we've given the PDE enough information that it can put all this together for us now.In the Exporting section of the Product Configuration editor, click the link to Use the Eclipse Product export wizard. Set the root directory to something like RcpTutorial1. Then select the option to deploy into a Directory, and enter a directory path to a temporary (scratch) area such as C:\Deploy. Check the option to Include source code if you're building an open source project. Press Finish to build and export the program.The compiler options for source and class compatibility in the Eclipse Product export wizard will override any options you have specified on your project or global preferences. As part of the Export process, the plug-in is code is recompiled by an Ant script using these options.The application is now ready to run outside Eclipse. When you're done you should have a structure that looks like this in your deployment directory:RcpTutorial1| .eclipseproduct| eclipse.exe| startup.jar+--- configuration| config.ini+--- pluginsmands_3.1.0.jarorg.eclipse.core.expressions_3.1.0.jarorg.eclipse.core.runtime_3.1.2.jarorg.eclipse.help_3.1.0.jarorg.eclipse.jface_3.1.1.jarorg.eclipse.osgi_3.1.2.jarorg.eclipse.swt.win32.win32.x86_3.1.2.jarorg.eclipse.swt_3.1.0.jarorg.eclipse.ui.tutorials.rcp.part1_1.0.0.jarorg.eclipse.ui.workbench_3.1.2.jarorg.eclipse.ui_3.1.2.jarNote that all the plug-ins are deployed as jar files. This is the recommended format starting in Eclipse 3.1. Among other things this saves disk space in the deployed application.Previous versions of this tutorial recommended using a batch file or shell script to invoke your RCP program. It turns out this is a bad idea because you will not be able to fully brand your application later on. For example, you won't be able to add a splash screen. Besides, theexport wizard does not support the batch file approach so just stick with the native launcher.Give it a try! Execute the native launcher (eclipse or eclipse.exe by default) outside Eclipse and watch the application come up. The name of the launcher is controlled by branding options in the product configuration.TroubleshootingError: Launching failed because the org.eclipse.osgi plug-in is not included...You can get this error when testing the product if you've forgotten to list the plug-ins that make up the product. In the Product Configuration editor, select the Configuration tab, and add all your plug-ins plus all the ones they require as instructed above.Compatibility and migrationIf you are migrating a plug-in from version 2.1 to version 3.1 there are number of issues covered in the on-line documentation that you need to be aware of. If you're making the smaller step from 3.0 to 3.1, the number of differences is much smaller. See the References section for more information.One word of advice: be careful not to duplicate any information in both plug-in.xml and MANIFEST.MF. Typically this would not occur unless you are converting an older plug-in that did not use MANIFEST.MF into one that does, and even then only if you are editing the files by hand instead of going through the PDE.ConclusionIn part 1 of this tutorial, we looked at what is necessary to create a bare-bones Rich Client application. The next part will delve into the classes created by the wizards such as the WorkbenchAdvisor class. All the sample code for this part may be found in the accompanying zip file.ReferencesRCP Tutorial Part 2RCP Tutorial Part 3Eclipse Rich Client PlatformRCP Browser example (project org.eclipse.ui.examples.rcp.browser)PDE Does Plug-insHow to Internationalize your Eclipse Plug-inNotes on the Eclipse Plug-in ArchitecturePlug-in Migration Guide: Migrating to 3.1 from 3.0Plug-in Migration Guide: Migrating to 3.0 from 2.1译文：Rich Client教程第一部分The Rich Client Platform (RCP)是一种创建Java应用程序的令人兴奋的新方法，可以和任何平台下的自带应用程序进行竞争。
计算机专业毕业外文翻译原文+封面+中文翻译
本科毕业论文外文翻译外文译文题目（中文）：具体数学：汉诺塔问题学院: 计算机科学与技术专业: 计算机科学与技术学号:学生姓名:指导教师:日期: 二○一二年六月1 Recurrent ProblemsTHIS CHAPTER EXPLORES three sample problems that give a feel for what’s to c ome. They have two traits in common: They’ve all been investigated repeatedly by mathe maticians; and their solutions all use the idea of recurrence, in which the solution to eac h problem depends on the solutions to smaller instances of the same problem.1.1 THE TOWER OF HANOILet’s look first at a neat little puzzle called the Tower of Hanoi,invented by the Fr ench mathematician Edouard Lucas in 1883. We are given a tower of eight disks, initiall y stacked in decreasing size on one of three pegs:The objective is to transfer the entire tower to one of the other pegs, movingonly one disk at a time and never moving a larger one onto a smaller.Lucas furnished his toy with a romantic legend about a much larger Tower of Brah ma, which supposedly has 64 disks of pure gold resting on three diamond needles. At th e beginning of time, he said, God placed these golden disks on the first needle and orda ined that a group of priests should transfer them to the third, according to the rules abov e. The priests reportedly work day and night at their task. When they finish, the Tower will crumble and the world will end.It's not immediately obvious that the puzzle has a solution, but a little thought (or h aving seen the problem before) convinces us that it does. Now the question arises：What' s the best we can do？That is，how many moves are necessary and suff i cient to perfor m the task?The best way to tackle a question like this is to generalize it a bit. The Tower of Brahma has 64 disks and the Tower of Hanoi has 8；let's consider what happens if ther e are TL disks.One advantage of this generalization is that we can scale the problem down even m ore. In fact, we'll see repeatedly in this book that it's advantageous to LOOK AT SMAL L CASES first. It's easy to see how to transfer a tower that contains only one or two di sks. And a small amount of experimentation shows how to transfer a tower of three.The next step in solving the problem is to introduce appropriate notation：NAME ANO CONQUER. Let's say that T n is the minimum number of moves that will t ransfer n disks from one peg to another under Lucas's rules. Then T1is obviously 1 , an d T2= 3.We can also get another piece of data for free, by considering the smallest case of all：Clearly T0= 0，because no moves at all are needed to transfer a tower of n = 0 disks! Smart mathematicians are not ashamed to think small,because general patterns are easier to perceive when the extreme cases are well understood(even when they are trivial).But now let's change our perspective and try to think big；how can we transfer a la rge tower? Experiments with three disks show that the winning idea is to transfer the top two disks to the middle peg, then move the third, then bring the other two onto it. Thi s gives us a clue for transferring n disks in general：We first transfer the n−1 smallest t o a different peg (requiring T n-1moves), then move the largest (requiring one move), and finally transfer the n−1 smallest back onto the largest (req uiring another T n-1moves). Th us we can transfer n disks (for n > 0)in at most 2T n-1+1 moves：T n≤2T n—1+1，for n > 0.This formula uses '≤' instead of '=' because our construction proves only that 2T n—1+1 mo ves suffice; we haven't shown that 2T n—1+1 moves are necessary. A clever person might be able to think of a shortcut.But is there a better way? Actually no. At some point we must move the largest d isk. When we do, the n−1 smallest must be on a single peg, and it has taken at least T moves to put them there. We might move the largest disk more than once, if we're n n−1ot too alert. But after moving the largest disk for the last time, we must trans fr the n−1 smallest disks (which must again be on a single peg)back onto the largest；this too re quires T n−1moves. HenceT n≥ 2T n—1+1，for n > 0.These two inequalities, together with the trivial solution for n = 0, yieldT0=0；T n=2T n—1+1 , for n > 0. (1.1)(Notice that these formulas are consistent with the known values T1= 1 and T2= 3. Our experience with small cases has not only helped us to discover a general formula, it has also provided a convenient way to check that we haven't made a foolish error. Such che cks will be especially valuable when we get into more complicated maneuvers in later ch apters.)A set of equalities like (1.1) is called a recurrence (a. k. a. recurrence relation or r ecursion relation). It gives a boundary value and an equation for the general value in ter ms of earlier ones. Sometimes we refer to the general equation alone as a recurrence, alt hough technically it needs a boundary value to be complete.The recurrence allows us to compute T n for any n we like. But nobody really like to co m pute fro m a recurrence，when n is large；it takes too long. The recurrence only gives indirect, "local" information. A solution to the recurrence would make us much h appier. That is, we'd like a nice, neat, "closed form" for Tn that lets us compute it quic kly，even for large n. With a closed form, we can understand what T n really is.So how do we solve a recurrence? One way is to guess the correct solution,then to prove that our guess is correct. And our best hope for guessing the solution is t o look (again) at small cases. So we compute, successively,T3= 2×3+1= 7; T4= 2×7+1= 15; T5= 2×15+1= 31; T6= 2×31+1= 63.Aha! It certainly looks as ifTn = 2n−1，for n≥0. (1.2)At least this works for n≤6.Mathematical induction is a general way to prove that some statement aboutthe integer n is true for all n≥n0. First we prove the statement when n has its smallest v alue,no; this is called the basis. Then we prove the statement for n > n0,assuming that it has already been proved for all values between n0and n−1, inclusive; this is called th e induction. Such a proof gives infinitely many results with only a finite amount of wo rk.Recurrences are ideally set up for mathematical induction. In our case, for exampl e，(1.2) follows easily from (1.1)：The basis is trivial，since T0 = 20−1= 0.And the indu ction follows for n > 0 if we assume that (1.2) holds when n is replaced by n−1：T n= 2T n+1= 2(2n−1−1)+1=2n−1.Hence (1.2) holds for n as well. Good! Our quest for T n has ended successfully.Of course the priests' task hasn't ended；they're still dutifully moving disks,and wil l be for a while, because for n = 64 there are 264−1 moves (about 18 quintillion). Even at the impossible rate of one move per microsecond, they will need more than 5000 cent uries to transfer the Tower of Brahma. Lucas's original puzzle is a bit more practical, It requires 28−1 = 255 moves, which takes about four minutes for the quick of hand.The Tower of Hanoi recurrence is typical of many that arise in applications of all kinds. In finding a closed-form expression for some quantity of interest like T n we go t hrough three stages：1 Look at small cases. This gives us insight into the problem and helps us in stages2 and 3.2 Find and prove a mathematical expression for the quantity of interest.For the Tower of Hanoi, this is the recurrence (1.1) that allows us, given the inc lination，to compute T n for any n.3 Find and prove a closed form for our mathematical expression.For the Tower of Hanoi, this is the recurrence solution (1.2).The third stage is the one we will concentrate on throughout this book. In fact, we'll fre quently skip stages I and 2 entirely, because a mathematical expression will be given tous as a starting point. But even then, we'll be getting into subproblems whose solutions will take us through all three stages.Our analysis of the Tower of Hanoi led to the correct answer, but it r equired an“i nductive leap”；we relied on a lucky guess about the answer. One of the main objectives of this book is to explain how a person can solve recurrences without being clairvoyant. For example, we'll see that recurrence (1.1) can be simplified by adding 1 to both sides of the equations：T0+ 1= 1;T n + 1= 2T n-1+ 2, for n >0.Now if we let U n= T n+1，we haveU0 =1；U n= 2U n-1，for n > 0. (1.3)It doesn't take genius to discover that the solution to this recurrence is just U n= 2n；he nce T n= 2n −1. Even a computer could discover this.Concrete MathematicsR. L. Graham, D. E. Knuth, O. Patashnik《Concrete Mathematics》，1.1 ，The Tower Of HanoiR. L. Graham, D. E. Knuth, O. PatashnikSixth printing, Printed in the United States of America1989 by Addison-Wesley Publishing Company，Reference 1-4 pages具体数学R.L.格雷厄姆，D.E.克努特，O.帕塔希尼克《具体数学》，1.1，汉诺塔R.L.格雷厄姆，D.E.克努特，O.帕塔希尼克第一版第六次印刷于美国，韦斯利出版公司，1989年，引用1-4页1 递归问题本章将通过对三个样本问题的分析来探讨递归的思想。
计算机专业英文文献
What Is an Object?Objects are key to understanding object-oriented technology. You can look around you now and see many examples of real-world objects: your dog, your desk, your television set, your bicycle.Real-world objects share two characteristics: They all have state and behavior. For example, dogs have state (name, color, breed, hungry) and behavior (barking, fetching, wagging tail). Bicycles have state (current gear, current pedal cadence, two wheels, number of gears) and behavior (braking, accelerating, slowing down, changing gears).Software objects are modeled after real-world objects in that they too have state and behavior. A software object maintains its state in one or more variables.A variable is an item of data named by an identifier. A software object implements its behavior with methods. A method is a function (subroutine) associated with an object.Definition:An object is a software bundle of variables and related methods. You can represent real-world objects by using software objects. You might want to represent real-world dogs as software objects in an animation program or a real-world bicycle as a software object in the program that controls an electronic exercise bike. You can also use software objects to model abstract concepts. For example, an event is a common object used in window systems to represent the action of a user pressing a mouse button or a key on the keyboard. The following illustration is a common visual representation of a software object.A software object.Everything the software object knows (state) and can do (behavior) is expressed by the variables and the methods within that object. A software object that modelsyour real-world bicycle would have variables that indicate the bicycle's current state: Its speed is 18 mph, its pedal cadence is 90 rpm, and its current gear is 5th. These variables are formally known as instance variables because they contain the state for a particular bicycle object; in object-oriented terminology, a particular object is called an instance. The following figure illustrates a bicycle modeled as a software object.A bicycle modeled as a softwareobject.In addition to its variables, the software bicycle would also have methods to brake, change the pedal cadence, and change gears. (It would not have a method for changing its speed because the bike's speed is just a side effect of which gear it's in and how fast the rider is pedaling.) These methods are known formally as instance methods because they inspect or change the state of a particular bicycle instance.Object diagrams show that an object's variables make up the center, or nucleus, of the object. Methods surround and hide the object's nucleus from other objects in the program. Packaging an object's variables within the protective custody of its methods is called encapsulation. This conceptual picture of an object —a nucleus of variables packaged within a protective membrane of methods — is an ideal representation of an object and is the ideal that designers of object-oriented systems strive for. However, it's not the whole story.Often, for practical reasons, an object may expose some of its variables or hide some of its methods. In the Java programming language, an object can specify one of four access levels for each of its variables and methods. The access level determines which other objects and classes can access that variable or method. Refer to the Controlling Access to Members of a Class section for details.Encapsulating related variables and methods into a neat software bundle is a simple yet powerful idea that provides two primary benefits to software developers:Modularity:The source code for an object can be written and maintainedindependently of the source code for other objects. Also, an objectcan be easily passed around in the system. You can give your bicycleto someone else, and it will still work.Information-hiding: An object has a public interface that otherobjects can use to communicate with it. The object can maintain privateinformation and methods that can be changed at any time withoutaffecting other objects that depend on it. You don't need to understanda bike's gear mechanism to use it.What Is a Message?A single object alone generally is not very useful. Instead, an object usually appears as a component of a larger program or application that contains many other objects. Through the interaction of these objects, programmers achieve higher-order functionality and more complex behavior. Your bicycle hanging from a hook in the garage is just a bunch of metal and rubber; by itself, it is incapable of any activity; the bicycle is useful only when another object (you) interacts with it (by pedaling).Software objects interact and communicate with each other by sending messages to each other. When object A wants object B to perform one of B's methods, object A sends a message to object B (see the following figure).Objects interact by sending each other messages.Sometimes, the receiving object needs more information so that it knows exactly what to do; for example, when you want to change gears on your bicycle, you have to indicate which gear you want. This information is passed along with the message as parameters.Messages use parameters to pass alongextra information that the objectneeds —in this case, which gear thebicycle should be in.These three parts are enough information for the receiving object to perform the desired method. No other information or context is required.Messages provide two important benefits:An object's behavior is expressed through its methods, so (aside fromdirect variable access) message passing supports all possibleinteractions between objects.Objects don't need to be in the same process or even on the same machineto send messages back and forth and receive messages from each other. What Is a Class?In the real world, you often have many objects of the same kind. For example, your bicycle is just one of many bicycles in the world. Using object-orientedterminology, we say that your bicycle object is an instanceof the class of objects known as bicycles. Bicycles have some state (current gear, current cadence, two wheels) and behavior (change gears, brake) in common. However, each bicycle's state is independent of and can be different from that of other bicycles.When building them, manufacturers take advantage of the fact that bicycles share characteristics, building many bicycles from the same blueprint. It would be very inefficient to produce a new blueprint for every bicycle manufactured.In object-oriented software, it's also possible to have many objects of the same kind that share characteristics: rectangles, employee records, video clips, and so on. Like bicycle manufacturers, you can take advantage of the fact that objects of the same kind are similar and you can create a blueprint for those objects.A software blueprint for objects is called a class (see the following figure).A visual representation of a class.Definition: A class is a blueprint that defines the variables and the methods common to all objects of a certain kind.The class for our bicycle example would declare the instance variables necessary to contain the current gear, the current cadence, and so on for each bicycle object. The class would also declare and provide implementations for the instance methods that allow the rider to change gears, brake, and change the pedaling cadence, as shown in the next figure.The bicycle class.After you've created the bicycle class, you can create any number of bicycleobjects from that class. When you create an instance of a class, the system allocates enough memory for the object and all its instance variables. Each instance gets its own copy of all the instance variables defined in the class, as the next figure shows.MyBike and YourBike are two different instances of the Bike class. Each instance has its own copy of the instance variables defined in the Bike class but has different values for these variables.In addition to instance variables, classes can define class variables. A class wariable contains information that is shared by all instances of the class. For example, suppose that all bicycles had the same number of gears. In this case, defining an instance variable to hold the number of gears is inefficient; each instance would have its own copy of the variable, but the value would be the same for every instance. In such situations, you can define a class variable that contains the number of gears (see the following figure); all instances share this variable. If one object changes the variable, it changes for all other objects of that type.YourBike, an instance of Bike, has access to the numberOfGears variable in the Bike class; however, the YourBike instance does not have a copy of this class variable.A class can also declare class methods You can invoke a class method directly from the class, whereas you must invoke instance methods on a particular instance.The Understanding Instance and Class Members section discusses instance variables and methods and class variables and methods in detail.Objects provide the benefit of modularity and information-hiding. Classes provide the benefit of reusability. Bicycle manufacturers use the same blueprint over and over again to build lots of bicycles. Software programmers use the same class, and thus the same code, over and over again to create many objects.Objects versus ClassesYou've probably noticed that the illustrations of objects and classes look very similar. And indeed, the difference between classes and objects is often the source of some confusion. In the real world, it's obvious that classes are not themselves the objects they describe; that is, a blueprint of a bicycle is not a bicycle. However, it's a little more difficult to differentiate classes and objects in software. This is partially because software objects are merelyelectronic models of real-world objects or abstract concepts in the first place. But it's also because the term object is sometimes used to refer to both classes and instances.In illustrations such as the top part of the preceding figure, the class is not shaded because it represents a blueprint of an object rather than the object itself. In comparison, an object is shaded, indicating that the object exists and that you can use it.What Is Inheritance?Generally speaking, objects are defined in terms of classes. You know a lot about an object by knowing its class. Even if you don't know what a penny-farthing is, if I told you it was a bicycle, you would know that it had two wheels, handlebars, and pedals.Object-oriented systems take this a step further and allow classes to be defined in terms of other classes. For example, mountain bikes, road bikes, and tandems are all types of bicycles. In object-oriented terminology, mountain bikes, road bikes, and tandems are all subclasses of the bicycle class. Similarly, the bicycle class is the supclasses of mountain bikes, road bikes, and tandems. This relationship is shown in the following figure.The hierarchy of bicycle classes.Each subclass inherits state (in the form of variable declarations) from the superclass. Mountain bikes, road bikes, and tandems share some states: cadence, speed, and the like. Also, each subclass inherits methods from the superclass. Mountain bikes, road bikes, and tandems share some behaviors — braking and changing pedaling speed, for example.However, subclasses are not limited to the states and behaviors provided to them by their superclass. Subclasses can add variables and methods to the ones they inherit from the superclass. Tandem bicycles have two seats and two sets of handlebars; some mountain bikes have an additional chain ring, giving them a lower gear ratio.Subclasses can also override inherited methods and provide specialized implementations for those methods. For example, if you had a mountain bike with an additional chain ring, you could override the "change gears" method so that the rider could shift into those lower gears.You are not limited to just one layer of inheritance. The inheritance tree, or class hierardry, can be as deep as needed. Methods and variables are inherited down through the levels. In general, the farther down in the hierarchy a class appears, the more specialized its behavior.Note:Class hierarchies should reflect what the classes are, not how they're implemented. When implementing a tricycle class, it might be convenient to make it a subclass of the bicycle class —after all, both tricycles and bicycles have a current speed and cadence. However, because a tricycle is not a bicycle, it's unwise to publicly tie the two classes together. It could confuse users, make the tricycle class have methods (for example, to change gears) that it doesn't need, and make updating or improving the tricycle class difficult.The Object class is at the top of class hierarchy, and each class is its descendant (directly or indirectly). A variable of type Object can hold a reference to any object, such as an instance of a class or an array. Object provides behaviors that are shared by all objects running in the Java Virtual Machine. For example, all classes inherit Object's toString method, which returns a string representation of the object. The Managing Inheritance section covers the Object class in detail.Inheritance offers the following benefits:Subclasses provide specialized behaviors from the basis of commonelements provided by the superclass. Through the use of inheritance,programmers can reuse the code in the superclass many times.Programmers can implement superclasses called abstract classes thatdefine common behaviors. The abstract superclass defines and maypartially implement the behavior, but much of the class is undefinedand unimplemented. Other programmers fill in the details withspecialized subclasses.What Is an Interface?In general, an interface is a device or a system that unrelated entities use to interact. According to this definition, a remote control is an interface between you and a television set, the English language is an interface between two people, and the protocol of behavior enforced in the military is the interface between individuals of different ranks.Within the Java programming language, an interface is a type, just as a class is a type. Like a class, an interface defines methods. Unlike a class, an interface never implements methods; instead, classes that implement the interface implement the methods defined by the interface. A class can implement multiple interfaces.The bicycle class and its class hierarchy define what a bicycle can and cannot do in terms of its "bicycleness." But bicycles interact with the world on other terms. For example, a bicycle in a store could be managed by an inventory program. An inventory program doesn't care what class of items it manages as long as each item provides certain information, such as price and tracking number. Instead of forcing class relationships on otherwise unrelated items, the inventory program sets up a communication protocol. This protocol comes in the form of a set of method definitions contained within an interface. The inventory interface would define, but not implement, methods that set and get the retail price, assign a tracking number, and so on.计算机专业中英文文献翻译To work in the inventory program, the bicycle class must agree to this protocol by implementing the interface. When a class implements an interface, the class agrees to implement all the methods defined in the interface. Thus, the bicycle class would provide the implementations for the methods that set and get retail price, assign a tracking number, and so on.You use an interface to define a protocol of behavior that can be implemented by any class anywhere in the class hierarchy. Interfaces are useful for the following:Capturing similarities among unrelated classes without artificiallyforcing a class relationshipDeclaring methods that one or more classes are expected to implementRevealing an object's programming interface without revealing itsclassModeling multiple inheritance, a feature of some object-orientedlanguages that allows a class to have more than one superclass。
计算机专业毕业设计文献翻译
单位代码学号分类号密级_________ 文献翻译一切都是对象院（系）名称专业名称学生姓名指导教师2008年4月15日英语译文一切都是对象王瑞“尽管以C++为基础，但Java是一种更纯粹的面向对象程序设计语言”。
无论C++还是Java都属于杂合语言。
但在Java中，设计者觉得这种杂合并不像在C++里那么重要。
杂合语言允许采用多种编程风格；之所以说C++是一种杂合语言，是因为它支持与C语言的向后兼容能力。
由于C++是C的一个超集，所以包含的许多特性都是后者不具备的，这些特性使C++在某些地方显得过于复杂。
Java语言首先便假定了我们只希望进行面向对象的程序设计。
也就是说，正式用它设计之前，必须先将自己的思想转入一个面向对象的世界（除非早已习惯了这个世界的思维方式）。
只有做好这个准备工作，与其他OOP语言相比，才能体会到Java的易学易用。
下面，我们将探讨Java程序的基本组件，并体会为什么说Java乃至Java程序内的一切都是对象。
(1)用句柄操纵对象。
每种编程语言都有自己的数据处理方式。
有些时候，程序员必须时刻留意准备处理的是什么类型。
您曾利用一些特殊语法直接操作过对象，或处理过一些间接表示的对象吗（C或C++里的指针）？所有这些在Java里都得到了简化，任何东西都可看作对象。
因此，我们可采用一种统一的语法，任何地方均可照搬不误。
但要注意，尽管将一切都“看作”对象，但操纵的标识符实际是指向一个对象的“句柄”（Handle）。
在其他Java参考书里，还可看到有的人将其称作一个“引用”，甚至一个“指针”。
可将这一情形想象成用遥控板（句柄）操纵电视机（对象）。
只要握住这个遥控板，就相当于掌握了与电视机连接的通道。
但一旦需要“换频道”或者“关小声音”，我们实际操纵的是遥控板（句柄），再由遥控板自己操纵电视机（对象）。
如果要在房间里四处走走，并想保持对电视机的控制，那么手上拿着的是遥控板，而非电视机。
此外，即使没有电视机，遥控板亦可独立存在。
计算机专业毕业设计论文外文文献中英文翻译——java对象
1 . Introduction To Objects1.1The progress of abstractionAll programming languages provide abstractions. It can be argued that the complexity of the problems you’re able to solve is directly related to the kind and quality of abstraction。
By “kind” I mean，“What is it that you are abstracting?” Assembly language is a small abstraction of the underlying machine. Many so—called “imperative” languages that followed （such as FORTRAN，BASIC, and C) were abstractions of assembly language。
These languages are big improvements over assembly language，but their primary abstraction still requires you to think in terms of the structure of the computer rather than the structure of the problem you are trying to solve。
The programmer must establish the association between the machine model (in the “solution space，” which is the place where you’re modeling that problem, such as a computer) and the model of the problem that is actually being solved (in the “problem space,” which is the place where the problem exists). The effort required to perform this mapping, and the fact that it is extrinsic to the programming language，produces programs that are difficult to write and expensive to maintain，and as a side effect created the entire “programming methods” industry.The alter native to modeling the machine is to model the problem you’re trying to solve。
计算机中英论文
Understanding Web Addresses You can think of the World Wide Web as a network of electronic files stored on computers all around the world. Hypertext links these
news - a newsgroup
Ø telnet - a computer system that you can log into over the Internet Ø WAIS - a database or document in a Wide Area Information Search database Ø file - a file located on a local drive (your hard drive)
1
resources together. Uniform Resource Locators or URLs are the addresses used to locate these files. The information contained in a URL gives you the ability to jump from one web page to another with just a click of your mouse. When you type a URL into your browser or click on a hypertext link, your browser is sending a request to a remote computer to download a file. What does a typical URL look like? Here are some examples: / The home page for study English. ftp:///pub/ A directory of files at MIT available for downloading. news:rec.gardens.roses A newsgroup on rose gardening. The first part of a URL (before the two slashes* tells you the type of resource or method of access at that address. For example: Ø Ø Ø files Ø http - a hypertext document or directory gopher - a gopher document or menu ftp - a file available for downloading or a directory of such
计算机科学与技术专业 外文翻译 外文文献 英文文献 记录
外文文献原稿和译文原稿IntroductionThe creation and maintenance of records relating to the students of an institution are essential to:. managing the relationship between the institution and the student;. providing support and other services and facilities to the student;. controlling the student’s academic progress and measuring their achievement, both at the institution and subsequently;. providing support to the student after they leave the institution.In addition, student records contain data which the institution can aggregate and analyse to inform future strategy, planning and service provision.The number of students in HEIs has increased rapidly in the last twenty years. An institution’s relationship with an individual student has also become increasingly complex because of the range of support services institutions now provide to students and life long learning initiatives. Consequently, the volume and complexity of student records have also increased, as have the resources required to create, maintain, use, retain and dispose of them, irrespective of the format in which they are kept. Ensuring that the personal data contained in student records is controlled and managed in line with the principles of the Data Protection Act 1998 creates an additional complication.Institutions should, therefore, establish a policy on managing student records to ensure that they are handled consistently and effectively wherever they are held and whoever holds them. This policy should ensure that:. records relating to an individual student are complete, accurate and up to date;. duplication of student data is deliberate rather than uncontrolled and kept to the minimum needed to support effective administration;. records are held and stored securely to prevent unauthorised access to them;. records relating to the academic aspects of the student’s relationship with the institution are clearly segregated from those dealing with financial, disciplinary, social, support and contractual aspects of that relationship. This will enable differential retention periods to be applied to each of these to meet business and regulatory requirements.What are student records?Records are documents or other items which:. contain recorded information;. are produced or received in the initiation, conduct or completion of an activity;. are retained as evidence of that activity, or because they have other informational value.The recorded information may be in any form (e.g. text, image, sound) and the records may be in any medium or format.Student records –records associated with managing the relationship between an institution and its students –can be organised into three broad categories, each of which may be additionally divided:1. Records documenting the contractual relationship between the student and the institutione.g. records documenting admission and enrolment, payment of tuition fees, non-academic disciplinary proceedings.2. Records documenting the student as a learnere.g. records documenting programmes undertaken, academic progress and performance, awards.3. Records documenting the student as an individual and consumer of services provided by the institutione.g. records documenting use of accommodation services, counseling services, library and IT support services, careers and employment services.Most records in categories 1 and 3 have specific retention periods triggered by the formal end of a student’s direct relationship with an institution, although the information they contain may be aggregated and analyzed to provide data requested by third parties1 orto support the institution’s planning and development activities. An institution will need to retain some of the records in category 2 to provide confirmatory information to potential employers, professional bodies and associations, and to bodies which regulate entry to medical and other professions and which assess and maintain evidence of fitness to practice in those professions.Who is responsible for managing student records?HEI organizational structures vary considerably. As a result, it is difficult to specify exactly where these responsibilities should lie in any one institution.Responsibility for managing student records should be clearly defined and documented. It is important to define the responsibilities of staff involved in: . managing the institution’s general, contractual relationship with the student;. managing the institution’s relationship with the student as a learner;. providing technical and personal support services to the student;for creating, maintaining, using, retaining and disposing of records documenting those activities during the student’s time at the institution.Institutions should also designate one clear point of responsibility for maintaining complete, accurate and up to date records on every student, covering all aspects of the relationship. They should also define the minimum content of the core student record so that the institution can, if required:. demonstrate, within the provisions of limitation statutes, that its implied contract with the student has been fulfilled;. provide information on the student’s academic performance and award(s) to potential employers, to licensing/regulatory bodies (normally first registration only)which control entry to professions and to other organizations (e.g. those providing chartered status) as well as to the student;. provide information on the student as an individual as a means of enabling the institution, or others acting on its behalf, to analyse and aggregate student data for planning and developing its future programmes, recruitment activities and the facilities and services required to support future students.Where and how should student records be stored?The nature of student records and the personal information they contain demands that they should be stored in facilities and equipment (‘hard copy’ records) or electronic systems (digital records) which are, above all, secure and accessible only to authorized staff whose work requires them to have access. In addition, the facilities and equipment should provide: . adequate space for all the records which need to be produced and retained;. appropriate environmental conditions for the record media used.Storage facilities and systems should meet the same standards irrespective of where they are located and who is responsible for managing them.Authorized staff should maintain a record of:. the content, format and location of all student records;. the names and designations of all staff with access to student records, and any limitations on that access;. student records which have been transferred to another part of the institution, particularly after the student has left;. organizations, professional bodies, statutory regulators to whom personal data relating to the student has been provided.Student records should be stored and indexed so that they can be identified and retrieved quickly and easily.. Paper records should be housed in durable containers which carry only an impersonal code number related to a restricted-access list or index to prevent casual, unauthorised access. These containers should be stored in locked equipment or rooms when they are not being used to ensure that the personal data they contain is protected in line with the requirements of the Data Protection Act 1998.. Digital records should be uniquely identified and protected with passwords and other electronic security measures. In all cases, access should be limited to those staff who have ‘a need to know’. If ele ctronic systems are not centrally managed, designated staff should make back-up copies to prevent loss of records through accidental or intentional damage.Whatever its format, the ‘core student record’ shou ld be treated as a vital record and action taken to protect it from disaster or systems failure by copying and dispersal.Student records will become relatively inactive once the student leaves the institution.They may then be transferred to other storage facilities or systems. At this point, duplicates of records created for administrative convenience should be destroyed so that only the designated official records survive.Who should have access to student records?Institutions should tightly control access to student records to prevent unauthorised use, alteration, removal or destruction of the records themselves and unauthorised disclosure of the information they contain. Only those members of staff who need them to do their work should have access to student records and, their access should be restricted to records of the direct relationship and not to the content of the whole file.Student records contain personal data and are therefore subject to the provisions of the Data Protection Act 1998, including the provision that the student, as the data subject, should be given access to personal data held, whether in digital or hard copy form. In addition, the ‘core student record’ as defined by the KCL study includes personal data on the student’s parents which is also subject to the provisions of th e Act.How long should student records be kept?In general, student records should be kept only for as long as is necessary to:. fulfill and discharge the contractual obligations established between the institution and the student, including the completion of any non-academic disciplinary action;. provide information on the academic career and achievements of the student to employers, licensing/regulatory bodies and other organizations, as well as to the student as part of their lifelong learning record;. record the activities of the student as an individual and as a consumer of student support and other institutional services as a means of managing those services and planning and developing them in the future.The nature of the activities which give rise to these categories of records drives their retention.. The contractual relationship between the institution and the student is subject to the same statutory limitations on action as any other contract. This will include records of disciplinary action taken against the student. The records should be disposed of accordingly. The date at which the student leaves the institution normally provides the retention‘trigger’.. The records relating to the student as a learner need to be retained for longer than other student records. Institutions accept that they have an obligation, during a student’s working life, to provide factual information on what they have studied and achieved, i.e. a Transcript. The proposed lifelong learning record or progress file would also include additional data on relevant non-academic achievements and activities (e.g. voluntary work). The retention period for these records should reflect the need to fulfill this obligation over long periods of time, perhaps for the lifetime of the student. It is important to segregate these records from those relating to other aspects of the relationship so that non-academic records are not retained for unnecessarily long periods, consuming storage resources and creating potential breaches of the Data Protection Act 1998.. Records relating to the student as an individual and as a user of student support and institutional services are relatively short term and should be retained for a short finite period once the student leaves the institution. This period should be shorter than for records relating to the wider contractual arrangements.The KCL study proposed the development of a ‘core student record’ which would contain, in addition to the formal transcript, data relating to the background of the student, including parents’ address and occupation, schools attended, first employment, etc. In addition to providing academic information on the individual student, KCL suggested that the availability of this data facilitates its analysis for institutional business planning and development purposes, as well as supporting subsequent academic historical, sociological and demographic research.Individual institutions should decide whether they wish to retain this data for research purposes once immediate institutional business needs have been met. In doing so they will need to take account of:. the cost and technical difficulty of maintaining records, even in summary form, permanently;. the security and subject access implications of retaining personal data relating to named individuals;. the need to create and maintain finding aids so that individual records can be easilyand quickly retrieved when required, particularly to meet subject access requests.How should student records be destroyed?Student records should be destroyed in line with agreed retention periods. Destruction should be authorized by staff with appropriate authority and it should be carried out in accordance with the institution’s procedures for the destruction of redundant rec ords containing personal data.The authority for destruction and the date of destruction should be recorded and held by the section of the institution with final responsibility for the student record.译文介绍创建与维护和学生相关的记录对一个公共机构来说是十分重要的：处理机关和学生之间的关系；提供支持和其他服务以及便利给学生；在机关，控制学生学术进展和测量他们的成就；随后提供支持给学生，在他们离开机关之后。
计算机专业毕业设计外文翻译-毕业设计外文翻译
淮阴工学院毕业设计(论文)外文资料翻译系（院）：计算机工程学院专业：计算机科学与技术（网络工程）姓名：学号：外文出处：http://hub.hku.hk/handle/10722/153180 (用外文写)附件： 1.外文资料翻译译文；2.外文原文。
注：请将该封面与附件装订成册。
附件1：外文资料翻译译文自组织云中动态优化的多属性资源分配1引言云计算已经成为一个引人注目部署分布式服务的范例。
云计算系统中的资源分配问题强调如何利用多属性的资源复用操作系统。
使用虚拟机（VM）技术，我们可以在同一硬件上复用多个操作系统和允许执行任务的无干扰性能。
可以实现细微的资源共享，为每个虚拟机基板配置适当的资源（如CPU，内存，存储，网络带宽等）动态股份。
近年来，对资源的各种隔离技术不断增强，已经提出了实现细粒度的动态资源配置。
基于Xen的按比例共享的信用调度，可以实现以公平的方式在虚拟机之间的复用CPU资源。
不同的引擎的驱动程序联合虚拟机技术，可以动态地调整虚拟机的内存资源，在同位虚拟机的磁盘I / O带宽之间可以动态地控制使用。
这些先进的技术，使计算资源被动态地分配或重新组合，以满足最终用户的弹性需求。
这样的解决方案创造了前所未有的机会，最大限度地提高资源的利用率，但是这是不可能适用于大多数的网格系统，通常把限制使用不可分割的资源，并避免同时对它们的访问。
今天的云计算架构是没有问题的。
但是大多数云服务建立在集中式架构之上，可能会受到拒绝服务（DoS）攻击，意外停电，和有限的计算资源池等威胁。
相反，计算系统（或台式机电网）可以容易聚集巨大潜力的计算能力，以解决重大挑战的科学问题。
鉴于此，我们提出了一个新的云架构，即自组织云（SOC），它可以连接在互联网上的P2P网络大量的台式电脑。
在SOC中，参与的每台计算机都作为资源提供者和资源使用者。
他们自主定位更丰富的资源，独特的服务，他们的任务是在网络中的节点分担一些工作，同时他们执行任务时提交的其他有闲置的资源可以构建多个虚拟机实例。
英文文献及翻译(计算机专业)
英文文献及翻译(计算机专业)The increasing complexity of design resources in a net-based collaborative XXX common systems。
design resources can be organized in n with design activities。
A task is formed by a set of activities and resources linked by logical ns。
XXX managementof all design resources and activities via a Task Management System (TMS)。
which is designed to break down tasks and assign resources to task nodes。
This XXX。
2 Task Management System (TMS)TMS is a system designed to manage the tasks and resources involved in a design project。
It poses tasks into smaller subtasks。
XXX management of all design resources and activities。
TMS assigns resources to task nodes。
XXX。
3 Collaborative DesignCollaborative design is a process that XXX a common goal。
In a net-based collaborative design environment。
n XXX n for all design resources and activities。
计算机专业毕业设计--英文文献(含译文)
外文文献原文THE TECHNIQUE DEVELOPMENT HISTORY OF 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 progress to the each claimses, and make use of the multi-threadingmechanism 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.3 JSP 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.4 JSP 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 the expression logic enter the original web page entirely heap what better solvethe 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 claimdirectly 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 six built-in objectsrequest for:The object of the package of information submitted by users, by calling the object corresponding way to access the information package, namely the use of the target users can access the information.response object:The customer's request dynamic response to the client sent the data.session object1. What is the session: session object is a built-in objects JSP, it in the first JSP pages loaded automatically create, complete the conversation of management.From a customer to open a browser and connect to the server, to close the browser, leaving the end of this server, known as a conversation.When a customer visits a server, the server may be a few pages link between repeatedly, repeatedly refresh a page, the server should bethrough some kind of way to know this is the same client, which requires session object.2. session object ID: When a customer's first visit to a server on the JSP pages, JSP engines produce a session object, and assigned aString type of ID number, JSP engine at the same time, the ID number sent to the client, stored in Cookie, this session objects, and customers on the establishment of a one-to-one relationship. When a customer to connect to the server of the other pages, customers no longer allocated to the new session object, until, close your browser, the client-server object to cancel the session, and the conversation, and customer relationship disappeared. When a customer re-open the browser to connect to the server, the server for the customer to create a new session object.aplication target1. What is the application:Servers have launched after the application object, when a customer to visit the site between the various pages here, this application objects are the same, until the server is down. But with the session difference is that all customers of the application objects are the same, that is, all customers share this built-in application objects.2. application objects commonly used methods:(1) public void setAttribute (String key, Object obj): Object specified parameters will be the object obj added to the application object, and to add the subject of the designation of a keyword index.(2) public Object getAttribute (String key): access to application objects containing keywords for.out targetsout as a target output flow, used to client output data. out targets for the output data.Cookie1. What is Cookie:Cookie is stored in Web server on the user's hard drive section of the text. Cookie allow a Web site on the user's computer to store information on and then get back to it.For example, a Web site may be generated for each visitor a unique ID, and then to Cookie in the form of documents stored in each user's machine.If you use IE browser to visit Web, you will see all stored on your hard drive on the Cookie. They are most often stored in places: c: \ windows \ cookies (in Window2000 is in the C: \ Documents and Settings \ your user name \ Cookies).Cookie is "keyword key = value value" to preserve the format of the record.2. Targets the creation of a Cookie, Cookie object called the constructor can create a Cookie. Cookie object constructor has two string .parameters: Cookie Cookie name and value.Cookie c = new Cookie ( "username", "john");3. If the JSP in the package good Cookie object to send to the client, the use of the response addCookie () method.Format: response.addCookie (c)4. Save to read the client's Cookie, the use of the object request getCookies () method will be implemented in all client came to an array of Cookie objects in the form of order, to meet the need to remove the Cookie object, it is necessary to compare an array cycle Each target keywords.JSP的技术发展历史Java Server Pages(JSP)是一种基于web的脚本编程技术，类似于网景公司的服务器端Java脚本语言—— server-side JavaScript(SSJS)和微软的Active Server Pages(ASP)。
计算机外文翻译(完整)
毕业设计(论文)外文资料翻译附件1：外文资料翻译译文Internet的历史起源——ARPAnetInternet是被美国政府作为一项工程进行开发的。
这项工程的目的，是为了建立远距离之间点与点的通信，以便处理国家军事范围内的紧急事件，例如核战争。
这项工程被命名为ARPAnet，它就是Internet的前身。
建立此工程的主要应用对象就是军事通讯，那些负责ARPAnet的工程师们当时也没有想到它将成为“Internet”。
根据定义，一个“Internet”应该由四或者更多的计算机连接起来的网络。
ARPAnet是通过一种叫TCP/IP的协议实现连网工作的。
此协议最基础的工作原理是：如果信息在网络中的一条路径发送失败，那么它将找到其他路径进行发送，就好象建立一种语言以便一台计算机与其他计算机“交谈”一样，但不注意它是PC，或是Macintosh。
到了20世纪80年代，ARPAnet已经开始变成目前更为有名的Internet了，它拥有200台在线主机。
国防部很满意ARPAnets的成果，于是决定全力将它培养为能够联系很多军事主机，资源共享的服务网络。
到了1984年，它就已经超过1000台主机在线了。
在1986年ARPAnet关闭了，但仅仅是建立它的机构关闭了，而网络继续存在与超过1000台的主机之间。
由于使用NSF连接失败，ARPAnet才被关闭。
NSF是将5个国家范围内的超级计算机连入ARPAnet。
随着NSF的建立，新的高速的传输介质被成功的使用，在1988年，用户能通过56k的电话线上网。
在那个时候有28，174台主机连入Internet。
到了1989年有80，000台主机连入Internet。
到1989年末，就有290，000台主机连入了。
另外还有其他网络被建立，并支持用户以惊人的数量接入。
于1992年正式建立。
现状——Internet如今，Internet已经成为人类历史上最先进技术的一种。
每个人都想“上网”去体验一下Internet中的信息财富。
计算机毕业设计中英文文献
At present, there are many b/s, c/s structure examination systems based on-line, this paper first introduced most of these systems’ formed and developed process, and structures. Then, analysis these systems, and pointed out that there still have many defects about them, just like the update and the service to these systems .Thinking based on these produces, and now the J2EE technical is becoming mature, we thinking about is this technical can be used in examination systems, so we mentioned a on-line system based on J2EE structure. Compared to other systems, and also analysis its’ advantages, we introduced this structure’s construction and technical as emphasize. Finally, makeJ2EE technical a expectation and it can progress quiet great and have a nice foreground. With the educational thinking and scientific and technological progress update to the traditional pen and paper as the main tool for examinations revealed many shortcomings increasingly prominent.1.became the main object of interest in taking the examination candidates can not be activated. Has always been the traditional way of examination papers to students the teacher made test, when test, test what, how to judge the whole by the teacher decided to test scores, students have been in a passive position and even forced.2.Therefore, the main test became teachers, students, have become the subject of the real object. Thus, the exam, students passive defense, a passive response or even fraud. Examination of the torture process is the process of serving the students, no fun at all, let alone in the examination process glorious life in flash.3.Important results than process, candidates can not objectively reflect the real level of ability. Traditional examinations only one goal: results of the examinations. Both teachers and students value this, the general view is that the higher levels of test scores high and low test scores were low. But in fact the examination process for various reasons, an examination candidate fails to play at this level of a normal or failed to fully play a level, such examination can not objectively reflect the candidate's level.With the rapid development of network technology, many foreign universities and other sectors of society have been set up distance education, remote education through computer networks and training. Now, computer hardware technology has reached a very high level. However, distance learning software development is still in its infancy, with the further development of this technology continues to require better, more comprehensive software system which is applied to distance education to go, which gives software designers made more High design requirements.Distance education includes many areas, such as teaching systems, answering system and examination system and so on. One very important aspect is the examination system, it is also the most difficult to achieve the link. In China, although distance education has been vigorously developed, but the current school examinations with the community's most traditional examinations, in this way,After the organization of a test at least five steps, namely artificial out of question, candidates test, artificial grading, performance evaluation and analysis papers. Clearly, as the type of examination and examination requirements of increasing the continuous improvement will be increasing the workload of teachers and their work will be a very cumbersome and very error-prone things can be said that the traditional test method hasbeen Can not meet the exam requirements. With the rapid development of computer applications, web applications continue to expand, such as distance education and the emergence of virtual universities, etc., and these applications are gradually deep into millions of households.Admittedly, online teaching has a very broad application prospects, assistant teaching building of the network path is absolutely inevitable. It is worth mentioning that the distance education in China after years of development in the post has become increasingly mature. Over the years, China has been very seriously the development of distance education, distance education in the university education system, now or at the initiation stage. Facts have proved that today's society, no matter what the industry is engaged in the future, online exams are irreplaceable status, its applications are among the most widely used of all the disciplines, the establishment of online examination system is the premise of such a background generated.Over the years, along with the development of the school, either from hardware or from software on my school have certain basic conditions, the University building of online examination system is imperative. Produced by our "online examination system"is mainly for the majority of students and their teachers to provide a convenient place, so that we can learn more about the Internet in different places all aspects of the operating system, and teacher exchanges, exchange views with other students, and Online test and so on. The majority of students believe that it will provide convenient and efficient way of learning.The results of the project to provide a database of online test site, the students through the campus network or the Internet to access the site, students can follow the recommendations of teachers or their own plans for what they have learned self-test; teachers can provide the environment through the web site for students Dynamic management of the learning and test scores based on site records of each student is given an objective evaluation. Online examination system to reduce the workload of teachers and improve work efficiency, while also improving the quality of the examination, so that the notary exam tends to be more objective and more to stimulate students interest in learning.The database is online examination system mainly uses JSP, Java, HTML, SQL database technologies and tools, and integration of today's popular web application development and integration tools for Java development environment, MyEclipse DreamWeaver overall design follows the software engineering methods, through needs analysis, general design , the preparation of documentation and code, module testing and system implementation stages. Here are several techniques and methods to make this an overview.Database to provide online examination system for the candidates to sign up, online testing and other functions. Is based on the computer network applications. It can make the test without time, place restrictions on the one hand, greatly reducing the teacher a question, change the volume of work, on the other hand to enable students to test their learning at any time, so that learning efficiency is greatly improved. Online examination system in the generation of questions, the submission of papers, marking and other results can be done automatically on the network, as long as the formation of a maturereal paperless exam to exam.This phase of the system through initial research and target analysis, and to demonstrate the feasibility of the program. We are here mainly from the technical feasibility, economic feasibility and operational feasibility were analyzed.Software development cycle is generally 2-3 months, developing the necessary hardware and software facilities are currently able to take the majority of PC computer system, the development cost is not high. Currently, most units have high-performance computer and LAN, the software system installation, deployment, operation and maintenance units will not increase the cost too high.Development of the relevant information required by the system through the existing system of investigation related to acquisition, other necessary software applications, hardware systems are easy to obtain. Therefore, the development costs low. The introduction of using this system, compared with the traditional way, with high efficiency, low cost, high-quality features, you can save a lot of manpower, material and financial resources. So, from an economic point of view, the system is feasible.Browser-based online exam, the key technology is the dynamic Web page display and management, from database to obtain the appropriate papers in the data, and collect user input data to control the examination process. Jsp and SQL using the latest technology development, management interface used in all client and candidate B / S Mode, system deployment, application, maintenance more convenient. At the same time, SqlServer database provides database management capabilities, the technical solution is mature and feasible.Technical feasibility to consider whether the existing technology the successful completion of development work, development of hardware and software configured to meet the demand. This site is JSP development language, debugging a relatively simple, the current computer hardware configuration is also fully able to meet the needs of development, so technically it is absolutely feasible. Software: due to the currentstand-alone model is relatively mature, so mature and viable software development platform, they speed, large capacity, high reliability, low price, can meet the system requirements.Feasibility of running the organization structure, existing staff and institutions and environmental adaptability of the system and personnel training additional feasibility. Current information technology is already quite popular, various operators have very high levels, so the run is feasible.The development of this system is a typical Mis development, mainly for data processing, including data collection, data transformation, and data output of the various report forms. Using the popular JSP + SQLSERVER 2000 system, with no technical problems.From the time point of view, in two months to learn the knowledge and the development of the hotel management system, time is a bit tight, but not impossible, to function through more than two months basically.①All technical data are as lawful.②the development process there is no intellectual property rights.③not copying any hotel management system, there is no infringement of copyright.④the development process not involved in any legal responsibility.In summary, this system development is technically, economically, legally are completely reliable.To implement a software system needs analysis should be conducted first, so can the design of software to meet user's various functions. Here the design of the online examination system needs analysis.Database online examination system should have the following requirements:(1) The test corresponds to a particular object, so the system needs through effective authentication before they can login. And the system needed to manage the session functions. In the examination process for tracking test status.(2) and system access is generally divided into two kinds: administrators and students. Different identities with different privileges and functions.(3) the administrator of the questions and candidates need effective management, responsible for questions of entry and updates and modifications of the classification of questions, each time before the exam, candidates need to state examination center exam environment and initialization. Note that, given the test environment is generally room, close the distance between the examination, in order to do online test specifications for each candidate, the amount of questions and examination papers should be the same, but the questions Not the same.System has to be a good paper and recycling upload function to ensure the accuracy of information transfer. System has to be a friendly interface to ensure smooth progress of the examination candidates. Because the papers need teachers mark the subjective questions, it may take some time to check the results. However, if the paper is composed by objective kinds of questions, candidates can check the end of the exam to their score. System provides statistics on test scores and query management functions. System should have a good safety management.The current examination system, there are still many is based on the c / s mode, each time accompanied by a system upgrade, should update the software on each client,time-consuming and labor-intensive. Fortunately, as technology evolves, based on the b / s mode of online examination system more and more, and gradually occupy a dominant position. It overcomes the c / s mode, many of the shortcomings of the traditional-based C / S mode changes to the examination system based on B / S mode test system that enables users on any computer, as long as access to the Internet to connect Use the service, greatly simplifying the operation, to provide users with convenient. The other hand, the management and marking for teachers to provide a convenient and improved efficiency. But according to my multi-party observation and research, found that most of the online examination system models are developed based on the page, each page contains all the features you need to use the logic, lead to code repetition rate, the structure is not clear, Maintenance upgrades is also very time-consuming and manpower. Given this situation, so we added the concept of J2EE to online examination system to make the system more easy to upgrade and maintain.目前国内基于B/S、C/S结构的数据库在线考试系统产品已经有许多，本文首先介绍了这些考试系统的形成和发展过程，大致结构。
计算机专业中英文翻译外文翻译文献翻译
英文参考文献及翻译Linux - Operating system of cybertimes Though for a lot of people , regard Linux as the main operating system to make up huge work station group, finish special effects of " Titanic " make , already can be regarded as and show talent fully. But for Linux, this only numerous news one of. Recently, the manufacturers concerned have announced that support the news of Linux to increase day by day, users' enthusiasm to Linux runs high unprecedentedly too. Then, Linux only have operating system not free more than on earth on 7 year this piece what glamour, get the favors of such numerous important software and hardware manufacturers as the masses of users and Orac le , Informix , HP , Sybase , Corel , Intel , Netscape , Dell ,etc. , OK?1.The background of Linux and characteristicLinux is a kind of " free (Free ) software ": What is called free,mean users can obtain the procedure and source code freely , and can use them freely , including revise or copy etc.. It is a result of cybertimes, numerous technical staff finish its research and development together through Inte rnet, countless user is it test and except fault , can add user expansion function that oneself make conveniently to participate in. As the most outstanding one in free software, Linux has characteristic of the following:(1)Totally follow POSLX standard, expand the network operatingsystem of supporting all AT&T and BSD Unix characteristic. Because of inheritting Unix outstanding design philosophy , and there are clean , stalwart , high-efficient and steady kernels, their all key codes are finished by Li nus Torvalds and other outstanding programmers, without any Unix code of AT&T or Berkeley, so Linu x is not Unix, but Linux and Unix are totally compatible.(2)Real many tasks, multi-user's system, the built-in networksupports, can be with such seamless links as NetWare , Windows NT , OS/2 ,Unix ,etc.. Network in various kinds of Unix it tests to be fastest in comparing and assess efficiency. Support such many kinds of files systems as FAT16 , FAT32 , NTFS , Ex t2FS , ISO9600 ,etc. at the same time .(3) Can operate it in many kinds of hardwares platform , including such processors as Alpha , SunSparc , PowerPC , MIPS ,etc., to various kinds of new-type peripheral hardwares, can from distribute on global numerous programmer there getting support rapidly too.(4) To that the hardware requires lower, can obtain very good performance on more low-grade machine , what deserves particular mention is Linux outstanding stability , permitted " year " count often its running times.2.Main application of Linux At present,Now, the application of Linux mainly includes:(1) Internet/Intranet: This is one that Linux was used most at present, it can offer and include Web server , all such Inter net services as Ftp server , Gopher server , SMTP/POP3 mail server , Proxy/Cache server , DNS server ,etc.. Linux kernel supports IPalias , PPP and IPtunneling, these functions can be used for setting up fictitious host computer , fictitious service , VPN (fictitious special-purpose network ) ,etc.. Operating Apache Web server on Linux mainly, the occupation rate of market in 1998 is 49%, far exceeds the sum of such several big companies as Microsoft , Netscape ,etc..(2) Because Linux has outstanding networking ability , it can be usedin calculating distributedly large-scaly, for instance cartoon making , scientific caculation , database and file server ,etc..(3) As realization that is can under low platform fullness of Unix that operate , apply at all levels teaching and research work of universities and colleges extensively, if Mexico government announce middle and primary schools in the whole country dispose Linux and offer Internet service for student already.(4) Tabletop and handling official business appliedly. Application number of people of in this respect at present not so good as Windows of Microsoft far also, reason its lie in Lin ux quantity , desk-top of application software not so good as Windows application far not merely, because the characteristic of the freedom software makes it not almost have advertisement thatsupport (though the function of Star Office is not second to MS Office at the same time, but there are actually few people knowing).3.Can Linux become a kind of major operating system?In the face of the pressure of coming from users that is strengthened day by day, more and more commercial companies transplant its application to Linux platform, comparatively important incident was as follows, in 1998 ①Compaq and HP determine to put forward user of requirement truss up Linux at their servers , IBM and Dell promise to offer customized Linux system to user too. ②Lotus announce, Notes the next edition include one special-purpose edition in Linux. ③Corel Company transplants its famous WordPerfect to on Linux, and free issue. Corel also plans to move the other figure pattern process products to Linux platform completely.④Main database producer: Sybase , Informix , Oracle , CA , IBM have already been transplanted one's own database products to on Linux, or has finished Beta edition, among them Oracle and Informix also offer technical support to their products.4.The gratifying one is, some farsighted domestic corporations have begun to try hard to change this kind of current situation already. Stone Co. not long ago is it invest a huge sum of money to claim , regard Linux as platform develop a Internet/Intranet solution, regard this as the core and launch Stone's system integration business , plan to set up nationwide Linux technical support organization at the same time , take the lead to promote the freedom software application and development in China. In addition domestic computer Company , person who win of China , devoted to Linux relevant software and hardware application of system popularize too. Is it to intensification that Linux know , will have more and more enterprises accede to the ranks that Linux will be used with domestic every enterprise to believe, more software will be planted in Linux platform. Meanwhile, the domestic university should regard Linux as the original version and upgrade already existing Unix content of courses , start with analysing the source code and revising the kernel and train a large number of senior Linux talents, improve our country's own operating system. Having only really grasped the operating system, the software industry of our country could be got rid of and aped sedulously at present, the passive state led by the nose by others, create conditions for revitalizing the software industry of our country fundamentally.中文翻译Linux—网络时代的操作系统虽然对许多人来说，以Linux作为主要的操作系统组成庞大的工作站群，完成了《泰坦尼克号》的特技制作，已经算是出尽了风头。
计算机专业毕业设计论文外文文献中英文翻译(Object)
外文资料Object landscapes and lifetimesTechnically, OOP is just about abstract data typing, inheritance, and polymorphism, but other issues 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 the data for an object and how is the lifetime of the object controlled? There are different philosophies at work here. C++ takes the approach that control of efficiency is the most important issue, so it gives the programmer a choice. For maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocation and release, and control of these can be very valuable in some situations. However, you sacrifice flexibility because you must know the exact quantity, lifetime, and type of objects while you're writing the program. If you are trying to solve a more general problem such as computer-aided design, warehouse management, or air-traffic control, this is too restrictive.The second approach is to create objects dynamically in a pool of memory called the heap. In this approach, you don't know until run-time how many objects you need, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is running. 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 allocate storage on the heap is significantly longer than the time to create storage on the stack. (Creating storage on the stack is often a single assembly instruction tomove the stack pointer down, and another to move it back up.) The dynamic approach makes the generally logical assumption that objects tend to be complicated, so the extra overhead of finding storage and releasing that storage will not have an important impact on the creation of an object. In addition, the greater flexibility is essential to solve the general programming problem.Java uses the second approach, exclusively]. Every time you want to create an object, you use the 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 allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no knowledge of its lifetime. In a language like C++, you must determine programmatically when to destroy the object, which can lead to memory leaks if you don’t do it correctly (and this is a common problem in C++ programs). Java provides a feature called a garbage collector that automatically discovers when an object is no longer in use and destroys it. A garbage collector is much more convenient because it reduces the number of issues that you must track and the code you must write. More important, the garbage collector provides a much higher level of insurance against the insidious problem 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 landscapes.1 Collections and iteratorsIf you don’t know how many objects you’re going to need to solve a particular problem, or how long they will last, you also don’t know how to store those objects. How can you know how much space to create for thoseobjects? You can’t, since that information isn’t known until run-time.The solution to most problems in object-oriented design seems flippant: you create another type of object. The new type of object that solves this particular problem holds references to other objects. Of course, you can do the same thing with an array, which is available in most languages. But there’s more. This new object, generally called a container(also called a collection, but the Java library uses that term in a different sense so this book will use “container”), will expand itself whenever necessary to accommodate everything you place inside it. So you don’t need to know how manyobjects you’re going to hold in a container. Just create a container object and let it take care of the details.Fortunately, a good OOP language comes with a set of containers as part of the package. In C++, it’s part of the Standard C++ Library and is sometimes called the Standard Template Library (STL). Object Pascal has containers in its Visual Component Library (VCL). Smalltalk has a very complete set of containers. Java also has containers in its standard library. In some libraries, a generic container is considered good enough for all needs, and in others (Java, for example) the library has different types of containers for different needs: a vector (called an ArrayListin Java) for consistent access to all elements, and a linked list for consistent insertion at all elements, for example, so you can choose the particular type that fits your needs. Container libraries may also include sets, queues, hash tables, trees, stacks, etc.All containers have some way to put things in and get things out; there are usually functions to add elements to a container, and others to fetch those elements back out. But fetching elements can be more problematic, because a single-selection function is restrictive. What if you want to manipulate or compare a set of elements in the container instead of just one?The solution is an iterator, which is an object whose job is to select the elements within a container and present them to the user of the iterator. As a class, it also provides a level of abstraction. This abstraction can be used to separate the details of the container from the code that’s accessing that container. The container, via the iterator, is abstracted to be simply a sequence. The iterator allows you to traverse that sequence without worrying about the underlying structure—that is, whether it’s an ArrayList, a LinkedList, a Stack, or something else. This gives you the flexibility to easily change the underlying data structure without disturbing the code in your program. Java began (in version 1.0 and 1.1) with a standard iterator, called Enumeration, for all of its container classes. Java 2 has added a much more complete container library that contains an iterator called Iterator that does more than the older Enumeration.From a design standpoint, all you really want is a sequence that can be manipulated to solve your problem. If a single type of sequence satisfied all of your needs, there’d be no reason to have different kinds. There are two reasons that you need a choice of containers. First, containers provide different types of interfaces and external behavior.A stack has a different interface and behavior than that of a queue, which is different from that of a set or a list. One of these might provide a more flexible solution to your problem than the other. Second, different containers have different efficiencies for certain operations. The best example is an ArrayList and a LinkedList. Both are simple sequences that can have identical interfaces and external behaviors. But certain operations can have radically different costs. Randomly accessing elements in an ArrayList is a constant-time operation; it takes the same amount of time regardless of the element you select. However, in a LinkedList it is expensive to move through the list to randomly selectan element, and it takes longer to find an element that is further down the list. On the other hand, if you want to insert an element in the middle of a sequence, it’s much cheaper in a LinkedList than in an ArrayList. These and other operations have different efficiencies depending on the underlying structure of the sequence. In the design phase, you might start with a LinkedList and, when tuning for performance, change to an ArrayList. Because of the abstraction via iterators, you can change from one to the other with minimal impact on your code.In the end, remember that a container is only a storage cabinet to put objects in. If that cabinet solves all of your needs, it doesn’t really matter how it is implemented (a basic concept with most types of objects). If you’re working in a programming environment that has built-in overhead due to other factors, then the cost difference between an ArrayList and a LinkedList might not matter. You might need only one type of sequence. You can even imagine the “perfect”container abstraction, which can automatically change its underlying implementation according to the way it is used.2 The singly rooted hierarchyOne of the issues in OOP that has become especially prominent since the introduction of C++ is whether all classes should ultimately be inherited from a single base class. In Java (as with virtually all other OOP languages) the answer is “yes”and the name of this ultimate base class is simply Object. It turns out that the benefits of the singly rooted hierarchy are many.All objects in a singly rooted hierarchy have an interface in common, so they are all ultimately the same type. The alternative (provided by C++) is that you don’t know that everything is the same fundamental type. From a backward-compatibility standpoint this fits the model of C better and can be thought of as less restrictive, but when you want to do full-onobject-oriented programming you must then build your own hierarchy to provide the same convenience that’s built into other OOP languages. And in any new class library you acquire, some other incompatible interface will be used. It requires effort (and possibly multiple inheritance) to work the new interface into your design. Is the extra “flexibility” of C++ worth it? If you need it—if you have a large investment in C—it’s quite valuable. If you’re starting from scratch, other alternatives such as Java can often be more productive.All objects in a singly rooted hierarchy (such as Java provides) can be guaranteed to have certain functionality. You know you can perform certain basic operations on every object in your system. A singly rooted hierarchy, along with creating all objects on the heap, greatly simplifies argument passing (one of the more complex topics in C++).A singly rooted hierarchy makes it much easier to implement a garbage collector (which is conveniently built into Java). The necessary support can be installed in the base class, and the garbage collector can thus send the appropriate messages to every object in the system. Without a singly rooted hierarchy and a system to manipulate an object via a reference, it is difficult to implement a garbage collector.Since run-time type information is guaranteed to be in all objects, you’ll never end up with an object whose type you cannot determine. This is especially important with system level operations, such as exception handling, and to allow greater flexibility in programming.3 Collection libraries and support for easy collection useBecause a container is a tool that you’ll use frequently, it makes sense to have a library of containers that are built in a reusable fashion, so you can take one off the shelf Because a container is a tool that you’ll use frequently, it makes sense to have a library of containers that are built in a reusable fashion, so you can take one off the shelf and plugit into your program. Java provides such a library, which should satisfy most needs.Downcasting vs. templates/genericsTo make these containers reusable, they hold the one universal type in Java that was previously mentioned: Object. The singly rooted hierarchy means that everything is an Object, so a 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 back. But, since the container holds only Objects, when you add your object reference into the container it is upcast to Object, thus losing its identity. When you fetch it back, you get an Object reference, and not a reference to the type that you put in. So how do you turn it back into something that has the 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 hierarchy to a more general type, you cast down the hierarchy to a more specific type. This manner of casting is called downcasting. With upcasting, you know, for example, that a Circle is a type of Shape so it’s safe to upcast, but you don’t know that an Object is necessarily a Circle or a Shape so it’s hardly 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’ll get a run-time error called an exception, which will be described shortly. When you fetch object references from a container, though, you must have some way to remember exactly what they are so you can perform a proper downcast.Downcasting and the run-time checks require extra time for the runningprogram, and extra effort from the programmer. Wouldn’t it make sense to somehow create the container so that it knows the types that it holds, eliminating the need for the downcast and a possible mistake? The solution is parameterized types, which are classes that the compiler can automatically customize to work with particular types. For example, with a parameterized container, the compiler could customize 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 rooted hierarchy. In C++, the keyword that implements parameterized types is “template.” Java currently has no parameterized types since it is possible for it to get by—however awkwardly—using the singly rooted hierarchy. However, a current proposal for parameterized types uses a syntax that is strikingly similar to C++ templates.译文对象的创建和存在时间从技术角度说，OOP（面向对象程序设计）只是涉及抽象的数据类型、继承以及多形性，但另一些问题也可能显得非常重要。
计算机专业外文文献翻译
毕业设计（论文）外文文献翻译（本科学生用）题目：Plc based control system for the music fountain 学生姓名：_ ___学号：060108011117 学部（系）: 信息学部专业年级: _06自动化（1）班_指导教师： ___职称或学位：助教__20 年月日外文文献翻译（译成中文1000字左右）：【主要阅读文献不少于5篇，译文后附注文献信息，包括：作者、书名（或论文题目）、出版社（或刊物名称）、出版时间（或刊号）、页码。
提供所译外文资料附件（印刷类含封面、封底、目录、翻译部分的复印件等，网站类的请附网址及原文】英文节选原文：Central Processing Unit (CPU) is the brain of a PLC controller. CPU itself is usually one of the microcontrollers. Aforetime these were 8-bit microcontrollers such as 8051, and now these are 16-and 32-bit microcontrollers. Unspoken rule is that you’ll find mostly Hitachi and Fujicu microcontrollers in PLC controllers by Japanese makers, Siemens in European controllers, and Motorola microcontrollers in American ones. CPU also takes care of communication, interconnectedness among other parts of PLC controllers, program execution, memory operation, overseeing input and setting up of an output. PLC controllers have complex routines for memory checkup in order to ensure that PLC memory was not damaged (memory checkup is done for safety reasons).Generally speaking, CPU unit makes a great number of check-ups of the PLC controller itself so eventual errors would be discovered early. You can simply look at any PLC controller and see that there are several indicators in the form. of light diodes for error signalization.System memory (today mostly implemented in FLASH technology) is used by a PLC for a process control system. Aside form. this operating system it also contains a user program translated forma ladder diagram to a binary form. FLASH memory contents can be changed only in case where user program is being changed. PLC controllers were used earlier instead of PLASH memory and have had EPROM memory instead of FLASH memory which had to be erased with UV lamp and programmed on programmers. With the use of FLASH technology this process was greatly shortened. Reprogramming a program memory is done through a serial cable in a program for application development.User memory is divided into blocks having special functions. Some parts of a memory are used for storing input and output status. The real status of an input is stored either as “1”or as “0”in a specific memory bit/ each input or output has one corresponding bit in memory. Other parts of memory are used to store variable contents for variables used in used program. For example, time value, or counter value would be stored in this part of the memory.PLC controller can be reprogrammed through a computer (usual way), but also through manual programmers (consoles). This practically means that each PLC controller can programmed through a computer if you have the software needed for programming. Today’s transmission computers are ideal for reprogramming a PLC controller in factory itself. This is of great importance to industry. Once the system is corrected, it is also important to read the right program into a PLC again. It is also good to check from time to time whether program in a PLC has not changed. This helps to avoid hazardous situations in factory rooms (some automakers have established communication networks which regularly check programs in PLC controllers to ensure execution only of good programs). Almost every program for programming a PLC controller possesses various useful options such as: forced switching on and off of the system input/outputs (I/O lines),program follow up in real time as well as documenting a diagram. This documenting is necessary to understand and define failures and malfunctions. Programmer can add remarks, names of input or output devices, and comments that can be useful when finding errors, or with system maintenance. Adding comments and remarks enables any technician (and not just a person who developed the system) to understand a ladder diagram right away. Comments and remarks can even quote precisely part numbers if replacements would be needed. This would speed up a repair of any problems that come up due to bad parts. The old way was such that a person who developed a system had protection on the program, so nobody aside from this person could understand how it was done. Correctly documented ladder diagram allows any technician to understand thoroughly how system functions.Electrical supply is used in bringing electrical energy to central processing unit. Most PLC controllers work either at 24 VDC or 220 VAC. On some PLC controllers you’ll find electrical supply as a separate module. Those are usually bigger PLC controllers, while small and medium series already contain the supply module. User has to determine how much current to take from I/O module to ensure that electrical supply provides appropriate amount of current. Different types of modules use different amounts of electrical current. This electrical supply is usually not used to start external input or output. User has to provide separate supplies in starting PLC controller inputs because then you can ensure so called “pure” supply for the PLC controller. With pure supply we mean supply where industrial environment can not affect it damagingly. Some of the smaller PLC controllers supply their inputs with voltage from a small supply source already incorporated into a PLC.中文翻译：从结构上分，PLC分为固定式和组合式（模块式）两种。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机专业毕业论文文献翻译资料附录一Compared to multi-threaded operating system, means is that it can run a program withthe ability of different parts; each part of the implementation was as a thread. Therefore, in the preparation of applications, we have very good design in order to avoid the implementation of the different threads of mutual interference. Which will help us to design robust procedures, we can make at any time when necessary to add the thread.Thread can be described as a micro-process; it has a starting point for theimplementation of the order of series and a destination. It is responsible for the maintenance of its own stack, the stack for exception handling, priority scheduling and a number of other threading systems re-implementation of the information needed. From this concept, it seems there is no thread with the process of distinction, in fact, thread and process is certainly different: the process of a complete independence to have their own memory space and data, but the same thread within a process is shared memory space and data. Corresponds to a process for some procedures, it is by the same procedure in which an independent threads running at the same time the composition. Thread is sometimes referred to as parallel program running on lightweight processes, threads are lightweight processes called because it is dependent on the operationand process the context of the environment, and the process of using resources. In a process, the threads are preemptive scheduling or non-preemptive model. In seizing the model, the operating system responsible for the allocation of CPU time for each process, once the current process used to finish the distribution of CPU time, the next operating system will determine the CPU time is occupied by a single thread. Thus the operating system will periodically interrupt the current thread is running, the allocation will be cup to the next in the queue waiting for a thread.Therefore, a thread can not be any exclusive CPU. Occupied by each thread CPU timedepends on the process and the operating system. Process assigned to each thread a short period of time that we feel all the threads are executed at the same time. In fact, the system time for each process, 2 ms, and then scheduling other threads. It the same time, he maintainedall the threads and circulation, the distribution of small amount of CPU time tothe thread. Thread switching and scheduling is so fast that the feeling is that all the threadsare executed simultaneously.What does scheduling mean? Scheduling processor storage means to be implemented by the end of the process of CPU time for the state and a future time loading the state of theprocess to resume its operation. In this way, however there are deficiencies, one thread at any given time interruption of the implementation of a thread. Suppose a thread is a document does write operation, and another thread interrupts its operation, also the same documents dowrite operation. Windows 95/NT, UNIX is used in such a way thread scheduling.In non-preemptive scheduling model, each thread may need to occupy much time CPU time CPU. Scheduling in this way, it may be a very long execution time makes all the otherthreads need to thread CPU "starving to death." In the processor is idle, that is, when theprocess does not use CPU, the system can allow the process of temporarily using other CPU.CPU occupation CPU thread has the power to control the release of only its own initiative, CPU; other threads can use the CPU. Some I / O and Windows 3.x is the use of thisscheduling strategy.In some operating systems inside, which will use two scheduling strategy. Non-preemptive scheduling strategy of running in the thread priority when used in general,and for high-priority scheduling of threads is the use of preemptive scheduling strategy. Ifyou are unsure about the kind of system is that scheduling strategy, assuming that thescheduling strategy can not be seized is relatively safe to use.Application in the design, we believe that those who occupy a relatively large number of CPU time for a certain interval thread will release the control of the CPU, this time thesystem will check the queue of those waiting inside the thread currently running with thesame priority level or higher priority threads, and thread to use these CPU. If you find such a system of thread, immediately suspend the currently executing thread and activate the threadsatisfy certain conditions. If you do not find the same or higher- priority thread, the currentthread has also continued to occupy CPU.When the thread is running CPU would like to release control to a low priority thread, the current thread into sleep state to allow low- priority threads hold the CPU.In a multi-processor system, the operating system will these independent threadsallocated to the different processor implementation, this willgreatly speed up the process of running. The implementation of the efficiency of the thread will be greatly improved,because the threads of time-sharing a single processor into adistributed multi-processor implementation. This multi-processor in the three-dimensional modeling and graphicsprocessing is very useful.Do you need to multi-threaded? We sent a print order requesting the printer to print tasks, assuming that this time in response to the computer and the printer stopped working also, would it mean that we do things to stop waiting for this slow on the printer? Fortunately, this situation does not occur, we work in the printer can also listen to music or drawing.Because we use a separate threads to perform these tasks. May you have multiple users 'simultaneous access to a database or web server was surprised at how they work? This isbecause for each connected to a database or web server user set up an independent thread to maintain the status of the user.If a program is running a certain degree of order, this time in this way problem may arise, and even lead to the collapse of the entire process. If the program can be divided into different independent tasks, the use of multi-threaded, even if a certain part of the task failed, on the other would not be affected, will not lead to the collapse of the entire process. There is no doubt that the procedures for the preparation of multi-threaded tool makes you a slave to drive the process of non-multi-threaded, multi-threaded but may also become a burden orcost need not be small. If the improper use of it will bring more of the disadvantages.If a program has a lot of threads, then the thread is bound to other programs can only take up less CPU time; and a lot of CPU time is usedfor thread scheduling; operating system also requires sufficient memory space to maintain each thread context information; therefore, a large number of threads will reduce the efficiency of system operation. Therefore, if the use of multi-threaded, then the multi-threaded program must be designed well, otherwise thebenefits will be far less than the disadvantages. The use of multi-threaded so we must be careful to deal with these threads of the creation, scheduling and work release.There are many ways to design multi-threaded applications. As shownin the back of the article, I will give detailed examples of programming, through these examples; you will be able to better understand the multi-threaded. Threads can have different priorities, forexamples, in our applications there, or do a lot of graphics rendering operations at the same time to accept user input, it is clear the user's input needs to be the first time to respond to, and Rendering or you need a lot of computing time, the suspension is not the problem, so users will need to enter the thread of high-class leisure, andgraphics rendering, or low priority operation can be. Independent of each otherbetween these threads.In the above example, graphics rendering, or a lot of computing is clearly need to stopusing a lot of CPU time, during this period of time, the user waiting for them there is no need to re-input information is completed, we will process designed to separate the two threads, one for the user's input, those responsible for dealing with a very long time-consuming task. This will make the procedure more flexible and can quickly respond. At the same time, users can also run any time the possibility of the abolition of the task. Drawing graphics in this case, the procedure should always be made to the system responsible for receiving the news. If the procedures are busy on a mission, there may result into a blank screen, which is obviously the need for our procedures to deal with such incidents. So I have to have a thread to deal with these sources is responsible for, as I said earlier should be the trigger of the work of re-drawing the screen.We should grasp the principle of time-for those who need to compare the urgency of thetask immediately, we are due to the high priority given the other priorities of the threads should be lower than her priority. Client requests listener thread should always be high priority, for a user interaction with the task of the user interface; it needs to be the first time responses, and its priority because ofthe high-priority.附录二多线程相对于操作系统而言 , 指的是可以同时执行同一个程序的不同部分的能力,每个执行的部分被成为线程。