Index

A

Absolute addressing manual, 207 pointers and, 297

problems with, 40, 42 Abstract cells, 209

Abstract classes

in Ada, 561–562 in C++, 547

introduction to, 529 in Java, 555

Abstract data types

design issues for, 478–479 floating-point as, 476 introduction to, 474

in Ada, 482–485, 503–504 in C++, 485–490,

505–506 in C#, 497–499

in C# 2005, 509

in Java, 496–497, 506–509 in Java 5.0, 506–509

in Objective-C, 490–496 parameterized, 503–509 problem set on, 520–521 in Ruby, 499–503

for stacks, 478

summary of, 517–518 user-defined, 476–478

Abstract methods, 529

Abstraction

beginnings of, 72–73 in BNF, 118

in imperative programming languages, 204

support for, 14, 21

Accept clause body, 595 Accept clauses, 595–600

Access

deep vs. shallow, 462–466 to heaps, 289

in nested subprograms, 454–460

nonblocking synchronized, 612 in subprogram linkage, 442 types, 293

ACM (Association for Computing Machinery)

GAMM and, 53, 117

Grace Murray Hopper Award of, 480, 536

Turing Award of, 672

Activation record instances, 444–445

774 Index

Activation records, 444–445

Active subprograms characteristics of, 389

in referencing environments, 231

stack-dynamic local variables and, 448

Actor tasks, 596 Actual parameters, 392

Ad hoc binding, 418–419 Ad hoc polymorphism, 422 Ada

95 version of. see Ada 95

2005 version of, 84–85 abstract data types in,

482–485, 503–504 competition synchronization in,

599–601

compiler implementation in, 25

concurrency in, 21, 594–603 continuation in, 638–639 cooperation synchronization

in, 599 costs of, 17

design process for, 81–82 encapsulation constructs in,

482

evaluation of, 83–84 exception handling in, 16,

636–643

historical background of, 81 information hiding in,

482–483

language overview of, 82–83 packages in, 512, 516 pointer types in, 293

priorities of tasks in, 601–602 protected objects in, 602–603 task termination in, 601

Ada 95

child packages in, 562 dynamic binding in, 561–562 inheritance in, 559–560 introduction to, 84–85

object-oriented programming in, 21, 558–563

Addresses

fields for, 687

of simple subprograms, 443–445

of stack-dynamic local variables, 445–449

of variables, 208 Adopting protocols, 551

Aggregate values, 265 Aho, Al, 95

AI (artificial intelligence) introduction to, 6 LISP in, 47–48, 50 Project at MIT, 680

ALGOL 58

design process for, 53–54 overview of, 54

report on, 55 ALGOL 60

ALGOL 58 vs., 53–55 BNF in, 117–118

design process for, 55–56 evaluation of, 56–58 historical background of, 53 introduction to, 4–5, 52 overview of, 56

ALGOL 68

design process for, 73 evaluation of, 74–75 language overview of, 74 orthogonality in, 11, 73

ALGOL Bulletin, 55

Aliases, 208

Aliasing, 16

Allocation, 214, 532–533

Ambiguous grammars, 122–123 AND operators, 333–336

and then operators, 15, 336

Anonymous variables, 290 ANSI (American National Standards Institute)

on Ada, 82 on C, 78

Minimal BASIC standard of, 64

Antecedents, 149, 731–732 APES system, 758

APL (A Programming Language) as dynamic language,

generally, 71 introduction to, 14–15 origins and characteristics of,

71–72 trade-offs in, 23

append operations, 747–750 Apple, 90

Apply-to-all functional forms, 676, 697–698

APT (Automatically Programmed Tools), 22

Arithmetic expressions associativity in, 321–323 coercion in, 330–331 conditional, 325

errors in, 332

explicit type conversions and, 331–332

introduction to, 319 in LISP, 324

operand evaluation order in, 319–325

operand evaluation order in, 325–328

operator overloading and, 328–329

parentheses in, 323–324 precedence in, 319–321 in Prolog, 743–746

referential transparency in, 327–328

in Ruby, 324

side effects in, 325–328

type conversions and, 329–332

Array types

array initialization in, 264–265 array operations in, 266–267 categories in, 262–264

design issues for, 260

evaluation of, 269 formal parameters, 394

implementation of, 269–272 indices and, 260–262 introduction to, 259–260 jagged arrays in, 267–268 rectangular arrays in,

267–268 slices in, 268–269

subscript bindings in, 262–264

Artificial intelligence (AI). see AI (artificial intelligence)

ASCII (American Standard Code for Information Interchange), 249

Assemblies, .NET, 512

Assertions

in axiomatic semantics, 148–149

in Java, 653–654 Assignment statements

in axiomatic semantics, 150–152

compound assignment operators in, 337

conditional targets and, 337 in denotational semantics, 146 as expressions, 339–340

in functional programming languages, 340–341

introduction to, 318 mixed-mode, 341 multiple, 340

problem set on, 343–345 programming exercises on,

345–346

review questions on, 342–343 simple, 336–337

summary of, 341–342

syntax of, 118, 121–122, 127 unary assignment data types

in, 338–339 Association for Computing

Machinery (ACM), 53

Associative arrays implementation of, 276 introduction to, 272 structure and operations of,

272–276

Associativity, 126–128, 321–323

Atomic propositions, 729

Atoms, Prolog, 737

