【计算机专业文献翻译】题库管理系统

附录一英文材料

While you’re going through the development process, the most important issue is this: Don’t get lost. It’s easy to do. Most of the analysis and design methods are intended to solve the largest of problems. Remember that most projects don’t fit in to that category, so you can usually have successful analysis and design with a relatively small subset of what a method recommends. But some sort of process, no matter how limited, will generally get you on your way in a much better fashion than simply beginning to code.

It’s also easy to get stuck, to fall into “analysis paralysis,” where you feel like you can’t move forward because you haven’t nailed down every little detail at the current stage. Remember, no matter how much analysis you do, there are so me things about a system that won’t reveal themselves until design time, and more things that won’t reveal themselves until you’re coding, or not even until a program is up and running. Because of this, it’s crucial to move fairly quickly through analysis and design, and to implement a test of the proposed system.

This point is worth emphasizing. Because of the history we’ve had with procedural languages, it is commendable that a team will want to proceed carefully and understand every minute detail before moving design and implementation. Certainly, when creating a DBMS, it pays to understand a customer’s needs thoroughly. But a DBMS is in a class of problems that is very well-posed and well-understood; in many such programs, the database structure is the problem to be tackled. The class of programming problem discussed in this chapter is of the “wild-card” (my term) variety, in which the solution isn’t simply re-forming a well-known solution, but instead involves one or more “wild-card factors”-elements for which there is no well-understood previous solution, and for which research is necessary. Attempting to thoroughly analyze a wildcard problem before moving into design and

implementation results in analysis paralysis because you don’t have enough inform ation to solve this kind of problem during the analysis phase. Solving such a problem requires iteration through the whole cycle, and that requires risk-taking behavior (which makes sense, because you’re trying to do something new and the potential rewards are higher). It may seem like the risk is compounded by “rushing” into a preliminary implementation, but it can instead reduce the risk in a wild-card project because you’re finding out early whether a particular approach to the problem is viable. Product development is risk management.

It’s often proposed that you “build one to throw away.” With OOP, you may still throw part of it away, but because code is encapsulated into classes, during the first iteration you will inevitably produce some useful class designs and develop some worthwhile ideas about the system design that do not need to be thrown away. Thus, the first rapid pass at a problem not only produces critical information for the next analysis, design, and implementation iteration, it also creates a code foundation for that iteration.

That said, if you’re looking at a methodology that contains tremendous detail and suggests many steps and documents, it’s still difficult to know when to stop. Keep in mind what you’re trying to discover: What are the objects? (How do you partition your project into its component parts?)

What are their interfaces? (What messages do you need to be able to send to each object?)

If you come up with nothing more than the objects and their interfaces, then you can write a program. For various reasons you might need more descriptions and documents than this, but you can’t get away with any less.

The process can be undertaken in five phases, and a phase 0 that is just the initial commitment to using some kind of structure.

Phase 0: Make a plan

You must first decide what steps you’re going to have in your process. It sounds simple (in fact, all of this sounds simple) and yet people often don’t make this decision before they start coding. If your plan is “let’s jump in and start coding,” fine. (Sometimes that’s appropriat e when you have well-understood

problem.) At least agree that this is the plan.

You might also decide at this phase that some additional process structure is necessary, but not the whole nine yards. Understandab ly enough, some programmers like to work in “vacation mode” in which no structure is imposed on the process of developing their word; “It will be done when it’s done.” This can be appealing for awhile, but I’ve found that having a few milestones along the way helps to focus and galvanize your efforts around those milestones instead of being stuck with the single goal of “finish the project.” In addition, it divides the project into more bite-sized pieces and makes it seem less threatening (plus the milestones offer more opportunities for celebration).

When I began to study story structure (so that I will someday write a novel) I was initially resistant to the idea of structure, feeling that when I wrote I simply let it flow onto the page. But I later realized that when I write about computers the structure is clear enough so that I don’t think much about it. But I still structure my work, albeit only semi-consciously in my head. So even if you think that your plan is to just start coding, you still somehow go through the subsequent phases while asking and answering certain questions.

The mission statement

Any system you build, no matter how complicated, has a fundamental purpose, the business that it’s in, and the basic need that it satisfies. If you can look past the user interface, the hardware- or system-specific details, the coding algorithms and the efficiency problems, you will eventually find the core of its being, simple and straightforward. Like the so-called high concept from a Hollywood movie, you can describe it in one ore two sentences. This pure description is the starting point.

The high concept is quite important because it sets the tone for your project; it’s a mission statement. You won’t necessarily get it right the first time (you may be in a later phase of the project before it becomes completely clear), but keep trying until it feels right. For example, in an air-traffic control system to a very small airfield; perhaps there’s only a human controller or none at all. A more useful model won’t concern the solution you’re creating as much as it describes the problem: “Aircraft arrive, unload, service and reload, and depart.”

Phase 1: What are we making?

It’s necessary to stay focused on the heart of what you’re trying to accomplish in this phase: determine what the system is supposed to do. The most valuable tool for this is a collection of what are called “use cases.” Use cases identify key features in the system that will reveal some of the fundamental classes you’ll be using. These are essentially descriptive answers to questions like:

“Who will use this system?”

“What can those actors do with the system?”

“How does this actor do that with this system?”

“How else might this work if someone else were doing this, or if the same actor had a different objective?”(to reveal variations)

“What problems might happen while doing this with the system?”(to reveal exceptions)

If you are designing an auto-teller, for example, the use case for a particular aspect of the functionality of the system is able to describe what the auto-teller does in every possible situation. Each of these “situations” is referred to as a scenario, and a use case can be considered a collection of scenarios. You can think of a scenario as a question that starts with: “What does the system do if…?” For example, “What does the auto-teller do if a customer has just deposited a check within 24 hours and there’s not enough in the account without the check to provide the desired withdrawal?”

