计算机系——外文翻译(中英对照-3000汉字左右)

国家计算机教育认证 计算机英语计算机英语词汇对译蒙阴高新电脑学校资料整理：孙波2010年9月1日IT CF AC gaoxindiannaoxuexiao⏹PC personal computer 个人计算机⏹IBM International Business Machine 美国国际商用机器公司的公司简称，是最早推出的个人计算机品牌。

⏹Intel 美国英特尔公司，以生产CPU芯片著称。

⏹Pentium Intel公司生产的586 CPU芯片,中文译名为“奔腾”。

⏹Address地址⏹Agents代理⏹Analog signals模拟信号⏹Applets程序⏹Asynchronous communications port异步通信端口⏹Attachment附件⏹Access time存取时间⏹access存取⏹accuracy准确性⏹ad network cookies广告网络信息记录软件⏹Add-ons 插件⏹Active-matrix主动矩阵⏹Adapter cards适配卡⏹Advanced application高级应用⏹Analytical graph分析图表⏹Analyze分析⏹Animations动画⏹Application software 应用软件⏹Arithmetic operations算术运算⏹Audio-output device音频输出设备⏹Basic application基础程序⏹Binary coding schemes二进制译码方案⏹Binary system二进制系统⏹Bit比特⏹Browser浏览器⏹Bus line总线⏹Backup tape cartridge units备份磁带盒单元⏹Business-to-consumer企业对消费者⏹Bar code条形码⏹Bar code reader条形码读卡器⏹Bus总线⏹Bandwidth带宽⏹Bluetooth蓝牙⏹Broadband宽带⏹Business-to-business企业对企业电子商务⏹cookies-cutter programs信息记录截取程序⏹cookies信息记录程序⏹cracker解密高手⏹cumulative trauma disorder积累性损伤错乱⏹Cybercash电子现金⏹Cyberspace计算机空间⏹cynic愤世嫉俗者⏹Cables连线⏹Cell单元箱⏹Chain printer链式打印机⏹Character and recognition device字符标识识别设备⏹Chart图表⏹Chassis支架⏹Chip芯片⏹Clarity清晰度⏹Closed architecture封闭式体系结构⏹Column列⏹Combination key结合键⏹computer competency计算机能力⏹connectivity连接，结点⏹Continuous-speech recognition system连续语言识别系统⏹Channel信道⏹Chat group谈话群组⏹chlorofluorocarbons(CFCs) ]氯氟甲烷⏹Client客户端⏹Coaxial cable同轴电缆⏹cold site冷网站⏹Commerce servers商业服务器⏹Communication channel信道⏹Communication systems信息系统⏹Compact disc rewritable⏹Compact disc光盘⏹computer abuse amendments act of 19941994计算机滥用法案⏹computer crime计算机犯罪⏹computer ethics计算机道德⏹computer fraud and abuse act of 1986计算机欺诈和滥用法案⏹computer matching and privacy protection act of 1988计算机查找和隐私保护法案⏹Computer network计算机网络⏹computer support specialist计算机支持专家⏹computer technician计算机技术人员⏹computer trainer计算机教师⏹Connection device连接设备⏹Connectivity连接⏹Consumer-to-consumer个人对个人⏹Control unit操纵单元⏹Cordless or wireless mouse无线鼠标⏹Cable modems有线调制解调器⏹carpal tunnel syndrome腕骨神经综合症⏹CD-ROM可记录光盘⏹CD-RW可重写光盘⏹CD-R可记录压缩光盘⏹Disk磁碟⏹Distributed data processing system分部数据处理系统⏹Distributed processing分布处理⏹Domain code域代码⏹Downloading下载⏹DVD 数字化通用磁盘⏹DVD-R 可写DVD⏹DVD-RAM DVD随机存取器⏹DVD-ROM 只读DVD⏹Database数据库⏹database files数据库文件⏹Database manager数据库管理⏹Data bus数据总线⏹Data projector数码放映机⏹Desktop system unit台式电脑系统单元⏹Destination file目标文件⏹Dumb terminal非智能终端⏹data security数据安全⏹Data transmission specifications数据传输说明⏹database administrator数据库管理员⏹Dataplay数字播放器⏹Demodulation解调⏹denial of service attack拒绝服务攻击⏹Dial-up service拨号服务⏹Digital cash数字现金⏹Digital signals数字信号⏹Digital subscriber line数字用户线路⏹Digital versatile disc数字化通用磁盘⏹Digital video disc数字化视频光盘⏹Direct access直接存取⏹Directory search目录搜索⏹disaster recovery plan灾难恢复计划⏹Disk caching磁盘驱动器高速缓存⏹Diskette磁盘⏹Digital cameras数码照相机⏹Digital notebooks数字笔记本⏹Digital bideo camera数码摄影机⏹Discrete-speech recognition system不连续语言识别系统⏹Document文档⏹document files文档文件⏹Dot-matrix printer点矩阵式打印机⏹Dual-scan monitor双向扫描显示器⏹environment环境⏹Erasable optical disks可擦除式光盘⏹ergonomics人类工程学⏹ethics道德规范⏹External modem外置调制解调器⏹extranet企业外部网⏹e-book电子阅读器⏹Expansion cards扩展卡⏹electronic commerce电子商务⏹electronic communications privacy act of1986电子通信隐私法案⏹encrypting加密术⏹energy star能源之星⏹Enterprise computing企业计算化⏹end user终端用户⏹e-cash电子现金⏹e-commerce电子商务⏹electronic cash电子现金⏹Floppy-disk cartridge磁盘盒⏹Formatting格式化⏹freedom of information act of 1970信息自由法案⏹frequency频率⏹frustrated受挫折⏹Full-duplex communication全双通通信⏹Fax machine传真机⏹Field域⏹Find搜索⏹FireWire port火线端口⏹Firmware固件⏹Flash RAM闪存⏹Flatbed scanner台式扫描器⏹Flat-panel monitor纯平显示器⏹floppy disk软盘⏹filter过滤⏹firewall防火墙⏹firewall防火墙⏹Fixed disk固定硬盘⏹Flash memory闪存⏹Flexible disk可折叠磁盘⏹Floppies磁盘⏹Formatting toolbar格式化工具条⏹Formula公式⏹Function函数⏹fair credit reporting act of 1970公平信用报告法案⏹Fiber-optic cable光纤电缆⏹File compression文件压缩⏹File decompression文件解压缩⏹green pc绿色个人计算机⏹Grop by 排序⏹General-purpose application通用运用程序⏹Gigahertz千兆赫⏹Graphic tablet绘图板⏹Hard-disk pack硬盘组⏹Head crash磁头碰撞⏹header标题⏹help desk specialist帮助办公专家⏹helper applications帮助软件⏹Hierarchical network层次型网络⏹history file历史文件⏹handheld computer手提电脑⏹Hard copy硬拷贝⏹hard disk硬盘⏹hardware硬件⏹Help帮助⏹hits匹配记录⏹horizontal portal横向用户⏹hot site热网站⏹Hybrid network混合网络⏹Host computer主机⏹Home page主页⏹Hyperlink超链接⏹hacker黑客⏹Half-duplex communication半双通通信⏹Hard-disk cartridge硬盘盒⏹information pushers信息推送器⏹initializing 初始化⏹instant messaging计时信息⏹internal hard disk内置硬盘⏹Internet hard drive 网络硬盘驱动器⏹intranet企业内部网⏹Image capturing device图像获取设备⏹information technology信息技术⏹Ink-jet printer墨水喷射印刷机⏹Integrated package综合性组件⏹Intelligent terminal智能终端设备⏹Intergrated circuit集成电路⏹Interface cards接口卡⏹illusion of anonymity匿名幻想⏹index search索引搜索⏹Internal modem内部调制解调器⏹internet telephony网络电话⏹internet terminal互联网终端⏹Identification识别⏹drive网络硬盘驱动器⏹joystick操纵杆⏹keyword search关键字搜索⏹laser printer激光打印机⏹Layout files版式文件⏹Light pen光笔⏹Locate定位⏹lurking潜伏⏹Logical operations逻辑运算⏹Lands凸面⏹Line of sight communication视影通信⏹Low bandwidth低带宽计算机英语名词解释⏹ADIMM（Advanced Dual In-line Memory Modules，高级双重内嵌式内存模块）⏹AMR（Audio／Modem Riser，音效／调制解调器主机板附加直立插卡）⏹AHA（Accelerated Hub Architecture，加速中心架构）⏹ASK IR（Amplitude Shift Keyed Infra-Red，长波形可移动输入红外线）⏹ATX（AT Extend，扩展型AT）⏹BIOS（Basic Input/Output System，基本输入/输出系统）⏹CSE（Configuration Space Enable，可分配空间）⏹DB（Device Bay，设备插架）⏹DMI（Desktop Management Interface，桌面管理接口）⏹EB（Expansion Bus，扩展总线）⏹EISA（Enhanced Industry Standard Architecture，增强形工业标准架构）⏹EMI（Electromagnetic Interference，电磁干扰）⏹ESCD（Extended System Configuration Data，可扩展系统配置数据）⏹FBC（Frame Buffer Cache，帧缓冲缓存）⏹FireWire（火线，即IEEE1394标准）⏹FSB（Front Side Bus，前置总线，即外部总线）⏹FWH（Firmware Hub，固件中心）⏹GMCH（Graphics & Memory Controller Hub，图形和内存控制中心）⏹GPIs（General Purpose Inputs，普通操作输入）⏹ICH（Input/Output Controller Hub，输入/输出控制中心）⏹IR（Infrared Ray，红外线）⏹IrDA（Infrared Ray，红外线通信接口可进行局域网存取和文件共享）⏹ISA（Industry Standard Architecture，工业标准架构）⏹ISA（Instruction Set Architecture，工业设置架构）⏹MDC（Mobile Daughter Card，移动式子卡）⏹MRH-R（Memory Repeater Hub，内存数据处理中心）⏹MRH-S（SDRAM Repeater Hub，SDRAM数据处理中心）⏹MTH（Memory Transfer Hub，内存转换中心）⏹NGIO（Next Generation Input/Output，新一代输入/输出标准）⏹P64H（64-bit PCI Controller Hub，64位PCI控制中心）⏹PCB（Printed Circuit Board，印刷电路板）⏹PCBA（Printed Circuit Board Assembly，印刷电路板装配）⏹PCI（Peripheral Component Interconnect，互连外围设备）⏹PCI SIG（Peripheral Component Interconnect Special Interest Group，互连外围设备专业组）⏹POST（Power On Self Test，加电自测试）⏹RNG（Random number Generator，随机数字发生器）⏹RTC（Real Time Clock，实时时钟）⏹KBC（KeyBroad Control，键盘控制器）⏹SAP（Sideband Address Port，边带寻址端口）⏹SBA（Side Band Addressing，边带寻址）⏹SMA（Share Memory Architecture，共享内存结构）⏹STD（Suspend To Disk，磁盘唤醒）⏹STR（Suspend To RAM，内存唤醒）⏹SVR（Switching V oltage Regulator，交换式电压调节）⏹USB（Universal Serial Bus，通用串行总线）⏹USDM（Unified System Diagnostic Manager，统一系统监测管理器）⏹VID（Voltage Identification Definition，电压识别认证）⏹VRM （V oltage Regulator Module，电压调整模块）⏹ZIF（Zero Insertion Force ，零插力）⏹主板技术⏹ACOPS（Automatic CPU OverHeat Prevention System，CPU过热预防系统）⏹SIV（System Information Viewer，系统信息观察）⏹ESDJ（Easy Setting Dual Jumper，简化CPU双重跳线法）⏹UPT（USB、PANEL、LINK、TV-OUT四重接口）⏹芯片组⏹ACPI（Advanced Configuration and Power Interface，先进设置和电源管理）⏹AGP（Accelerated Graphics Port，图形加速接口）⏹I/O（Input/Output，输入/输出）⏹MIOC（Memory and I/O Bridge Controller，内存和I/O桥控制器）⏹NBC（North Bridge Chip，北桥芯片）⏹PIIX（PCI ISA/IDE Accelerator，加速器）⏹PSE36（Page Size Extension 36－bit，36位页面尺寸扩展模式）⏹PXB（PCI Expander Bridge，PCI增强桥）⏹RCG（RAS/CAS Generator，RAS/CAS发生器）⏹SBC（South Bridge Chip，南桥芯片）⏹SMB（System Management Bus，全系统管理总线）⏹SPD（Serial Presence Detect，内存内部序号检测装置）⏹SSB（Super South Bridge，超级南桥芯片）⏹TDP（Triton Data Path，数据路径）⏹TSC（Triton System Controller，系统控制器）⏹QPA（Quad Port Acceleration，四接口加速）⏹ASIC（Application Specific Integrated Circuit，特殊应用积体电路）⏹ASC（Auto-Sizing and Centering，自动调效屏幕尺寸和中心位置）⏹ASC（Anti Static Coatings，防静电涂层）⏹AGAS（Anti Glare Anti Static Coatings，防强光、防静电涂层）⏹BLA（Bearn Landing Area，电子束落区）⏹BMC（Black Matrix Screen，超黑矩阵屏幕）⏹CRC（Cyclical Redundancy Check，循环冗余检查）⏹CRT（Cathode Ray Tube，阴极射线管）⏹DDC（Display Data Channel，显示数据通道）⏹DEC（Direct Etching Coatings，表面蚀刻涂层）⏹DFL（Dynamic Focus Lens，动态聚焦）⏹DFS（Digital Flex Scan，数字伸缩扫描）⏹DIC（Digital Image Control，数字图像控制）⏹Digital Multiscan II（数字式智能多频追踪）⏹DLP（Digital Light Processing，数字光处理）⏹DOSD（Digital On Screen Display，同屏数字化显示）⏹DPMS（Display Power Management Signalling，显示能源管理信号）⏹Dot Pitch（点距）⏹DQL（Dynamic Quadrapole Lens，动态四极镜）⏹DSP（Digital Signal Processing，数字信号处理）⏹EFEAL（Extended Field Elliptical Aperture Lens，可扩展扫描椭圆孔镜头）⏹FRC（Frame Rate Control，帧比率控制）⏹HVD（High Voltage Differential，高分差动）⏹LCD（liquid crystal display，液晶显示屏）⏹LCOS（Liquid Crystal On Silicon，硅上液晶）⏹LED（light emitting diode，光学二级管）⏹L-SAGIC（Low Power-Small Aperture G1 wiht Impregnated Cathode，低电压光圈阴极管）⏹LVD（Low Voltage Differential，低分差动）⏹LVDS（Low V oltage Differential Signal，低电压差动信号）⏹MALS（Multi Astigmatism Lens System，多重散光聚焦系统）⏹MDA（Monochrome Adapter，单色设备）⏹MS（Magnetic Sensors，磁场感应器）⏹Porous Tungsten（活性钨）⏹RSDS（Reduced Swing Differential Signal，小幅度摆动差动信号）⏹SC（Screen Coatings，屏幕涂层）⏹Single Ended（单终结）⏹Shadow Mask（阴罩式）⏹TDT（Timeing Detection Table，数据测定表）⏹TICRG（Tungsten Impregnated Cathode Ray Gun，钨传输阴级射线枪）⏹TFT（Thin Film Transistor，薄膜晶体管）⏹UCC（Ultra Clear Coatings，超清晰涂层）⏹V AGP（Variable Aperature Grille Pitch，可变间距光栅）⏹VBI（Vertical Blanking Interval，垂直空白间隙）⏹VDT（Video Display Terminals，视频显示终端）⏹VRR（Vertical Refresh Rate，垂直扫描频率）计算机函数数据库#include <iostream.h>class Myclas{private:int m-number;publicvoid setNumber(int number){m-number = number;}int getNumber(){return m-number}};void showMe(){cout<<"我是一个类"<<endl;}};void main (){Myclass mc;//mc.m_number=10;mc.setNumber(10);cout<<mc.showMe()<<endl;}⏹AGP(Accelerated Graphics Port) －图形加速接口⏹Access Time－存取时间⏹Address-地址⏹ANSI (American National Standards Institute) 美国国家标准协会⏹ASCII （American Standard Code for Information Interchange）⏹Async SRAM-异步静态内存⏹BSB (Backside Bus)⏹Bandwidth－带宽⏹Bank －内存库⏹Bank Schema －存储体规划⏹Base Rambus －初级的Rambus内存⏹Baud －波特⏹BGA (Ball Grid Array)－球状引脚栅格阵列封装技术⏹Binary －二进制⏹BIOS (Basic Input-Output System) －基本输入/输出系统⏹Bit－位、比特⏹BLP－底部引出塑封技术⏹Buffer－缓冲区⏹Buffered Memory－带缓冲的内存⏹BEDO (Burst EDO RAM) －突发模式EDO随机存储器⏹Burst Mode－突发模式⏹Bus－总线⏹Bus Cycle－总线周期⏹Byte－字节⏹Cacheability－高速缓存能力⏹Cache Memory－高速缓存存储器⏹CAS (Column Address Strobe)－列地址选通脉冲⏹CL（CAS Latency ）－列地址选通脉冲时间延迟⏹CDRAM （Cache DRAM）－快取动态随机存储器⏹Checksum－检验和，校验和⏹Chipset－芯片组⏹Chip-Scale Package (CSP)－芯片级封装⏹Compact Flash－紧凑式闪存⏹Concurrent Rambus－并发式总线式内存⏹Continuity RIMM (C-RIMM)－连续性总线式内存模组⏹CMOS（Complementary Metal-Oxide-Semicomductor）－互补金属氧化物半导体用于晶体管⏹CPU (Central Processing Unit)－中央处理单元⏹Credit Card Memory －信用卡内存⏹DDR(Double Data Rate SDRAM)－双数据输出同步动态存储器。