Attribute computation functions, 133

Attribute grammars

basic concepts of, 133–134 computing attribute values in,

137–138 defined, 134

evaluation of, 138–139 examples of, 135–136

intrinsic attributes in, 134–135 introduction to, 132–133 static semantics and, 133

Attributes

binding, 209–210 defined, 133 instance data as, 501 intrinsic, 134–135

Automatic generalization, 427 Automatic programming, 41 Automatically Programmed Tools

(APT), 22

awk scripting language, 95

Axiomatic semantics assertions in, 148–149 assignment statements in,

150–152 evaluation of, 160–161 introduction to, 148 logical pretest loops in,

154–158

program proofs in, 158–160 selection in, 153–154 sequences in, 152–153 weakest preconditions in,

149–150

Axioms, 149

B

B, language, 77

Babbage, Charles, 82, 388

Backtracking, 742 Backus, John

Fortran by, 20, 41–43

on functional vs. imperative languages, 672–673

on syntax, 117

Backus-Naur Form (BNF). see

BNF (Backus-Naur Form) Backward chaining, 741–742 base prefix, 557

BASIC

design process for, 63–64 evaluation of, 64–65 introduction to, 18 timesharing in, generally, 63

BASIC-PLUS, 64 Bauer, Fritz, 53

BCD (binary coded decimal), 248 Bell Laboratories. see AT&T Bell

Laboratories

BINAC computer, 40

binary coded decimal (BCD), 248

Binary operators, 319

Binary semaphors, 589

Binding

ad hoc, 418–419 attributes to variables,

209–210 deep, 418–419

dynamic. see Dynamic binding dynamic type, 212–214 exceptions to handlers, Ada,

637–638

exceptions to handlers, C++, 644

exceptions to handlers, Java, 648–649

explicit heap-dynamic variables in, 216–218

implicit heap-dynamic variables in, 218

introduction to, 204

776 Index

Binding (continued) lifetime of, 214–215 overview of, 209–210 shallow, 418–419

stack-dynamic variables in, 215–216

static type, 211–212 static variables in, 215 storage, 214–215 subscript, 262–264 type, 210–214

Binding time, 209 BLISS, 6

Blocked tasks, 584

Blocks

in Ruby, 374

for scope, 220–223

in subprograms, implementing, 460–462

Block-structured language, 56, 220

BNF (Backus-Naur Form) analyzing syntax in, 169 describing lists in, 119 expressions in, 145 Extended, 129–132 fundamentals of, 118–119 if-then-else statements

in, 128–129 introduction to, 55–57 static semantics in, 133 syntax and, 117–118

Body packages, 482–484 Böhm, Corrado, 350, 379

Boolean abstract data types, 497–498

Boolean data types, 249

Boolean expressions, 332–335, 340 boolean type variables, 92, 255,

612

Borland JBuilder, 31

Bottom-up parsers introduction to, 180

LR parsers and, 193–197 problem for, 190–192

systems software in, 6 trade-offs in, 23

Call chains, 450 Calls

dynamic binding of method, 566–568

indirect, 419–421

semantics of subprogram,442

Cambridge Polish, 679

Cambridge University, 77 Camel notation, 205 Caml, 52

canonical LR algorithm, 193 CAR functions, 687–688,

691–694

Case expressions, 357–359

Case sensitivity, 206

case statements, 75, 359–361 catch, 643, 648–649 Category interfaces, 550

C-based languages, 204–206 CBL (Common Business

Language), 59

CDE (Solaris Common Desktop Environment), 31

CDR functions, 687–688, 691–694

Celes, Waldemar, 100

central processing units (CPUs), 18–19

CGI (Common Gateway Interface), 97, 99

chain_offset, 455 Chambers, Craig, 548 char arrays, 250–251, 265 char ordinal types, 255

Character string types design issues for, 250 evaluation of, 253

implementation of, 253–255 string length options in,

252–253

string operations in, 250–252 type checking in, 302–303

Checked exceptions, 650

778 Index

Concurrency (continued) cooperation synchronization in,

586–589, 591–592 cooperation synchronization in,

Ada, 599

cooperation synchronization in, Java, 608–611

design issues for, 585–586 explicit locks in, Java 5.0,

612–613 in F#, 620–621

in functional languages, 618–621

in High-Performance Fortran, 621–623

introduction to, 21, 576–581 in Java threads. see Threads language design for, 585 message passing in, 593–594 monitors in, 591–593

in Multilisp, 618 multiprocessor architectures

in, 577–579 nonblocking synchronization

in, 612

protected objects in, 602–603 reasons for using, 580–581 semaphores in, 586–590, 607 statement-level, 621–623 subprogram-level, 581–586 synchronizing threads in,

616–617

synchronous message passing in, 593–594

task priorities in, 601–602 task termination in, 601 thread priorities in, 606–607

Concurrent Pascal, 591 Concurrent ML (CML), 619 Conditional expressions, 325, 708 Conditional targets, 337

Conjunctions, 738

CONS function, 688–694 Consequents, 149, 731–732 const constants, 233

Constrained variant variables, 285–287

Constraint_Error

exceptions, 639–642

Constructors, 487

Context-free grammars, 117–118 Continuation, 634–635

Control expressions, 350 Control flow, 685–686

Control statements, 348 Control structures, 349 Cooper, Alan, 66 Cooper, Jack, 82