Use case diagrams are intentionally simple to prevent you from getting bogged down in system implementation details prematurely:

The use cases produce the requirements specifications by determining all the interactions that the user may have with the system. You try to discover a full set of use cases f or your systems, and once you’ve done that you have the core of what the system is supposed to do. The nice thing about focusing on use cases is that they always bring you back to the essentials and keep you from drifting off into issues that aren’t critic al for getting the job done. That is, if you have a full set of use cases you can describe your system and move onto the next phase. You probably won’t get it all figured out perfectly on the first try, but that’s OK. Everything will reveal itself in time, and if you demand a perfect system specification

at this point you’ll get stuck.

Phase 2: How will we build it?

In this phase you must come up with a design that describes what the classes look like and how they will interact. An excellent technique in determining classes and interactions is the Class-Responsibility-Collaboration (CRC) card. Part of the value of this tool is that it’s so low-tech: you start out with a set of blank 3” by 5” cards, and you write on them. Each card represents a single class, and on the card you write:

The name of the class. It’s important that this name capture the essence of what the class does, so that it makes sense at a glance.

The “responsibilities” of the class: what it should do. This can typically be summarized by ju st stating the names of the member functions (since those names should be descriptive in a good design), but it does not preclude other notes. If you need to seed the process, look at the problem from a lazy programmer’s standpoint: What objects would you like to magically appear to solve your problem?

The “collaborations” of the class: what other classes does it interact with? “Interact” is an intentionally broad term; it could mean aggregation or simply that some other object exists that will perform services for an object of the class. Collaborations should also consider the audience for this class. For example, if you create a class Firecracker, who is going to observe it, a Chemist or a Spectator? The former will want to know what chemicals go into the construction, and the latter will respond to the colors and shapes released when it explodes.

You may feel like the cards should be bigger because of all the information you’d like to get on them, but they are intentionally small, not only to keep your classes small but also to keep you from getting into too much detail too early. If you can’t fit all you need to know about a class on a small card, the class is too complex (either you’re getting too detailed, or you should create more than one class). The i deal class should be understood at a glance. The idea of CRC cards is to assist you in coming up with a first cut of the design so that you can get the big picture and then refine your design.

One of the great benefits of CRC cards is in communication. It’s best done real-time, in a group, without computers. Each person takes responsibility for several classes (which at first have no names or other information). You run a live simulation by solving one scenario at a time, deciding which messages are sent to the various objects to satisfy each scenario. As you go through this process, you discover the classes that you need along with their responsibilities and collaborations, and you fill out the cards as you do this. When you’ve moved through all the use cases, you should have a fairly complete first cut of your design.

Before I began using CRC cards, the most successful consulting experiences I had when coming up with an initial design involved standing in front of a team, who hadn’t built an OOP project bef ore, and drawing objects on a whiteboard. We talked about how the objects should communicate with each other, and erased some of them and replaced them with other objects. Effectively, I was managing all the “CRC cards” on the whiteboard. The team (who kne w what the project was supposed to do) actually created the design; they “owned” the design rather than having it giving it given to them.

All I was doing was guiding the process by asking the right questions, trying out the assumptions, and taking the feedback from the team to modify those assumptions. The turn beauty of the process was that the team learned how to do object-oriented design not by reviewing abstract examples, but by working on the one design that was most interesting to them at that moment: theirs.

Once you’ve come up with a set of CRC cards, you may want to create a more formal description of your design using UML. You don’t need to use UML .but it can be helpful, especially if you want to put up a diagram on the wall for everyone to ponder, which is a good idea. An alternative to UML is a textual description of the objects and their interfaces, or, depending on your programming languages, the code itself.

UML also provides an additional diagramming notation for describing the dynamic model of your system. This is helpful in situations in which the state transitions of a system or subsystem are dominant enough that they need their own diagrams (such as in a control system). You may also need to describe the data structures, for systems or subsystems in which data is a dominant factor (such as a database),

You’ll know you’re done with phase 2 when you have described the objects and their interfaces.

Well, most of them –there are usually a few that slip through the cracks and don’t make them selves known until phase 3. But that’s OK. All you are concerned with is that you eventually discover all of your objects. It’s nice to discover them early in the process but OOP provides enough structure so that it’s not so bad if you discover them later. In fact, the design of an object tends to happen in five stages, throughout the process of program development.

Phase 3: Build the core

This is the initial conversion from the rough design into a compiling and executing body of code that can be tested, and especially that will prove or disprove your architecture. This is not a one-pass process, but rather the beginning of a series of steps that will iteratively build the system, as you’ll see in phase4.

Your goal is to find the core of your system architecture that needs to be implemented in order generate a running system, no matter how incomplete that system is in this initial pass. You’re creating a framework that you can build upon with further iterations. You’re also performing the first of many system integrations and tests, and giving the stakeholders feedback about what their system will look like and how it is progressing. Ideally, you are also exposing some of the critical risks. You’ll probably also discover changes and improvements that can be made to your original architecture – things you would not have learned without implementing the system.

Part of building the system is the reality check that you get from testing against your requirements analysis and system specification (in whatever form they exist). Make sure that your tests verify the requirements and use cases. When the core of the system is stable, you’re ready to move on and add more functionality.

Phase 4: Iterate the use cases

Once the core framework is running, each feature set you add is a small project in itself. You add a feature set during an iteration, a reasonably short period of development.

