`
`COMPUTER SC ENCE
`
`AN OVERVIEW
`
`Jig-GLENN BROOKSHEAR
`
`Facebook's Exhibit No. 1017
`
`Page 1
`
`Facebook's Exhibit No. 1017
`Page 1
`
`

`

`Facebook's Exhibit No. 1017
`
`Page 2
`
`Facebook's Exhibit No. 1017
`Page 2
`
`

`

`FOURTH EDITION
`
`COMPUTER
`SCIENCE
`
`AN OVERVIEW
`
`Facebook's Exhibit No. 1017
`Page 3
`
`

`

`SELECTED TITLES FROM THE BENJAMIN/CUMMINGS SERIES IN
`COMPUTER SCIENCE
`F. Carrano/P. Helman/R. Veroff
`Data Structures and Problem Solving with Turbo Pascal: Walls and Mirrors
`(1993)
`A. Kelley and I. Pohl
`A Book on C: Programming in C, Second Edition (1990)
`A. Kelley and I. Pohl
`C by Dissection: Essentials of C Programming, Second Edition (1992)
`I. Pohl
`C + + for C Programmers, Second Edition (1994)
`I. Pohl
`C + + for Pascal Programmers (1990)
`W.J. Savitch
`Pascal: An Introduction to the Art and Science of Programming, Third Edition
`(1990)
`W.J. Savitch
`Turbo Pascal: An Introduction to the Art and Science of Programming, Fourth
`Edition (1993)
`
`Facebook's Exhibit No. 1017
`Page 4
`
`

`

`FOURTH EDITION
`
`COMPUTER
`SCIENCE
`
`AN OVERVIEW
`
`J. Glenn Brookshear
`Marquette University
`
`I
`
`The Benjamin/Cummings Publishing Company, Inc.
`
`Redwood City, California • Menlo Park, California
`ew York • Don Mill , Ontario • Wokingham, U.K.
`Reading, Massachusetts •
`Amsterdam • Bonn • Sydney • Tokyo • Madrid • Spain
`
`Facebook's Exhibit No. 1017
`Page 5
`
`

`

`To my parents
`Garland and Reba Brookshear
`
`Sponsoring Editor: Carter Shanklin
`Editorial Assistant: Mdissa Standen
`Production Coordinator: Andy Marinkovich
`Cover Design: Yvo Riezebos
`Copyedicor: Barbara Conway
`Proofreader: Holly Mclean-Aldis
`Artists: Ben Turner Graphics
`Composition: Graphic World
`
`Copyright © 1994 by The Benjamin/Cummings Publishing Company, Inc.
`
`All rights reserved. No part of this publication may be reproduced, or stored in a database or
`retrieval system, distributed, or transmitted in any form or by any means, electronic,
`mechanical, photocopying, recording, or otherwise without the prior written permission of the
`publisher. Printed in the United States of America. Published simultaneously in Canada.
`
`Library of Congress Cataloging-in-Publication Data
`Brookshear, J. Glenn.
`Computer science : an overview/ J. Glenn Brookshear. - 4th ed.
`p.
`cm.
`Includes bibliographical references and index.
`ISBN 0-8053-4627-9
`1. Computer science.
`QA76.B743 1993
`004-dc20
`
`93-24520
`CIP
`
`I. Title.
`
`12345 678910-DOCR-97 96 95 94 93
`
`The Benjamin/Cummings Publishing Company, Inc.
`390 Bridge Parkway
`Redwood City, CA 94065
`
`Facebook's Exhibit No. 1017
`Page 6
`
`

`