Cooperation synchronization in Ada, 599

in concurrency, 586–589 introduction to, 581–585 in Java, 608–611

with monitors, 591–592 with semaphores, 586–589

Coroutines, 73, 432–435 Costs of languages, 16–18 Counter-controlled loops, 363,

367–368 in Ada, 364

in C-based languages, 364–366

in functional languages, 367–368

in Python, 366–367 Cox, Brad, 90

CPUs (central processing units), 18–19

CSP (Communicating Sequential Processes), 597

Currie, Malcolm, 81

Currying, 706

Cut Prolog, 752–753

D

Dahl, Ole-Johan, 72–73

Dangling pointers, 292–293 Dangling references, 294

Data abstraction. see Abstraction Data members, 486, 539

Data structures, 371–375

Data types

array. see Array types associative array, 272–276 boolean, 249

character, 249–250 character string, 250–255 complex, 248

decimal, 248–249 equivalence in, 304–308 floating point, 247–248 integer, 246–247 introduction to, 12, 244–246 in LISP, 677–678

list, 281–284 numeric, 246–249 ordinal, 255–258

pointer, 289–295, 297–302 primitive, 246–250 problem set on, 314–315 programming exercises on,

315–316 record, 276–280

reference, 290, 295–302 review questions on, 312–313 string length options in,

252–253 string operations in,

250–252

strong typing, 303–304 summary of, 310–311 theory and, 308–310 tuple, 280–281

union, 284–289 Dead tasks, 584

Deadlocks, 585 Deallocation, 214, 532–533 Decimal data types, 248–249 Declaration order, 223–224

Declarative languages, 728, 734–735

declare blocks, Ada, 263

Decorating parse trees, 137 Decrement fields, 687

Deep access, 462–464

Deep binding, 418–419 Deferred reference counting,

299–300

Definitions

in COBOL, 60

of functions, 682–684

in subprograms, 389–391

Delegates, 420–421 delete

in associative arrays, 273 in C++, 291–293, 486 data types, 263

explicit deallocation using, 538 Delphi, 90

Denotational semantics assignment statements in, 146 evaluation of, 147

examples of, 143–145 expressions in, 145–146 introduction to, 142–143 logical pretest loops in, 147 state of programs and, 145

Department of Defense (DoD), 59–61, 81

Dependents, 601 Depth-first searches, 742

Dereferencing pointers, 291 Derivations, 119–121

Derived classes, 526, 540–544 Derived types, 306 Descriptors, 245

Design issues

for abstract data types, 478–479

for array types, 260

for character string types, 250 for concurrency, 585–586

for exception handling, 633–636 for functions, 428–429

for iterative statements, 363 for multiple-selection

statements, 354–355 for names, 205

for object-oriented programming, 529–534

for pointer types, 290

for subprograms, 396–397, 413–414

trade-offs, 23

for two-way selection statements, 350

for union types, 285

Destructors, 487 Diamond inheritance, 531

Dictionaries, 99, 273 Dijkstra, Edsger

guarded commands by, 376–379, 593

on PL/I, 70 semaphores by, 586

on synchronization operations, 591

Direct left recursion, 187 Discriminated unions, 285–287 Disjoint tasks, 581

dispose, 298

DLLs (dynamic link libraries), 67, 512

DO CONCURRENT constructs, 45 do-while statements,

369–370

DoD (Department of Defense), 59–61, 81

Dot notation, 278–279

Double floating-point data types, 247

Dynabook, 86

Dynamic binding

in Ada 95, 561–562 in C#, 557–558

in C++, 544–547 introduction to, 210 in Java, 555

of method calls to methods, 566–568

in Objective-C, 551–552

in object-oriented programming, 527–529, 533

in Ruby, 565

in Smalltalk, 535

Dynamic chains, 450

Dynamic dispatch. see Dynamic binding

Dynamic languages, 68–71

Dynamic length strings, 253–255

dynamic link libraries (DLLs), 67, 512

Dynamic links, 446 Dynamic scoping, 227–229,

462–466

Dynamic semantics

axiomatic semantics as. see

Axiomatic semantics denotational semantics as,

142–147 introduction to, 139 operational semantics as,

139–142

Dynamic type binding, 212–214, 303, 569

Dynamic type checking, 303

E

Eager approach, 299

EBNF (Extended BNF), 129–132, 181–182

ECMA (European Computer Manufacturers Association), 97

Edinburgh syntax, 737 Edwards, Daniel J., 680 Eich, Brendan, 97

Elaboration, 215

Elemental operators, Fortran 95+, 266

Elliptical references, 279 else-if clause, 360–361 Encapsulation constructs

in Ada, 482, 512, 516 in C, 510–511

in C#, 498, 512–513 in C++, 486, 511–512,

514–515

780 Index

Encapsulation (continued) introduction to, 474,

509–510

in Java, 515–516 naming, 513–517

in Objective-C, 490–492

in Ruby, 499, 516–517 summary of, 517–518

entry clauses, 595

Enumeration constants, 255

Enumeration types in C, 308

in C#, 102

in C++, 256, 258 designing, 255–257 evaluation of, 257–258 introduction to, 255

Environment pointers (EPs), 442–448

Epilogue of subprogram linkage, 443–448

EPs (Environment pointers), 442–448

EQ? functions, 689–690, 693

Equivalence, 304–308 Erasure rule, 187

Errors