How big is an iteration? Ideally, each iteration lasts one to three weeks (this can vary based on the implementation language). At the end of that period, you have an integrated, tested system with more functionality than it had before. But what’s particularly interesting is the basis for the iteration: a single use case. Each use case is a package of related functionality that you build into the system all at once, during one iteration. Not only does this give you a better idea of what the scope of a use case should be, but it also gives more validation to the idea of a use case, since the concept isn’t discarded after analysis and design, but instead it is a fundamental until of development throughout the software-building process.

You stop iterating when you achieve target functionality or an external deadline arrives and the customer can be satisfied with the current version. (Remember, software is a subscription business.) Because the process is iterative, you have many opportunities to ship a product instead of a single endpoint; open-source projects work exclusively in an iterative, high-feedback environment, which is precisely what makes them successful.

An iterative development process is valuable for many reasons. You can reveal and resolve critical risks early, the customers have ample opportunity to change their minds, programmer satisfaction is higher, and the project can be steered with more precision. But an additional important benefit is the feedback to the stakeholders, who can see by the current state of the product exactly where everything lies. This may reduce or eliminate the need for mind-numbing status meetings and increase the confidence and support from the stakeholders.

Phase 5: Evolution

This is the point in the development cycle that has traditionally been called “maintenance,” a catch-all term that can mean everything from “getting it to work the way it was really supposed to in the first place” to “adding features that the customer forgot to mention” to the more traditional “fixing the bugs that show up” and “adding new features as the need arises.” So many misconceptions have been applied to the term “maintenance” t hat it has taken on a slightly deceiving quality, partly because it suggests that you’ve actually build a pristine program and all you need to do is change parts, oil it, and keep it from rusting. Perhaps there’s a better term to describe what’s going on.

I’ll use the term evolution. That is, “You won’t get it right the first time, so give yourself the latitude to learn and to go back and make changes.” You might need to make a lot of changes as you learn and understand the problem more deeply. The elegance you’ll produce if you evolve until you get it right will

pay off, both in the short and the long term. Evolution is where your program goes from good to great, and where those issues that you didn’t really understand in the first pass become clear. It’s also where your classes can evolve from single-project usage to reusable resources.

What is it means to “get it right” isn’t just that the program works according to the requirements and the use cases. It also means that the internal structure of the code makes sense to you, and feels like it fits together well, with no awkward syntax, oversized objects, or ungainly exposed bits of code. In addition, you must have some sense that the program structure will survive the changes that it will inevitably go through during its lifetime, and that those changes can be made easily and cleanly. This is no small feat. You must not only understand what you’re building, but also how the program will evolve (what I call the vector of change). Fortunately, object-oriented programming languages are particularly adapt at supporting this kind of continuing modification –the boundaries created by the objects are what tend to keep the structure from breaking down. They also allow you to make changes –ones that would seem drastic in a procedural program –without causing earthquakes

throughout your code. In fact, support for evolution might be the most important benefit of OOP.

英文文献译文

整个开发过程时，最重要的问题是：不要迷路。这是很容易做到的。大部分的分析和设计方法都是为了解决最大的一些问题。记住，大多数的项目都不适合这一点，因此我们通常可以用一个相对较小的子集成功地进行分析和设计。但是采用某种过程，不论它怎么有局限，总比一开始就直接编码好得多。

在开发过程中很容易受阻，陷入到“分析瘫痪状态”，这种状态往往是由没有弄清当前阶段的所有细节而感到不能继续了。记住，不论做了多少分析，总有系统的一些问题直到设计时才暴露出来，并且更多的问题是到编程或是直到程序完成运行适才出现。因此，迅速进行分析和设计并对提出的系统进行测试是很重要的。

这个问题值得强调。因为我们在面向过程型语言上的历史经验，一个项目组希望进入和实现之前认真处理和理解每个细节，这是值得赞赏的。的确，在构造DBMS时，需要彻底理解用户的需要。但是DBMS属于能很好表达和充分理解的一类问题。在许多这种程序中，数据库结构就是主要问题之所在。本章讨论的编程问题属于所谓的“不定（will card）”（本人的术语）类型，这种问题的解决方法不是将众所周知的解决方案简单地重组，而是包含一个或多个“不定因素”—先前没有较了解的解决方案的要素，为此，需要研究。由于在分析阶段没有充分的信息去解决这一类问题，所以在设计和执行之前试图彻底地分析“不定型”问题会造成分析瘫痪。解决“不定型”问题需要在整个循环中反复，且需要冒风险（这是很有意义的，由于是在试图完成一些新颖的且潜在回报很高的事情）。看来似乎有风险是由于“匆忙”进入初步实现而引起的，但是这样反而可以降低风险，因为我们正在较早地确定一个特定的方法对这个问题是不是可行的。产品开发也是一种风险管理。

经常有人提到“建立一个然后丢掉”。在OOP中，我们仍然可以把一部分丢掉，然而由于代码被封装成类，在第一次的迭代中我们必将生成一些有用的类设计，并且一些不必抛弃的关于系统设计的有价值的思想。因此，在问题的第一次快速遍历中不仅要为下一遍分析、设计及实现产生关键的信息，还为下一遍建立代码基础。

也就是说，如果我们正在考虑的是一个包含丰富细节且需要许多步骤和文档的方法学，将很难判断什么时候停止。应当牢记我们正努力寻找的是什么：