`PREFACE
`
`I wrote thi book to provide a comprehen ive overview of computer science, one that
`pre ems a thought-provoking introduction to the key i ues and concepts throughout
`the field. 1 have done thi with rwo primary audiences in mind.
`
`Computer Science Majors
`
`The first audience consi ts of computer cience major and minors in the early stage
`of their college careers. Students at this stage tend to equate computer science with
`programming because that i essentially all they have een. Yet computer science is
`much more than programming. In turn beginning computer science students need to
`b exposed to the breadth of the subject in which they are planning to major.
`Providing chi exposure i che purpose of chi book. It give
`tudents an overview of
`computer ci nee-a foundation from which they can understand the relevance and
`interrelation hips of future courses. Without such a perspective,
`tudents easily
`become immer ed in the details of specialized course and never understand the true
`cope and dynamics of che field. In hart this book represents the application of
`top-down mcthodologie , a taught within che curriculum, co the computer science
`curriculum itself.
`A lot ha happened since the first edition of this book. Today, the computer-
`cience-is-much-more-than-programming philosophy is widely endor ed, as wit(cid:173)
`nessed by the famous Denning Report and, more recently, che report of the
`ACM/IEEE-CS Joint Curriculum Task Force. Those who ubscribe co this movement
`will be plea ed that this fourth edition continues the tradition of the preceding ones
`in that its content conforms closely to the subject areas of computer science a
`identified in the e report . This text provides students of computer cience with an
`accessible introduction to chc breadth of their subject, all within a ingle volume.
`
`Students of Other Disciplines
`
`I also designed trus book with majors of others fields in mind. Too often, these
`students are channelled into courses that teach them merely how co use some software
`packages or provide an elementary introduction co programming. Unfortunately, the
`subject matter of these course is often time-sensitive, limited in portability, or not
`
`V
`
`Facebook's Exhibit No. 1017
`Page 7
`
`

`

`vi
`
`PREFACE
`
`developed to a depth to be useful outside the classroom. Any benefits from such
`courses dissipate quickly after the semester is over.
`I believe that these students are seeking "computer literacy," which I loosely
`define as the ability to distinguish between computer science and science fiction.
`Providing this level of "literacy" in their respective fields is the purpose of such
`courses as general chemistry, biology, and physics. Students do not take these courses
`to develop specific skills. Rather, the major goal is to develop an understanding of the
`discipline- including its scope, major results and consequences, research techniques,
`and the current status of the field. The fact that a student might be required to develop
`certain skills while taking the course is merely a temporary consequence. The true
`benefit of the course - obtaining an overall picture of the subject-survives long after
`these specific items have been forgotten.
`Why, then, do we insist that a computer science course for nonmajors emphasize
`skills? The goal should be to present an overall picture of the science, which is exactly
`what I have designed this book to provide. After caking a course based on this text,
`a student will have obtained an understanding of the science behind today's
`computerized society. This understanding w ill remain long after the details and skills
`"memorized" during the semester have dissipated. Indeed, the student will have been
`educated rather than trained.
`
`The Fourth Edition
`
`In addition to numerous minor changes designed to update, correct, or generally
`improve the text, this fourth edition differs from the third in the following, more
`significant ways.
`
`•
`
`The role of abstraction and abstract tools is explicitly presenting as a recurring
`theme.
`Ties to social, ethical, and professional issues have been expanded.
`The material on networks in Chapter 3 has been expanded to include an
`introduction to the OSI reference model and its significance.
`The material on parallel computing has been expanded , including a new section
`on parallel programming using the Linda primitives in Chapter 5.
`A new section in Chapter 6 discusses the role of metrics in software engineering.
`The object-oriented paradigm has been given additional emphasis by means of
`specific examples using Ada and C + + in Chapter 7 and a new section on
`object-oriented databases in Chapter 9.
`Significantly more exercises have been added.
`•
`• Manuals for closed laboratories are now available m the languages Pascal
`and C.
`
`•
`•
`
`•
`
`•
`•
`
`Facebook's Exhibit No. 1017
`Page 8
`
`

`