in arithmetic expressions, 332 in assignment statements,

146–147

in recursive-descent parsers, 183–184

European Computer Manufacturers Association (ECMA), 97

EVAL, 690, 698–699

Evaluation environments, 702

Event handling

bibliographic notes on, 665 in C#, 661–664

introduction to, 630, 655–656 in Java, 656–660

summary of, 664–665

Event listeners, 657

Events, 619, 655

Exception handling in Ada, 636–643

basic concepts of, 631–633 bibliographic notes on, 665 in C++, 643–647

design issues for, 633–636 introduction to, 16, 630–631 in Java, 647–655

summary of, 664–665

Exceptions, 332, 631 Exclusivity of objects, 529–530

Executable images, 27 expected_type, 136 Expert systems, 757–758

Explicit declarations, 211 Explicit heap-dynamic variables,

216–218

Explicit locks, Java 5.0, 612–613, 617

Explicit type conversions, 331–332

Expressions

arithmetic. see Arithmetic expressions

assignment statements as, 339–340

Boolean, 333–335

in denotational semantics, 145–146

introduction to, 318 mixed-mode, 330–331

in recursive-descent parsers, 182–185

relational, 332–333 short-circuit evaluation of,

335–336 summary of, 341–342

unambiguous grammar for, 125

Expressivity, 14–15

Extended accept clauses, 598 Extended ALGOL, 6

Extended BNF (EBNF), 129–132, 181–182

eXtensible Stylesheet Language Transformations (XSLT), 22

extern qualifiers, 224

F

F#, 620–621, 712–715 Fact statements, 737–738 Farber, J. D., 72

Fatbars, 377

Feature multiplicity, 9 Fetch-execute cycles, 19

FGCS (Fifth Generation Computing Systems), 736

Fields, 277

Fifth Generation Computing Systems (FGCS), 736

de Figueiredo, Luis Henrique, 100

filter, 705

final, Java, 233, 553–556 Finalization, 635 finalize methods, 553

finally clauses, 612, 652–653

Finite automata, 171 Finite mappings, 260 Firm coercion, 74

First-order predicate calculus, 729

Fixed heap-dynamic arrays, 262 Fixed stack-dynamic arrays, 262 flex arrays, 74

float

in C, 510

in C#, 498 introduction to, 15

in type checking, 302–303 in type conversions, 329–332

Floating-point data types, 247–248, 476

Floating-point operations, 42, 68 FLOW-MATIC, 59

FLPL (Fortran List Processing Language), 48

Flynn, Michael J., 578

for statements in Ada, 364 in C, 77–78

in C-based languages, 364–366

declaration order and, 224 defined, 12

in Plankalkül, 38

in Python, 366–367

in user-located loop control mechanisms, 372–373

foreach statements

in array processing, 264 in C#, 102

in JSP, 106

in .NET languages, 373–374 Form, 13, 205–206

Formal parameters, 391, 394 Fortran

abstraction support in, 14 Backus designing, 20 design process for, 43 evaluation of, 45–47 evolution of, generally, 42

historical background of, 42–43 introduction to, 4–5

name forms in, 205–207 versions of, 14, 43–45,

204–207

Fortran List Processing Language (FLPL), 48

Forward chaining, 741

FP (functional programming), 673 Free Software Organization, 737

Free unions, 285

Fully attributed parse trees, 134 Fully qualified references, 279

Functional compositions introduction to, 675 operators for, 714 in Scheme, 697

Functional forms, 675–676, 696–698

Functional programming (FP), 673

Functional programming languages assignment statements in,

340–341 bibliographic notes on, 721

Common LISP as, 699–701 concurrency in, 618–621 F# as, 712–715

functional forms in, 675–676

fundamentals of, 676–677 Haskell as, 707–712 imperative languages

supporting, 715–717 imperative languages vs.,

717–719 introduction to, 672–673 LISP as, 677–680

mathematical functions in, 673–676

ML as, 701–707 Scheme as. see Scheme

simple functions in, 674–675 summary of, 720–721

Functions

design issues for, 428–429 in Scheme, 691–694

side effects of, 428–429 as subprograms, 395–396

Functors, 729

future constructs, 618

G

GAMM (German Society for Applied Mathematics and Mechanics), 53

Garbage collection, 299–302 Gates, Bill, 66

Genealogy of languages, 37 General Purpose Simulation

System (GPSS), 22

Generality, 18 Generate and test, 753 Generation, 116–117 Generators, 709

Generic subprograms in C# 2005, 427 in C++, 423–425 in F#, 427–428

introduction to, 397, 422–423

in Java 5.0, 425–426 German Society for Applied

Mathematics and Mechanics (GAMM), 53

getPriority methods, 606 Getter methods, 564

Glennie, Alick E., 42–43 Global scope, 224–227 GNOME, 31

Go, 91

Goals, 739–740 Google, 91 Gosling, James, 92 goto, 195–197

GPSS (General Purpose Simulation System), 22

Grammars

ambiguous, 122–123 attribute. see Attribute

grammars context-free, 117–118 derivations and, 119–121 LL grammar class,

187–190 recognizers and, 132 unambiguous, 125–129 van Wijngaarden, 74

Graphical user interfaces (GUIs). see GUIs (graphical user interfaces)

Griesemer, Robert, 91 Griswold, R.E., 72

Guarded commands, 376–379, 593 Guards, 586