1．什么是对象？(如何将项目分成多个组成部分？）

2．它们的接口是什么？(需要向每个对象发送什么信息？）

只要我们知道了对象和接口，就可以编写程序了。由于各种的原因我们可能需要比这些更多的描述和文档，但我们需要的信息不能比这些更少。

整个过程可以分5个阶段完成，阶段0只是使用一些结构的初始约定。

阶段0：制定计划

我们必须首先决定在此过程中应有那些步骤。这听起来很简单（事实上，所有听起来都是挺简单的），但是人们常常在开始编码之前没有考虑这一问题。如果计划是“让我们一开始就编码”，那很好（有时，当我们对问题充分理解时，这是合适的）。至少，我们承认这是一个计划。

在这个阶段，我们可能还要决定一些另外的过程结构，但不是全部。可以理解，有些程序员喜欢用“休假方式”工作，也就是在开展他们的工作过程中，没有强制性的结构。“想做的时候就做”。这也许在短时间内是吸引人的，但是我发现，在进程中设立一些里程碑可以帮助集中我们的注意力，激发我们的热情，而不是只注意“完成项目”这个单一的目标。另外，里程碑将项目分成更细的阶段使得风险更小（此外里程碑还提供更多庆祝的机会）。

当我开始研究小说结构时（有一天我也要写小说），我最初是反对结构思想的，我觉得自己在写作时，直接下笔千言就行了，但是，稍后我认识到，在涉及计算机的文字时，本身结构足够清晰，所以不需要多想。但是我仍然要组织文字结构，虽然这在我头脑中是半意识的。即便我们认为自己的计划只是一上来就开始编码，在后续阶段仍然需要不断地询问和回答一些问题。

任务陈述

无论构建什么系统，不管如何复杂，都有其基本目的的，有其要处理的业务，有其所要满足的基本需要。通过依次审视用户界面、硬件或系统的特殊细节、算法编码和效率问题，我们将最终找出它的核心。通常简单又直接。就像来自好莱坞电影的所谓的高层概念，我们能用一句或两句话表述。这种纯粹的表述是起点。

高层概念很重要，因为它设定了项目的基调，这是一种任务陈述。我们不必一开始就让它正确（我们也许正处于在项目变得完全清晰之前的最后阶段），但是要不停地努力直到它越来越正确。例如：在一个空中交通指挥系统中，我们可以从关于正在建立的系统的一个高层概念入手：“塔楼程序跟踪飞机”。但是

计算机专业毕业设计说明书外文翻译(中英对照)

Talking about security loopholes Richard S. Kraus reference to the core network security business objective is to protect the sustainability of the system and data security, This two of the main threats come from the worm outbreaks, hacking attacks, denial of service attacks, Trojan horse. Worms, hacker attacks problems and loopholes closely linked to, if there is major security loopholes have emerged, the entire Internet will be faced with a major challenge. While traditional Trojan and little security loopholes, but recently many Trojan are clever use of the IE loophole let you browse the website at unknowingly were on the move. Security loopholes in the definition of a lot, I have here is a popular saying: can be used to stem the "thought" can not do, and are safety-related deficiencies. This shortcoming can be a matter of design, code realization of the problem. Different perspective of security loo phole s In the classification of a specific procedure is safe from the many loopholes in classification. 1. Classification from the user groups: ● Public loopholes in the software category. If the loopholes in Windows, IE loophole, and so on. ● specialized software loophole. If Oracle loopholes, Apach e,

图书管理系统概要设计概要

图书管理系统概要设计

目录 一、引言 (3) 1.1编写目的 (3) 1.2项目背景 (3) 1.3开发环境 (3) 1.4参考资料 (4) 二、任务概述 (4) 2.1需求概述 (4) 2.2运行环境 (4) 三、总体设计 (4) 3.1基本设计概念和处理流程 (4) 3.2系统结构和模块外部设计 (6) 3.3功能分配 (6) 四、接口设计 (7) 4.1用户接口 (7) 4.2外部接口 (7) 4.3内部接口 (7) 五、运行设计 (8) 5.1运行模块的组合 (8) 5.3运行时间 (8) 六、数据结构设计 (9) 6.1逻辑结构设计 (9) 6.2物理结构设计 (15) 6.3数据结构与程序的关系 (15) 七、维护设计 (15)

一、引言 1.1编写目的 由前面的需求分析，得出了系统的基本需求，和基本的数据流图，要实现整个系统，需要对用户的需求进行设计，概要设计主要是利用比较抽象的语言对整个需求进行概括，确定对系统的物理配置，确定整个系统的处理流程和系统的数据结构，接口设计，实现对系统的初步设计 1.2项目背景 图书管理是高效内每一个系部或院部都必须切实面对的工作，但是一直以来人们都使用传统的人工方式管理图书资料。这种方式存在着效率低下，保密性差等缺点。另外，随着图书资料数量的增加，其工作量也大大增加，这必将增加图书资料管理者的工作量和劳动强度，这将给图书资料信息的查找、更新和维护都带来了很多困难。图书管理作为计算机应用的一分支，有着手工无法比拟的优点，如检索迅速，查找方便，可靠性高等，这些优点能够极大地提高图书管理的效率。因此，开发一套能够为用户提供充足的信息和快捷的查询手段的图书管路系统，将是十分必要的 1.3开发环境 ?SQL Sever 2008：数据库管理软件 ?DBMS：数据库管理系统 ?Windows7：运行环境 ?Java ：软件开发语言

某图书馆智能化系统的设计说明书

某图书馆智能化系统的设计 【摘要】本文结合某市级图书馆智能化系统建设项目，给出了一套完整的图书馆智能化系统规划与设计，阐述了图书馆智能化系统的智能化系统的系统配置、体系结构、集成方式。【关键词】图书馆信息化智能化数字化 1.引言 当今国际上计算机技术、控制技术、通信技术、图形显示技术等高新技术日新月异，可以供选择的智能化系统的设计方案、设备配置以及应用软件种类繁多。使用单位通常较难对智能化智能化系统的系统配置、体系结构、集成方式和对新技术产品的选型作出快速地决断和得到最优化的实施方案。 因此，如何运用系统工程的环境与制约条件来一体化综合集成智能化智能化各子系统，集国内外各制造厂家产品之长，采用好各种先进技术，把握住合理的设备配置，让整个图书馆建筑物智能化系统设备在总体上发挥最大的运行优势，以获得最佳的投资效益。 2.工程概况 某市级图书馆建筑总面积约2.6056万m2，地上4层（面积约1.9131万m2）、地下1层（面积约0.6925万m2）。建筑物的主要结构为钢筋混凝土框架剪力墙结构；防火分类等级（一）类，防火等级（一）级。 3.设计思想 设计所按照的原则 公共图书馆是各级人民政府举办的面向社会公众开放的公益性文化与社会教育设施，是实现和保障公众基本文化权利、满足公众知识和信息基本需求的建筑之一，是社会公平保障体系的重要组成部分，亦是公共文化服务体系的重要组成部分。 设计的框架理念 智能化系统设计中应依据图书馆建筑的特点进行定位，并按建筑的绿色、节能、环保等为设计宗旨，完善其智能化智能化功能，将本建筑物建设成为江苏省宜兴市文化中心的一个亮点，同时让图书馆成为体现社会全面文明进步的窗口之一。 设计的目标 将某市级图书馆建设成为一个集智能化、数字化、绿色环保化及数字城市信息节点于一身的文化建筑。 设计的基础平台

计算机专业英语课后单词翻译

P21.KEY TERMS application software 应用软件basic application 基本应用软件communication device通信设备compact disc (CD) 光盘computer competency计算机能力connectivity连通性 data数据 database file数据库文件 desktop computer台式计算机device driver磁盘驱动程序 digital versatile disc（DVD）数字多用途光盘 digital video disc（DVD）数字多用途光盘 document file文档文件 end user终端用户 floppy disk软盘 handheld computer手持计算机hard disk硬盘 hardware硬件 high definition高清 Information信息 information system信息系统information technology信息技术input device输入设备 Internet因特网 keyboard键盘 mainframe computer主机；电脑存储机 memory内存 microcomputer微型机microprocessor微处理器midrange computer中型机minicomputer小型计算机modem调制解调器 monitor监视器 mouse鼠标 network网络 notebook computer笔记本电脑operating system操作系统optical disk光盘 output device输出设备 palm computer掌上电脑 people用户 personal digital assistant（PDA）个人数字助理 presentation file演示文稿primary storage主存 printer打印机 procedure规程 program程序 random access memory随机存储器 secondary storage device辅存software软件 specialized application专门应用软件 supercomputer巨型机 system software系统软件system unit系统单元 tablet PC平板电脑 utility实用程序 wireless revolution无线革命worksheet file工作表

计算机专业外文文献翻译6

外文文献翻译（译成中文2000字左右）： As research laboratories become more automated,new problems are arising for laboratory managers.Rarely does a laboratory purchase all of its automation from a single equipment vendor. As a result,managers are forced to spend money training their users on numerous different software packages while purchasing support contracts for each. This suggests a problem of scalability. In the ideal world,managers could use the same software package to control systems of any size; from single instruments such as pipettors or readers to large robotic systems with up to hundreds of instruments. If such a software package existed, managers would only have to train users on one platform and would be able to source software support from a single vendor. If automation software is written to be scalable, it must also be flexible. Having a platform that can control systems of any size is far less valuable if the end user cannot control every device type they need to use. Similarly, if the software cannot connect to the customer’s Laboratory Information Management System (LIMS) database,it is of limited usefulness. The ideal automation software platform must therefore have an open architecture to provide such connectivity. Two strong reasons to automate a laboratory are increased throughput and improved robustness. It does not make sense to purchase high-speed automation if the controlling software does not maximize throughput of the system. The ideal automation software, therefore, would make use of redundant devices in the system to increase throughput. For example, let us assume that a plate-reading step is the slowest task in a given method. It would make that if the system operator connected another identical reader into the system, the controller software should be able to use both readers, cutting the total throughput time of the reading step in half. While resource pooling provides a clear throughput advantage, it can also be used to make the system more robust. For example, if one of the two readers were to experience some sort of error, the controlling software should be smart enough to route all samples to the working reader without taking the entire system offline. Now that one embodiment of an ideal automation control platform has been described let us see how the use of C++ helps achieving this ideal possible. DISCUSSION C++: An Object-Oriented Language Developed in 1983 by BjarneStroustrup of Bell Labs,C++ helped propel the concept of object-oriented programming into the mainstream.The term ‘‘object-oriented programming language’’ is a familiar phrase that has been in use for decades. But what does it mean? And why is it relevant for automation software? Essentially, a language that is object-oriented provides three important programming mechanisms:

软件工程图书管理系统详细设计说明

图书馆管理系统详细设计 1项目概述： 1.1产品描述： 图书馆管理系统使用C/S模式。用户可以以管理员的身份登陆，进行读者管理，书目管理；以普通用户登陆，可以进行自身信息管理，自主借书，还书。 1.2项目背景： 用于图书馆管理图书信息，及读者信息。主要由登陆模块，图书管理模块，用户管理模块，用户操作模块。 2图书馆管理系统结构图：

3．模块详细设计说明： 1)初始化模块： ●功能描述：系统初始时，由操作系统调用，经过身份验证，进入不同的模块。 ●输入项：用户名：任意长度字符串或数字；密码：任意长度字符串或数字。 ●输出项：有效用户和无效用户。 2)关闭系统模块： ●功能描述：由管理员模块或用户模块调用，执行完毕后返回操作系统。 3)管理员模块： ●功能描述：接受消息循环，启动查询书目模块，删除书目模块，插入书目模块， 修改书目模块，查询读者模块，删除读者模块，插入读者模块，修改读者模块。 ●输入项：管理员鼠标或键盘操作。 ●输出项：启动相应模块。 4)用户模块： ●功能描述：接受消息循环，启动查询书目模块，查询已借图书模块，修改读者 模块，借书模块，还书模块。