`PREFACE
`
`vii
`
`Pedagogical Features
`
`This.text i the product of many years of teaching the material. As a result it is rich
`in pedagogical aid . Paramount in this regard i the abundance of problems to enhance
`rhe student' participation. Each section within a chapter do e with everal
`Questions/Exerci e to chaUeoge students to think independently. They review the
`material just cli cu ed, extend the previou di cu
`ion or hint at related topic to be
`covered later. These questions are answered in Appendix F.
`Each chapter concludes with a collection of Chapter Review Problems. Th se
`problems are designed to serve as "homework" problems in that they call for specific
`answers, can be solved in a short period of time, and are not answered in the text.
`Following the Chapter Review Problem are Problems for the Programmer.
`These problem are designed for student who al ready have a programming
`background and
`erve
`to enhance
`the
`tudenr'
`problem-solving/program(cid:173)
`development kill a weU as provide additional insights into the material in the
`chapter. 1£ de ired many of these problems can be expanded into programming
`projects. The e problems are an excellent resource when the book i used as a text for
`a course following the traditional introductory programming course.
`Another pedagogical aid is the use of optional sections. These sections are
`marked in the table of contents. The fact that a ectiou i declared optional doe not
`mean that its material is necessarily more difficult or should be skipped. It merely
`means that the material in later (nonoptional) ections does not rely on the e sections.
`The purpose of identifying the.se sections is to allow students to reach later portions
`of the text more quickly than would otherwi e be possible. For example, many
`instructor may wi h to skip or po tpone much of the material on machine
`architecture and operating systems in order to spend more time on algorithm
`development and representation as di cus ed in chapters 4 and 5. The u e of optional
`sections allow for this change yet leave the material available for the more inquisitive
`students or courses with different goals.
`
`Laboratory Materials
`
`Supplementary laboratory manual that are coordinated with the text are available for
`courses with an introductory-level programming component. These manual , one for
`the language Pa cal and the other for C are designed for a closed laboratory that meets
`once a week for approximately two hours. Each manual contains material for 16
`laboratory sessions (many are optional) that teach the rudiments of the particular
`programming language and provide experiments that reinforce material in the parent
`text.
`Each laboratory ession consists of explanatory material, activities for the tudent
`
`Facebook's Exhibit No. 1017
`Page 9
`
`

`