GUIs (graphical user interfaces) defined, 655

in Delphi, 90 UNIX and, 31

782 Index

H

Hammond, P., 758

Handles, 191–192 Harbison, Samuel P., 356 Hashes, 272–273, 276

introduction to, 96 Haskell, 707–712

Headed horn clauses, 734 Header files, 510–511 Headless horn clauses, 734 Heap-dynamic arrays, 263 Heap-dynamic variables, 290 Heaps, 289

Heavyweight tasks, 581 Hejlsberg, Anders, 90, 101

Hidden concurrency, 579 Higher-order functions, 675 High-Order Language Working

Group (HOLWG), 81 High-Performance Fortran (HPF),

621–623 Hoare, C.A.R. on Ada, 83

on language design, 14, 23 message passing by, 593–594 on monitors, 591

Pascal by, 75

HOLWG (High-Order Language

Working Group), 81 Hopper, Grace

award in name of, 480, 536 compiling systems by, 41

on programming languages, 59

Horn clauses, 734

HPF (High-Performance Fortran), 621–623

HTML (HyperText Markup Language)

introduction to, 7, 22 JavaScript and, 97–98 JSP and, 105

PHP and, 99 XML and, 104 Hursley Laboratory, 69

Hybrid implementation systems, 29–30

HyperText Markup Language (HTML). see HTML (HyperText Markup Language)

Hypotheses, 734

I

IAL (International Algorithmic Language), 54

IBM

APL developed by, 71 Fortran developed by, 42–47 orthogonality and, 10

PL/I developed by, 68, 73–74 PL/S developed by, 6 UNIVAC ”compiling” system

and, 41

“The IBM Mathematical FORmula TRANslating System: FORTRAN,” 43

id type, 551–552

Identifiers, 115, 204

Identity operators, 320

IEEE Floating-Point Standard, 247–248

Ierusalimschy, Roberto, 100, 274–275

If logical constructs, 45

IF selector functions, 685–686 if statements

assignments and, 340

in compound statements, 351

in Extended BNF, 130 in JSP, 105–106

in multiple-selection statements, 360–362

in nesting selectors, 351–354 in recursive-descent parsers,

181–186 rules for, 119

in selector expressions, 354

IFIP (International Federation of

Information Processing), 75

if-then-else statements,

128–129, 325 Imperative programming

languages functional languages

supporting, 715–717 functional languages vs.,

717–719 introduction to, 18

object-oriented hybrid languages and. see C++

Implementation methods compiler implementation,

24–28

hybrid implementation systems, 29–30

preprocessors in, 30 for protocols, 551 pure interpretation, 28 for subprograms. see

Subprograms, implementing understanding of, 4

Implicit declarations, 211 Implicit heap-dynamic arrays, 74

Implicit heap-dynamic variables, 218

Implicit locks, 612–613 import declarations, 515–516

In mode parameter passing, 400 in operators, 266

include statements, 565

Incremental mark-sweep garbage collection, 301

Indicants, 74 Indices, 260–262

Inference rules

evaluation of, 160–161 in logical pretest loops,

154–158

in program proofs, 158–160 as rule of consequence, 152

Loaders, 444

Local nested classes, 556 Local referencing environments,

397–399

Local variables, 218, 397–399 local_offset, 450

Locks, 612–613, 616–617

Locks-and-keys approach, 298 Logic for Computable Functions

(LCF), 52

Logic programming languages applications of, 757–758 bibliographic notes on, 759 clausal form in, 731–732 defined, 728

expert systems and, 757–758 introduction to, 22, 728 overview of, 734–736 predicate calculus for,

728–734

problem set on, 760–761 programming exercises on,

761

Prolog. see Prolog propositions in, 729–731 relational database

management systems and, 757

summary of, 758–759 theorem-proving in, 732–734

Logical concurrency, 579 Logical pretest loops, 147,

154–158

Logically controlled loops, 368–370

long primitive type variables, 612

Loop invariants, 154–158 Loop parameters, 363 Loop variables, 363–364

Loops

counter-controlled, 363–368 defined, 362

logical pretest, 147, 154–158 logically controlled, 368–370 user-located, 370–371

Lost heap-dynamic variables, 293 Love, Tim, 90

LR parsers, 190, 193–197 Lua

anonymous functions in, 390 arrays in, 264, 272, 276 enumeration types in, 257 evolution of, 37, 100–101 global variables in, 399 Ierusalimschy on, 274–275 multiple assignments in, 340 nested subprograms in, 454 parameters in, 393–395 records in, 278

relational operators in, 333 selection statements in, 353 tables in, 276

L-value, 208–209

M

MAC OS X, 90

Mark-sweep garbage collection, 299–302

Markup languages, defined, 22 Markup/programming hybrid languages, 104–106

Massachusetts Institute of Technology (MIT). see MIT (Massachusetts Institute of Technology)

match expressions, 288, 362

Matching subgoals, 740 Matching type parameters, 644 Mathematical functions,

673–676 Matsumoto, Yukihiro, 100 Mauchly, John, 40 McCabe, F. G., 737

McCarthy, John, 48, 677–680 McCracken, Daniel, 23

Meek coercion, 74 Mellish, C. S., 753

Member functions, 486, 539 Memory cells, 209

Memory leakage, 293

Message interfaces, 526 Message protocols, 526

Messages

binding dynamically. see