● 输入项：用户鼠标或键盘操作。 ● 输出项：启动相应模块。 5) 查询书目模块： ● 功能描述：根据要求，求出查询结果。 ● 输入项：查找条件。 ● 输出项：显示查询结果。 ● 实现：source = "select * from bookinfo" Adodc1.RecordSource = source ● 流程图： 6) 删除书目模块： ● 功能描述：完成删除一条记录。 ● 输入项：查找条件。 ● 输出项：删除信息。 ● 实现：varsource = "delete from bookinfo where bookname='" & Trim(DeleteBooks.bookname.Text)&"'and bookno='" & Trim(DeleteBooks.bookno.Text) & "'" rsl.Open varsource 7) 插入书目模块： ● 功能描述：完成插入一条记录。 ● 输入项：记录信息。 ● 输出项：插入信息。 ● 流程图： ● 实现： varsource = "insert into bookinfo values('" & Trim(txtBookNo.Text) & "','" & Trim(txtBookName.Text) & "','" & Trim(txtAuthor.Text) & "','" &

图书馆智能化管理系统方案

图书馆智能化管理方案 一、系统背景 图书馆拟对图书馆管理系统进行软硬件的升级，通过采用先进的RFID（无线射频卡）技术和设备，从而有效地提高图书管理的效率、简化图书管理的流程、降低图书管理人员的劳动强度。 北京赤坤科技有限公司根据的图书馆的实际情况，为图书馆设计了采用RFID技术的图书自动管理系统，系统可以作为一个独立的图书馆管理系统运行，也可以接入学院的校园网络实现图书馆在校园网络的信息共享以及借阅服务，是图书馆管理现代化、智能化的有力体现，是学校教学手段现代化的必然选择。系统以RFID技术为基础，以RFID中间件为媒介实现了先进的RFID技术和图书管理方法的有机结合，为图书馆的管理提供了十分有效的技术手段，将先进RFID技术同图书管理系统有机地结合起来，有效地提高了图书管理的效率、简化了图书管理的流程、降低了图书管理人员的劳动强度并在为读者提供更加便利快捷的图书借还书、查询等服务的同时做到对读者信息和借阅图书的双重（数据库和图书标签芯片）记录，并实现了EAS和记录借阅信息流程的统一。 二、方案构成 2.1 基本功能 建设图书馆RFID智能馆藏管理系统网络运行环境并部署相应的RFID硬件设备。用来识别、追踪、和保护图书馆的所有资料，通过RFID系统实现图书借还、顺架、查找、馆藏盘点等功能，目标是极大地提高图书馆资料处理的效率。 2.2 系统介绍 2.2.1 系统构成