外文文献翻译（译成中文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.DISCUSSIONC++: An Object-Oriented LanguageDeveloped 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:encapsulation, inheritance, and polymorphism.Encapsulation is the ability of an object to maintain its own methods (or functions) and properties (or variables).For example, an ‘‘engine’’ object might contain methods for starting, stopping, or accelerating, along with properties for ‘‘RPM’’ and ‘‘Oil pressure’’. Further, encapsulation allows an object to hide private data from a ny entity outside the object. The programmer can control access to the object’s data by marking methods or properties as public, protected,or private. This access control helps abstract away the inner workings of a class while making it obvious to a caller which methods and properties are intended to be used externally.Inheritance allows one object to be a superset of another object. For example, one can create an object called Automobile that inherits from Vehicle. The Automobile object has access to all non-private methods and properties of Vehicle plus any additional methods or properties that makes it uniquely an automobile.Polymorphism is an extremely powerful mechanism that allows various inherited objects to exhibit different behaviors when the same named method is invoked upon them. For example, let us say our Vehicle object contains a method called CountWheels. When we invoke this method on our Automobile, we learn that the Automobile has four wheels.However, when we call this method on an object called Bus,we find that the Bus has 10 wheels.Together, encapsulation, inheritance, and polymorphism help promote code reuse, which is essential to meeting our requirement that the software package be flexible. A vendor can build up a comprehensive library of objects (a serial communications class, a state machine class, a device driver class,etc.) that can be reused across many different code modules.A typical control software vendor might have 100 device drivers. It would be a nightmare if for each of these drivers there were no building blocks for graphical user interface (GUI) or communications to build on. By building and maintaining a library of foundation objects, the vendor will save countless hours of programming and debugging time.All three tenets of object-oriented programming are leveraged by the use of interfaces. An interface is essentially a specification that is used to facilitate communication between software components, possibly written by different vendors. An interface says, ‘‘if your cod e follows this set of rules then my software component will be able to communicate with it.’’ In the next section we will see how interfaces make writing device drivers a much simpler task.C++ and Device DriversIn a flexible automation platform, one optimal use for interfaces is in device drivers. We would like our open-architecture software to provide a generic way for end users to write their own device drivers without having to divulge the secrets of our source code to them. To do this, we define a simplifiedC++ interface for a generic device, as shown here:class IDevice{public:virtual string GetName() ? 0; //Returns the name//of the devicevirtual void Initialize() ? 0; //Called to//initialize the devicevirtual void Run() ? 0; // Called to run the device};In the example above, a Ctt class (or object) called IDevice has been defined. The prefix I in IDevice stands for ‘‘interface’’. This class defines three public virtual methods: GetName, Initialize, and Run. The virtual keyword is what enables polymorphism, allowing the executing program to run the methods of the inheriting class. When a virtual method declaration is suffixed with ?0, there is no base class implementation. Such a method is referred to as ‘‘pure virtual’’. A class like IDevice that contains only pure virtual functions is known as an ‘‘abstract class’’, or an‘‘interface’’. The IDevice definition, along with appropriate documentation, can be published to the user community,allowing developers to generate their own device drivers that implement the IDevice interface.Suppose a thermal plate sealer manufacturer wants to write a driver that can be controlled by our software package. They would use inheritance to implement our IDevice interface and then override the methods to produce the desired behavior: class CSealer : public IDevice{public:virtual string GetName() {return ‘‘Sealer’’;}virtual void Initialize() {InitializeSealer();}virtual void Run() {RunSealCycle();}private:void InitializeSealer();void RunSealCycle();};Here the user has created a new class called CSealer that inherits from the IDevice interface. The public methods,those that are accessible from outside of the class, are the interface methods defined in IDevice. One, GetName, simply returns the name of the device type that this driver controls.The other methods,Initialize() and Run(), call private methods that actually perform the work. Notice how the privatekeyword is used to prevent external objects from calling InitializeSealer() and RunSealCycle() directly.When the controlling software executes, polymorphism will be used at runtime to call the GetName, Initialize, and Run methods in the CSealer object, allowing the device defined therein to be controlled.DoSomeWork(){//Get a reference to the device driver we want to useIDevice&device ? GetDeviceDriver();//Tell the world what we’re about to do.cout !! ‘‘Initializing ’’!! device.GetName();//Initialize the devicedevice.Initialize();//Tell the world what we’re about to do.cout !! ‘‘Running a cycle on ’’ !!device.GetName();//Away we go!device.Run();}The code snippet above shows how the IDevice interface can be used to generically control a device. If GetDevice-Driver returns a reference to a CSealer object, then DoSomeWork will control sealers. If GetDeviceDriver returns a reference to a pipettor, then DoSomeWork will control pipettors. Although this is a simplified example, it is straightforward to imagine how the use of interfaces and polymorphism can lead to great economies of scale in controller software development.Additional interfaces can be generated along the same lines as IDevice. For example, an interface perhaps called ILMS could be used to facilitate communication to and from a LIMS.The astute reader will notice that the claim that anythird party can develop drivers simply by implementing the IDevice interface is slightly flawed. The problem is that any driver that the user writes, like CSealer, would have to be linked directly to the controlling software’s exec utable to be used. This problem is solved by a number of existing technologies, including Microsoft’s COMor .NET, or by CORBA. All of these technologies allow end users to implement abstract interfaces in standalone components that can be linked at runtime rather than at design time. The details are beyond the scope of this article.中文翻译：随着研究实验室更加自动化，实验室管理人员出现的新问题。

Talking about security loopholesRichard 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 sIn 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, IEloophole, and so on.● specialized software loophole. If Oracle loopholes, Apach e, etc. loopholes.2. Data from the perspective include :● could not reasonably be read and read data, including the memory of thedata, documents the data, Users input data, the data in the database, network,data transmission and so on.● designa ted can be written into the designated places (including the localpaper, memory, databases, etc.)● Input data can be implemented (including native implementation,according to Shell code execution, by SQL code execution, etc.)3. From the point of view of the scope of the role are :● Remote loopholes, an attacker could use the network and directly throughthe loopholes in the attack. Such loopholes great harm, an attacker can createa loophole through other people's computers operate. Such loopholes and caneasily lead to worm attacks on Windows.● Local loopholes, the attacker must have the machine premise accesspermissions can be launched to attack the loopholes. Typical of the local authority to upgrade loopholes, loopholes in the Unix system are widespread, allow ordinary users to access the highest administrator privileges.4. Trigger conditions from the point of view can be divided into:● Initiative trigger loopholes, an attacker can take the initiative to use the loopholes in the attack, If direct access to computers.● Passive trigger loopholes must be computer operators can be carried out attacks with the use of the loophole. For example, the attacker made to a mail administrator, with a special jpg image files, if the administrator to open image files will lead to a picture of the software loophole was triggered, thereby system attacks, but if managers do not look at the pictures will not be affected by attacks.5. On an operational perspective can be divided into:● File opera tion type, mainly for the operation of the target file path can be controlled (e.g., parameters, configuration files, environment variables, the symbolic link HEC), this may lead to the following two questions: ◇Content can be written into control, the contents of the documents can be forged. Upgrading or authority to directly alter the important data (such as revising the deposit and lending data), this has many loopholes. If history Oracle TNS LOG document can be designated loopholes, could lead to any person may control the operation of the Oracle computer services;◇information content can be output Print content has been contained to a screen to record readable log files can be generated by the core users reading papers, Such loopholes in the history of the Unix system crontab subsystem seen many times, ordinary users can read the shadow ofprotected documents;● Memory coverage, mainly for memory modules can be specified, writecontent may designate such persons will be able to attack to enforce the code (buffer overflow, format string loopholes, PTrace loopholes, Windows 2000 history of the hardware debugging registers users can write loopholes), or directly alter the memory of secrets data.● logic errors, such wide gaps exist, but very few changes, so it is difficult todiscern, can be broken down as follows : ◇loopholes competitive conditions (usually for the design, typical of Ptrace loopholes, The existence of widespread document timing of competition) ◇wrong tactic, usually in design. If the history of the FreeBSD Smart IO loopholes. ◇Algorithm (usually code or design to achieve), If the history of Microsoft Windows 95/98 sharing password can easily access loopholes. ◇Imperfections of the design, such as TCP / IP protocol of the three-step handshake SYN FLOOD led to a denial of service attack. ◇realize the mistakes (usually no problem for the design, but the presence of coding logic wrong, If history betting system pseudo-random algorithm)● External orders, Typical of external commands can be controlled (via the PATH variable, SHELL importation of special characters, etc.) and SQL injection issues.6. From time series can be divided into:● has long found loopholes: manufacturers already issued a patch or repairmethods many people know already. Such loopholes are usually a lot of people have had to repair macro perspective harm rather small.● recently discovered loophole: manufacturers just made patch or repairmethods, the people still do not know more. Compared to greater danger loopholes, if the worm appeared fool or the use of procedures, so will result in a large number of systems have been attacked.● 0day: not open the loophole in the private transactions. Usually such loopholes to the public will not have any impact, but it will allow an attacker to the targetby aiming precision attacks, harm is very great.Different perspective on the use of the loopholesIf a defect should not be used to stem the "original" can not do what the (safety-related), one would not be called security vulnerability, security loopholes and gaps inevitably closely linked to use.Perspective use of the loopholes is:● Data Perspective: visit had not visited the data, including reading and writing.This is usually an attacker's core purpose, but can cause very serious disaster (such as banking data can be written).● Competence Perspective: Major Powers to bypass or p ermissions. Permissionsare usually in order to obtain the desired data manipulation capabilities.● Usability perspective: access to certain services on the system of controlauthority, this may lead to some important services to stop attacks and lead to a denial of service attack.● Authentication bypass: usually use certification system and the loopholes willnot authorize to access. Authentication is usually bypassed for permissions or direct data access services.● Code execution perspective: mainly procedures for the importation of thecontents as to implement the code, obtain remote system access permissions or local system of higher authority. This angle is SQL injection, memory type games pointer loopholes (buffer overflow, format string, Plastic overflow etc.), the main driving. This angle is usually bypassing the authentication system, permissions, and data preparation for the reading.Loopholes explore methods mustFirst remove security vulnerabilities in software BUG in a subset, all software testing tools have security loopholes to explore practical. Now that the "hackers" used to explore the various loopholes that there are means available to the model are:● fuzz testing (black box testing), by constructing procedures may lead toproblems of structural input data for automatic testing.● FOSS audit (White Box), now have a series of tools that can assist in thedetection of the safety procedures BUG. The most simple is your hands the latest version of the C language compiler.● IDA anti-compilation of the audit (gray box testing), and above the sourceaudit are very similar. The only difference is that many times you can obtain software, but you can not get to the source code audit, But IDA is a very powerful anti-Series platform, let you based on the code (the source code is in fact equivalent) conducted a safety audit.● dynamic tracking, is the record of proceedings under different conditions andthe implementation of all security issues related to the operation (such as file operations), then sequence analysis of these operations if there are problems, it is competitive category loopholes found one of the major ways. Other tracking tainted spread also belongs to this category.● patch, the software manufacturers out of the question usually addressed in thepatch. By comparing the patch before and after the source document (or the anti-coding) to be aware of the specific details of loopholes.More tools with which both relate to a crucial point: Artificial need to find a comprehensive analysis of the flow path coverage. Analysis methods varied analysis and design documents, source code analysis, analysis of the anti-code compilation, dynamic debugging procedures.Grading loopholesloopholes in the inspection harm should close the loopholes and the use of the hazards related Often people are not aware of all the Buffer Overflow Vulnerability loopholes are high-risk. A long-distance loophole example and better delineation:●R emote access can be an OS, application procedures, version information.●open unnecessary or dangerous in the service, remote access to sensitiveinformation systems.● Remote can be restricted for the documents, data reading.●remotely important or res tricted documents, data reading.● may be limited for long-range document, data revisions.● Remote can be restricted for important documents, data changes.● Remote can be conducted without limitation in the important documents, datachanges, or for general service denial of service attacks.● Remotely as a normal user or executing orders for system and network-leveldenial of service attacks.● may be remote management of user identities to the enforcement of the order(limited, it is not easy to use).● can be remote management of user identities to the enforcement of the order(not restricted, accessible).Almost all local loopholes lead to code execution, classified above the 10 points system for:●initiative remote trigger code execution (such a s IE loophole).● passive trigger remote code execution (such as Word gaps / charting softwareloopholes).DEMOa firewall segregation (peacekeeping operation only allows the Department of visits) networks were operating a Unix server; operating systems only root users and users may oracle landing operating system running Apache (nobody authority), Oracle (oracle user rights) services.An attacker's purpose is to amend the Oracle database table billing data. Its possible attacks steps:● 1. Access pea cekeeping operation of the network. Access to a peacekeepingoperation of the IP address in order to visit through the firewall to protect the UNIX server.● 2. Apache services using a Remote Buffer Overflow Vulnerability direct accessto a nobody's competence hell visit.● 3. Using a certain operating system suid procedure of the loophole to upgradetheir competence to root privileges.● 4. Oracle sysdba landing into the database (local landing without a password).● 5. Revised target table data.Over five down for process analysis:●Step 1: Authentication bypass●Step 2: Remote loopholes code execution (native), Authentication bypassing ● Step 3: permissions, authentication bypass● Step 4: Authentication bypass● Step 5: write data安全漏洞杂谈Richard S. Kraus 网络安全的核心目标是保障业务系统的可持续性和数据的安全性，而这两点的主要威胁来自于蠕虫的暴发、黑客的攻击、拒绝服务攻击、木马。

毕业设计（论文）外文资料原文及译文原文出处：《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.。

计算机专业外文文献及翻译微软Visual Studio1微软Visual Studio是微软公司推出的软软软境～可以用软建来平台下的 Visual Studio Visual StudioWindows软用程序和软软用程序～也可以用软建软服软、智能软软软用程序和网来网插件。

WindowsOffice Visual是一自微软的个来集成软软软境;,～可以用软软由它来微StudioIDEinteqrated development environment软软窗～软手机窗～、框架、精软架框和微软的支持的控制台和软Windows Silverlight 形用软界面的软用程序以及窗体软用程序～站网～软用程序和软服软网中的本地代软软同托管WindowsWeb代软。

包含一由个智能感知和代软重构支持的代软软软器。

集成的软软工作作软一源代软软软既个Visual Studio软器又可以作软一台机器软软软器。

其他置工具包括一软软内个窗体的软用程序～软软软软～软软软软～网数据软架GUI构软软软。

有乎各软面的件增强功能～包括增加软支持它几个插源代软控制系软;如和SubversionVisual,添加新的工具集软软和可软化软软器～如并特定于域的软言或用于其他方面的软件软软生命周期SourceSafe的工具;例如的客软端,软软软源管理器,。

Team Foundation Server支持不同的软程软言的服软方式的软言～允软代软软软器和软软器;在不同程度上,支持它Visual Studio几乎所有的软程软言～提供了一软言特定服软的存在。

置的软言中包括个内中;通软C/C + +Visual C+,;通软,～,中;通软,,和,;作软+,VisualCVisual CFVisual Studio,～软支持其他软言～如和等～可通软安软的软言服软。

软也支持装独它的2010M,Python,Ruby和软特定用软提供服软的也是存在的,微XML/XSLT,HTML/XHTML ,JavaScriptCSS.Visual Studio软～,、,和。

附录（英文翻译）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 递归问题本章将通过对三个样本问题的分析来探讨递归的思想。

附件1：外文资料翻译译文大容量存储器由于计算机主存储器的易失性和容量的限制, 大多数的计算机都有附加的称为大容量存储系统的存储设备, 包括有磁盘、CD 和磁带。

相对于主存储器，大的容量储存系统的优点是易失性小，容量大，低成本, 并且在许多情况下, 为了归档的需要可以把储存介质从计算机上移开。

术语联机和脱机通常分别用于描述连接于和没有连接于计算机的设备。

联机意味着，设备或信息已经与计算机连接，计算机不需要人的干预，脱机意味着设备或信息与机器相连前需要人的干预，或许需要将这个设备接通电源，或许包含有该信息的介质需要插到某机械装置里。

大量储存器系统的主要缺点是他们典型地需要机械的运动因此需要较多的时间，因为主存储器的所有工作都由电子器件实现。

1. 磁盘今天，我们使用得最多的一种大量存储器是磁盘，在那里有薄的可以旋转的盘片，盘片上有磁介质以储存数据。

盘片的上面和（或）下面安装有读/写磁头，当盘片旋转时，每个磁头都遍历一圈，它被叫作磁道，围绕着磁盘的上下两个表面。

通过重新定位的读/写磁头，不同的同心圆磁道可以被访问。

通常，一个磁盘存储系统由若干个安装在同一根轴上的盘片组成，盘片之间有足够的距离，使得磁头可以在盘片之间滑动。

在一个磁盘中，所有的磁头是一起移动的。

因此，当磁头移动到新的位置时，新的一组磁道可以存取了。

每一组磁道称为一个柱面。

因为一个磁道能包含的信息可能比我们一次操作所需要得多，所以每个磁道划分成若干个弧区，称为扇区，记录在每个扇区上的信息是连续的二进制位串。

传统的磁盘上每个磁道分为同样数目的扇区，而每个扇区也包含同样数目的二进制位。

（所以，盘片中心的储存的二进制位的密度要比靠近盘片边缘的大）。

因此，一个磁盘存储器系统有许多个别的磁区, 每个扇区都可以作为独立的二进制位串存取，盘片表面上的磁道数目和每个磁道上的扇区数目对于不同的磁盘系统可能都不相同。

磁区大小一般是不超过几个KB; 512 个字节或1024 个字节。

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。

毕业设计(论文)外文资料翻译系别计算机信息与技术系专业计算机科学与技术班级姓名学号外文出处附件 1. 原文； 2. 译文2012年3月History of computingMain article: History of computing hardwareThe first use of the word "computer" was recorded in 1613, referring to a person who carried out calculations, or computations, and the word continued with the same meaning until the middle of the 20th century. From the end of the 19th century the word began to take on its more familiar meaning, a machine that carries out computations.Limited-function early computersThe Jacquard loom, on display at the Museum of Science and Industry in Manchester, England, was one of the first programmable devices.The history of the modern computer begins with two separate technologies, automated calculation and programmability, but no single device can be identified as the earliest computer, partly because of the inconsistent application of that term. A few devices are worth mentioning though, like some mechanical aids to computing, which were very successful and survived for centuries until the advent of the electronic calculator, like the Sumerian abacus, designed around 2500 BC of which a descendant won a speed competition against a modern desk calculating machine in Japan in 1946, the slide rules, invented in the 1620s, which were carried on five Apollo space missions, including to the moon and arguably the astrolabe and the Antikythera mechanism, an ancient astronomical computer built by the Greeks around 80 BC. The Greek mathematician Hero of Alexandria (c. 10–70 AD) built a mechanical theater which performed a play lasting 10 minutes and was operated by a complex system of ropes and drums that might be considered to be a means of deciding which parts of the mechanism performed which actions and when. This is the essence of programmability.Around the end of the 10th century, the French monk Gerbert d'Aurillac brought back from Spain the drawings of a machine invented by the Moors that answered either Yes or No to the questions it was asked. Again in the 13th century, the monks Albertus Magnus and Roger Bacon built talking androids without any further development.In 1642, the Renaissance saw the invention of the mechanical calculator, a device that could perform all four arithmetic operations without relying on human intelligence. The mechanical calculator was at the root of the development ofcomputers in two separate ways. Initially, it was in trying to develop more powerful and more flexible calculators that the computer was first theorized by Charles Babbage and then developed. Secondly, development of a low-cost electronic calculator, successor to the mechanical calculator, resulted in the development by Intel of the first commercially available microprocessor integrated circuit.First general-purpose computersIn 1801, Joseph Marie Jacquard made an improvement to the textile loom by introducing a series of punched paper cards as a template which allowed his loom to weave intricate patterns automatically. The resulting Jacquard loom was an important step in the development of computers because the use of punched cards to define woven patterns can be viewed as an early, albeit limited, form of programmability.In 1837, Charles Babbage was the first to conceptualize and design a fully programmable mechanical computer, his analytical engine. Limited finances and Babbage's inability to resist tinkering with the design meant that the device was never completed ; nevertheless his son, Henry Babbage, completed a simplified version of the analytical engine's computing unit (the mill) in 1888. He gave a successful demonstration of its use in computing tables in 1906. This machine was given to the Science museum in South Kensington in 1910.In the late 1880s, Herman Hollerith invented the recording of data on a machine-readable medium. Earlier uses of machine-readable media had been for control, not data. "After some initial trials with paper tape, he settled on punched cards ..." To process these punched cards he invented the tabulator, and the keypunch machines. These three inventions were the foundation of the modern information processing industry. Large-scale automated data processing of punched cards was performed for the 1890 United States Census by Hollerith's company, which later became the core of IBM. By the end of the 19th century a number of ideas and technologies, that would later prove useful in the realization of practical computers, had begun to appear: Boolean algebra, the vacuum tube (thermionic valve), punched cards and tape, and the teleprinter.During the first half of the 20th century, many scientific computing needs were met by increasingly sophisticated analog computers, which used a direct mechanical or electrical model of the problem as a basis for computation. However, these were not programmable and generally lacked the versatility and accuracy of modern digitalcomputers.Alan Turing is widely regarded as the father of modern computer science. In 1936 Turing provided an influential formalisation of the concept of the algorithm and computation with the Turing machine, providing a blueprint for the electronic digital computer. Of his role in the creation of the modern computer, Time magazine in naming Turing one of the 100 most influential people of the 20th century, states: "The fact remains that everyone who taps at a keyboard, opening a spreadsheet or a word-processing program, is working on an incarnation of a Turing machine".EDSAC was one of the first computers to implement the stored-program (von Neumann) architecture.Die of an Intel 80486DX2 microprocessor (actual size: 12×6.75 mm) in its packaging.The Atanasoff–Berry Computer (ABC) was the world's first electronic digital computer, albeit not programmable. Atanasoff is considered to be one of the fathers of the computer.Conceived in 1937 by Iowa State College physics professor John Atanasoff, and built with the assistance of graduate student Clifford Berry, the machine was not programmable, being designed only to solve systems of linear equations. The computer did employ parallel computation. A 1973 court ruling in a patent dispute found that the patent for the 1946 ENIAC computer derived from the Atanasoff–Berry Computer.The first program-controlled computer was invented by Konrad Zuse, who built the Z3, an electromechanical computing machine, in 1941. The first programmable electronic computer was the Colossus, built in 1943 by Tommy Flowers.George Stibitz is internationally recognized as a father of the modern digital computer. While working at Bell Labs in November 1937, Stibitz invented and built a relay-based calculator he dubbed the "Model K" (for "kitchen table", on which he had assembled it), which was the first to use binary circuits to perform an arithmetic operation. Later models added greater sophistication including complex arithmetic and programmability.A succession of steadily more powerful and flexible computing devices were constructed in the 1930s and 1940s, gradually adding the key features that are seen in modern computers. The use of digital electronics (largely invented by Claude Shannon in 1937) and more flexible programmability were vitally important steps, but defining one point along this road as "the first digital electronic computer" is difficult.Notable achievements include. Konrad Zuse's electromechanical "Z machines". The Z3 (1941) was the first working machine featuring binary arithmetic, including floating point arithmetic and a measure of programmability. In 1998 the Z3 was proved to be Turing complete, therefore being the world's first operational computer.The non-programmable Atanasoff–Berry Computer (commenced in 1937, completed in 1941) which used vacuum tube based computation, binary numbers, and regenerative capacitor memory. The use of regenerative memory allowed it to be much more compact than its peers (being approximately the size of a large desk or workbench), since intermediate results could be stored and then fed back into the same set of computation elements.The secret British Colossus computers (1943), which had limited programmability but demonstrated that a device using thousands of tubes could be reasonably reliable and electronically reprogrammable. It was used for breaking German wartime codes.The Harvard Mark I (1944), a large-scale electromechanical computer with limited programmability.The U.S. Army's Ballistic Research Laboratory ENIAC (1946), which used decimal arithmetic and is sometimes called the first general purpose electronic computer (since Konrad Zuse's Z3 of 1941 used electromagnets instead of electronics). Initially, however, ENIAC had an inflexible architecture which essentially required rewiring to change its programming.Stored-program architectureReplica of the Small-Scale Experimental Machine (SSEM), the world's first stored-program computer, at the Museum of Science and Industry in Manchester, EnglandSeveral developers of ENIAC, recognizing its flaws, came up with a far more flexible and elegant design, which came to be known as the "stored-program architecture" or von Neumann architecture. This design was first formally described by John von Neumann in the paper First Draft of a Report on the EDV AC, distributed in 1945. A number of projects to develop computers based on the stored-program architecture commenced around this time, the first of which was completed in 1948 at the University of Manchester in England, the Manchester Small-Scale Experimental Machine (SSEM or "Baby"). The Electronic Delay Storage Automatic Calculator(EDSAC), completed a year after the SSEM at Cambridge University, was the first practical, non-experimental implementation of the stored-program design and was put to use immediately for research work at the university. Shortly thereafter, the machine originally described by von Neumann's paper—EDV AC—was completed but did not see full-time use for an additional two years.Nearly all modern computers implement some form of the stored-program architecture, making it the single trait by which the word "computer" is now defined. While the technologies used in computers have changed dramatically since the first electronic, general-purpose computers of the 1940s, most still use the von Neumann architecture.Beginning in the 1950s, Soviet scientists Sergei Sobolev and Nikolay Brusentsov conducted research on ternary computers, devices that operated on a base three numbering system of ?1, 0, and 1 rather than the conventional binary numbering system upon which most computers are based. They designed the Setun, a functional ternary computer, at Moscow State University. The device was put into limited production in the Soviet Union, but supplanted by the more common binary architecture.Semiconductors and microprocessorsComputers using vacuum tubes as their electronic elements were in use throughout the 1950s, but by the 1960s had been largely replaced by semiconductor transistor-based machines, which were smaller, faster, cheaper to produce, required less power, and were more reliable. The first transistorised computer was demonstrated at the University of Manchester in 1953. In the 1970s, integrated circuit technology and the subsequent creation of microprocessors, such as the Intel 4004, further decreased size and cost and further increased speed and reliability of computers. By the late 1970s, many products such as video recorders contained dedicated computers called microcontrollers, and they started to appear as a replacement to mechanical controls in domestic appliances such as washing machines. The 1980s witnessed home computers and the now ubiquitous personal computer. With the evolution of the Internet, personal computers are becoming as common as the television and the telephone in the household.Modern smartphones are fully programmable computers in their own right, and as of 2009 may well be the most common form of such computers in existenc.历史的计算主要文章:计算机硬件的历史在第一次使用“计算机”这个词被记录在1613年,指的是对一个人进行了计算,或计算,与词的意思相同,直到继续20世纪中期。

计算机外⽂翻译（完整）毕业设计(论⽂)外⽂资料翻译专业：计算机科学与技术姓名：王成明学号：06120186外⽂出处：The History of the Internet附件： 1.外⽂原⽂ 2.外⽂资料翻译译⽂；附件1：外⽂原⽂The History of the InternetThe Beginning - ARPAnetThe Internet started as a project by the US government. The object of the project was to create a means of communications between long distance points, in the event of a nation wide emergency or, more specifically, nuclear war. The project was called ARPAnet, and it is what the Internet started as. Funded specifically for military communication, the engineers responsible for ARPANet had no idea of the possibilities of an "Internet."By definition, an 'Internet' is four or more computers connected by a network.ARPAnet achieved its network by using a protocol called TCP/IP. The basics around this protocol was that if information sent over a network failed to get through on one route, it would find another route to work with, as well as establishing a means for one computer to "talk" to another computer, regardless of whether it was a PC or a Macintosh.By the 80's ARPAnet, just years away from becoming the more well known Internet, had 200 computers. The Defense Department, satisfied with ARPAnets results, decided to fully adopt it into service, and connected many military computers and resources into the network. ARPAnet then had 562 computers on its network. By the year 1984, it had over 1000 computers on its network.In 1986 ARPAnet (supposedly) shut down, but only the organization shut down, and the existing networks still existed between the more than 1000 computers. It shut down due to a failied link up with NSF, who wanted to connect its 5 countywide super computers into ARPAnet.With the funding of NSF, new high speed lines were successfully installed at line speeds of 56k (a normal modem nowadays) through telephone lines in 1988. By that time, there were 28,174 computers on the (by then decided) Internet. In 1989 there were 80,000 computers on it. By 1989, there were290,000.Another network was built to support the incredible number of people joining. It was constructed in 1992.Today - The InternetToday, the Internet has become one of the most important technological advancements in the history of humanity. Everyone wants to get 'on line' to experience the wealth of information of the Internet. Millions of people now use the Internet, and it's predicted that by the year 2003 every single person on the planet will have Internet access. The Internet has truly become a way of life in our time and era, and is evolving so quickly its hard to determine where it will go next, as computer and network technology improve every day.HOW IT WORKS:It's a standard thing. People using the Internet. Shopping, playing games,conversing in virtual Internet environments.The Internet is not a 'thing' itself. The Internet cannot just "crash." It functions the same way as the telephone system, only there is no Internet company that runs the Internet.The Internet is a collection of millioins of computers that are all connected to each other, or have the means to connect to each other. The Internet is just like an office network, only it has millions of computers connected to it.The main thing about how the Internet works is communication. How does a computer in Houston know how to access data on a computer in Tokyo to view a webpage?Internet communication, communication among computers connected to the Internet, is based on a language. This language is called TCP/IP. TCP/IP establishes a language for a computer to access and transmit data over the Internet system.But TCP/IP assumes that there is a physical connecetion between onecomputer and another. This is not usually the case. There would have to be a network wire that went to every computer connected to the Internet, but that would make the Internet impossible to access.The physical connection that is requireed is established by way of modems,phonelines, and other modem cable connections (like cable modems or DSL). Modems on computers read and transmit data over established lines,which could be phonelines or data lines. The actual hard core connections are established among computers called routers.A router is a computer that serves as a traffic controller for information.To explain this better, let's look at how a standard computer might viewa webpage.1. The user's computer dials into an Internet Service Provider (ISP). The ISP might in turn be connected to another ISP, or a straight connection into the Internet backbone.2. The user launches a web browser like Netscape or Internet Explorer and types in an internet location to go to.3. Here's where the tricky part comes in. First, the computer sends data about it's data request to a router. A router is a very high speed powerful computer running special software. The collection of routers in the world make what is called a "backbone," on which all the data on the Internet is transferred. The backbone presently operates at a speed of several gigabytes per-second. Such a speed compared to a normal modem is like comparing the heat of the sun to the heat of an ice-cube.Routers handle data that is going back and forth. A router puts small chunks of data into packages called packets, which function similarly to envelopes. So, when the request for the webpage goes through, it uses TCP/IP protocols to tell the router what to do with the data, where it's going, and overall where the user wants to go.4. The router sends these packets to other routers, eventually leadingto the target computer. It's like whisper down the lane (only the information remains intact).5. When the information reaches the target web server, the webserver then begins to send the web page back. A webserver is the computer where the webpage is stored that is running a program that handles requests for the webpage and sends the webpage to whoever wants to see it.6. The webpage is put in packets, sent through routers, and arrive at the users computer where the user can view the webpage once it is assembled.The packets which contain the data also contain special information that lets routers and other computers know how to reassemble the data in the right order.With millions of web pages, and millions of users, using the Internet is not always easy for a beginning user, especially for someone who is not entirely comfortale with using computers. Below you can find tips tricks and help on how to use main services of the Internet.Before you access webpages, you must have a web browser to actually be able to view the webpages. Most Internet Access Providers provide you with a web browser in the software they usually give to customers; you. The fact that you are viewing this page means that you have a web browser. The top two use browsers are Netscape Communicator and Microsoft Internet Explorer. Netscape can be found at /doc/bedc387343323968011c9268.html and MSIE can be found at /doc/bedc387343323968011c9268.html /ie.The fact that you're reading this right now means that you have a web browser.Next you must be familiar with actually using webpages. A webpage is a collection of hyperlinks, images, text, forms, menus, and multimedia. To "navigate" a webpage, simply click the links it provides or follow it's own instructions (like if it has a form you need to use, it will probably instruct you how to use it). Basically, everything about a webpage is made to be self-explanetory. That is the nature of a webpage, to be easily navigatable."Oh no! a 404 error! 'Cannot find web page?'" is a common remark made by new web-users.Sometimes websites have errors. But an error on a website is not the user's fault, of course.A 404 error means that the page you tried to go to does not exist. This could be because the site is still being constructed and the page hasn't been created yet, or because the site author made a typo in the page. There's nothing much to do about a 404 error except for e-mailing the site administrator (of the page you wanted to go to) an telling him/her about the error.A Javascript error is the result of a programming error in the Javascript code of a website. Not all websites utilize Javascript, but many do. Javascript is different from Java, and most browsers now support Javascript. If you are using an old version of a web browser (Netscape 3.0 for example), you might get Javascript errors because sites utilize Javascript versions that your browser does not support. So, you can try getting a newer version of your web browser.E-mail stands for Electronic Mail, and that's what it is. E-mail enables people to send letters, and even files and pictures to each other.To use e-mail, you must have an e-mail client, which is just like a personal post office, since it retrieves and stores e-mail. Secondly, you must have an e-mail account. Most Internet Service Providers provide free e-mail account(s) for free. Some services offer free e-mail, like Hotmail, and Geocities.After configuring your e-mail client with your POP3 and SMTP server address (your e-mail provider will give you that information), you are ready to receive mail.An attachment is a file sent in a letter. If someone sends you an attachment and you don't know who it is, don't run the file, ever. It could be a virus or some other kind of nasty programs. You can't get a virus justby reading e-mail, you'll have to physically execute some form of program for a virus to strike.A signature is a feature of many e-mail programs. A signature is added to the end of every e-mail you send out. You can put a text graphic, your business information, anything you want.Imagine that a computer on the Internet is an island in the sea. The sea is filled with millions of islands. This is the Internet. Imagine an island communicates with other island by sending ships to other islands and receiving ships. The island has ports to accept and send out ships.A computer on the Internet has access nodes called ports. A port is just a symbolic object that allows the computer to operate on a network (or the Internet). This method is similar to the island/ocean symbolism above.Telnet refers to accessing ports on a server directly with a text connection. Almost every kind of Internet function, like accessing web pages,"chatting," and e-mailing is done over a Telnet connection.Telnetting requires a Telnet client. A telnet program comes with the Windows system, so Windows users can access telnet by typing in "telnet" (without the "'s) in the run dialog. Linux has it built into the command line; telnet. A popular telnet program for Macintosh is NCSA telnet.Any server software (web page daemon, chat daemon) can be accessed via telnet, although they are not usually meant to be accessed in such a manner. For instance, it is possible to connect directly to a mail server and check your mail by interfacing with the e-mail server software, but it's easier to use an e-mail client (of course).There are millions of WebPages that come from all over the world, yet how will you know what the address of a page you want is?Search engines save the day. A search engine is a very large website that allows you to search it's own database of websites. For instance, if you wanted to find a website on dogs, you'd search for "dog" or "dogs" or "dog information." Here are a few search-engines.1. Altavista (/doc/bedc387343323968011c9268.html ) - Web spider & Indexed2. Yahoo (/doc/bedc387343323968011c9268.html ) - Web spider & Indexed Collection3. Excite (/doc/bedc387343323968011c9268.html ) - Web spider & Indexed4. Lycos (/doc/bedc387343323968011c9268.html ) - Web spider & Indexed5. Metasearch (/doc/bedc387343323968011c9268.html ) - Multiple searchA web spider is a program used by search engines that goes from page to page, following any link it can possibly find. This means that a search engine can literally map out as much of the Internet as it's own time and speed allows for.An indexed collection uses hand-added links. For instance, on Yahoo's site. You can click on Computers & the Internet. Then you can click on Hardware. Then you can click on Modems, etc., and along the way through sections, there are sites available which relate to what section you're in.Metasearch searches many search engines at the same time, finding the top choices from about 10 search engines, making searching a lot more effective.Once you are able to use search engines, you can effectively find the pages you want.With the arrival of networking and multi user systems, security has always been on the mind of system developers and system operators. Since the dawn of AT&T and its phone network, hackers have been known by many, hackers who find ways all the time of breaking into systems. It used to not be that big of a problem, since networking was limited to big corporate companies or government computers who could afford the necessary computer security.The biggest problem now-a-days is personal information. Why should you be careful while making purchases via a website? Let's look at how the internet works, quickly.The user is transferring credit card information to a webpage. Looks safe, right? Not necessarily. As the user submits the information, it is being streamed through a series of computers that make up the Internet backbone.The information is in little chunks, in packages called packets. Here's the problem: While the information is being transferred through this big backbone, what is preventing a "hacker" from intercepting this data stream at one of the backbone points?Big-brother is not watching you if you access a web site, but users should be aware of potential threats while transmitting private information. There are methods of enforcing security, like password protection, an most importantly, encryption.Encryption means scrambling data into a code that can only be unscrambled on the "other end." Browser's like Netscape Communicator and Internet Explorer feature encryption support for making on-line transfers. Some encryptions work better than others. The most advanced encryption system is called DES (Data Encryption Standard), and it was adopted by the US Defense Department because it was deemed so difficult to 'crack' that they considered it a security risk if it would fall into another countries hands.A DES uses a single key of information to unlock an entire document. The problem is, there are 75 trillion possible keys to use, so it is a highly difficult system to break. One document was cracked and decoded, but it was a combined effort of14,000 computers networked over the Internet that took a while to do it, so most hackers don't have that many resources available.附件2：外⽂资料翻译译⽂Internet的历史起源——ARPAnetInternet是被美国政府作为⼀项⼯程进⾏开发的。

题目Programming Overlay Networkswith Overlay SocketsProgramming Overlay Networks with Overlay Sockets The emergence of application-layer overlay networks has inspired the development of new network services and applications. Research on overlay net-workshas focused on the design of protocols to maintain and forward data in an overlay network, however, less attention has been given to the software development process of building application programs in such an environment. Clearly,the complexity of overlay network protocols calls for suitable application programming interfaces (APIs) and abstractions that do not require detailed knowledge of the overlay protocol, and, thereby, simplify the task of the application programmer. In this paper, we present the concept of an overlay socket as a new programming abstraction that serves as the end point of communication in an overlay network. The overlay socket provides a socket-based API that is independent of the chosen overlay topology, and can be configured to work for different overlay topologies. The overlay socket can support application data transfer over TCP, UDP, or other transport protocols. This paper describes the design of the overlay socket and discusses API and configuration options.1 IntroductionApplication-layer overlay networks [5, 9, 13, 17] provide flexible platforms for develop-ing new network services [1, 10, 11, 14, 18–20] without requiring changes to the network-layer infrastructure. Members of an overlay network, which can be hosts, routers, servers, or applications, organize themselves to form a logical network topology, and commu-nicate only with their respective neighbors in the overlay topology. A member ofan overlay network sends and receives application data, and also forwards data intended for other members. This paper addresses application development in overlay networks. We use the term overlay network programming to refer to the software development process of building application programs that communicate with one another in an application-layer overlay_This work is supported in part by the National Science Foundation through grant work. The diversity and complexity of building and maintaining overlay networks make it impractical to assume that application developers can be concerned with the complexity of managing the participation of an application in a specific overlay networktopology.We present a software module, called overlay socket, that intends to simplify the task of overlay network programming. The design of the overlay socket pursues the following set of objectives: First, the application programming interface (API) of the overlay socket does not require that an application programmer has knowledge of the overlay network topology. Second, the overlay socket is designed to accommodate dif-ferent overlay network topologies. Switching to different overlay network topologies is done by modifying parameters in a configuration file. Third, the overlay socket, which operates at the applicationlayer,can accommodate different types of transport layer protocols. This is accomplished by using network adapters that interface to the un-derlying transport layer network and perform encapsulation and de-encapsulation of messages exchanged by the overlay socket. Currently available network adapters are TCP, UDP, and UDP multicast. Fourth, the overlay socket provides mechanisms for bootstrapping new overlay networks. In this paper, we provide an overview of the overlay socket design and discuss over-lay network programming with the overlay socket. The overlay socket has been imple-mented in Java as part of the HyperCast 2.0 software distribution [12]. The software has been used for various overlay applications, and has been tested in both local-area as well as wide-area settings. The HyperCast 2.0 software implements the overlay topolo-gies described in [15] and [16]. This paper highlights important issues of the overlay socket, additional information can be found in the design documentation available from[12]. Several studies before us have addressed overlay network programming issues. Evenearly overlay network proposals, such as Yoid [9], Scribe [4], and Scattercast [6], have presented APIs that aspire to achieve independence of the API from the overlay network topology used. Particularly, Yoid and Scattercast use a socket-like API, how-ever, these APIs do not address issues that arise when the same API is used by different overlay network topologies. Several works on application-layer multicast overlays inte-grate the application program with the software responsible for maintaining the overlay network, without explicitly providing general-purpose APIs.These include Narada [5], Overcast [13], ALMI [17], and NICE [2]. A recent study [8] has proposed a common API for the class of so-called structured overlays, which includes Chord [19], CAN [18], and Bayeux [20], and other overlays that were originally motivated by distributed hash tables. Our work has a different emphasis than [8], since we assume a scenario where an application programmer must work with several, possibly fundamentally dif-ferent, overlay network topologies and different transmission modes (UDP, TCP), and, therefore, needs mechanisms that make it easy to change the configuration of the un-derlying overlay network..Internet Overlay socket Application Overlay socket Application Application Overlay socket Application Application Overlay socket Application Overlay Network. Fig. 1. The overlay network is a collection of overlay sockets. Root (sender) Root (receiver) (a) Multicast (b) Unicast.Fig. 2. Data forwarding in overlay networks.The rest of the paper is organized as following. In Section 2 we introduce con-cepts, abstractions, and terminology needed for the discussion of the overlay socket. In Section 3 we present the design of the overlay socket, and discuss its components. In Section 4 we show how to write programs using the overlay socket. We present brief conclusions in Section 5.2 Basic ConceptsAn overlay socket is an endpoint for communication in an overlay network, and an overlay network is seen as a collection of overlay sockets that self-organize using an overlay protocol (see Figure 1). An overlay socket offers to an application programmer a Berkeley socket-style API [3] for sending and receiving data over an overlay network.Each overlay socket executes an overlay protocol that is responsible for maintaining the membership of the socket in the overlay network topology. Each overlay socket has a logical address and a physical address in the overlay network. The logical address is dependent on the type of overlay protocol used. In the overlay protocols currently implemented in HyperCast 2.0, the logical addresses are 32- bit integers or_x_y_coordinates, where x and y are positive 32-bit positive integers. The physical address is a transport layer address where overlay sockets receive messages from the overlay network. On the Internet, the physical address is an IP address and a TCP or UDP port number. Application programs that use overlay sockets only work with logical addresses, and do not see physical addresses of overlay nodes. When an overlay socket is created, the socket is configured with a set of configu-ration parameters, called attributes. The application program can obtain the attributes from a configuration file or it downloads the attributes from a server. The configuration file specifies the type of overlay protocol and the type of transport protocol to be used,.but also more detailed information such as the size of internal buffers, and the value of protocol-specific timers. The most important attribute is the overlay identifier (overlay ID) which is used as a global identifier for an overlay network and which can be used as a key to access the other attributes of the overlay network. Each new overlay ID corresponds to the creation of a new overlay network. Overlay sockets exchange two types of messages, protocol messages and application messages. Protocol messages are the messages of the overlay protocol that main-tain the overlay topology. Application messages contain applicationdata that is encap-sulatedn an overlay message header. An application message uses logical addresses in the header to identify source and, for unicast, the destination of the message. If an overlay socket receives an application message from one of its neighbors in the over-laynetwork, it determines if the message must be forwarded to other overlay sockets, and if the message needs to be passed to the local application. The transmission modes currently supported by the overlay sockets are unicast, and multicast. In multicast, all members in the overlay network are receivers.In both unicast and multicast,the com-mon abstraction for data forwarding is that of passing data in spanning trees that are embedded in the overlay topology. For example, a multicast message is transmitted downstream a spanning tree that has the sender of the multicast message as the root (see Figure 2(a)). When an overlay socket receives a multicast message, it forwards the message to all of its downstream neighbors (children) in the tree, and passes the mes-sage to the local application program. A unicast message is transmitted upstream a tree with the receiver of the message as the root (see Figure 2(b)). An overlay socket that receives a unicast message forwards the message to the upstream neighbor (parent) in the tree that has the destination as the root. An overlay socket makes forwarding decisions locally using only the logical ad-dresses of its neighbors and the logical address of the root of the tree. Hence, there is a requirement that each overlay socket can locally compute its parent and its children in a tree with respect to a root node. This requirement is satisfied by many overlay network topologies, including [15, 16, 18–20].3 The Components of an Overlay SocketAn overlay socket consists of a collection of components that are configured when the overlay socketis created, using the supplied set of attributes. These components include the overlay protocol, which helps to build and maintain the overlay network topology, a component that processes application data, and interfaces to a transport-layer network. The main components of an overlay socket, as illustrated in Figure 3, are as follows:The overlay node implements an overlay protocol that establishes and maintains the overlay network topology. The overlay node sends and receives overlay protocol messages, and maintains a set of timers. The overlay node is the only component of an overlay socket that is aware of the overlay topology. In the HyperCast 2.0. Overlay socket Forwarding EngineApplication Programming InterfaceStatistics InterfaceProtocol MessagesApplicationReceiveBufferApplicationTransmitBuffer Overlay NodeO verlay NodeInterfac eNode AdapterAdapter InterfaceSocket AdapterA dapter InterfaceApplication MessagesApplication ProgramTransport-layer NetworkApplication MessagesFig. 3. Components of an overlay socket.software, there are overlay nodes that build a logical hypercube [15] and a logical Delaunay triangu-lartion [16].The forwarding engine performs the functions of an application-layer router, that sends, receives, and forwards formatted application-layer messages in the overlay network. The forwarding engine communicates with the overlay node to query next hop routing information for application messages. The forwarding decision is made using logical addresses of the overlay nodes. Each overlay socket has two network adapters that each provides an interface to transport-layer protocols, such as TCP or UDP. The nodeadapter serves as the in-terface for sending and receiving overlay protocol messages, and the socket adapter serves as the interface for application messages. Each adapter has a transport level address, which, in the case of the Internet, consists of an IP address and a UDP or TCP port number. Currently, there are three different types of adapters, for TCP, UDP, and UDP multicast. Using two adapters completely separates the handling of messages for maintaining the overlay protocol and the messages that transport application data.The application receive buffer and application transmit buffer can temporarily store messages that, respectively, have been received by the socket but not been deliv-ered to theapplication, or that have been released by the application program, but not been transmitted by the socket. The application transmit buffer can play a role when messages cannot be transmitted due to rate control or congestion control con-straints. The application transmit buffer is not implemented in the HyperCast 2.0 software.Each overlay socket has two external interfaces. The application programming in-terface (API) of the socket offers application programs the ability to join and leave existing overlays, to send data to other members of the overlay network, and receive data from the overlay network. The statistics interface of the overlay socket provides access to status information of components of the overlay socket, and is used for monitoring and management of an overlay socket. Note in Figure 3 that some components of the overlay socket also have interfaces, which are accessed by other components of the overlay socket. The overlay manager is a component external to the overlay socket (and not shown in Figure 3). It is responsible for configuring an overlay socket when the socket is created. The overlay manager reads a configuration file that stores the attributes of an overlay socket, and, if it is specified in the configuration file, may access attributes from a server, and then initiates the instantiation of a new overlay socket.4 Overlay Network ProgrammingAn application developer does not need to be familiar with the details of the components of an overlay socket as described in the previous section. The developer is exposed only to the API of the overlay socket and to a file with configuration parameters.The configuration file is a text file which stores all attributes needed to configure an overlay socket. The configuration file is modified whenever a change is needed to the transport protocol, the overlay protocol, or some other parameters of the overlay socket. In the following, we summarize only the main features of the API, and we refer to [12] for detailed information on the overlay socket API.4.1 Overlay Socket APISince the overlay topology and the forwarding of application-layer data is transparent to the application program, the API for overlay network programming can be made simple. Applications need to be able to create a new overlay network, join and leave an existing overlay network, send data to and receive data from other members in the overlay.The API of the overlay socket is message-based, and intentionally stays close to the familiar Berkeley socket API [3]. Since space considerations do not permit a description of the full API, we sketch the API with the help of a simplified example. Figure 4 shows the fragment of a Java program that uses an overlay socket. An application program configures and creates an overlay socket with the help of an overlay manager (o m). The overlay manager reads configuration parameters for the overlay socket from a configu-ration file (hypercast.pro p), which can look similarly as shown in Figure 5. The applica-tion program reads the overlay ID with command om.getDefaultProperty(“OverlayID”) from the file, and creates an configuration object (confi g) for an overlay socket with the.// Generate the configuration object OverlayManager om = newOverlayManager("hypercast.prop");String MyOverlay = om.getDefaultProperty("OverlayID"); OverlaySocketConfig config = new om.getOverlaySocketConfig(MyOverlay); // create an overlay socketOL Socket socket = config.createOverlaySocket(callback);// Join an overlaysocket.joinGroup();// Create a messageOL Message msg = socket.createMessage(byte[] data, int length);// Send the message to all members in overlay networksocket.sendToAll(msg);// Receive a message from the socketOL Message msg = socket.receive();Fig. 4. Program with overlay sockets.# OVERLAY Server:OverlayServer =# OVERLAY ID:OverlayID = 1234KeyAttributes= Socket,Node,SocketAdapter# SOCKET:Socket = HCast2-0HCAST2-0.TTL = 255HCAST2-0.ReceiveBufferSize = 200# SOCKET ADAPTER:SocketAdapter = TCPSocketAdapter.TCP.MaximumPacketLength = 16384# NODE:Node = DT2-0DT2-0.SleepTime = 400# NODE ADAPTER:NodeAdapter = NodeAdptUDPServer NodeAdapter.UDP.MaximumPacketLength = 8192 NodeAdapter.UDPServer.UdpServer0 =128.143.71.50:8081Fig. 5. Configuration file (simplified) given overlay ID. The configuration objectalso loads all configuration information from the configuration file, and then creates the overlay socket(config.createOverlaySocke t).Once the overlay socket is created, the socket joins the overlay network (socket.join-Grou p). When a socket wants to multicast a message, it instantiates a new message (socket.createMessage) and trans-mits the message using the sendToAll method. Other transmission options are send-To-Parent, send-To-Children, sendToNeighbors, and sendToNode, which, respectively, send a message to the upstream neighbor with respect to a given root (see Figure 2), to the downstream neighbors, to all neighbors, or to a particular node with a given logical address.4.2 Overlay Network Properties ManagementAs seen, the properties of an overlay socket are configured by setting attributes in a configuration file. The overlay manager in an application process uses the attributes to create a new overlay socket. By modifying the attributes in the configuration file, an application programmer can configure the overlay protocol or transport protocol that is used by the overlay socket. Changes to the file must be done before the socket is created. Figure 5 shows a (simplified) example of a configuration file. Each line of the configuration file assigns a value to an attribute. The complete list of attributes and the range of values is documented in [12]. Without explaining all entries in Figure 5, the file sets, among others, the ov erlay ID to …1234 ‟, selects version 2.0 of the DT protocol as overlay protocol (…Node=DT2-0 ‟), and it sets the transport protocol of the socket adaptor to TCP(…SocketAdapter=TCP ‟).Each overlay network is associated with a set of attributes that characterize the properties of the over-lay sockets that participate in the overlay network. As mentioned earlier, the most important attribute is the overlay ID, which is used to identify an y network, andwhich can be used as a key toaccess all other attributes of an overlay network. The overlay ID should be a globally unique identifier.A new overlay network is created by generating a new overlay ID and associating a set of attributes that specify the properties of the overlay sockets in the overlay network. To join an overlay network, an overlay socket must know the overlay ID and the set of attributes for this overlay ID. This information can be obtained from a configuration file, as shown in Figure 5.All attributes have a name and a value, both of which are strings. For example, the overlay protocol of an overlay socket can be determined by an attribute with name NODE. If the attribute is set to NOD-E=DT2- 0, then the overlay node in the overlay socket runs the DT (version 2) overlay protocol. The overlay socket distinguishes between two types of attributes: key attributes and configurable attributes. Key attributes are specific to an overlay network with a given overlay ID. Key attributes are selectedwhen the overlay ID is created for an overlay network, and cannot be modified after-wards.Overlay sockets that participate in an overlay network must have identical key attributes, but can have different configurable attributes. The attributes OverlayID and KeyAttributes are key attributes by default in all overlay networks. Configurable at-tributes specify parameters of an overlay socket, which are not considered essential for establishing communication between overlay sockets in the same overlay network, and which are considered …tunable‟.5 ConclusionsWe discussed the design of an overlay socket which attempts to simplify the task of overlay network programming. The overlay socket serves as an end point of commu-nication in the overlay network. The overlay socket can be used for various overlay topologies and support different transport protoc-ols. The overlay socket supports a simple API for joining and leaving an overlaynetwork, and for sending and receiving data to and from other sockets in the overlay network. The main advantage of the overlay socket is that it is relatively easy to change the configuration of the overlay network. An implementation of the overlay socket is distributed with the HyperCast2.0 soft-ware. The software has been extensively tested. A variety of different applications, such as distributed whiteboard and a video streaming application, have been developed with the overlay sockets. Acknowledgement. In addition to the authors of this article the contributors include Bhupinder Sethi, Tyler Beam, Burton Filstrup, Mike Nahas, Dongwen Wang, Konrad Lorincz, Jean Ablutz, Haiyong Wang, Weisheng Si, Huafeng Lu, and Guangyu Dong.应用层覆盖网络的出现促进了新网络服务和应用的发展。

中英文资料外文翻译网站建设技术1.介绍网络技术的发展,为今天全球性的信息交流与资在建立源共享和交往提供了更多的途径和可能。

足不出户便可以知晓天下大事,按几下键盘或点几下鼠标可以与远在千里之外的朋友交流,网上通信、网上浏览、网上交互、网上电子商务已成为现代人们生活的一部分。

Internet 时代, 造就了人们新的工作和生活方式,其互联性、开放性和共享信息的模式,打破了传统信息传播方式的重重壁垒,为人们带来了新的机遇。

随着计算机和信息时代的到来,人类社会前进的脚步在逐渐加快。

近几年网页设计发展,快得人目不暇接。

随着网页设计技术的发展,丰富多彩的网页成为网上一道亮丽的风景线。

要想设计美观实用的网页就应该深入掌握网站建设技术。

在建立网站时,我们分析了网站建立的目的、内容、功能、结构,应用了更多的网页设计技术。

2、网站的定义2.1 如何定义网站确定网站的任务和目标,是建设网站所面临的最重要的问题。

为什么人们会来到你的网站? 你有独特的服务吗? 人们第一次到你的网站是为了什么? 他们还会再来吗? 这些问题都是定义网站时必须考虑的问题。

要定义网站,首先,必须对整个网站有一个清晰认识,弄清到底要设计什么、主要的目的与任务、如何对任务进行组织与规划。

其次,保持网站的高品质。

在众多网站的激烈竞争中,高品质的产品是长期竞争的最大优势。

一个优秀的网站应具备：（1）用户访问网站的速度要快；（2）注意反馈与更新。

及时更新网站内容、及时反馈用户的要求；（3）首页设计要合理。

首页给访问者留下的第一印象很重要,设计务必精美,以求产生良好的视觉效果。

2.2 网站的内容和功能在网站的内容方面,就是要做到新、快、全三面。

网站内容的类型包括静态的、动态的、功能的和事物处理的。

确定网站的内容是根据网站的性质决定的,在设计政府网站、商业网站、科普性网站、公司介绍网站、教学交流网站等的内容和风格时各有不同。

我们建立的网站同这些类型的网站性质均不相同。

外文资料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（面向对象程序设计）只是涉及抽象的数据类型、继承以及多形性，但另一些问题也可能显得非常重要。

本科毕业设计外文文献及译文文献、资料题目：Evolving Java Without Changingthe Language文献、资料来源：/articles/evolving-java-no-lang-change 文献、资料发表（出版）日期：院（部）：专业：班级：姓名：学号：指导教师：翻译日期：外文文献：Evolving Java Without Changing the Language In "The Feel of Java" James Gosling stated that: Java is a blue collar language. It's not PhD thesis material but a language for a job. Java feels very familiar to many different programmers because I had a very strong tendency to prefer things that had been used a lot over things that just sounded like a good idea.The extraordinary success of Java offers weight to the notion that this was a sensible approach, and if it remains an important goal for Java today, then it makes sense that the language should continue to evolve relatively slowly. In addition to this, the fact that Java is a mature, widely used language causes its evolution to be fraught with difficulty. For one thing, each feature added to the language can change the way it feels in subtle and often unpredictable ways, risking alienating developers who have already adopted it as their language of choice. For another, a feature that makes perfect sense on its own may interact with other features of the language in awkward or unexpected ways. Worse, once a language feature has been added it is all but impossible to remove even if it turns out to be detrimental to the language as a whole. To justify adding a new feature, a language designer must be highly confident that it will be of long term benefit to the language rather than a short term or fashionable solution to a problem that rapidly becomes redundant. To mitigate the risk a language designer will typically experiment by creating a separate language or branch, such as the Pizza language used to experiment with Java's generics, prior to their implementation. The problem with this approach is that the audience for such experiments is both small and self-selecting; obviously they will all be interested in language features, and many may be academics or researchers. An idea which plays well to such an audience may still play badly when it is incorporated into the main language and general programmers start to work with it.To get a sense of this, consider the closures debate that became so heated for Java 7. Implementations for the main proposals (and some others) have been available for some time but no consensus has emerged. In consequence Sun decided that JDK 7 will not get full closures support. The core argument came down to whether Java had become as complex as it could afford to be when generics (and in particular the wildcard syntax) were added to Java 5; andwhether the addition of full support for closures was justified when Java already has a more limited form through anonymous inner classes. Two important use cases for adding full closures support were to simplify working with the fork/join API that is being added to JDK 7 to improve multi-core programming, and to help with resource clean-up. Josh Bloch's ARM block proposal, which is now expected to be in JDK 7 via Project Coin, offers an alternative solution to the latter problem. Dr. Cliff Click's research on a scalable, non-blocking programming style for Java offers an alternative approach to fork/join that may be more appropriate as the number of processor cores increases. If this were to happen, then the uses for closures in Java may arguably be too limited to justify their inclusion.It remains important though that a programming language continues to develop at some level. This article therefore examines three alternative techniques for adding new language features to Java that don't require changes to the language itself - using a custom Domain Specific Language, exploiting the Java 6 annotation processor to add optional language features via a library, and moving the syntactic sugar from the language to the IDE. Each offers the potential to allow a wide audience of mainstream developers to experiment with the new features over the medium term in a non-invasive manner, and the best ideas can then filter down for inclusion in the core language.Custom DSLsThe most widely discussed of the three is the Domain-Specific Language or DSL. There is some disagreement on exactly what the term means, but for the purposes of this discussion we'll refer to it simply as a language that has been created with a narrow focus to solve a particular problem, rather than as a general purpose language designed to solve every computing problem. As such we would expect a DSL to be non-Turing complete and for the most part this is the case. There are edge cases of course. Postscript, for example, is a Turing complete language but also qualifies as a DSL using our definition.As the above example also illustrates, the idea of a DSL is not new. Other familiar DSLs include Regular Expressions, XSLT, Ant, and JSP, all of which require some sort of custom parser to process them. Martin Fowler also suggests that fluent interfaces/APIs can be considered a second type of DSL, which he refers to as an internal DSL. His definition is that an internal DSL is developed directly within the host language. This was a common practice amongst bothLisp and Smalltalk programmers, and more recently the Ruby community has been popularising the technique.Whilst many well-known DSLs are commercially developed and maintained, some enterprise development teams have used the technique to create a language that allows them to rapidly explore aspects of their problem domain. It isn't however as common as it might be, perhaps because DSLs have a fairly intimidating barrier to entry. The team has to design the language, build the parser and possibly other tools to support the programming team, and train each new developer that joins the team on how the DSL works. Here the emergence of tools to specifically support DSL development could significantly change the landscape. Intentional Software's Intentional Domain Workbench, which has been in development longer than Java has been around, is the first significant implementation of such a tool. The project started life at Microsoft Research, and Dr. Charles Simonyi's 1995 paper "The Death of Computer Languages, the Birth of Intentional Programming" describes his vision. In 2002 Simonyi founded Intentional Software to continue working on his ideas and a hugely impressive video demo of the system is available. The product itself is at 1.0 status, but access is restricted to very limited partners.Other software houses are also exploring the concepts, amongst them JetBrains, well respected for their IntelliJ IDEA Java IDE, who have recently released the 1.0 version of their Meta Programming System (MPS). MPS doesn't use a parser, instead working with the Abstract Syntax Tree (AST) directly. It provides a text-like projectional editor which allows the programmer to manipulate the AST, and is used to write languages and programs. For each node in the tree a textual projection is created - as the programmer works with the projection, the change is reflected in the node. This approach allows you to extend and embed languages in any combination (often referred to as language composing) promoting language re-use. JetBrains are using the product internally and have recently released YouTrack, a bug tracking product developed using the system.The Java 6 Annotation ProcessorWhilst DSLs are less common in more mainstream languages such as Java than they are in Ruby, Smalltalk and Lisp, recent developments in the Java language, in particular the annotation processor which was added in Java 6, offer new possibilities for developers looking to use them in Java. The JPA 2.0 criteria API that will ship as part of Java EE 6, itself a DSL, offers anexample. Here the annotation processor builds up a metamodel type for each persistent class in the application. Whilst it would be perfectly possible for the developer to hand craft the metamodel in Java, it would be both tedious and error prone. The use of the annotation processor eliminates that pain and, since the annotation processor is built into Java 6, the approach requires no specific IDE support – an IDE delegates to the annotation processor triggered by the compiler, and the metadata model is generated on the fly.Using the annotation processor it is also possible for a library to add a new language feature. Bruce Chapman's prototype "no closures" proposal, for example, uses the technique to provide a mechanism for casting a method to a Single Abstract Method (SAM) type which compiles on top of Java 6. During our conversation Chapman pointed out that the SAM type also supports free variables, a key aspect of a closure:The method body can declare additional parameters beyond those required for the Single **********************************************.Theseparameterscanhavevaluesbound to them at the point where you obtain an instance of the SAM type, and are then passed to the method each time it is invoked.Chapman also set up the Rapt project to explore other uses of the technique, and has added implementations for two language changes - Multiline Strings and XML literals - that were considered for JDK 7 but won't now make it into the final release. Java could even get a form of closures support using this approach. When asked about this, Chapman said: We are just finishing a Swing project which we used it for. We have found a couple of minor bugs around generic types, one recently discovered remains to be fixed but other than that it seems quite nice to use, and nobody has been wanting to rush back to use conventional anonymous inner classes.Project Lombok, another project exploring the the annotation processor, pushes the technique still further. In effect Lombok uses annotation processing as a hook to run a Java agent that re-writes various javac internals based on the annotations. Since it is manipulating internal classes it is probably not suited to production use (internal classes can change even between minor releases of the JVM) but the project is an eye-opening example of just what can be done using the annotation processor, including:•Support for properties using a pair of @Getter and/or @Setter annotations with varying access levels, e.g. @Setter(AccessLevel.PROTECTED) private String name;•The @EqualsAndHashCode annotation, which generates hashCode() and equals() implementations from the fields of your object•The @ToString annotation, which generates an implementation of the toString() method •The @data method, which is equivalent to combining @ToString, @EqualsAndHashCode, @Getter on all fields, and @Setter on all non-final fields along with a constructor to initialize your final fieldsOther language experimentation, such as removing checked exceptions from Java, can also be done using this approach.Whilst the annotation processor technique opens up a welcome new route to language experimentation, care needs to be taken that the generated code can be easily read by developers, not just by the machine. Chapman made a number of suggestions during our conversation:Generate source code not bytecode, and pay attention to formatting (indenting especially) in the generated code. The compiler won't care whether it is all on one line or not, but your users will. I even sometimes add comments and javadoc in the source code generated by my annotation processors where appropriate.Hopefully if the technique becomes more prevalent IDEs will also make it easier to view the code that is to be generated at compile time.Syntactic Sugar in the IDEBruce Chapman also touches on our third technique - moving the syntactic sugar from the language to the IDE - in his blog and he elaborated on his ideas during our conversation. It is already routine for Java IDEs to create portions of boilerplate code for you such as the getters and setters of a class, but IDE developers are beginning to push the concept further. JetBrains' IntelliJ 9 offers a terse code block syntax for inner classes similar to a closure, which a developer can also type. Acting like code folds, these can then be expanded into the full anonymous inner classes which the compiler works with - this allows developers who prefer to stick with the standard anonymous inner class syntax to do so. A similar plug-in for Eclipse also exists. The key point here is that the "alternate" syntax is just a view of the actual code which the compiler and any source management tools continue to work with. Thus the developer should be able to switchviews between either form (like expanding or collapsing a code fold), and anyone without access to the definition of the sugar just sees the normal Java code. Chapman writes:There are many details to work out in order to make this easily accessible, but long term I see developers relatively easily defining a two way sugaring/desugaring transformation (jackpot is a good start for how this might be done), trying them out, evolving them and sharing the good ones with colleagues and the community. The advantages of this are almost the same as for a language change, without the disadvantages. The very best could become ubiquitous and then form the basis of an actual language change if necessary to get rid of any remaining "noise" not possible with this approach.Since syntactic sugar has to map to another (more verbose) language feature it cannot offer complete closure support; there are some features of BGGA closures for example that cannot be mapped to anonymous inner classes, and so they couldn't be implemented through this approach. Nevertheless the idea opens up the possibility of having various new syntaxes for representing anonymous inner classes, similar to BGGA syntax or FCM syntax, and allowing developers to pick the syntax they want to work with. Other language features, such as the null-safe Elvis operator, could certainly be done this way. To experiment further with the idea this NetBeans module also developed by Chapman, is what he describes as a "barely functional" prototype for Properties using this approach.ConclusionIn language development there is always a trade-off between stability and progress. The advantage that all of these techniques bring is that they don't affect the platform or the language. In consequence they are more tolerant to mistakes and are therefore more conducive to rapid and radical experimentation. With developers freely able to experiment we should begin to see more people separately tackling the poor signal to noise ratio of some common boilerplate such as the anonymous inner class syntax, mixing and evolving these ideas to some optimum form that adds the most value in the most cases. It will be fascinating to see how developers use these different approaches to push the Java platform in new directions.中文译文：不改变语言的前提下推进Java演进James Gosling在“The Feel of Java”中说过：Java是一种蓝领语言，它并不是博士的论文材料而是可以完成工作上的语言。

计算机专业中英文翻译外文翻译文献翻译英文参考文献及翻译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 T orvalds and otheroutstanding 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 asMicrosoft , 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.。

计算机专业英语3000多词计算机专业英语词库file 文件command 命令 use 使用program 程序 line 行display 显示 set 设置key 关键帧list 列表byprep 凭靠沿 press 按format 格式 change 改变 cursor 光标 directory 目录 from pre 预先从menun 菜单option 选项 character 特性 current 当前 type 类型screen 屏幕 specify 指定 move 移动disk 磁盘text 文本drive 驱动see 查看name 名字record 记录box 长方体database 数据库help 帮助memory 内存which 哪个all 全部ona 发信网点地址 copy 复制shell 壳delete 删除enter 键入margin 页边距mark 标记also 同样do 数据输出informationn信息情报 choosev挑选选择选定 selectvt选择groupn组群firsta&ad&n第一首先 fieldn字段域栏场 proceduren过程程序工序 printv 打印印刷returnv返回回送 numbern数字号码vt编号 selecteda精选的 wantv需要应该缺少 windown窗口messagen信息消息电文 dialogn&vt对话examplen例子实例 createvt创立建立 insertvt插入relateda相关的itemn项项目条款 editvt编辑编排编篡 markeda有记号的 arean(区)域面积方面 parametern参数参变量 thenad&conj那时则 variablea可变的n变量 tabn 制表键upad上向上a高的 stringn行字符串 eacha&ad各(自)每个 activea激活的活动的 topicn题目论题startv起动开始启动 moden态方式模selectionn选择functionn函数功能操作 wordn字(词)单词 makevt制造形成接通 righta右边的正确的 valuen值buttonn按钮indexn索引变址指数appearvi出现显现好像 lefta&n左边(的) savev保存nextn下一次a其次 offad(设备)关着脱离 followinga下列的以下的controlv控制支配管理 onlya唯一的ad仅仅 usern用户endn结束终点端点systemn系统containvt包含包括 timen时间vt计时lettern字母信datan数据settingn设置调整desirev&n期望positionn位置vt定位 downad落下降低减少 taskn任务v派给…任务viewn&v视图景象switchn&v开关转换切换 includevt包括包含 getv得到获得取defaultv缺省预置约定 structuren结构构造构件 intoprep向内进入pathn路径通路轨道 blankn空白间隔openv打开开启断开 addv&n加增加添enablevt启动恢复正常操作 operationn操作运算动作 erasev擦除取消删除filenamen文件名searchv检索查询搜索 anothera另一个别的 lasta&n最后(的) columnn列柱栏afterprep&ad以后后面 promptn&v提示twon&a二两双executev实行实施 aboutad关于大约附近 escapev逃避逸出换码 errorn错误误差差错 currentlyad目前现在 extensionn扩充延伸 samea同样的相同的statusn状态态状况 runv运行运转操作 argumentn变元自变量 statementn语句陈述命题 shiftv转义换档移位 storen&vt存储存储器 scrollvt上滚(卷)n纸卷replacevt替换置换代换 macron宏宏功能宏指令 pagen页面页版面quitv退出结束definevt定义规定分辨 referencen&a参考参考的 othera别的另外的whileconj当…的时候 pressingn&a压制紧急的restorevt恢复复原topn顶尖端howad如何怎样多么colorn颜色色彩(彩)色 allowv允许容许blockn(字信息数据)块 decimaln&a十进制十进制的 maina主要的definitionn定义确实清晰度 betweenprep在…之间中间 optionala任选的可选的 daten日期removev除去移动arrown箭头指针labeln标签标号标识符 withinprep在…以内 issuev发行出版流出differenta不同的各种各样的 availablea可用的returneda退回的associatev相联联想关联 attributen属性标志表征 dos磁盘操作系统beforeprep以前前先 ordern&vt指令次序排序 modifyvt修改改变变址arrayn数组阵列mousen鼠标器noten注解注释locatevt定位videon视频电视printern打印机印刷机 barn条杆棒bottomn&a底基础底下的 carriagen滑架托架 contentn含量容量内容eithera&pron任何一个各 okad&a对好全对spacen空格键空间 editorn编辑程序existvi存在生存有 scopen范围显示器 paragraphn段(落)节短讯 multi(词头)多clearv清除弄干净 exitn&vi出口退出 reportvt&n报告报表 executionn执行backupn备份后备后援 versionn版本findv寻找发现pointern指针指示字 subsetn子集子设备 keyboardn键盘fulla&ad&n全(的)满 checkv校对栓查核算 shouldv&aux应当该 singlea&n 单个的一个单 positioningn定位 providev提供titlen题目标题expressionn表达式throughprep&ad通过直通 togglen&v触发器系紧 coden码代码编码sucha&pron这样的如此 beginningn起点初 guiden向导指南入门 treen树语法树environmentn环境 but但是可是除非不过 devicen设备器件装置 highlightn 增强亮度提示区 callv调用访问呼叫 continuev连续继续 indicatevt指示表示untilprep到…为止直到 beginv开始着手开端 placevt放位地点renamevt更名改名 swapv交换调动workn工作remainvi剩下留下仍然 closev&a关闭闭合紧密的 combinationn结合组合profilen简要剖面概貌 unlessconj除非sopron&conj如此这样 exceptprep除…之外除非 turnv&n转转动圈匝 backn 背面反向底座 surea&ad确实的的确 sectionn节段区域followv跟随跟踪splitv分开分离needv必须需要accessn存取选取接近 additionala附加的辅助的 cancelv删除取消作废documentn文献资料文件 casen情况场合numericn&a数字的分数 govi运行达到loadn&v装入负载寄存 tryn(尝)试试验sizen尺寸大小容量 entirea&n完全的总体 leavev离开留下historyn历史secondn&a秒第二(的) reflowv&n回流逆流 outputn输出输出设备 outn&a输入在外botha&ad两双都installvt安装sourcen源电源源点 wayn路线途径状态 assignvt赋值指定分派 supportvt 支援支持配套 specifica特殊的具体的 joinv&n连接并(运算) expandv扩充扩展展开 likea类似的同样的 disketten软磁盘软盘片skipv跳跃(定位)跳过 applicationn应用 confirmationn认可 whetherconj 无论不管 holdv保持clickn"卡搭"声插销 writev写存入byten(二进制的)字节 abbreviatevt缩写省略 showv显示呈现出示otherwisead&a另外 workingn工作操作作业 delimitern定界符分界符locationn定位(存储器)单元performv执行完成 graphicn&a图形图形的 readv读读阅confirmvt证实确认 sortv分类排序clausen条款项目子句 oncead&n只一次一旦 howeverconj然而可是 extendv 扩充lookv看查看startinga起始的nowad&n此刻现在originaln&a原文原(初)始的correspondvi通信(联系) propertyn性(质)特征 severala&n若干个几个learnv学习训练causen原因理由bracketn(方)括号等级 omitvt省略删去遗漏 runninga运行着的游动的 sub-directoryn子目录 edgen棱边边缘界限 formn格式表格方式 instructionn指令指导 asciin美国信息交换标准码 belowa&prep下列的低于 standardn标准occurrencen出现发生 lockn&v锁封闭自动跟踪 appendvt附加增补destinationn目的地接收站 passwordn口令保密字 pointn点小数点句号varietyn变化种类品种 manya&n许多多数buffern缓冲器usefula有用的objectn对象目标物体 againad再又重新也 operatinga操作的控制的 carryv 进位带updatev更新修改校正 movingn&a活动的自动的 coprocessorn协同处理器overlayv覆盖重叠practicen实习实践 navigationn导航automaticallyad自动地机械地totaln&v总数总计previousa早先的上述的 softwaren软件shortcutn近路捷径 longa长的远的uniquea唯一的独特的 partn部分零件updateda适时的更新的 internala内部的fillv填充basicn&a基本基本的 mathn数学sinceprep自从…以来 determinev确定makingn制造构造centern中心中央alreadyad已经早已 keywordn关键字(词) actionn操作运算conditionn条件情况vt调节 quicka&ad快速的灵敏的 assigneda指定的赋值的 givevt给出赋予发生 largea(巨)大的大量的 chaptern章段computern计算机completev&a完成完整的 pasta过去的结束的 matchv比较匹配符合 recoverv 恢复回收alwaysad总是一直始终 requirev需要要求openingn打开断路孔 networkn&vt网络联网 signn符号信号记号releasevt&n释放核发版 threea&n三(的)recallvt撤消复活检索 deletionn删去(部分)删除 fixeda固定的不变的amountvt&n总计合计 aliasn别名代号标记 quoten&v引号加引号 correcta&vt正确的改正 elsead&conj否则此外 maximumn&a最大(的)最高 underprep在…下面(之下) takev取拿switchingn开关转接交换 elementn元件元素码元 modificationn改变修改modifieda修改的变更的 inputn输入输入设备 uppercasen大写字母 plusprep加加上外加 foundv建立创办debugvt调试forcev&n强制压力强度 lowercasen下档小写体 justad恰好undovt取消废除environvt围绕包围 whyad为什么temporarya暂时的临时的 putv存放(记录)放置 insteadad(来)代替当作encounterv&n遇到碰到 acrossprep交叉越过 matchingn匹配调整 wildcardn通配符spillv漏出溢出漏失 leveln水平级层次 browsev浏览speechn说话言语语音 occurvi发生出现存在 memon备忘录priora先验的优先的 loadeda有负载的lengthn(字记录块)长度 roundv舍入四舍五入 variantn&a变体易变的floppyn软磁盘machinen机器计算机 squaren&a正方形方形的 supplyvt&n电源供给 homen&a 家出发点normala&n正常标准 ontoprep向…到…上 duringprep在…期间 modulen模块(程序设计) monochromen单色assistancen辅助设备帮助telln讲说教计算libraryn(程序…)库图书馆 demonstrationn(公开)表演示范 stackn栈堆栈存储栈 evena&ad偶数的甚至 evaluatev估计估算求值 timesn次数previouslyad以前预先 directlyad直接地立即 logicala逻辑的逻辑"或" templaten标准框样板模板 callingn呼叫调用调入 latera更后的后面的drivern驱动器驱动程序 thereforead&conj因此所以 savinga保存的detailn元件零件细节 linkern连接程序loopn圈环(程序)循环回路 processvt处理进程加工 schemen方案计划图everya每个全体所有的 referv访问引用涉及 possiblea可能的潜在的abovea在…之上大于 overviewn综述概要resultn结果syntaxn语法文法句法 abbreviationn缩短省略简称 biosn基本输入/输出系统 hiddena隐藏的秘密的nulln&a空(的)零(的) sendv发送privatea专用的私人的 harda硬的hardwaren硬件sayv说显示假定equalvt&n等于相等等号 packn压缩包裹minusa&n负的负数减 alternatea交替的备用的 collapsev崩溃破裂cornern角角落转换presenta&v现行的提供 interpretern解释程序翻译机 advancev&n进步提高进展 forwarda正向的fasta&ad快速的speciala专用的特殊的 slashn斜线utilityn&a实用程序实用性 regardlessa不注意的不考虑的 disablevt禁止停用compatiblea可兼容的可共存的 dependvi随…而定取决于 emptya空零未占用alphabeticala字母(表)的abc的branchn分支支线v转换 resumev重(新)开(始) multiplea多次的复杂的monitorn监视器监督程序 configurationn配置replacementn替换置换更新 requireda需要的macrosn宏命令(指令) tablen表lossn损耗损失batchn批批量成批exacta正确的aboveboardad&a照直公开的 activatevt&n使激活驱动 aroundad&prep周围围绕 slowa&ad慢速的floatinga浮动的浮点的 refreshv刷新更新再生 stopv停止停机passv传送传递遍(数) publica公用的公共的 ejectn弹出ignorevt不管忽略不计 sharev共享共用sequencen顺序时序序列 consistvi符合包括 stepn步步骤步长档 doublea 两倍的成双的 comevi来到出现lowera下部的低级的 describevt描述沿…运行 countv计数计算popv上托弹出(栈) valida有效的suspendv中止暂停挂起 enhancevt增强放大夸张separatev&a分隔分离各自的 echon回波反射波necessarya必要的必然的 greaterthan大于ablea能…的有能力的 markingn标记记号传号 askv请求需要termn项条款术语bringv引起产生拿来 warningn&a报警预告 lessa&ad更小更少whosepron谁的commentn&vi注解注释 effectn效率作用效能 expandinga扩展的扩充的 on-linea联机的reorderv(按序)排列排序 directa直接的enclosevt封闭密封围住包装 resetvt复位置""variousa不同的各种各样的 papern纸文件论文preventv防止预防siden(旁)边面侧(面) pushv推按压进(栈) programmingn程序设计编程序uppera上的上部的rown行presseda加压的压缩的 temporarilyad暂时dayn日天白天时代repaintvt重画redefinevt重新规定(定义) relationn关系关系式 dimensionn尺寸维因次boundaryn边界界限约束 zoomv变焦距initializev初始化 personala个人的自身的 helloint&v喂!呼叫 truea&n 真实选中wishv&n祝愿希望fontn铅字字形knowv知道了解认识 convertv转换变换globaln全局全程全局符 stilla&n&v静止的静平静 installationn安装装配invokevt调用请求interactivea交互式交互的 describeda被看到的被发现的 centuryn世纪literala文字的ratherad宁可有点exclusivea排斥排它性 markern记号标记标志 waitv等待appropriatea适当的合适的 fitv&n适合装配非特 adaptern适配器转换器filtern滤波器滤光材料 breakv断开撕开中断backwardad向后逆倒 searchingn搜索receivev接收duala对偶的双的retryvt再试复算normallyad正常地通常 exactlyad正好完全精确地 immediatelyad直接地separateda分开的 higha高equivalenta相等的等效的 lightn&a光(波源)轻的 zeron零零位零点storagen存储存储器 widthn宽度languagen语言startupn启动mucha&n很多许多大量 perprep每按overprep在…上方 mirrorn&v镜反射反映 requestn&vt请求keypadn小键盘keepv保持保存residenta驻留的learningn学问知识 talkv通话谈话summaryn摘要汇总提要 welln&a井好良好linkn&v链接连接联络 accordingtoa按照根据identifyv识别辨认 designateda指定的特指的 pertainvi附属属于关于expansionn展开展开式 incompatiblea不兼容的 blinkingn闪烁monthn月份precedev先于readilyad容易地不勉强 transportablea可移动的 appropriatelyad适当地routinen程序例行程序 readya就绪准备好的 listingn列表编目newlyad新近重新yearn(一)年年度年龄 contactn接触触点sessionn对话通话owna&v自己的拥有redrawvt再拉heread在这里manuala手工的手动的 particulara特定的特别的 rectanglen矩形additivea&n相加的附加物 similara相似的assemblyn汇编安装装配 copyrightn版权descriptionn描述retrievev检索mistaken错误producev生产制造ram随机存取存储器exceptionn例外异常异议 digitn数字位数位reversev&a反向的逆 minimumn&a最小(的)最低 enougha&ad足够的充足的althoughconj虽然即使 reindexv&n变换(改变)符号 thirda&n第三三分之一reda&n红色(的)alongprep&ad沿着testn&v测试smalla小的小型的feedv馈给(打印机)进纸 companyn&v公司交际交往 movien影片电影(院) compilevt编译frequentlyad常常频繁地 undefineda未定义的 staten&vt状态确定tickvn滴答(响)勾号(?) acceptvt接受认可同意 intensea强烈的高度的documentationn文件编制文本 asteriskn星号(*) easilyad容易地轻易地becomev成为变成适宜 addressvt&n寻址地址 interfacen接口pausevi暂停repeatv重复restartv重新启动再启动 assumeda假定的speedn速度entryn输入项(目)入口 combinev组合联合organizev组织创办成立 finisheda完成的mixeda混合的permitv许可容许formattingn格式化rootn根symboln符号记号binaryn&a二进制双态的 wheneverad&conj随时 reachv&n范围达到范围cautionn&v警告注意 subtotaln&v小计求部分和 cardn卡片插件(板) generala 通用的associateda联合的相联的 transferv传送转换转移 connectv连接partitionv划分分区部分 hexadecimala十六进制的 generatevt产生发生生成 specificationn说明书规则说明书customizevt定制定做 fara远的遥远的nestv嵌套后进先出duplicatevt复制转录加倍compressionn压缩浓缩 unablea不能的meansn方法手段alternatelyad交替地轮流地 intensityn强度亮度readingn读读数letv让允许explicitlyad明显地显然地 comparev比较对照比喻 sectorn&v扇区段分段problemn问题难题verticallyad竖直地直立地 horizontallyad水平地 backspacev退格回退terminatev端接终止peoplen人们shorta&n短的短路dragvt拖拉牵曳formatteda有格式的previewn&vt预映underscorevt在…下面划线 correctlyad正确地initiallyad最初开头 reformatv重定格式insiden&a内部内容内部的 integratev综合集成controlleda受控制的受操纵的 periodn周期hugea巨大的非常的determineda坚决的毅然的 trailingn&a结尾尾随的seekv查找寻找探求introductionn入门介绍引进 indentv缩排basen基底基地址integern整数attemptvt&n尝试试验 twicen&ad两次两倍于 formeda&n成形subscriptn注脚下标 tinya微小的微量的modeln模型样机型号 correctionn校正修正 ratingn定额标称值secondarya辅助的第二的 openeda开路的断开的 limitn极限限界sunn太阳日translatev翻译转换平移 reasonn原因理由colonn冒号":"avoidvt避免取消无效 rangen范围域区域allocatevt分配wordperfecta一字不错地熟记的simplyad简单地单纯地 verifyvt鉴定检验核对 mannern方法样式惯例directionn方向定向指向 portionn&vt部分分配 emulatorn仿真器仿真程序successfula成功的applieda适用的外加的 sumn和合计总额achievevt完成实现 togetherad一同共同相互 affectvt影响改变感动delayv延迟freea自由的空闲的 properlyad真正地适当地 kindn种类属级等splittingn分区(裂) featuren特征特点consolen控制台操作台 operatev操作运算kerneln内核(核心)程序 easya&ad容易的容易地 modifiern修改量变址数invalida无效的compilern编译程序(器) dotn点beepn蜂鸣声嘀嘀声 facen面表面randoma随机的facilityn设施装备便利 headingn标题asynchronousa异步的非同步的seriesn序列系列串联 individuala个别的单个的 explainv阐明解释pasten湖胶膏welcomevt&n欢迎sixn&a六(个)(的)earlya&ad早期初期 wrapv&n包装缠绕bluea&n蓝(色)青色 queuev&n排队队列 interruptv&n中断 respectn&vt遵守关系 converteda转换的变换的 commona公用的hyphenn连字符短线 seriala串行的串联的 loadingn装入加载存放 retainvt 保持维持 setupn安排准备配置 freezev冻结结冰intendvt打算设计 explanationn说明注解注释 certaina确实的确定的 zapv 迅速离去击溃 archivevt归档negativea负的否定的 imagen图像影像映像 platformn平台台架 oftenad经常往往屡次 signaln&v信号发信号 cpu控制处理部件bitn比特(二进制)位 fullyad十分完全deactivatevt释放去活化 especiallyad特别(是)尤其 usuallyad通常平常一般 recommendvt推荐建议maintainvt维护保养保留 importanta严重的显著的 centrala中央的中心的additionn加法增加 anytimead在任何时候 analystn分析员falsea假(布尔值)错误 blacka&n黑色的黑色 gathern聚集集合cyclen&v周周期循环 relativea相对的offerv提供给予呈现 endingn结束rentv&n租用裂缝sentencen句(子)rememberv存储记忆记住 propera真的固有的 designv设计examinev检验考试审查 initiala最初的初始的 corruptv&a恶化有毛病的buyv买购买赢得increasev增加增大 hostn主机samplen&v样品样本抽样 pendinga悬而未决的未定的 dividev除bootn引导靴hidev隐藏隐蔽halfn&a&ad一半半个 magentan&a深红色(的)leadingn&a引导(的) wronga&adn错误(的) todayn&ad今天leasta&ad最小(的) oppositea&n&ad相反的 whitea&n白色(的)overridev&n超越克服 browna&n褐色(的)棕色 hexa&n六角形的restn&v剩余休息damagen&vt损伤故障 instanta立刻的直接的 reserveda保留的预订的technologyn工艺技术制造学 handlen处理句柄applyv应用适用于作用 standv处于(状态)保持 paymentn支付付款kilobyten千字节(kb) parenthesisn括弧圆括号 scanv扫描扫视搜索locatingn定位查找developern开发者显影剂 murdern弄坏毁掉flushv弄平使齐平unlockv开锁打开movementn传送移动consecutivea连续的连贯的 collectionn集合聚集画卷 fronta前面的正面的addressingn寻址prefixn前缀carouseln圆盘传送带 safetyn安全保险statica静态的不变的 backgroundn背景底色基础 productn(乘)积产品assignmentn赋值分配 bada坏的不良的declarev说明adjustvt调整调节控制 recognizev识别routen路线路由respectivelyad分别地 unsuccessfula不成功的失败的receiveda被接收的公认的 navigatev导航驾驶 considereda考虑过的被尊重的duea到期的应付(给)的 recentlyad近来roomn房间空间descendv下降落下 factn事实alterv改变修改trackn磁道轨道precedencen优先权 skeletonn骨架框架 logn&v记录存入starn星形星号hota热的replaceablea可替换的 accessiblea可以使用的involvevt涉及卷入占用 configurevt使成形 questionn问题greenn&a绿色绿色的 entirelyad完全地彻底地 helpfula有帮助的有用的middlea中间的declareda承认的申报的 compressvt压缩精减 graphicallyad用图表表示autoa自动的automatica自动的aligneda对准的均衡的 anywheread在任何地方 terminaln终端端子 doorn 舱门入口孔expirev终止期满resolutionn分辨率 locala局部的本地的 semicolonn分号() rereadvt重读overwritev重写criticala&n临界的临界值 managern管理程序capabilityn能力效力权力 affecteda受了影响的 alloweda容许的bordern边界框界限 cachen高速缓存belln铃钟playv玩奏放音放象quicklya快迅速地fastbackn快速返回answern&v响应回答答复 representv表示表现代表 differencen差分差highesta最高的projectn项目计划设计 physicala物理的实际的 mattern物质内容事情herculesn大力神大力士 reducev减少降低简化 publishern出版者发行人 trimn 区标微调substitutev代替替换代入 disableda禁止的报废的 recenta近来的positivea正的阳的正片 upgradev升级提高质量 instancen&vt例子情况举例happenvi(偶然)发生碰巧 elapsedvi&n经过futuren&a将来未来的 midnightn&a午夜thoughconj虽然尽管 norconj也不monoa&n单音的slidev&n滑动滑动触头 abortv&n中断故障jumpv&n转移towardprep朝(着…方向) throughoutprep贯穿整遍viaprep经过经由amongprep在…之中中间 neithera&pron(两者)都不 layern&v层涂层scatterv散射分散散布 attentionn注意(信号) conventionn常规约定协定conventionala常规的习惯的 tooln工具刀handlern处理程序processorn处理机处理程序 desktopa台式的buildv建造建立组合windowingn开窗口developmentn开发研制显影 exceedv超过大于understandv懂明白(了)理解 horizontala水平的横向的 alphabeticallyad 按字母表顺序 meetv"与"符合满足protectvt保护reservevt保留预定预约 clockn时钟计时器同步 manifestvt表明显示显现safea安全的可靠的disconnectvt拆接断开拆线 clockwisea顺时针的eliminatevt除去消除切断 actuala实际的现实的 declarationn说明申报probablyad多半很可能ringn&v环圈按铃covervt盖罩套indicatorn指示器指示灯 applen苹果iconn图符象征considerationn考虑研究讨论 skilln技巧picturen图象画面layoutn布置布局安排 suggestvt建议提议暗示 convenienta方便的便利的instructvt讲授命令 appendixn附录mediumn&a媒体中等的 truncatevt截尾截断 inhibitvt禁止nearlyad近乎差不多几乎 warnvt警告警戒预告 underlinen下划线registern寄存器stuffn&vt材料装入excludevt排除除去destroyvt破坏毁坏打破 calculationn计算统计估计 anglen角角度lexicala辞典的词法的 decidev(使)判定判断 troublen故障processingn(数据)处理加工 customern顾客客户portn端口进出口discussvt讨论论述segmentn段片段图块filingn(文件的)整理汇集 identicallyad相等恒等 marketn市场行情销路valuablea有价值的贵重的 limiteda有限的(受)限制的 tryinga费劲的困难的heapn堆阵greyn&a灰色灰色的permanentlyad永久地持久地 acceleratorn加速装置加速剂 originallyad原来最初 abilityn性能能力效率 internallyad在内(部) derelictvt中途淘汰redirectvt重定向residevi驻留headern首部标题报头 extraa特别的额外的repeateda重复的deathn毁灭消灭observev观察探测densityn密度managementn管理environmentala周围的环境的 surroundinga周围的环绕的 mastera总要的总的recursivea递归的循环的 trapn&vt陷阱俘获dimensionaln尺寸的…维的logicn逻辑(线路)conjunctionn逻辑乘"与" identicala相等的相同的 advicen意见参考说明meaningn意义含义falln落下降落intervaln间歇区间compatibilityn兼容性适应性 rulen规则法则尺flagn标志(记)特征(位) criterionn标准判据准则 officen办公室局站expressa快速的volumen卷册体积容量 softa软的rateda额定的activityn活力功率odometern里程表计程仪 phoenixn凤凰绝世珍品 obtainv获得得到easeln框(画)架lattera后面的最近的 decreasev减少降低缩短 mainframen主机大型机debuggern调试程序diacriticala区分的辩别的 confidentiala机密的 tracev跟踪追踪divisionn除除法(程序)部分 regulara正则的正规的 implicita隐式的mentionvt&n叙述说到 nearad&prep领近接近 fifthn&a第五五分之一sevenn&a七(个)whereasconj面其实既然 reviewv&n(再)检查 whateverpron&a无论什么transformv&n变换变换式 alignv&n定位对准yellowa&n黄色(的) assistv&n加速帮助 finishv&n完成结束 microa&n微的百万分之一 beyondprep超过那边 againstprep反对阻止 uponprep依据遵照servicen&vt服务业务 littlea小的少量的 exhaustv取尽用完choicen选择精品soundinga发声的developv发展研制显影 holdingn保持固定存储 alphan希腊字母α未知数constantn常数warrantyn保证(书)授权 stayv停止停留industryn工业triggern&v触发器触发 lessonn功课教训handlingn处理操纵treatv处理加工busya忙碌的占线的usagen应用使用用法 difficulta困难的不容易的 failuren失效故障失败communicationn通信 buildingn建造建筑房屋 allyv联合与…关联exclamationn惊叹(号) turninga转弯的旋转的 wholea全部的整个的parentn双亲父代connectionn连接(法) connectivityn连通性联络性 translationn翻译变换平移 dynamica动态的动力的 foregroundn前台preserve。

外文翻译题目：网络安全保护服务器保护服务器保护服务器因此,您要运行的Web服务器在你的地下室,创造未来大件事,你要找一些廉价安全咨询如何展开? 好,我的第一个和最佳建议是不要这样做。

我只是说:“如果美国航天局-你知道,火箭科学家-不能使黑客的Web服务器,是什么使你认为你可以呢? 要去找一些ISP的服务,已找你,和薪酬的ISP,做它。

你们真的是仍读? 这个画面:你找到完美,别人。

您计划一个浪漫的夜晚,走到一个电影和有漂亮晚餐。

只是当事开始吹角,得到有趣你的电话铃声的骑兵负责通知你的15未经许可登录尝试在Web服务器上。

你道歉后,周围的人对破坏其晚餐,您的日期提出了一个眉毛和决定,跳过甜品。

还有,呃? 我很抱歉。

我知道,它必须健全璀璨,有你的Web服务器,但除非你付出了时间想一个黑客、赔率是无论你放在互联网将受到攻击。

阿贾克斯队应用程序需要一个Web服务器来工作。

所有后,什么是良好thexml-httprequestobject没有一个Web服务器,并在后端。

因此,阿贾克斯队的安全启动Web服务器。

如果您的Web服务器是不安全的,也不是你的申请。

你要知道什么作用发挥的Web服务器的安全。

确保一个Web服务器是一个非微不足道,需要了解Web服务器的关系网的工作。

看见滑稽看电话象从您的DSL/cable调制解调器出来的缆绳？那是互联网。

在我们可以设定网络服务器之前，我们必须首先准备网络。

您不想要塞住网络服务器入互联网与巨型乱砍我标志对此，是？我们必须首先采取一些防备措施。

我们真正地需要什么将从他们分离我们，正确？我们是你知道我们和他们是很好这坏人。

我们需要墙壁做那a防火墙对保留他们。

防火墙防火墙是坐在一个专用网和一个公共网络之间的设备。

分开什么帮助使一个专用网私有是，实际上，防火墙。

防火墙的工作是控制计算机网络之间的交通用信任为例子，一个内部，被信任的区域不同的区域，例如一个专用网和外部，非被信任的区域，例如互联网。