Dynamic binding in object-oriented

programming, 525–527 passing, 593–594

MetaLanguage (ML), 52, 701–707

Metalanguages, 118

Metasymbols, 130 Method calls, 566–568

Methods, 526–527, 566–568 Microsoft

C# by, 101 JScript.NET by, 97

.NET computing platform by, 89 Visual BASIC by, 66–67 Visual Studio .NET by, 31

Milner, Robin, 52 MIL-STD 1815, 82

MIMD (Multiple-Instruction Multiple-Data) computers, 578

Minsky, Marvin, 48 Miranda, 52

MIT (Massachusetts Institute of Technology)

AI Project at, 48 LISP at, 677 Scheme at, 51, 681

Mixed-mode assignment statements, 341

Mixed-mode expressions, 330–331

Mixins, 550

ML (MetaLanguage), 52, 701–707

M-notation, 678, 690 Modules, 516–517 Monitors, 591–593 MSDOS.exe, 66–67

Multicast delegates, 421 Multilisp, 618

Multiparadigm programming, 536

786 Index

Multiple assignment statements, 340

Multiple inheritance, 527, 531–532 Multiple-Instruction Multiple-

Data (MIMD) computers, 578

Multiple-selection statements design issues for, 354–355 examples of, 355–358 implementation of, 358–359 using if, 360–362

Multiprocessors, 577–579

Multithreaded programs, 579–580

N

Name type equivalence, 305 Named constants, 232–234

Names

design issues for, 205

in encapsulation constructs, 513–517

form of, 205–206 introduction to, 204–205 keywords, 206

reserved words and, 206–207 special words, 206–207 summary of, 234–235

of variables, 208 variables vs., 207–209

Narrowing type conversions, 329 National Physical Laboratory, 69

Natural operational semantics, 140 Naur, Peter, 55–56, 117

NCC (Norwegian Computing Center), 72

Negation problem, Prolog, 754–756

Nested classes in C#, 558

in Java, 555–556 in object-oriented

programming, 533 Nested list structures, 49

Nested subprograms, 397–399, 454–460

Nesting classes, 533 Nesting selectors, 351–354 nesting_depth, 455

.NET languages

assemblies in, 512–513 computing platform for, 89 evolution of, 101

F# as, 712 introduction to, 22 JIT systems in, 30 JScript.NET as, 97

Microsoft Visual Studio .NET as, 31

programming environments of, 31

NetBeans, 31

Netscape, 97

von Neumann, John, 18 von Neumann architecture

in imperative programming languages, 204

introduction to, 18–19 in LR parsing, 195

von Neumann bottlenecks, 27

new

in allocation of objects, 532 in C#, 498, 557

in C++, 486 data types, 263

in heap management, 298 in Java, 552

in Ruby, 564

New Programming Language (NPL), 69

Newell, Allen, 47

NeXT, 90

next iterators, 373 Nil values, 49, 289

Nonblocking synchronization, 612

Nonconverting cast conversions, 304

nonlocal, 227

Nonstrict programming languages, 710

Nonterminal symbols, 118, 122

Norwegian Computing Center (NCC), 72

NOT operators, 333–334 not operators, 755–756 NPL (New Programming Language), 69

NULL, 691–692

Numeric data types, 246–249 Numeric predicate functions, 685 Nygaard, Kristen, 72–73

O

Object slicing, 532–533 Objective-C

abstract data types in, 490–496

C++ and, 90

dynamic binding in, 551–552 encapsulation constructs in,

490–492

information hiding in, 492–493 object-oriented programming

in, 549–552 Object-oriented constructs, 566–568 Object-oriented languages

allocation of objects in, 532–533

deallocation of objects in, 532–533

design issues for, 529–534 dynamic binding in, 533 exclusivity of objects in,

529–530 initialization of objects in,

533–534

multiple inheritance in, 531–532

nested classes in, 533

single inheritance in, 531–532 subclasses vs. subtypes in,

530–531

Object-oriented programming in Ada, 558–563

binding method calls to methods in, 566–568

788 Index

PDA (Pushdown automaton), 193

Perl

arrays in, 261–264 assignments in, 337–341 associative arrays in, 272–276 binary logic operators in, 334 C# vs., 103

dynamic length strings in, 253 dynamic scoping in, 227–228 evolution of, 36–37 exponentiation in, 396 foreach statements in, 380 hybrid system implementing,

30

as imperative programming language, 22

overview of, 95–97 parameter passing in, 407 pattern matching in, 170, 252 prefix operators in, 319 Python vs., 99–100

Ruby vs., 100 slices in, 268

then and else clauses in, 350, 352

Unicode in, 249 variables in, 205, 211

Perlis, Alan, 46, 53 PHP

arrays in, 273, 276, 373 execution speed in, 718 foreach statements in, 103 global variables in, 224–225 overview of, 98–99

parameter passing in, 392, 407 pattern matching in, 252

pure interpretation in, 28 relational operators in, 333 as scripting language, 7, 28 switch statements in, 357 type binding in, 213 variable names in, 205

Phrases, 191–192

Physical concurrency, 579 Pike, Rob, 91

pipeline (|>) operators, 714 Plankalkül, 38–39

PL/I

design process for, 69 evaluation of, 70–71 historical background of, 68 introduction to, 68

language overview of, 69–70 operational semantics in, 142 overview of, 68–71

PL/S, 6