系统模块包含读者自助借阅系统馆员、工作站读取器、便携式馆藏点检器、智能流通标签转换连接工作站、读者自助还书系统、智能安全监测系统、应用服务器及校园借阅信息提示器。 整个图书馆RFID智能馆藏系统应用软件包括：智能流通标签初始化转换系统、管员工作站应用功能集成系统、读者自助借阅系统、读者自助还书系统、手持设备查询、顺架及盘点系统、安全通道门系统。 2.2.2 系统应用 1. 智能监测系统：当入出图书馆经过该系统，图书被遗漏处理自动提醒 2. 馆员工作站：在线设备的实时监控管理；为读者提供更多更好的增值服务；辅助业务处理 3. 自助借书系统：可供读者自主借书操作 4. 自助还书系统：可供读者自主还书操作 5. RFID馆藏标签：可记录书名、作者、出版社、索书号、ISBN/ISSN、等信息 6. 馆藏资料：书、磁带、光盘等 7. 便携式馆藏点检系统：馆藏资料盘点、寻找、顺架 8. 标签转换系统：对馆藏标签编写数据或分流 9. 图书馆应用系统：北京赤坤科技创新研发部提供与各类图书馆应用系统无缝集 2.2.3 系统优点 1. 管理 1) 更高、更先进的管理模式 2) 人力资源的合理配置，低层次服务转变为高层次服务 3) 简化人工作业，节约时间和成本

计算机专业英语翻译参考