`viii
`
`PREFACE
`
`that are presented in a true experiment format th:tt encourages investigation, and
`post-laboratory problems that ask students to apply their knowledge outside the
`closed laboratory environment.
`The laboratory manuals are supported by software that is available from The
`Benjamin/Cummings Publishing Company via the Internet using ftp. The address is
`be.aw.com. When asked for a name, respond by typing anonymous; when asked for
`a password, respond with your own address. From the directory in which you will
`be placed, the software is two directories down along the path bc/brookshear. (For
`non-UNIX readers, you get to this directory by typing cd bdbrookshear.) For more
`details, consult the OOREADME file in the brookshear directory. (Again, for the
`non-UNIX crowd, type get OOREADME to download this file to your local environment
`and type bye to terminate the connection.)
`
`Acknowledgments
`
`With each new edition, the list of those who have contributed through their
`suggestions and comments continues to grow. Today this list includes J. M. Adams,
`D. C. S. Allison, P. Bankston, M. Barnard, K. Bowyer, P. W. Brashear, C. M. Brown,
`B. Calloni, M. Clancy, D. H. Cooley, F. Deek, M. J. Duncan, N. E. Gibbs,]. D. Harris,
`D. Hascom, P. Henderson, L. Hunt, L.A. Jehn, K. Korb, G. Krenz, T.J. Long, C. May,
`S. J. Merrill, J. C. Moyer, J. Paul Myers, Jr., G. Rice, N. Richert, J. B. Rogers, J. C.
`Simms, M. C. Slattery, J. Slimick, D. Smith, J. Solderitsch, L. Steinberg, J. Talburt, P.
`Tromovitch, and M. Ziegler. To these individuals I give my sincere thanks. A special
`thank you goes to Phil Bender and Jody Jung for writing the laboratory manuals.
`As in the case of the earlier editions, I also thank my family, Earlene and Cheryl,
`for their support. They have seen how the development of a manuscript can expand
`to dominate an author's time. I thank them for their understanding and patience.
`
`J.G.B.
`
`Facebook's Exhibit No. 1017
`Page 10
`
`

`

`CONTENTS
`
`Introduction
`0-1
`The Study of Algorithm
`0- 2
`The Development of Algorithmic Machine
`0-3
`Modern Machine Architecture
`0-4
`The Evolution of Computer Science
`Additional Reading
`
`PART ONE MACHINE ARCHITECTURE
`
`Chapter 1
`
`Chapter 2
`
`Data Storage
`1-1
`Main M emory
`1-2
`Mass Storage
`1-3
`Coding Information for Storage
`1-4•
`The Binary System
`1-5•
`Storing Integers
`1- 6*
`Storing Fractions
`1- 7*
`Communication Error
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`Data Manipulation
`2- 1
`The Central Processing Unit
`2-2
`The Stored-Program Concept
`2- 3
`Program Execution
`2-4*
`Other Architectures
`2- 5*
`Arithmetic/Logic In tructions
`2- 6*
`Computer/Peripheral Communication
`Review Problems
`Problem for the Programmer
`Additional Reading
`
`1
`1
`5
`9
`12
`14
`
`15
`
`17
`18
`23
`29
`33
`36
`44
`47
`52
`55
`55
`
`57
`58
`62
`66
`71
`75
`80
`85
`88
`89
`
`• Sections marked by an asterisk are optional in that they provide additional depth of coverage
`thar i nor n:quired for an understanding of future chapters.
`
`ix
`
`Facebook's Exhibit No. 1017
`Page 11
`
`

`

`X
`
`CONTENTS
`
`PART TWO SOFTWARE
`
`Chapter 3
`
`Chapter 4
`
`Chapter 5
`
`Operating Systems
`3-1
`Functions of Operating Systems
`3-2
`Virtual Characteristics and Abstraction
`3-3
`The Evolution of Operating Systems
`3-4*
`Operating System Architecture
`3-5*
`Rudiments of Time-Sharing
`3-6*
`Resource Allocation
`3-7*
`Getting It Started
`3-8*
`A Closer Look at Networks
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`Algorithms
`4-1
`Definition
`4-2
`Algorithm Representation
`4-3
`Algorithm Discovery
`Iterative Structures
`4-4
`4-5
`Recursive Structures
`4-6
`Efficiency and Correctness
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`Programming Languages
`5-1
`Historical Perspective
`5-2
`Language Implementation
`5-3
`Programming Language Design
`5-4
`Procedural Language Components
`5-5 *
`Parallel Computing
`5-6*
`Declarative Programming
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`Chapter 6
`
`Software Engineering
`6-1
`The Software Engi neering Discipline
`6-2
`The Software Life Cycle
`6-3
`Modularity
`
`91
`
`93
`94
`97
`99
`105
`109
`112
`116
`118
`127
`129
`130
`
`131
`132
`133
`142
`148
`158
`173
`182
`186
`186
`
`187
`188
`197
`201
`206
`229
`232
`238
`241
`242
`
`243
`244
`246
`250
`
`Facebook's Exhibit No. 1017
`Page 12
`
`

`

`CONTENTS
`
`xi
`
`6-4
`6-5
`
`Development Tools and Techniques
`Documentation
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`PART THREE DATA ORGANIZATION
`
`Chapter 7
`
`Chapter 8
`
`Chapter 9
`
`Data Structures
`7-1
`Arrays
`7-2
`Lists
`7-3
`Stacks
`7-4
`Queues
`7-5
`Trees
`7-6
`Abstract Data Types
`7-7 ..
`Object-Oriented Programming
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`File Structures
`8-1
`Sequential Files
`8-2
`Text Files
`8-3
`Indexed Files
`8-4
`Hashed Files
`8-5
`The Role of the Operating Sy tern
`Review Problems
`Problems for the Programmer
`Additi.onal Reading
`
`Database Structures
`9-1
`General Issues
`9-2
`The Layered Approach to Dacaba e
`Implementation
`The Relational Model
`The
`etwork Model
`Object-Oriented Databases
`Concurrency Control
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`9-3
`9-4•
`9-s•
`9-6*
`
`255
`261
`263
`266
`266
`
`267
`
`269
`270
`273
`280
`284
`289
`298
`302
`306
`310
`310
`
`311
`312
`317
`319
`324
`330
`332
`334
`334
`
`335
`336
`
`339
`342
`352
`360
`363
`368
`372
`372
`
`Facebook's Exhibit No. 1017
`Page 13
`
`

`

`xii
`
`CONTENTS
`
`PART FOUR THE POTENTIAL OF ALGORITHMIC
`MACHINES
`
`Chapter 10
`
`Chapter 11
`
`Artificial Intelligence
`10-1
`Some Philosophical Issues
`10-2
`Image Analysis
`10-3
`Reasoning
`10-4
`Control Sy tern Activities
`10-5
`Using Heuristics
`10-6
`Artificial Neural Networks
`10-7
`Applications of Artificial Intelligence
`Review Problems
`Problems for the Programmer
`Additional Reading
`
`Theory of Computation
`11-1
`A Bare Bones Programming Language
`11-2
`Turing Machines
`11- 3
`Computable Functions
`11-4
`A Noncomputable Function
`11-5
`Complexity and Its Measure
`11-6
`Problem Classification
`Review Problems
`Problem for the Programmer
`Additional Reading
`
`Appendix A
`
`Popular Codes
`
`Appendix B
`
`A Typical Machine Language
`
`Appendix C
`
`Insert.ion Sort in Assembly Language
`
`Appendix D
`
`Syntax Diagrams for Pascal
`
`Appendix E
`
`The Equivalence of Loop and Recursive
`Structures
`
`Appendix F
`
`Answers to Questions/Exercises
`
`Index
`
`375
`
`377
`378
`382
`384
`388
`393
`399
`405
`412
`415
`415
`
`417
`418
`424
`428
`432
`437
`444
`449
`451
`452
`
`454
`
`455
`
`457
`
`459
`
`469
`
`471
`
`499
`
`Facebook's Exhibit No. 1017
`Page 14
`
`

`

`CHAPTER FIVE •PROGRAMMING LANGUAGES
`
`209
`
`>erations and
`greater than
`:s other than
`s allowed on
`~pe character
`red in ASCII
`Bch as testing
`
`ician George
`true or false.
`~olding7 or as
`Section 3-6.
`se value and
`item of type
`
`Bey allow the
`ive part of a
`
`s containing
`:eger values
`ion in Pascal
`
`is beneficial
`er trying to
`
`e operation
`red. Indeed,
`makes little
`e all of type
`instruction,
`d,
`
`Sometimes the action requested by a program may be meaningful even though
`the data types involved are not the same. For instance, the above instruction makes
`sense if Price and Tex are integer but Total is real. In this case, the compiler uses the
`]nteger addition instrucrion, but the sum must be recoded into floating-point format
`before being assigned to Total. Such implicit conversion between types is called
`coercion.
`Coercion is frowned on by many language designers. They reason that the need
`for conversion usually indicates an error in the program's design and therefore should
`not be accommodated by the translator. The result is that most modern languages are
`strongly typed, which means that all activities requested by a program must involve
`data of agreeable types without coercion. In turn, compilers for these languages report
`all type conflicts as errors.
`
`Data Structure
`Another major concept associated with data is structure, which relates to the
`conceptual shape of the data. Perhaps the simplest example of this occurs when using
`a string of characters to represent an employee's name or a part identification number.
`It is not sufficient to know that the data item is of type character, but one must also
`know how many characters make up the item. If a translator must generate the
`machine instructions to move an employee's name from one location in memory to
`another, it must know how many memory cells to move. Thus, a FORTRAN program
`might contain the phrase
`
`CHARACTER(LEN = 8) Name
`
`indicating that Name is to refer to a string of eight characters. The same information
`would be expressed Ada as
`
`Name: STRING~1..8~;
`
`Another common example of structured data is an array. The term array refers
`to a block of values such as a list (often called avector), atwo-dimensional table (a
`matrix), or tables of higher dimensions (these do not have special names). Elements
`of an array normally are identified within a program through the use of indices. That
`is, the third entry in a vector named Sales is referenced by the expression Sales (3~, and
`the entry from the second row and fifth column of a matrix named Scores is identified
`by Scores~2,5~. (A minor exception is found in the C language, in which row and
`column numbers start at 0 rather than 1. Hence, in C, the entry in the second row
`and fifth column is identified by Scores [i][4].) Note that it is customary to list the row
`number before the column number.
`To describe an array in the declarative part of a program, most languages use a
`syntax similar to that used for referring to the array later in the program's procedural
`
`~~ —
`
`Facebook's Exhibit No. 1017
`Page 15
`
`

`

`270
`
`PART THREE • DATA ORGANIZATION
`
`W,e have used the terms virtual and conceptual several times in reference to properties
`that, akhough appearing ro belong to hardware, are actually simulated through a
`combination of hardware and software. For example, we saw that a ingle machine
`can appear to be many machines through the use of a time-sharing system or that a
`machine can appear co understand the words in a high-level programming language
`by means of an interpreter. This chapter is concerned with another conceptual feature,
`the structure (or organization) of data.
`Recall that any information stored in a machine's memory must be organized to
`fit into a row of memory cells, even though this data may be more useful as a
`rectangular table of values. In this case, our problem is to simulate the rectangular
`shape using the tools provided by the machine. The goal is to allow the user of the
`data to think of the data as having this simulated shape wid10ut being concerned with
`the data's actual organization within the machine.
`
`7-1 Arrays
`
`We begin our study of data structures by considering the organizations known as
`arrays encountered earlier in our discussion of high-level programming languages.
`There we saw that many high-level languages allow a programmer to express an
`algorithm as though the data being manipulated were stored in a rectangular
`arrangement; the programmer might refer to the fifth element in a one-dimensional
`array or the element in the third row and sixth column of a two-dimensional array.
`Since the array is actually stored in rhe memory cells of the machine, it becomes the
`job of either the translator or the interpreter co convert such references into the
`terminology of memory cells and addresses.
`
`One-Dimensional Arrays
`Suppose an algorithm for manipulating a series of 24 hourly temperature readings is
`expressed in a high-level language. The programmer would probably find it
`convenient to think of the e readings arranged as a one-dimensional array, that is, a
`list called Readings whose various entries are referenced in terms of their position in
`the list. This position is often called an index. The first reading might be referenced
`by Readings[!] , the second by Readings[2J, and so on.
`The conversion from the conceptual one-dimensional array organization to the
`actual arrangement within the machine can be rather straightforward. The data can
`be stored in a sequence of 24 memory cells in the same order envisioned by the
`programmer. Knowing the address of the first cell in this sequence, an interpreter or
`translator can then easily convert terms such as Readlngs[4J, into the proper memory
`terminology. In this case, to find rhe actual address, one merely subtracts one from
`the position of the desired entry and then adds the result to the address of the first
`
`Facebook's Exhibit No. 1017
`Page 16
`
`

`

`CHAPTER SEVEN• DATA STRUCTURES
`
`271
`
`Figure 7 • I The array of Readings stored in memo,y starting at address 13
`
`Addresses
`
`' - - 13
`
`14
`
`IS
`
`16
`
`17
`
`18
`
`19
`
`M~~r~,y{~I I I I I I I 11
`ReadITTQ, II I _j t 1
`
`Readings {2)
`Readings [3)
`Readings (4) _ _____ __,
`
`ceH in the sequence. (If the first cell in the sequence is at address 13 the reading
`referenced by Readlngs[4] is located at location 13 + (4 - 1) = 16, a
`hown in
`Figure 7-1.)
`
`Multidimensional Arrays
`imple with multidimensional array . Con ider, for
`The conversion i not quite o
`example, a record of the ales made by a company' aJes force during a one-week
`period. We can chink of such data arranged in tabular form, with the names of the
`the top.
`sales personnel listed down the left side and the days of the week listed aero
`Hence we can think of the data being arranged in row and column ; the value across
`each row indicate the sale made by a particular employee, while the value down a
`column represent all the sale made during a particular day. Extracting information
`from the table therefore involves finding the value common to both a given row and
`a given column.
`A machine' memory i arranged not in a rectangular fashion but rather a a row
`of memory cells; thus, the rectangular structure required by the sales table must be
`simulated. To do this, we fir t recognize that the ize of the array doe not vary as
`update are made. We can therefore calculate the amount of storage area needed and
`reserve a block of contiguou memory cell of that ize. Next, we score the data in
`the cell row by row. That i , starring at the first cell of the reserved block, we copy
`the values from the first row of the table into consecutive memory locations· following
`this we copy the next row then the next and so on (Figure 7-2, on the following
`page). Such a storage system is said to use row major order in contrast co column
`major order, in which the array is stored column by column.
`With the data stored, the problem now become locating particular entries as
`they are requested. Recall that because the user will be thinking in terms of rows and
`column , a request will be in the form of wanting, for example, the value of the entry
`in the third row and! fourth column (that is, the sales made by the third employee on
`
`Facebook's Exhibit No. 1017
`Page 17
`
`

`

`COMPUTER SCIENCE: AN OVERVIEW, Fourth Edition • J. Glenn Brookshear, Marquette University
`
`ISBN 0-8053-4627-9
`Q n (l n n
`IIII IIIIJllll llll lllll 111 11 111
`II I I II II IIIII I I 1111111111111111
`Warehouse - BK\05 13122
`Computer Science: An 01er1iew ... gs Seri es in Computer Science)
`(uG) _s_ mI
`Used, Good
`
`Facebook's Exhibit No. 1017
`Page 18
`
`