Pointer types in Ada, 293

in C and C++, 294–295 dangling, 292–293, 297–298 design issues for, 290 evaluation of, 297

heap management and, 298–302

introduction to, 289–290 lost heap-dynamic variables

in, 293

operations in, 290–291 problems in, 291 representations of, 297

Polonsky, I. P., 72

Polymorphic references, 528 Polymorphic subprograms,

422–423 Polymorphism, 422–423 Pontifical University of Rio de

Janeiro, 100, 274

Portability, 18

Portable systems languages. see C

Positional parameters, 392

Postconditions

in assignment statements, 150–152

introduction to, 148–149 in logical pretest loops,

154–158

in program proofs, 158–160

in selection statements, 153–154

in sequences, 152–153 weakest preconditions

and. see Weakest preconditions

Posttest, 363 pragma, 601, 640 Precedence, 319–321

Precision, 247

Preconditions

in assignment statements, 150–152

introduction to, 148–149 in logical pretest loops,

154–158

in program proofs, 158–160 in selection statements,

153–154

in sequences, 152–153 weakest. see Weakest preconditions

Predicate calculus defined, 729

for logic programming languages, 728–734

in Prolog, 79

Predicate functions, 134, 689–691

Predicate transformers, 154–158

Prefix operators, 319

Preprocessors, 30 Pretest, 362

Primitive data types boolean, 249 character, 249–250 complex, 248 decimal, 248–249

floating point, 247–248 integer, 246–247 numeric, 246–249

Primitive numeric functions, 681–682

Priorities of tasks, 601–602 Priorities of threads, 606–607

private

in Ada, 562

in C#, 498–499

in C++, 486–487, 540–544 in Ruby, 500–501

Private types, 482–484 Procedure-oriented programming,

21

Procedures, 395–396

Process abstraction, 475 Processes, 581 Producer-consumer problems,

582

Productions, 118 Program calculus, 38

Program counters, 19 Program proofs, 158–160

Program_Error exceptions,

639

Programming design methodologies, 20–21

Programming domains artificial intelligence in, 6

business applications in, 5–6 generally, 5

scientific applications in, 5 in systems programming, 6–7 Web software and, 7

Programming environments, 31 Prolog

arithmetic in, 743–746 closed-world assumption in, 754 deficiencies of, 751–756 design process for, 79

elements of, generally, 736–737

evaluation of, 80

fact statements in, 737–738 goal statements in, 739–740 inferencing process of, 740–743 intrinsic limitations in, 756 introduction to, 6

language overview of, 79–80 list structures in, 746–751 logic in, generally, 79 negation problem in, 754–756 origins of, 736

resolution order control in, 751–753

rule statements in, 738–739 terms in, 737

Prolog++, 21

Prologue of subprogram linkage, 443–448

Properties, C#, 498–499 Propositions, 729–731 protected access modifiers, 498 Protected objects, 592, 602–603

Protocols, 390, 551 Prototypes, 391 Pseudocodes

introduction to, 39–40 related work, 42 Short Code, 40–41 Speedcoding, 41

UNIVAC ”compiling” system, 41

public

in C#, 498

in C++, 486 derivations, 540–544 in Ruby, 500–501

Pure interpretation, 28

Pure virtual functions, 546 Pure virtual method, 529

Pushdown automaton (PDA), 193 Python

arrays in, 264–268 complex values in, 248 concurrency in, 585 def statements in, 390 dictionaries in, 273

elif statements in, 360 interpreting expressions in, 681 lambda expressions in, 716 long integer type of, 246

mutable lists in, 283–284, 311 nested subprograms in, 219,

454, 510 overview of, 99–100

parameters in, 392–394 pass-by-assignments in, 408 pattern matching in, 252 referencing environments and,

230 strings in, 251

subprograms in, 389

then and else clauses in, 351 tuples in, 280–281, 712 type binding in, 213 Unicode in, 249–250

Q

Quantifiers, 730

Quasi-concurrency, 433 Quasi-concurrent subprograms,

579–580 Queries, 739–740 QUOTE, 686–687

R

Race conditions, 582 Radio buttons

in C#, 661–664

in Java, 656–660 raise statements, 640

Raised exceptions, 631 RAND Corporation, 47

Range

for arrays, 284

in floating-point data types, 247

iterators, 372 in Python, 367

Raw methods, 425

RDBMSs (Relational database management systems), 757

Read statements, 630 Readability, 8, 16 Reader macros, 701

summary of, 466

without recursion, 449–451

Subrange types designing, 258–259 evaluation of, 259 introduction to, 258

Subscript bindings, 262–264

Subscripts, 258 Substring references, 250

subtype enumeration type, 258 Subtype polymorphism, 422

Subtypes, 306, 530–531 Sun Microsystems, 92

super

in Java, 553

in Objective-C, 550 pseudovariables, 535 in Ruby, 564

Superclasses, 526

Suppress pragma, 640 Swing GUI components, 656–657

switch

in C, 77–78

in C#, 376 multiple-selection statements

and, 355–358 Symbolic atoms and lists,

689–691

Symbolic logic, 729

Synchronization

in Ada, 599–601

in concurrency, 586–592 introduction to, 581–585 in Java, 607–608

of modifiers, 93, 592 nonblocking, 612

of statements, 608 of threads, 616–617

Synchronous message passing, 593–594

Syntactic domains, 142 Syntax