1.(P1) Computer science deals with the theoretical foundations of information and computation, together with practical techniques for the implementation and application of these foundations, such as programming language theory, computational complexity theory, computer graphics and human-computer interaction. 计算机科学涉及信息和计算的理论基础，以及这些基础的实施和应用的实际技术，如编程语言理论，计算复杂性理论，计算机图形学和人机交互。 2.(P17) The most important piece of graphics hardware is the graphics card, which is the piece of equipment that renders out all images and sends them to a display. There are two types of graphics cards: integrated and dedicated. An integrated graphics card, usually by Intel for use in their computers, is bound to the motherboard and shares RAM (Random Access Memory) with the CPU, reducing the total amount of RAM available. This is undesirable for running programs and applications that use a large amount of video memory. A dedicated graphics card has its own RAM and Processor for generating its images, and does not slow down the computer. Dedicated graphics cards also have higher performance than integrated graphics cards. It is possible to have both dedicated and integrated graphics card, however once a dedicated graphics card is installed, the integrated card will no longer function until the dedicated card is removed. 最重要的一块图形硬件是显卡，是一件呈现出所有的图像，并将它们发送到一个显示器的设备。有两种类型的显卡：集成和专用。集成的显卡，通常由英特尔在他们的计算机上使用，被绑定到主板并且与中央处理器共享内存（随机存取存储器），减少了可用的内存总量。这对于使用大量视频内存的程序和应用来说是不可取的。 专用显卡有它自己的内存和处理器，用于生成它的图像，并且不会减慢计算机的速度。专用显卡也比集成显卡有更高的性能。有可能既有专门的也有集成的显卡，但是，一旦安装了专用显卡，集成显卡将不再起作用，直到专用显卡被移除。 3.(P18) Channel I/O requires the use of instructions that are specifically designed to perform（执行）I/O operations. The I/O instructions address（处理）the channel or the channel and device; the channel asynchronously（异步的）accesses all other required addressing and control information. This is similar to DMA, but more flexible. I/O通道需要使用专门设计来执行I/O操作的指令。I/O指令处理通道或通道和设备；通道异步访问所有其他所需的寻址和控制信息。这是类似于DMA，但更灵活。 4.(P19) 调制解调器是在模拟和数字信号之间进行转换的设备，它经常用于实现计算机之间通过电话线的互相通 信。如果两个调制解调器可同时互相发送数据，那么它们采用的就是全双工工作方式；如果一次只有一个调制解调器可以发送数据，那么它们采用的则是半双工工作方式。 Modem is a device that converts analog（模拟）signals to digital signals or conversely（相反地）. It is often used to communicate between computers via（渠道）telephone lines. If the two modems can send data to each other, they use full-duplex mode; if only one modem can transmit data, they use half-duplex mode. 5.(P21) We many have defined our last generation of computer and begun the era of generationless computers. Even though computer manufacturers talk of “fifth” and “sixth” generation computers, this talk is more a marketing play than a reflection of reality. 我们已经定义了我们的上一代计算机，并且开始了计算机的无代时代。即使计算机制造商谈论的“第五”和“第六” 代电脑，这个说法比起现实的反映更像是一个营销游戏。 6.(P21) Although microprocessors are still technically considered to be hardware, portions of their function are also associated with computer software. Since microprocessors have both hardware and software aspects they are therefore often referred to as firmware. 虽然微处理器仍然在技术上被认为是硬件，它们的部分功能也与计算机软件有联系。因为微处理器有硬件和软件两个方面，因此，他们往往被称为固件。 7.(P22) Electronic hardware consists of interconnected（互联的）electronic components（元件/组件）which perform analog or logic operations on received and locally stored information to produce as output or store resulting new information or to provide control for output actuator mechanisms（机制）. Electronic hardware can range from individual chips/circuits to distributed information processing systems. Well-designed electronic hardware is composed of functional modules which inter-communicate via precisely

计算机专业外文翻译

专业外文翻译 题目JSP Technology Conspectus and Specialties 系（院）计算机系 专业计算机科学与技术 班级 学生姓名 学号 指导教师 职称讲师 二〇一三年五月十六日

JSP Technology Conspectus and Specialties The JSP (Java Server Pages) technology is used by the Sun micro-system issued by the company to develop dynamic Web application technology. With its easy, cross-platform, in many dynamic Web application programming languages, in a short span of a few years, has formed a complete set of standards, and widely used in electronic commerce, etc. In China, the JSP now also got more extensive attention; get a good development, more and more dynamic website to JSP technology. The related technologies of JSP are briefly introduced. The JSP a simple technology can quickly and with the method of generating Web pages. Use the JSP technology Web page can be easily display dynamic content. The JSP technology are designed to make the construction based on Web applications easier and efficient, and these applications and various Web server, application server, the browser and development tools work together. The JSP technology isn't the only dynamic web technology, also not the first one, in the JSP technology existed before the emergence of several excellent dynamic web technologies, such as CGI, ASP, etc. With the introduction of these technologies under dynamic web technology, the development and the JSP. Technical JSP the development background and development history In web brief history, from a world wide web that most of the network information static on stock transactions evolution to acquisition of an operation and infrastructure. In a variety of applications, may be used for based on Web client, look no restrictions. Based on the browser client applications than traditional based on client/server applications has several advantages. These benefits include almost no limit client access and extremely simplified application deployment and management (to update an application, management personnel only need to change the program on a server, not thousands of installation in client applications). So, the software industry is rapidly to build on the client browser multilayer application. The rapid growth of exquisite based Web application requirements development of

网上图书管理系统

自动化网上图书管理系统建设 目录 一、网上图书管理系统产品简介 (2) 二、网上图书管理系统产品特点 (3) 三、产品功能 (5) 四、多校区馆藏管理 (6) 五、校园一卡通、企业通结合。 (6) 5.1、免二次开发成本实现学生一卡通或员工卡借阅图书 (7) 5.2二次开发，同步读者信息。 (7) 六、图书馆防盗 (8) 七、数据加工回溯建库 (9) 八、常用清单 (10) 九、系统运行环境 (11)

卓一网上图书管理系统由广州卓一信息科技有限公司自主研发的一套非常非常有前景且通俗易懂的图书馆信息化管理系统,也是国内一套图书馆趋势化的应用系统,是中小图书馆的理想选择。广泛应用于职校图书馆、技校图书馆、中小学图书馆、网上图书管理系统、企业图书馆、政府图书馆。它实现了图书馆编目管理、借阅流通、数据统计、图书检索、图书预借、个人信息查阅等一系列相关图书馆的操作。它充分发挥了信息化管理的方便性，快捷性，并与一卡通无缝结合，让图书馆管理人员便捷地工作。