ambiguous grammars in, 122–123

analysis of, 25–27, 168–169

associativity in, 126–128 attribute grammars and. see

Attribute grammars bibliographic notes on,

161–162

BNF and, 117–118 context-free grammars and,

117–118 derivations in, 119–121 design of, 12–13

in Extended BNF, 129–132 fundamentals of, 118–119 generation of, 116–117 grammars and, 117–121, 132 if-then-else statements,

128–129 introduction to, 113–115

issues in describing, 115–117 of LISP, 50

list descriptions in, 119 methods of describing, 117 operator precedence in,

123–126

parsing and. see Parsing recognition of, 116 recognizers in, 132 semantics and. see Semantics summary of, 161, 197–199 unambiguous grammars in,

128–129

Synthesized attributes, 134 Syracuse University, 732

System.Object, 102

Systems programming, 6–7

Systems software, 6

T

Tagged types, 559–561 Tail recursive functions,

695–696

Task descriptors, 586 Task ready queues, 584

task specifications, 594–595 Task termination, 601 Tasking_Error exceptions, 639

Tasks, 581–585 Template functions, 423

Terminal symbols, 118, 122

Terminal values, 363 terminate, 599, 601

Terms, 737

Ternary operators, 319

Tests, 709

Texas A&M University, 480, 536 Text boxes, 656

then, 128–129, 350 Theorem-proving, 732–734 Theory of data types, 308–310 Thompson, Ken, 91

Threads

in C++, 544

in competition synchronization, 607–608

concurrency in, 603–604, 613 in cooperation synchronization,

608–611 defined, 581

explicit locks in, 612–613 in Java, 93, 606–607

in nonblocking synchronization, 612

priorities of, 606–607 semaphores in, 607 Thread class, 604–606

Threads of control, 579–580 throw statements, 644–651 Thrown exceptions, 631 throws clauses, 654 Tokens, 115, 170–177

Tombstones, 297–298 Top-down parsers, 179 Top-down resolution, 741 Total correctness, 158 Tracing models, 744–745 Trimming, 74

Tripod, 66–67

try blocks, 612, 614 try clauses

in C++, 643–646

in Java, 648–653

794 Index

Tuples, 280–281 Turing machines, 678 Turner, David, 52

twos complement, 247 Two-way selection statements

clause forms in, 350–351 control expressions for, 350 design issues for, 350

nesting selectors in, 351–354 selector expressions in, 354

type

in Ada enumeration types, 258 in Ada equivalence, 306–307 in Ada union types, 286, 289 in F#, 287

in ML, 281 Type, defined, 209 Type bindings

dynamic, 212–214 introduction to, 210 static, 211–212

Type checking introduction to, 15 overview of, 302–303

parameters in, 408–410 Type conversions, 329–332

type enumeration type, 257, 261 Type equivalence, 304–308

Type errors, 303 Type inference, 211 typedef, 308

U

Unambiguous grammars, 123–126 Unary assignment data types,

338–339 Unary operators, 319

Unchecked exceptions, 650 Unconditional branch statements,

375–376 undef, 145–147

undefined, 264

Underflow, 332

Ungar, David, 548

Unicode, 249

Unification, 733, 759 Uninstantiated variables, 737 union, 285, 308

Union types

in Ada, 285–287 design issues for, 285

discriminated vs. free unions in, 285

evaluation of, 288 in F#, 287–288

implementation of, 289 introduction to, 284

Unit-level concurrency. see subprogram-level

UNIVAC, 40–41

UNIVAC Scientific Exchange (USE), 53

University of Aix-Marseille, 79, 736

University of Edinburgh, 79, 736 University of Utah, 85

UNIX

programming environment of, 31

readability of, 13 systems software for, 6–7

Unlimited extent, 431 unsafe, C#, 296

USE (UNIVAC Scientific

Exchange), 53 use clause, 484, 516 User-defined

abstract data types, 476–478

ordinal data types. see Ordinal data types

overloaded data types, 430 User-located loop control mecha-

nisms, 370–371 using directive, 515

V

val statements, 341, 704–706

Value, 209 Value types, 290

var declarations, 211–212 Variables

addresses of, 208 defined, 245 names of, 208

names vs., 207–209 type of, 209

value of, 209

Variable-size cells, 301 VAX minicomputers, 10 VB (Visual BASIC), 13 VDL (Vienna Definition

Language), 142

Vector processors, 578 Vienna Definition Language

(VDL), 142

virtual method tables (vtables), 566–568

virtual reserved word, 545, 557

Visible variables, 218

Visual BASIC (VB), 13, 65–67 Visual languages, 22

Visual Studio, 22, 31 void, 11, 389–393 void * pointers, 295

vtables (virtual method tables), 566–568

W

wait semaphores, 586–590 Wall, Larry, 95

Weakest preconditions

in assignment statements, 150–152

in axiomatic semantics, 149–150

in logical pretest loops, 154–158

in sequences, 152–153 Web software, 7 Weinberger, Peter, 95

Well-definedness, 18

Wheeler, David J., 42 when clauses, 598–599

X

Xerox Palo Alto Research Center (Xerox PARC), 86

XML (eXtensible Markup Language), 104–106

XSLT (eXtensible Stylesheet Language Transformations), 22, 104–105

Y

yacc, 132

yield methods, 605

Z

Zuse, Konrad, 38