1、开放平台，系统采用JAVA开发，MYSQL数据库；采用浏览器智能界面，自动适应窗口大小；数据定时备份，可靠放心。 2、拓展性强，传统到智能化管理，支持微信定制。 3、兼容性强，支持WINDOWS所有操作系统，包括虚拟机、云平台。

4、升级容易，单机版到网络版，传统图书馆到智慧图书馆。 5、应用广泛，无论职技校、中小学、政府、企业单位都有成功案例。

三、产品功能

四、多校区馆藏管理 多校区采用同一数据库，通过不同的管理员账号可以实现同步编目入库，每个分校可以设置不同馆藏点，同步借书还书，还可以通过OAPC查询系统查询所需图书。 前提注意事项： 1、各分校的条形码不能有相同 2、读者借阅证不能有相同 3、图书馆系统需放在校内服务器里，其它分校都可以访问网上图书管理系统的服务器。 五、校园一卡通、企业通结合。 校园一卡通、企业通结合就是通过一卡通系统开放的数据接口，网上图书管理系统进行读者信息的同步，使用学生一卡通或员工卡即可进行借还图书，不需要重新制作借阅证，达到读者信息增加、删除、修改同步效果。

计算机专业英语2008影印版选择题的翻译加答案

CHAPTER 1 1、A common term that describes the combination of traditional computer and communication technologies is b. information technology 一个描述了传统的计算机和通信技术结合的常见的术语 B.信息技术 2、Procedures are typically documented in manuals written by b. computer specialists 程序一般是___在手册撰写记录的 B.计算机专家 3、Which of the following is an example of connectivity? a. Internet 下列哪一项是连接的一个例子吗？ A.互联网 4、Windows XP, windows Vista, and Macintosh OS X are all examples of b. operating systems Windows XP，Windows Vista，和Macintosh OS X都是__的例子 B.操作系统 5、Because of their size and cost, these computers are relatively rare. d. supercomputers 由于它们的尺寸和成本，这些电脑是比较少见的。 D.超级计算机 6、The system component that controls and manipulates data in order to produce information is called the d. microprocessor 系统组成，控制和操纵数据来产生信息称为 D.微处理器 7、A system component that translates data and programs that humans can understand into a form that the computer can process is called a(n) c. output device 一个系统组件，将人类可以理解成计算机能够处理的形式的数据和程序被称为 C.输出设备 8、A CD is an example of a(n) c. optical disc CD是___的简称 C.光盘 9、If you want to communicate a message or persuade other people, you would typically use this type of software. d. presentation 如果你想传达信息或说服别人，你通常会使用这种类型的软件。 D.演示 10、Many experts are predicting that this revolution is expected to dramatically affect the way we communicate and use computer technology. d. wireless

计算机专业外文文献及翻译

计算机专业外文文献及翻译 微软Visual Studio 1微软Visual Studio 是微软公司推出的软软软境～可以用软建来平台下的 Visual Studio Visual StudioWindows 软用程序和软软用程序～也可以用软建软服软、智能软软软用程序和网来网 插件。WindowsOffice Visual 是一自微软的个来集成软软软境;,～可以用软软由它来微StudioIDEinteqrated development environment软软窗～软手机窗～、框架、精软架框和微软的支持的控制台和软Windows https://www.wendangku.net/doc/50914901.html,Silverlight 形用软界面的软用程序以及窗体软用程序～站网～软用程序和软服软网中的本地代软软同托管WindowsWeb 代软。 包含一由个智能感知和代软重构支持的代软软软器。集成的软软工作作软一源代软软软既个Visual Studio 软器又可以作软一台机器软软软器。其他置工具包括一软软内个窗体的软用程序～软软软软～软软软软～网数据软架GUI 构软软软。有乎各软面的件增强功能～包括增加软支持它几个插源代软控制系软;如和SubversionVisual ,添加新的工具集软软和可软化软软器～如并特定于域的软言或用于其他方面的软件软软生命周期SourceSafe 的工具;例如的客软端,软软软源管理器,。Team Foundation Server

支持不同的软程软言的服软方式的软言～允软代软软软器和软软器;在不同程 度上,支持它Visual Studio 几乎所有的软程软言～提供了一软言特定服软的存在。置的软言中包括个内中;通软C/C + +Visual C+,;通软,～,中;通软,,和,;作软+,https://www.wendangku.net/doc/50914901.html,Visual https://www.wendangku.net/doc/50914901.html,CVisual CFVisual Studio ,～软支持其他软言～如和等～可通软安软的软言服软。软也支持装独它的2010M,Python,Ruby 和软特定用软提供服软的也是存在的,微 XML/XSLT,HTML/XHTML ,JavaScriptCSS.Visual Studio软～,、,和。Visual BasicVisual JVisual CVisual C++ 微软提供了“直通软”的软件的和,和～Visual Studio 2010Visual BasicVisual CVisual C + +和版本～不需任何软用。、年和软软版～以及Visual Web DeveloperVisual Studio 201020082005 的特定软言版本;、、,、,,～通软微软的下软Visual Studio 2005Visual BasicC++CJ 软～软生免软。划学DreamSpark 2架构 不支持任何软程软言～解方案或工具本软。相反～允软入各软功能。特定的功决它插Visual Studio 能是作软一个软软包的代软。安软～软功能可以服软器得到。装个从提供三软服软,～VSIDESVsSolution它决提供了能软列软的软目和解方案～提供了口和用软界面功能;包括软软～工具软和工它窗; SVsUIShell 具口,和窗～软理它软软包的注。此外～册软可以软软软软和服软之软软软通信。所有的软软器～SVsShellVSIDE