• 
  • Weitere Informationen zu diesem Buch:

    Inhaltsverzeichnis | Index | Probekapitel | Rezensionen |
    Leseprobe in dt. Sprache (PDF) |

Symbols[ Top ]
$ (dollar sign)
      end of line matching in regular expressions, 3, 5
      in Perl variable names, 195
% (percent sign), Perl variable names, 195
& (ampersand), && operator in JavaScript, 136
( ) (parentheses)
      invoking functions, 144
      type in Haskell, 389
* (asterisk)
      JavaScript operator, 135
      matching zero or more occurrences in regular expressions, 3, 4
+ (plus sign)
      JavaScript infix operator, 134
      matching one or more instances in regular expressions, 43
. (period)
      . operator in JavaScript, 136
      matching any single character in regular expressions, 3
= (equals sign), === (exact-equality comparison) operator in JavaScript, 135
-> (arrow), indicating object-oriented method call in Perl, 195
? (question mark), ?: ternary operator in JavaScript, 135
@ (at-sign) in Perl variable names, 195
[ ] (square brackets)
      [ ] operator in JavaScript, 136
      [^ .], matching any character not a space or period, 43
      array literals in JavaScript, 144
^ (caret), beginning of line matching in regular expressions, 3
{ } (curly braces)
      delimiting code blocks in Ruby, 48
      enclosing function body in JavaScript, 143
      object literals in JavaScript, 145
      statement blocks in JavaScript, 141
| (vertical bar), || operator in JavaScript, 136
` (single quote) transposition operator, 233

Numbers[ Top ]
1-bits in a word, counting (see population count)
32-bit word, 147
      adapting HAKMEM population count for 36-bit word, 151
8086 assembly language (Windows 1.0), 111

A[ Top ]
A,G,C,T (nucleotides), 188
Acceptor wrapper facade, 437
accidental complexities encountered by developers, 429
ACE wrapper facades, 436
      socket wrapper facade, 442
ACE_Handle_Set member variables, 441
ACSS (Aural CSS), 511-516
      adding auditory icons, 512
      basic HTML using Emacs W3 and ACSS, 517
      data structure encapsulating ACSS settings, 512
      enhancing spoken output with context-sensitive semantics, 514-516
      mappings to TTS engines, 508
      producing auditory icons while speaking content, 514
ActionFixture class (Java), 77
actions (Haskell), 389
      important characteristics of, 404
      IO actions, 398
      main, 390
      STM actions, 392
      treated as first-class values, 391
      type system preventing IO actions running inside STM actions, 394
Adapter or Facade pattern, 8
additional levels of indirection, 279-291
      FreeBSD using indirection to abstract read function arguments, 282-285
      layering and, 290
      multiplexing and demultiplexing, 289
      operating system supporting different filesystems, 279
            filesystem layers, 285-287
            FreeBSD implementation of read system call, 280
advFilter method (Gene Sorter columns), 224
advice (Emacs LISP), 505
      auditory icons confirming user actions, 513
      definitions attached to calendar navigation functions, 515
      put-text-property function implementation, 508
      tutorial, 507
adviced function (LISP), 507
AFL (Audio Formatting Language), 511
after advice (Emacs LISP), 507
      auditory icons confirming user actions, 513
Ajax Generic Genome Browser, 211
alarm function (Perl), 171
ALGOL-like syntax for LISP, 130
algorithms
      customizing on the fly in Intermediate Language, 127
      data structures as frozen algorithms, 37
      for dense or sparse matrices, 230
      detailed in routine's description, 258
      search algorithms, 52
Amdahl's Law, 231
analysis of programs, 40
annotation, 188
      large number of genome annotation types, 190
anonymous subroutines (Perl), 207
Apache Commons HttpClient, 457
Apache Log4J Java package, 329
application level, science captured in mathematical models, 229
application-specific control structures, defining using Haskell actions, 404
area of a triangle, measuring, 548
around advice (Emacs LISP), 507
array descriptors, 246
array literals (JavaScript), 131, 144
arrays
      binary search
            boundary value testing, 92-94
            testing, 96
      bitmap pixels stored in, 115
      digital filter
            generating elements, 122
            storing byte in destination array, 126
            zero byte stored in destination array, 126
      digital image filters, 112
      JavaScript, selecting member with [ ] operator, 136
      N-dimensional, 303
      one-, two-, and three-dimensional, 303
      one-dimensional array and digital filter algorithm in C#, 116
      Perl variable names beginning with @, 195
      population count, 154-159
            CSA circuits, 154-159
            direct indexed access to moderately sparse array, 159
      in PyArrayIterObject, 312
      Python, free-dicts array of disused dictionary structures, 300
      Ruby implementation, 52
      (see also NumPy)
Art of Computer Programming, The, 37
assembly language, computation-intensive routines in, 266
assertions verifying the state of locks, 288
assignment operators (JavaScript), 137
association lists, 415
      assq procedure for lookups, 419
associations (Gene Sorter columns), 224
associative stores, 46-49
      using in dynamically typed languages, 47
AsTeR (Audio System For Technical Readings), 503
asynchronous event demultiplexer in reactive logging server, 442
Atom feeds, 522
atomically function (Haskell), 392
atomicity (Haskell transactions), 392
audio desktop (see Emacspeak audio desktop)
audio formatting codes, converting personality property to (Emacspeak), 510
Audio Formatting Language (AFL), 511
audio formatting using voice-lock (Emacspeak), 508
auditory icons, 512
      producing while speaking content, 514
      user interactions producing, 512
Aural CSS (see ACSS)
aural display lists
      audio-formatted output from, 510
      augmenting Emacs to create, 508-510
automata, regular expressions translated into, 45
automated debugging, 468
      further reading, 476
awk programming language, 50
      creations from FreeBSD read system call specification, 288

B[ Top ]
backtick function (Cryptonite), 181
backup tasks, MapReduce implementation, 380
Backus-Naur Form (BNF) grammar, checking XML names, 61, 63
balance in beautiful code, 481
bank accounts (concurrent programming example), 386-388
      using locks, 386
base categories (ERP5)
      predecessor, 349
      source_project and destination_project, 347
      source_project, retrieving tasks of a project, 348
base category objects (Portal Categories), 346
base pairs (bp), 188
      handling scale in genomic feature representation, 191
bases of DNA (A, C, G, or T), 218
Basic Linear Algebra Subprograms (see BLAS)
baton (Subversion), 17
beautiful code
      characteristics of, 266
      CIP (Collaborative Information Portal), 319
      CIP system architecture, 322-325
      code that works accurately and efficiently, 253
      lack of type checking in Linux kernel, 272
      NumPy iterators, 307
      object-oriented framework-based design, 443
      object-oriented networked software, 431
      parallel programs, simple, elegant, and mistake-free, 385
      scalability, 259
      test and example programs, 260
before advice (Emacs LISP), 507
Bell, Gordon, 31
Bentley, Jon, 29-40, 87
Berkeley Fast Filesystem (ffs), 283
binary MIME message composition, 179
binary search, 52, 87
      advantages and disadvantages, 54
      escaping the loop, 54
      "On the Goodness of Binary Search", 52
      postings, 55
      testing, 90-102
            boundary value tests, 92-95
            performance, 101
            random testing, 95-100
            smoke test, 91
binary search tree (Quicksort), cost of inserting an element, 38
binary-ness, testing, 101
binding interaction, DNA/protein, 206
binding powers (JavaScript tokens), 134
      + operator, 134
bindings, 415
      determining binding associated with an identifier, 418
      mapping to labels with environments, 418
      variable, capture of a variable reference by, 408-411
binomially distributed random integers, 160
Bio::Graphics module (Perl), 188-215
      design process, 192-209
            developer interaction with the module, 192-195
            dynamic options, 206-209
            object classes, choosing, 198-200
            option processing, 200-205
            options, setting, 196-198
            script that uses (example), 205-206
      design requirements, 190
      examples of output, 189
            typical image, 189
Bio::Graphics module (Perl) (continued)
      extending, 210-214
            adding new glyphs, 212
            supporting publication-quality images, 211
            supporting web developers, 210
Bio::Graphics::Glyph class, 198-200
      factory( ) and option( ) methods, 204
      option( ) method, changing for dynamic options, 208
      subclasses, 204
Bio::Graphics::Glyph::Factory class, 201-205
      dynamic option processing, 207
      methods, 202
Bio::Graphics::Panel class, 192, 198
      configuration options, 197
      image_and_map( ) method, 210
      png( ) method, 212
      SVG images, 212
Bio::Graphics::Track class, 198
Bio::SeqFeature::CollectionI interface, 193
Bio::SeqFeature::Generic class, 206
Bio::SeqFeatureI interface, 214
bioinformatics, 187
      genome annotation types, 190
      SOAP-style web service architectures, 453
BioMoby project, 453
BioPerl
      annotation databases, 193
      Bio::Graphics module and, 188-192
      Bio::SeqFeatureI interface, 214
      (see also Bio::Graphics module)
bison, generating C code implementing high-level domain-specific language, 288
bit flags (binary lookup table), 70
bit shift operators (Java), 88
bit shifts for collisions in Python dictionaries, 299
BitBlt (bit block transfer) function (Windows 1.0), 106
      8086 machine code instructions as subroutine, 111
      C code implementing, 110
      raster operations, 108
bitmaps
      code dealing with, 110
      digital filter applied to, 112
      digital filter transforming source into destination bitmap, 113
      ImageFilterTest program, 115
BLACS (Basic Linear Algebra Communication Subprograms), 243
Blandy, Jim, 16, 17
BLAS (Basic Linear Algebra Subprograms), 230, 237
      Level-1 BLAS, 235
      Parallel BLAS (PBLAS), 245-247
      resources for further reading, 252
      ScaLAPACK library, 243
blessed reference, 174
block size (NB), 239
block statement (JavaScript), 141
blocking
      bank account transactions (example), 387
      lack of modularity, 388
      threads in Solaris, 354
blocking chain, 356
      iterating over it coherently, 358
      unblocking of thread blocked on synchronization primitive, 358
block-partitioned algorithms, 230
blocks of code (JavaScript), 141
blur filter, 113
BNF (Backus-Naur Form) grammar, checking XML names, 61, 63
Bonwick, Jeff, 355
boundary value tests, 91
      binary search, 92-95
            array, 92-94
            target item location, 94
bound-identifier=? predicate, 424
bp (base pairs), 188
      handling scale in genomic feature representation, 191
branch instructions (Intermediate Language), 120
      Blt (branch if less than) and S (short branch), 123
      labels, 121
Bray, Tim, 41-57
break statement (JavaScript), 142
breaking the code (beautiful tests), 95
brevity in code, 261, 478
      elimination of redundancy, 479
      leaving out unnecessary information, 478
broadcasting (in NumPy), 316, 317
BSD (see FreeBSD operating system)
BT (business template), 346
buffering, 290
_ _builtin_ _ module (Python), 294
business partners, integrating using REST, 451-462
      exchanging data with e-business protocols, 457-462
            assembling XML response, 462
            parsing XML using XPath, 458-462
      exposing services to external clients, 452-455
      routing services using factory pattern, 456-457
business processes, representing in ERP5, 341
business template (BT), 346

C[ Top ]
c (character), matching in regular expressions, 3
C language
      code for applying a digital filter, 113
      code implementing filesystem layers, 288
      code packing function arguments into a single structure, 288
      compilation from specialized high-level domain-specific language to, 288
      do-while loop, 4
      early Windows applications, 111
      hexadecimals, 150
      N-dimensional arrays, looping over, 304
      object-oriented model of code in Linux driver model, 277
      object-oriented programming and, 8
      operating system (OS) APIs, 429
      Perl interface to libraries, 168
      pointers, 5, 271
            compact code in regular expression matcher, 9
      polymorphic object, creating, 221
      population count for 36-bit word, adapting to 32-bit word, 151
      population count, counting 1-bits in a word x, 148
      PyDict_SetItem( ) function, 300
      Python implementation (see CPython)
      special-purpose syntactic constructs, 407
      structures
            inheriting and manipulating in Linux kernel, 272
            PyDictObject, 295
            reference counting, 273-276
      syntactic abstraction mechanism, preprocessor macros, 408
C#, 112
      code to implement digital image filters, 112
      code written for best performance, examining with IL Disassembler, 115
      digital filter algorithm, 116
      image processing code, 114
      indirection in, 290
      Intermediate Language, generating and then executing, 118
C++
      cfront preprocessor, compiling C++ code into C, 288
      implementation of MapReduce word frequency counting example, 382
      inheritance and overloading, 261
      parameterized types, 432
C. elegans genome, 189
caching
      in eLocutor, 486, 495
            SaveReverse subroutine, 495
      namespace URIs after verification, 72
Calendar (Emacs), speech-enabling, 515
calendar-forward-week function, advice definition for, 515
callbacks in Bio::Graphics
      usefulness of, 209
      using for each option passed to add_track( ), 207
cancellations, handling in Subversion delta editor, 25
Cantrill, Bryan, 353-369
capture of a variable reference by a variable binding, 408-411
carry-save adder (CSA) circuits, 154-159
cart object (Gene Sorter), 220
cart variables (Gene Sorter)
      avoiding name conflicts, 221
      communication between column filtering methods, 224
CAs (Certification Authorities), 164
causalities, 347
CD-ROMs, ISO-9660 filesystem, 279, 281
CERN library, 254
      inner beauty of code, 261-266
            beauty in flow, 265
            brevity and simplicity, 261
            frugality, 262-265
      outer beauty of code, 255-260
Certification Authorities (CAs), 164
CGI scripts
      advantages and disadvantages, 219
      Gene Sorter, 219
      lifetime, 220
      long-term data storage, 220
      short lifetime, advantages of, 221
chain of blocked threads, 356
chaining, 298
      in vector machines, 231
character classes (in regular expressions), 7
children with disabilities, communication in classroom via software, 501
choose function (Haskell), 402
CIP (Collaborative Information Portal), 319-338
      Mars Exploration Rover (MER) mission and, 320
            mission needs, 321
      Middleware Monitor Utility, 335
      robustness, 336-337
            dynamic reconfiguration, 337
            hot swapping, 337
CIP (Collaborative Information Portal) (continued)
      streamer service case study, 325-328
            functionality, 325
            reliability, 328-336
            service architecture, 326
      system architecture, code beauty of, 322-325
CISC computers, fundamental instructions, 147
class libraries, 433
client/server software
      Emacspeak speech servers and Emacspeak client, 504
      integrating RPG legacy systems with, 460
clipboard, 498
CMF (Content Management Framework), 340
      implementation of structural part of applications with CMF Types, 342
      overview, 342
CMF Types, 342
code and data, interplay between, 105
      becoming mirror images of each other, 127
code complexity, managing over time, 523
code examples from this book, using, xx
code generation, on the fly, 105-127
      FilterMethodCS, 116-118
      FilterMethodIL, 119-127
      graphics functions in Microsoft Windows 1.0, 106-112
code reuse, 228
      ERP5, 351
      promoted by good design and clear, concise code, 261
Collaborative Information Portal (see CIP)
collinearity problem (see computational geometry)
collision control
      for overlapping genomic features, 191
      for tracks in Bio::Graphics module, 195
collisions in Python dictionaries, 298
columnDb.ra files, containing column metadata, 222
column-oriented algorithms (LINPACK), 235
columns (Gene Sorter), 223
      filtering, 224
command dispatcher in Cryptonite::Mail::Server, 170
comments
      Haskell, 389
      presenting full documentation for purpose of a routine, 258
commercial off-the-shelf (COTS) software, 322
commits, transaction log, 394
Common LISP macros, 408
common words (in eLocutor), 496
commonality/variability analysis, 434
      logging server framework, 434
comparison count function (Quicksort), 33
comparison operators, Python data types providing versions of, 298
comparisons, counting for binary search, 101
compilation phase, regular expression processing, 7
compilers optimizing away indirection, 291
complexity of code, using simpler tools for complex problems, 481
computational geometry, 540-551
      collinearity problem, 541-543
      collinearity, testing by comparing slopes, 544-545
      LISP, using, 540
      river meandering model, 547
      testing collinearity by triangle inequality, 545
computed solutions vs. mathematical equations, 253
computer architecture, effects on matrix algorithms, 230
concurrency, 385-405
      bank accounts (example), 386-388
            using locks, 386
      different models, 432
      locks, problems with, 387
      sequential concurrency models in logging servers implementation, 439-444
      STM (Software Transactional Memory), 388-405
            implementing transactional memory, 394
            Santa Claus problem (example program), 396-403
            side effects and I/O in Haskell, 388-391
            summary of basic STM operations, 396
            transactions in Haskell, 392-393
condition variables
      blocking in bank account transactions, 387
      coordinating concurrent programs, 386
      no support for modular programming, 388
connection/data event handling, Reactive_Logging_Server, 442
constants
      hexadecimals in C, 150
      JavaScript, 138
constructors (methods), checking for correctness in XML verifier, 66
container_of macro, 271
      casting back from core kobject to main struct device, 274
Content Management Framework (see CMF)
content-addressable memory, 46-49
context-sensitive menu selection in eLocutor long click, 489-491
context-sensitive semantics, enhancing spoken output, 514-516
continuous testing, 467
conversions between s-expressions and syntax objects, 424
cookies
      CGI script data storage, 220
      key into user table for Gene Sorter, stored in persistent cookie, 220
core dump, analyzing for Solaris user-level priority inheritance bug, 360-366
COTS (commercial off-the-shelf) software, 322
CPython, 294, 301
      selecting storage function dynamically, 297
critical path, 248
Crockford, Douglas, 129-145
Crypt::GPG module (Perl), 173
      security audit, 180-182
Crypt::PGP5 module (Perl), 173
cryptographic software, 185
Cryptonite (mail system), 162-184
      basic design, 169
      code cleanup, Perl modules for jump to scalable product, 173
      decrypted messages, persistence of, 176
      design goals and decisions, 168
      functioning prototype, 172
      insights from development process, 162
      integrated interface for key management, 177
      Mail Daemon (cmaild), 171
      mail store, modifying to use IMAP as backend, 182
      revamping the mail store, 174
      securing the code, 178
      test suite, 172
      usability considerations, 166
Cryptonite::Mail::Config module (Perl), 179
Cryptonite::Mail::HTML package, 173
Cryptonite::Mail::Server, command dispatcher, 170
Cryptonite::Mail::Service class, 170
CSA (carry-save adder) circuits, 154-159
CSS (Cascading Style Sheets)
      CSS2, Aural CSS, 511
      early implementation by Emacs W3 browser, 517
      (see also ACSS)
Cunningham, Ward, 75
Cypherpunks, 185

D[ Top ]
\d, matching any digit in regular expressions, 43
data display debugger (ddd), 464
data management (MER Mission), 322
data movement through the memory hierarchy, 230, 239
data representation, 290
data structures as frozen algorithms, 37
data types
      C++ parameterized types, 432
      Haskell
            declaring, 398
            distinguishing actions from pure values, 404
      skipping declarations when unnecessary, 478
database code, prototyping in Perl, 173
database schemes, independence of Bio::Graphics from, 192
databases
      annotation, supported by BioPerl, 193
      ERP5 relational database, 341
      in operating system kernel for device naming, 268
      ZODB, 340
datum->syntax procedure (syntax-case), 412, 413
      converting s-expression to syntax object, 424
DBD::Recall module (Perl), 175
DBD::SQLite module (Perl), 173
DCWorkflow, 340
ddchange plug-in for Eclipse, 475
ddd (data display debugger), 464
de Carvalho, Rogerio Atem, 339-351
deadlock
      explicit locking code in bank account program, 387
      single-thread deadlock, 366
Dean, Jeffrey, 371-384
debugging, 463-476
      a debugger, 464
      delta debugging, 470-472
      finding failure cause automatically, 468
      hunting the defect, 473-475
            finding failure causes in program state, 473
            tracing failure-causing variables back to statements causing them, 475
      minimizing input, 472
            automated testing and splitting input into smaller pieces, 473
      prototype problem with fragile approach, 475
debugging (continued)
      search problem, 467
            determining if one change depends on another, 468
            divide and conquer strategy, using, 468
      systematic process of, 466
            backward traversal of cause-and-effect chain for failure, 466
            consistent, disciplined use of scientific method, 466
      user-level priority inheritance bug in Solaris, 360-366
      (see also testing)
declarations, skipping when unnecessary, 478
decompositional approach to solutions for dense linear systems, 232
decrypted email messages, persistence, 176
DECTalk Express, 504
define-syntax form, 411
defining new variables in a scope (JavaScript parser), 138
Delivery class, 347
DeliveryLine class, 343
delta debugging, 470-472
      current implementations, 475
      further reading, 476
      minimizing program code, 473
      on program states, 473
      searching for failure causes in program input, 472
            minimizing input, 472
delta editor (Subversion), 11-28
      benefits of, 27
      interface, 17-22
dense linear systems, decompositional approach to solutions, 232
dense matrix problem, 230
      decompositional approach to solutions, 232
      error analysis and operation count, 250
dentry structure (Linux), 276
depot, 356
design defects manifesting as bugs, 354
destination_project base category, 347
devfs filesystem, 268
device structure (Linux), 268
      memory usage, 276
      pointers to, 271
      reference counting, 273
devices (on Linux), 267
      no proper handling in persistent manner, 268
      shutting down/powering up properly, 268
      struct device as base class, 268
DGEMM routine, 239
DGETF2 routine, 239
      bottleneck in computers with faster processors, 240
dictionaries, Python, 293-301
      basic operations on, 293
      C implementation of Python, 294
      collisions, 298
      iterations and dynamic changes, 300
      keys and values of different data types in single dictionary, 294
      keys not ordered, 294
      passing keyword arguments to a function, 294
      PyDictObject structure, 295
      representing module contents, 294
      resizing, 299
            determining new table size, 299
      special-case optimization for small hashes, 297
      special-casing, when it's worthwhile, 297
diff tool, 465
digital filters, 112
      algorithm in C#, 116
      fast digital filter algorithm, 117
      generating code for elements, 122
digital image filters
      blur filter, 113
      C code to apply digital filter (example), 113
      sharpness filter, 113
direction (genomic features), 190
directory trees
      differences, expressing, 16
      version control and tree transformation, 12-15
disabled persons, software for
      eLocutor, 483-500
      Emacspeak audio desktop, 503-525
      future directions, 500
dispatcher state of threads in Solaris, 358
distance procedure (Lisp), 546
distributed programming with MapReduce, 371-384
      distributed grep, 375
      distributed implementation (example), 377-380
            execution overview, 377
      distributed sort, 376
      extensions to the model, 380
      inverted index, 376
      programming model, 374
      reverse web-link graph, 376
      term vector per host, 376
      word count program (example), 371-374
divide and conquer strategy
      debugging, finding cause of failure in gdb, 468
      logical subdivision of tasks into subroutines, 265
      population count, 149-151
      recursive LU algorithm, 240
DNA sequences, 188
DNA/protein binding site, 206
do notation (Haskell), 389
      composing STM actions, 393
documentation, 227
      full documentation of routine's usage in the code, 258
document-centric paradigm (ERP5), 339
Don't Repeat Yourself (DRY principle), 479
Dongarra, Jack, 229-252
double-precision IEEE floating-point arithmetic, 546
do-while loop, 4
driver program for Map and Reduce functions (example), 374
driver routines, 261
DRY principle (Don't Repeat Yourself), 479
DTRSM routine, 239
Duff's Device, 11
duplication of information in code, eliminating, 479
Dybvig, R. Kent, 407-428
dynamic dispatch, 289
dynamic programming, 34
dynamic tree repopulation in eLocutor, 491
dynamically typed languages, using associative stores, 47
DynamicMethod class, 119
      Invoke method, 126

E[ Top ]
e-business protocols
      exchanging data with, 457-462
            assembling XML response, 462
            parsing XML using XPath, 458-462
      Rosettanet, 453
edge conditions, focusing on, 369
editing text in eLocutor, 497
editor operated with a single button, designing, 483-501
educating children with disabilities, communication software for, 501
egrep, 2
EJBs (Enterprise JavaBeans), 322
elegant code, evolution with hardware, 229-252
      effects of computer architectures on matrix algorithms, 230
      further reading, 252
      future directions for research, 251
      LAPACK DGETRF subroutine, 237-240
      LINPACK DGEFA subroutine, 235-237
      multithreading for multi-core systems, 247-250
      recursive LU, 240-243
      ScaLAPACK PDGETRF, 243-247
element names (XML 1.0), checking, 61
eLocutor, 483-500
      basic design model, 484-487
      efficiency of user interface, 500
      input interface, 487-499
            cache implementation, 495
            clipboard, 498
            common words and favorites, 496
            dynamic tree repopulation, 491
            long click, 489-491
            macros, 499
            retracing paths, 497
            searching, 499
            Templates and Replace, 494
            tree structure presenting options, 488
            typing buffer, editing, and scrolling, 497
            typing, simple, 493
      niche market for wider community, 484
      search function, 499
      web sites for download and discussion list, 500
Emacs
      Emacspeak, 500
      extension for one-button tree navigation, 501
      IDE for development of secure mail system, 168
      W3 web browser, 517, 525
Emacspeak audio desktop, 503-525
      Aural CSS (ACSS), using to style speech output, 511-516
      insights gained from implementing and using, 524
      managing code complexity over time, 523
      online information access, 516-522
            basic HTML with Emacs W3 and ACSS, 517
            feed readers, 522
            Web command line and URL templates, 520
            websearch module for task-oriented search, 517-520
      producing spoken output, 504
      speech-enabling Emacs, 505-516
            advice tutorial, 507
            first-cut implementation, 505
            generating rich auditory output, 507-511
            implementing event queue in speech server, 505
emacspeak-auditory-icon property, 514
emacspeak-calendar module, 515
emacspeak-calendar-entry-marked-p function, 515
emacspeak-calendar-speak-date function, 515
emacspeak-minibuffer-setup-hook function, 513
emacspeak-personality-voiceify-faces variable, 509
emacspeak-speak-line function, 505
emacspeak-url-template module, 520
emacspeak-url-template-fetch command, 521
emacspeak-w3 module, 517
emacspeak-w3-extract-table-by-match function, 519
emacspeak-websearch tool for accessing directions from Yahoo! Maps, 518
emacspeak-websearch-yahoo-map-directions-get-locations function, 518
email client, full-featured (Cryptonite), 167
encrypted mail client, persistence of decryption, 176
encrypted or signed messages, information about MIME structures, 175
encryption of email, 165
end position (genomic features), 190
Enterprise JavaBeans (EJBs), 322
enterprise resource planning systems, 339
      goals of, 340
      (see also ERP5)
enterprise system architecture, beauty of, 322
enterprise system for NASA Mars Rover (see CIP)
environments (syntax-case expansion algorithm), 418
      meta environment and runtime environment, exp procedure, 419
Equalizer, 483
ERP (enterprise resource planning), goals of, 340
ERP5, 339-351
      code in its raw state, web site, 351
      concepts that lay the basis for representing business processes, 341
      features to enhance programming productivity, 345
      object-to-relational mapping scheme, 341
      Portal Categories portal service, 345
      Project, 346-351
            coding, 347-351
      UBM (Unified Business Model), 341
      XML technologies, use of, 341
      Zope components used by, 340
      Zope platform, 342-346
            four-level structure representing system classes, 345
error analysis, 250
error bounds, 250
error-correcting codes, 159
errors
      communication mechanism in LAPACK SGBSV routine, 260
      recovery problems with locks, 388
essay, treating code as, 477-481
Euclid
      advice to student, 540
      algorithm for calculating greatest common divisor of two numbers, 540
      formula for area of a triangle, 549
European Organization for Nuclear Research (see CERN library)
evaluation stack (virtual) in IL, 120
event queue, implementing inside speech server, 505
example programs, importance of, 260
execution phase, regular expression processing, 7
exp procedure, 419
expansion algorithms
      hygienic macro expansion algorithm (KFFD), 410
      syntax-case, 413-425
            comparing identifiers, 423
            conversions, 424
            core transformers, 421-423
            creating wraps, 417
            expander, 419-421
            expander example, 425-427
            identifier resolution, 418
            manipulating environments, 418
            parsing and constructing syntax objects, 423
            producing expander output, 415
            representations, 414
            starting expansion, 424
            stripping syntax objects, 415
            structural predicates, 416
            syntax errors, 416
exp-core procedure, 421
Expect module (Perl), 180
exp-exprs procedure, 421
exp-if procedure, 421
exp-lambda procedure, 421
exp-let procedure, 422
exp-letrec-syntax procedure, 422
explicit formulation of hypothesis (in debugging), 466
exp-macro procedure, 420
exp-quote procedure (syntax-case), 421
expression function, 134
expression-based LISP macros, 408
expressions
      datum->syntax procedure used for arbitrary expressions in syntax-case, 413
      statements vs., 140
extend-wrap helper, 423
extensibility of software, 83
extension points, discovering, 513
external clients, exposing services to, 452-455

F[ Top ]
Factory class (Bio::Graphics::Glyph), 201-205
      dynamic option processing, 207
      make_glyph( ) method, 202
      option( ) method, 202
factory pattern, routing services with, 456-457
familiarity (of beautiful code), 479
FAT-32 filesystem for the USB stick, 279
fault tolerance, MapReduce implementation, 379
favorites in eLocutor (frequently used words), 496
Feathers, Michael, 75-84
features (genomic), 190
      density of, 191
      handling scale in visual representations, 191
feed reading software, 522
ffs (Berkeley Fast Filesystem), 283
fgrep, 2
file readers and file writers (CIP streamer service), 326
filesystems, operating systems supporting different, 279
      code to access filesystems, 280
      filesystem layers, 285-287
      FreeBSD use of indirection to abstract read function arguments, 282-285
Filter class, ApplyFilter( ) method, 116
filterControls method (Gene Sorter columns), 224
FilterMethodCS, 116
      optimizing, 117
FilterMethodIL, 119-127
      DynamicMethod instance, invoking, 126
filters, Gene Sorter, 224
finding the definition of a name (JavaScript parser), 139
finite automata, regular expressions translated into, 45
first-class values, Haskell actions as, 404
FIT (Framework for Integrated Test), 75-84
      challenge of framework design, 78
      classes, 76
            relationships among, 77
      documents serving as tests, 76
      HTML parsing, 80-83
      open framework, 79
      open style of development, benefits of, 83
Fixture class (Java), 77, 79
flex, generating C code implementing high-level domain-specific language, 288
flexibility of beautiful code, 481
floating-point arithmetic, IEEE double precision, 546
flow in beautiful code, 265
Fogel, Karl, 11-28
for loops
      looping over N-dimensional arrays, 304
      Python iterators as predicates, 305
forkIO function (Haskell), 390, 401
fork-join model of computation, 247
Fortran, 234
      BLAS (Basic Linear Algebra Subprograms), 252
      LINPACK package, 235
      required use of Fortran 90 with recursive LU, 240
forward web link graph, 376
frameworks
      applied to networked software, 430
      Framework for Integrated Test (see FIT)
      object-oriented, key concepts, 433
free_dicts array (Python), 300
FreeBSD operating system
      high-level I/O abstraction independence, 289
      implementation of read system call, 280
            filesystem-independent part, 281
      interface functions and data structures, language written in, 287
      read system call, functions to avoid code duplication, 290
      supporting different filesystems, abstracting read function arguments, 282-285
freedom from enforcement from tools (flexibility), 481
free-identifier=? predicate, 424
frequently used words in eLocutor, 496
frugality in beautiful code, 262-265
full-text searches, 55
fullword immediate, 152
function arguments abstracted to argument pointers, 282-285
function calls, keyword arguments in (Python dictionaries), 300
function pointers, used to dispatch a request to different functions, 289
functional decomposition of nontrivial software, problems created by, 430
functions
      JavaScript, 131, 143
      naming, understanding purpose from the name, 226
      reentrant, 227
      reusable, 228
fundamental instructions on RISC and CISC computers, 147

G[ Top ]
Gaussian elimination, 229-252
      MATLAB tool, 233
GBrowse, 211
GD::SVG module (Perl), 212
gdb (GNU debugger), 464
      debugging
            running diff on source code, 465
            search problem, 467
            splitting changes into four or more subsets, 469
      failure caused by changes in new release, 464
      searching program states for failure cause, 473
gene expression columns (Gene Sorter)
      filtering, 224
Gene Sorter, 217-228
      beautiful code, 225-228
            function filtering associations that handles wildcards, 226
      dialog with user over the Web, 219
      filtering down to relevant genes, 224
      genome.ucsc.edu implementation, 221
      polymorphism, 221-224
      user interface, 218
Generic class (Bio::SeqFeature), 206
genes, 218
genome browsers, web-based, 211
genome map rendering module (see Bio::Graphics module)
genome, annotation of, 188
genome.ucsc.edu implementation of Gene Sorter, 221
gen-var helper, 415
GET and POST requests over HTTP, services exposed through, 452
GFS (Google File System), 377
      management of input data, 379
      paper about design and implementation, 381
GHC (Glasgow Haskell Compiler), 403
Ghemawat, Sanjay, 371-384
Glasgow Haskell Compiler (GHC), 403
Glyph class (Bio::Graphics)
      dynamic option processing, 208
      factory( ) and option( ) methods, 204
      subclasses, 204
glyphs (Bio::Graphics module), 196
      adding new, 212
      box model, 215
      dynamic creation of, 200-205
      Glyph class, 198-200
      subglyph generation, 214
GNU debugger (see gdb)
GnuPG, 173
Google
      high-quality search results, 56
      MapReduce programs, number of, 376
      MapReduce, development for large-scale computations, 371
      (see also MapReduce)
Google Maps, Emacspeak tool with similar functionality, 519
Google News searches via Atom feeds, Emacspeak URL template for, 522
goto instruction, 120
GPG, security audit of Crypt::GPG module, 180-182
graphic formats, independence of Bio::Graphics from, 191
graphics function in Windows 1.0 (see BitBlt function)
grep, 2
      distributed, 375
groupings of words (eLocutor), 486
Gulhati, Ashish, 161-186

H[ Top ]
HAKMEM memo, 151
Hamming distance between two bit vectors, 159
hardcoded parameter values, avoiding, 337
hardware interfaces, 290
hardware speech synthesizer (DECTalk Express), 504
hardware, evolution of elegant code with, 229-252
      effects of computer architecture on matrix algorithms, 230
            LAPACK DGEFR subroutine, 237-240
            LINPACK DGEFA subroutine, 235-237
      further reading, 252
      future directions for research, 251
      multithreading for multi-core systems, 247-250
      recursive LU, 240-243
      ScaLAPACK PDGETRF, 243-247
Harold, Elliotte Rusty, 59-74
hash tables, 46
      binary search vs., 54
      bitmask representing size in PyDictObject structure, 296
      keys hashing to same slot, 298
      loading a big hash, 50
      resizing for Python dictionaries, 299
hashes
      constructed by code reading columnDb, 223
      filtered genes in Gene Sorter, 225
      Ruby, 47
      unordered hash in Perl, 195
Haskell, 386, 388-405
      Glasgow Haskell Compiler (GHC), 403
      side effects and I/O
            functional nature of Haskell, 391
      side effects and input/output, 388-391
            actions, 389
      summary of basic STM Haskell operations, 396
Hawking, Stephen, 483
Hayes, Brian, 539-551
hidden CGI variables, 220
      key into session table for Gene Sorter, 220
Hoare, C. A. R., 30, 31, 37
hook methods, 435
      in Logging_Server run( ) template method, 439, 443
      use in reactive logging server implementation, 442
host infrastructure middleware, 430
hot swapping, 337
HotkeyAdaptor interface (example), 456
HotkeyAdaptorFactory class (example), 456
hourglass glyph (example), 213
HTML
      FIT (Framework for Integrated Test), 76
      rendered by speech-enabled Emacs W3 and ACSS, 517
HTTP exchanges, managing with Apache Commons HttpClient, 457
HTTP POST method, sending/receiving XML documents, 453
human genome sequence, 188
human memory, limiting factor in programming, 225
hygiene condition for macro expansion, 409
hygienic macro expansion
      KFFD algorithm, 410
      lexical scoping implemented for source code, 410
      solving variable capture problems, 409

I[ Top ]
I/O abstraction independence on FreeBSD, 289
I/O in Haskell, 389-391
      forkIO function, 390
IBM Java function library to integrate RPG systems with client/server software, 460
IBM WebSphere application server, Java Servlet running on, 453
icons, auditory (see auditory icons)
ideal partitioning method (Quicksort), 38
identifier? predicate, 416
identifiers
      comparing, 423
      determining binding associated with, 418
      mapping to bindings with substitutions, 414
      Python, built-in, 294
      unintended variable captures
            introduced bindings and references, 409
            scoping in output instead of input, 408
id-label procedure, 418
if form, 421
if statement (JavaScript), 142
IL (see Intermediate Language)
IL Disassembler, 115
ILGenerator class, 119
      Emit method, 120
image filters, 112
image maps for Bio::Graphics output, 210
image processing code, generating on the fly, 105-127
      FilterMethodCS, 116-118
      FilterMethodIL, 119-127
      graphics functions in Microsoft Windows 1.0, 106-112
ImageFilter class, 115
images held in NumPy array, cropping and shrinking, 304
IMAP
      modifying Cryptonite mail store to use, 182
      performance bottlenecks in Cryptonite mail store after implementing, 184
IMAP server as a mail store (Cryptonite), 175
in situ debugging, 360
inaudible (Emacspeak personality), 511
include form, defining in syntax-case, 413
indexing feature, VB TreeView control, 492
indexing, matrix, 233
indirection, levels of (see additional levels of indirection)
individual rights in the digital age, 161
      protection with communications privacy, 185
infix function (JavaScript), 135
infix operators (JavaScript), 134-136
inheritance structure, complicating code, 261
inheritance, JavaScript objects, 131
inode structure (Linux), 276
<INPUT> tags (HTML) of type hidden, 220
input interface (eLocutor), 487-499
      cache implementation, 495
      clipboard, 498
      common words and favorites, 496
      dynamic tree repopulation, 491
input interface (eLocutor) (continued)
      long click, 489-491
            context-sensitive menu selection, implementing, 489-491
      macros, 499
      retracing paths, 497
      searching, 499
      simple typing, 493
      Templates and Replace, 494
      tree structure presenting options, 488
      typing buffer, editing, and scrolling, 497
input validation (Cryptonite mail system), 179
instance method calls in Java, 290
instructions (fundamental), RISC and CISC computers, 147
integrating business partners (see business partners, integrating using REST)
integration as key to success in large applications, 324
intended variable captures, 411
interactive web applications, use of Bio::Graphics output, 191, 210
Intermediate Language (IL), 112
      algorithm customization on the fly, 127
      assignment and operational logic based on virtual evaluation stack, 120
      dynamic generation of, 119
      function optimization for fast digital filter, 117
      generated by C# compiler, 115
      jump or branch instruction (goto), 120
interrupts, reasons for, 159
intersections of segments, 547
intonation in speech, 506
inventor's paradox, 33
inversion of control in runtime architecture of OO framework, 434
inverted index, constructing with MapReduce, 376
IO actions (Haskell), 398
      list comprehension, used to create list of IO actions, 400
      situations where use is essential, 400
      STM (IO ( )) action type, 403
      STM actions vs. as function types, 400
IPC (interprocess communication) mechanisms, 431
      ACE wrapper facades, 436
      associating concurrency strategy with, 437
IPC::Run module (Perl), 181
ISO-9660 filesystem, initializing vop_vector structure, 280
isolation (Haskell transactions), 392
isXMLDigit( ) method, 64
items (ERP5), 341
iterating over entire blocking chain coherently (in Solaris), 357
iteration, use by NumPy for N-dimensional algorithms, 305
iterations through Python dictionaries, 300
Iterative_Logging_Server, 440
      evaluating, 443
Iterator pattern, instance implemented for socket handle sets, 442
iterators
      designing in NumPy, 307-313
            iterator counter tracking, 310
            iterator progression, 308
            iterator setup, 309
            iterator structure, 312
            iterator termination, 309
      iterator interface in NumPy, 313
      NumPy, origins of, 307
      use in NumPy, 314-318
            anecdotes, 317
            iteration over all but one dimension, 315
            multiple iterations, 316-317

J[ Top ]
J2EE (Java 2 Enterprise Edition), 322
      reliability, 325
      scalability, 325
      SOA based on, in CIP, 323
Java
      Apache Log4J package, 329
      API to access functions running on AS/400 server, 453
      arrays, 52
      binary search algorithm bug, 88
      binary search implementation, 52
      binary search program (example), 52
      class libraries for network programming, 430
      client and data tier of CIP, 322
      conversion of regular expression matcher to, 8
      Framework for Integrated Test (see FIT)
      Hello World program, 478
      indirection in, 290
      library for integrating RPG legacy systems with client/server software, 460
      Python implementation (Jython), 297
      random-number generator and Arrays utilities, 96
      Session class, 78
      Store class, 79
      table lookup, implementation with switch statement, 68
      (see also CIP)
Java Servlet running on IBM WebSphere application server, 453
JavaScript, 130-145
      array and object literals, 144
      assignment operators, 137
      constants, 138
      expressions, 134
      functions, 143
      infix operators, 134-136
      precedence, 133
      prefix operators, 136
      scope, 138-140
      Simplified, 130
      statements, 140-143
      symbol table, 131
      tokens, 132
      web sites creating smart client-side interaction via, 520
JDOM, 60
      bad package designs, 66
      name character verification, first version, 62
Jones, Simon Peyton, 385-406
JSLint, parsing technique (example), 145
jump or branch instruction (Intermediate Language), 120
JUnit, 89
Jython, 297

K[ Top ]
Kent, Jim, 217-228
kernel synchronization primitives, priority inheritance (Solaris), 356
Kernighan, Brian, 1-9
key authentication
      PKI vs. web of trust, 186
      public-key cryptography, 164
key management, integrated interface in Cryptonite, 177
key/expression pair (in JavaScript object literals), 145
key/value pairs, 46
      Python dictionaries, 293
keys
      Python dictionaries
            collisions, 298
            different data types in single dictionary, 294
            looking up, 297
            not ordered, 294
keyword arguments in function calls (Python dictionaries), 300
keyword bindings, 415
keywords
      keyword binding, associating the keyword or with a transformer, 411
      reserving the names of, 409
KFFD (hygienic macro expansion algorithm), 410
Kleene, Stephen, 1
Knuth, D. E., 37
kobject structure (Linux), 274
      changed to use struct kref, 275
Kolawa, Adam, 253-266
kref structure (Linux), 275
Kroah-Hartman, Greg, 267-277
Kuchling, Andrew, 293-301

L[ Top ]
labels, 415
      determined by marks and substitutions in an identifier's wrap, 418
      in Intermediate Language, 121
      mapping to bindings with environments, 418
lambda expressions
      in define-syntax form, 411
      exp-lambda procedure, 421
Lampson, Butler, 279
language independence in CIP, 324
LAPACK, 237-240
      LU factorization, 238
      resources for further reading, 252
      SGBSV routine, 255-260
            implementation details, 261
      SGBTRF routine, 262-265
      (see also ScaLAPACK)
large applications, beauty in, 338
large-scale data processing problems, programming system for (see MapReduce)
layering and indirection, 290
layering of filesystems, 285-287
      on FreeBSD, 282
led (left denotation) method, 134
let form, 422
letrec-syntax forms
      exp-letrec-syntax transformer, 422
letrec-syntax, binding macros within a single expression, 412
let-syntax form, 422
Level-1 BLAS, 235
      use in LINPACK factorization, 236
Level-2 BLAS, 230, 243
Level-3 BLAS, 230, 243
levels of indirection (see additional levels of indirection)
lex (lexical analyzer generator), mapping regular expressions into actions, 288
lexical scoping, implementation by hygienic macro expansion, 410
lexical variable bindings, 415
libgd, 211
likeliest causes first, examining in debugging, 467
linear algebra
      algorithms recast as matrix-matrix operations, 231
      core of scientific computing calculations, 229
      dense linear systems, decompositional approach to solutions, 232
      software for advanced-architecture computers, 229
            motivation for development, 230
linear probing, 298
line-segment intersection algorithms, 547
link counting (PageRank), 56
LINPACK, 235-237
      column-oriented algorithms, use of, 235
      implementation of factorization, 235
      resources for further reading, 252
Linux
      desktop environment for secure mail system, 168
      native filesystem, 279
Linux kernel, 267-277
      development process, how it works, 277
      devfs, problems with race conditions, 268
      device handling in persistent manner, lack of, 268
      devices, physical and virtual portions, 267
      power management for devices, 268
      unified driver and device model, 268
            object reference counting in virtual filesystem layer, 273-276
            pointers to struct device, passing around, 271
            runtime type checking, lack of, 272
            scaling up to thousands of devices, 276
            small objects loosely joined, 277
            struct device as base class for all devices, 268
            sysfs virtual filesystem, 269
LISP
      advice, 505
            extension points, discovery of, 513
            tutorial, 507
      ALGOL-like syntax, attempts at, 130
      macros, 408
      parsing techniques, 130
      procedure definition, 540
list comprehension (Haskell), 400
literals (in JavaScript), 131, 144
      literal symbol in JavaScript parser, 132
load balancing, MapReduce implementation, 379
loadable parameters for services, 337
locality, MapReduce implementation, 379
locking, 287
      bank accounts using locks, 386
      handling of locking assertions, 288
      Mutex wrapper facade for acquiring/releasing locks, 437
      problems with locks, 387
            error recovery, 388
            lost wakeups and erroneous retries, 388
            no support for modular programming, 388
            taking in wrong order, 388
            taking the wrong locks, 388
            taking too few, 387
            taking too many, 387
      Solaris user-level priority inheritance bug, 354-368
      strategies for, 432
Log_Handler class, 438
logging
      CIP streamer service, 329-334
      concurrent logging servers, implementing, 444-450
      log record formats, 432
      networked logging service (example application), 431
      Sawzall language for logs analysis, 382
      sequential logging servers, implementing, 439-444
logging server framework, OO design for, 432, 433-439
      associating concurrency strategy with IPC and synchronization, 437
      commonalities, understanding, 434
      key concepts about OO frameworks, 433
      variation, accommodating, 435
Logging_Server abstract base class, 432, 437
      open( ) and request( ) methods, 438
      run( ) method, 439
logical index into an array, translating to physical index, 160
logical operators (short-circuiting), in JavaScript, 136
longest match, 5
      leftmost longest matching, matchstar function, 6
look-ahead computations, 248
lookdict( ) and lookdict_string search functions, 300
lookup table
      binary format, 70
            loading, 70
            using to check a name, 71
      Java instance method calls dispatched through, 290
lookup type (Gene Sorter columns), 223
loops, escaping in binary search, 54
loose coupling of client applications and middleware services, 324
LU factorization, 230
      error analysis and operation count, 250
      LAPACK SGBTRF routine, 262-265
      LAPACK solution, 238
      multithreaded, 247-250
      recursive, 240-243
      ScaLAPACK solution, 243-245
      simple implementation, 233
Luszczek, Piotr, 229-252

M[ Top ]
m4 macro expander, 408
Mac OS X, development platform for secure mail system, 168
macros
      eLocutor, 499
      offsetof macro, 271
      for syntactic abstraction, types of, 408
      syntax-case macro definition, 411
      (see also syntactic abstraction)
magazines, 356
Mail Daemon (cmaild), Cryptonite, 171
      test suite, 172
mail system (Cryptonite), 162-184
      insights from development process, 162
      mail store, 173
            modifying to use IMAP as backend, 182
            performance bottlenecks with IMAP, 184
            replication, 175, 183
            revamping, 174
Mail::Cclient module (Perl), 184
Mail::Folder module (Perl), 175
Mail::Folder::Shadow module (Perl), 176
Mail::IMAPClient module (Perl), 184
main (I/O action in Haskell), 390
main action (Haskell), 401
Mak, Ronald, 319-338
managed code, 112
mapping (Python), 296
MapReduce, 371-384
      computations easily expressed as MapReduce, 375
      distributed implementation (example), 377-380
            execution overview, 377
      extensions to the model, 380
      programming model, 374
      resources for further reading, 381
      word count program (example)
            C++ implementation, 382
mark-object auditory icon, 514
marks, 413
      appearing in an identifier's wrap, determining associated label, 418
Mars Exploration Rover mission (MER), enterprise system for (see CIP)
match function, 4
matchhere function, 4
      longest matching implementation, 6
matchstar function, 5
      leftmost longest matching, 6
mathematical equations vs. computed solutions, 253
mathematical models, science at the application level, 229
MATLAB, 233
matrix algorithms, 230
      computer architecture effects on, 230
      development with MATLAB, 233
      expressing as vector-vector operations, 231
matrix computations through decomposition, 232
matrix functions built into MATLAB, 233
matrix-matrix operations
      Level-3 BLAS, 230
      linear algebra algorithms recast as, 231
      modularity for performance and transportability, 239
matrix-vector operations
      Level-2 BLAS, 230
      recasting linear algebra algorithms as, 237
      recasting linear algebra in terms of, 231
Matsumoto, Yukihiro, 477-481
mbox files, Cryptonite, 173
Mehta, Arun, 483-501
memory
      check looking at problem size and memory of computer, 265
      conservation of, 258
      content-addressable, 46-49
      usage by binary search, 54
      use of (LAPACK SGBSV routine), 260
memory models for N-dimensional array, 305
menu selection (context-sensitive), in eLocutor long click, 489-491
messenger RNA (mRNA), 218
Meta Classes (ERP5), 343
meta environment (exp procedure), 419
metacharacters (regular expressions), 1, 7
metadata in filesystem layering, 287
method form (syntax-case), 413
Microsoft Intermediate Language (MSIL) (see Intermediate Language)
Microsoft Windows (version 1.0), on-the-fly code generation, 106-112
middleware
      host infrastructure, 430
      in multitiered service-oriented architecture, 320
      services loosely coupled with client applications, 324
      stateless session beans as service providers, 323
Middleware Monitor Utility (CIP), 335
middleware.properties file, 337
midpoint calculation, binary search, 92
      calculateMidpoint( ) method, boundary test for, 94
MIME structure of Cryptonite mail messages, 175, 183
modular programming
      concurrent programming using STM, 404
      not supported by locks and condition variables, 388
      parallel programs less modular, 385
modularity in CIP, 324
modules (Python), contents represented as a dictionary, 294
modulus function, unsigned, 152
Monnerat, Rafael, 339-351
monotone voice with no inflection (Emacspeak), 512
motor disabilities, software designed to accommodate, 483-501
Movement class (ERP5), 342
      representing cash withdrawal and material transfer, 345
movements (ERP5), 341
mRNA (messenger RNA), 218
MSIL (Microsoft Intermediate Language) (see Intermediate Language)
multi-core systems, 231
      effects on matrix algorithms, 231
      multithreading for, 247-250
multidimensional iterators (see NumPy)
multithreaded programs in C, reference counting for structures, 273-276
multithreaded, multi-core processors, data consistency through locking, 287
multitiered service-oriented architecture, 320
mutable variables, reading/writing (Haskell side effect), 390
Mutex wrapper facade, 437

N[ Top ]
naïve-collinear function, 542
names
      single style convention, importance of, 227
      validation in XML, 60
      well-chosen, importance in making code understandable, 226
namespace URIs, caching after verification, 73
NASA's Mars Rover mission, enterprise system for (see CIP)
navigation in eLocutor, 497
NB (block size), 239
N-dimensional arrays, 303
      key challenges in operations, 304
      memory models for, 305
      (see also NumPy)
Neomailbox secure email service, 177
.NET Common Language Runtime, 112
.NET Intermediate Language, 117
networked software, object-oriented framework for, 429-450
      design of logging server framework, 433-439
            commonalities, 434
            key concepts about OO frameworks, 433
            tying it all together, 437
            variations, 435
      implementing concurrent logging servers, 444-450
      implementing sequential logging servers, 439-444
      logging service application, 431
next word (in eLocutor), 493
NFS (Network File System), interposing umapfs over, 285
nodes (ERP5), 341
noncontiguous arrays, 306
notation, regular expression, 2
NPR programs, URL template for (Emacspeak), 521
nucleotides (A,G,C,T), 188
nud (null denotation) method, 134
null match, 4
Null Mutex, 443
Null Object pattern, 437
Null_Mutex facade, 440
nullfs filesystem, implementing the bypass function, 284
NumPy (Python), 303-318
      accessing any region of an array using slicing, 304
      iterator design, 307-313
            counter tracking, 310
            progression, 308
            setup, 309
            structure, 312
            termination, 309
      iterator interface, 313
      iterator origins, 307
      iterator use, 314-318
            anecdotes, 317
            iteration over all but one dimension, 315
            multiple iterations, 316-317
      memory models for N-dimensional array, 305
      N-dimensional array operations, key challenges in, 304
      use of iteration for N-dimensional algorithms, 305

O[ Top ]
object classes (Bio::Graphics), 192
      choosing, 198-200
object literals (JavaScript), 131, 145
object reference counting in Linux kernel virtual filesystem layer, 273-276
object-caching allocator, 356
object-oriented (OO) programming languages
      dynamic dispatch to various subclass methods, 289
      frameworks for networked software, 430
object-oriented framework for networked software, 429-450
      design of logging server framework, 433-439
            commonalities, 434
            key concepts about OO frameworks, 433
            tying it all together, 437
            variations, 435
      implementing concurrent logging servers, 444-450
      implementing sequential logging servers, 439-444
      logging service application, 431
object-oriented programming
      C language and, 8
      method call in Perl, 195
objects
      dynamic, with prototypal inheritance (JavaScript), 131
      polymorphic, in Gene Sorter, 221-224
Objects/dictnotes.txt file, 301
Objects/dictobject.c source file, 301
Observer pattern, 434
offsetof macro, 271
Oliphant, Travis E., 303-318
one-dimensional arrays, 303
online information access with Emacspeak (see web-oriented tools in Emacspeak)
OpCodes class, 120
open addressing, 298
OpenBSD, development platform for secure mail system, 168
OpenPGP, 164
      communicating with in Cryptonite mail system, 181
      key operations made available to users, 166
      MIME-aware mail store, 175
      security embedded in Cryptonite, 165
operating systems
      C language APIs, 429
      database or devfs to handle device naming, 268
      locks for critical operating system structures, 287
      supporting different filesystems, 279
            code to access filesystems, 280
            filesystem layers, 285-287
            FreeBSD using indirection to abstract read function arguments, 282-285
      synchronous event demultiplexing APIs, using with reactive logging server, 441
operation count, 251
operator precedence, 129-145
      JavaScript, 130-145
            array and object literals, 144
            assignment operators, 137
            constants, 138
            expressions, 134
            functions, 143
            infix operators, 134-136
            precedence, 133
            prefix operators, 136
            scope, 138-140
            statements, 140-143
            symbol table, 131
            tokens, 132
      top down, 129
optimistic execution, 394
optimization
      base-case optimization for recursive code, 305
      XML verifier
            caching namespace URIs after verification, 72
            digit character verification, 65
            lookup table, 68-72
            parser-based digit character verification, 66
Order class (ERP5), 347
      source base category, 346
order_validateData script, 349
ordering guarantees (MapReduce), 380
OS X, development platform for secure mail system, 168
Otte, William R., 429-450
overloading, leading to complicated code, 261
ownership of locks, tracking for user-level locks, 363

P[ Top ]
package designs, Java, 66
PageRank, 56
pairs
      key/expression, in JavaScript object literals, 145
Panel class (Bio::Graphics), 192, 198
      configuration options, 197
      image_and_map( ) method, 210
      png( ) method, 212
      SVG images, 212
Parallel BLAS (PBLAS), 245-247
      array descriptors, 246
parallel programs, 385
parallel systems with distributed memory, 231
      effects on matrix algorithms, 231
parallelism
      application in web searches, 56
      (see also concurrency)
parallelized word count program (example), 372
      with partitioned processors, 373
      with partitioned storage, 372
Params::Validate module (Perl), 179
Parse class (Java), 77, 80-83
      doCells( ) method, 80
      doRows( ) method, 80
      doTables( ) method, 79
      ignore method, 80
      last( ) and more( ) methods, 83
      parsing code, 81
      representation of entire HTML document, 82
parser-based digit character verification for XML, 66
parsers
      JavaScript, 130-145
            array and object literals, 144
            assignment operators, 137
            constants, 138
            expressions, 134
            functions, 143
            infix operators, 134-136
            precedence, 133
            prefix operators, 136
            scope, 138-140
            statements, 140-143
            tokens, 132
      top-down operator, 129
      XML, checking for correctness in XML input, 66
parsing techniques in LISP, 130
partitioned processors for parallelized program, 373
partitioned storage for parallelized program, 372
partitioning an index based on binary search in arrays of postings, 56
partitioning function (MapReduce), 380
partitioning in Quicksort, ideal method, 38
paths
      ERP5, 341
      retracing in eLocutor tree structure, 497
Pattern and Matcher classes (Java), 8
pattern matching
      in regular expressions (see regular expressions)
      syntax form in syntax-case, 411
pattern or brush (graphical object), 108
patterns
      applied to networked software, 430
      event-dispatching, 434
      frequently encountered in computer programming, 407
      used in OO logging server framework, 432
Patzer, Andrew, 451-462
PBLAS (Parallel BLAS), 245-247
      array descriptors, 246
PCI and USB devices in Linux sysfs, 269
performance
      indirection and, 291
      poor design as root cause of problems, 259
      Python dictionary implementation and, 294
      recursion and, 305
      regular expression matcher, 6
      testing for binary search, 101
      XML verifiers, correct design vs., 74
Perl, 50
      alarm function, 171
      anonymous subroutines, 207
      AUTOLOAD feature, 176
      BioPerl, Bio::Graphics module and, 188-192
      Crypt::PGP5 module, 173
      Cryptonite mail system, 168
      Emacs's cperl mode, 168
      GD library, 211
      GD::SVG module, 212
      prototype-to-production path, DBD::SQLite module, 173
      summary of quirkier parts of syntax, 195
      Text::Template module, 173
      Tie interface, used to tie Postgres' large objects (BLOBs) to filehandles, 174
Persistence::Database::SQL class, 173
Persistence::Object::Postgres class, 173
Persistence::Object::Simple class, 173
personality text properties (Emacspeak), 508
      converting into audio formatting codes, 510
personnel management (MER mission), 322
Petzold, Charles, 105-127
PGP, 164
      encryption backend for Cryptonite mail, 173
physical index into an array, translating logical index to, 160
pitch setting for flat voice (Emacspeak), 512
pitch-range setting (Emacspeak), 512
pivots, 232
PKI (Public Key Infrastructure)
      reimposition of authoritarian cultural tendencies, 186
      shortcomings of, 164
pointers, 5
      contribution to compact code in regular expression matcher, 9
      function arguments to argument pointers, 282-285
      function pointers dispatching a request to different functions, 289
      function pointers, isolating filesystem implementation from code accessing its contents, 282
      PyDictEntry structures, 296
      runtime type checking lacking on Linux kernel, 272
      to a struct device (on Linux), 271
      to vop_vector structure, 280
polymorphism in Gene Sorter, 221-224
pop method, closing a scope in JavaScript parser, 139
population count, 147-160
      basic methods, 148
      comparing for two words, 153
      counting 1-bits in an array, 154-159
      divide and conquer strategy, 149-151
      HAKMEM memo, 151
      sum and difference of two words, 152
      uses of, 158
      uses of population count instruction, 158
portal (CMF), 340
Portal classes, 344
portal_types service, 342
POST and GET requests over HTTP, services exposed through, 452
Postgres database, object persistence, 173
postings, searching with, 55
postmortem debugging, 360
Practice of Programming, The, 2
Pratt, Vaughan, 129
pre-action and post-action hooks, 517
precedence, 133
      (see also operator precedence)
precedence levels (see binding powers)
predecessor base category, 349
prediction
      in eLocutor dynamic tree repopulation, 491
      evaluating efficiency of for typing in eLocutor, 500
      word completion and next word in eLocutor, 493
prefix operators (in JavaScript), 136
preprocessor macros (C), 408
priority inheritance, 356-368
      getting it correct, 357
      implementing for user-level locks, 363
      user-level locks
            waiving, 366
      user-level, debugging, 360-366
priority inversion, 355
privacy in communications, protecting individual rights, 185
private keys, user identify tied to in Cryptonite, 167
processor-independent Intermediate Language (see Intermediate Language)
product-line architecture, 432
programming languages, syntactic abstraction mechanisms, 407
Programming Pearls, 30, 87
Programming Windows with C#, 114
programs generating code while running, 106
progress report for large programs, 51
Project (ERP5), 346-351
      coding, 347-351
            typical project domain attributes and behavior, 348
      relations with Trade, 346
project management, 346
project, defined, 346
pronunciation rules (text preprocessing in Emacspeak), 510
property sheets, 343
      DeliveryLine class, 344
protein-coding genes, 188
prototypal nature, JavaScript, 131
public key cryptography, 186
Public Key Infrastructure (PKI)
      reimposition of authoritarian cultural tendencies, 186
      shortcomings of, 164
public keys tied to contacts in the user's address book (Cryptonite), 167
public-key cryptography, 163
      key authentication, 164
punctuation characters, repeated strings (text preprocessing in Emacspeak), 510
punctuations setting (Emacspeak), 512
put-text-property function, advice implementation, 508
PyArrayIterObject structure, 312
PyDict_SetItem( ) function, 300
PyDictEntry structure, pointers in, 296
PyDictObject structure, 295
      ma_lookup field, pointer to function for looking up keys, 297
      special-case optimization for small hashes, 297
PyIntObject type, 298
PyObject structure, 298
PyStringMap class (Jython), 297
PyStringObject type, 298
Python
      delta debugging algorithm implementation, 471
      dictionaries, 293-301
            basic operations on, 293
            C implementation of Python, 294
            collisions, 298
            iterations and dynamic changes, 300
            keys and values of different data types in single dictionary, 294
            keys not ordered, 294
            passing keyword arguments to a function, 294
            PyDictObject structure, 295
            representing module contents, 294
            resizing, 299
            special-case optimization for small hashes, 297
            special-casing, when it's worthwhile, 297
      download site, 293
      ERP5, 339
            document structure is implemented as portal class, 340
      iterators, 305
      NumPy, 303-318
            iterator design, 307-313
            iterator interface, 313
            iterator origins, 307
            iterator use, 314-318
            key challenges in N-dimensional array operations, 304
            memory models for N-dimensional array, 305
python command (Mac OS and Linux), 293

Q[ Top ]
Quicksort program, 29-40
      aphorisms about beauty, 39
      ideas for refining code, 39
      paring down code while increasing function, 31-36
            average comparisons as pseudocode, 33
            calculation with code moved out of loop, 34
            calculation with dynamic programming, 34
            calculation with inner loop removed, 35
            calculation with symmetry, 34
            counting comparisons used in array sort, 31
            final version of calculation, 36
            increment moved out of loop, 32
            inserting element into binary search tree, 38
            skeleton implemented as a function, 33
            skeleton reduced to counting, 32
            skeleton with single size argument, 33
            techniques used, mathematical analysis of, 37
            techniques used, summary of, 37
      quicksort( ) function, 30
quote form (syntax-case), 415
      exp-quote procedure, 421

R[ Top ]
Rails, pursuit of brevity and DRY, 479
Rake (build tool), 480
Rakefile (example), simplicity of Ruby code, 480
Raman, T. V., 503-525
random numbers
      generating binomially distributed random integers, 160
random-number generator facility of NumPy, 317
ranking search results, 56
raster operations, 107-112
      BitBlt and StretchBlt functions, Windows 1.0, 108
Reactive_Logging_Server
      evaluating, 443
      main program that uses the socket API, 442
Reactive_Logging_Server class, 441
Reactor pattern, 434
readability of code, 477-481
Recall replication framework, 175
records (faulty), skipping in MapReduce implementation, 380
recursion, 6
      contribution to small, clean, elegant code, 9
      for loops looping over N-dimensional arrays, 304
      LU factorization, 240-243
Recursive Descent, 129
Recursive LU Algorithm, basic steps, 242
redundancy, eliminating in code, 479
reentrant functions, 227
re-execution (transactions in STM), 394
re-expression and symmetry in programming, 34, 37
ref( ) function (Perl), 208
references (variable), capture by a variable binding, 408-411
regexps (see regular expressions)
regular expression matcher
      implementation, 3
      reasons for compactness of code, 8
      termination conditions, 6
regular expressions, 1-9, 43-46
      for input validity in Cryptonite mail system, 179
      mapping into actions with lex, 288
      notation, 2
      program for printing article-fetch lines (example), 43-46
regulatory DNA, 188
regulatory protein bound to specific site of the DNA, 206
relational databases
      in eLocutor, 486
            predictor databases, 493
      ERP5, 341
      Gene Sorter and, 223
relationship managers (ERP5), 345
reliability of CIP, 325
      streamer service, 328-336
            logging, 329-334
Replace feature (eLocutor), 494
replication, Cryptonite mail store, 175, 183
Replication::Recall module (Perl), 175
Representational State Transfer (see REST)
representations (syntax-case expansion algorithm), 414
reserved words, 139
resources (ERP5), 341
REST (Representational State Transfer), 452-462
      exchanging data using e-business protocols, 457-462
      exposing services to external clients, 452-455
            defining service interface, 453-455
      routing the service using factory pattern, 456-457
restrictions built into code, causing difficult-to-find errors, 259
retrieval of data, 230
return statement (JavaScript), 143
reuse of code
      ERP5, 351
      promoted by good design and clear, concise code, 261
reusing data to reduce memory traffic, 239
reverse web link graph, constructing with MapReduce, 376
revision number, 12
right associative operators (JavaScript), 136
right mouse button as single binary input for eLocutor, 487
RISC computers
      with cache hierarchies, 230
            effects on matrix algorithms, 231
      fundamental instructions, 147
      population count
            basic methods, 148
river meandering, model of, 547
RNA sequences, 188
RNA, messenger RNA (mRNA), 218
robustness
      CIP (Collaborative Information Portal), 336-337
            dynamic reconfiguration, 337
            hot swapping, 337
      (see also debugging; testing)
Rosettanet e-business protocol, 453
      exchanging requests and responses using, 457-462
      web site, 457
RowFixture class (Java), 77
RPG legacy systems, integrating with modern client/server software, 460
RSS and Atom feeds, 522
rsync's rolling checksum algorithm, 11
Ruby programming language, 43-49
      array implementation, 52
      beautiful code support
            brevity (Hello World example), 478
            brevity and DRY, 479
            familiarity, 479
            simplicity, 480
      counting article fetches, 47
      delimiting code blocks, 48
      optimizing program that reports most popular articles, 49
      stripped-down design, 46
runtime environment (exp procedure), 419

S[ Top ]
same-marks? predicate, 418
Santa Claus problem (concurrent program using STM), 396-403
Savoia, Alberto, 85-103
Sawzall language for logs analysis, 382
scalability
      of beautiful code, 259
      CIP, 325
Scalable Vector Graphics (SVG) images, 212
ScaLAPACK
      LU factorization, 243-245
      PBLAS (Parallel BLAS), 245-247
Scheme language
      expanding expressions containing macros into expressions in the core language, 424
      primitives for converting strings to and from symbols, 415
      quasiquote syntax for creating list structure, 415
      syntax-case, 411
      transformation of or form into let and if, 408
Schmidt, Douglas C., 429-450
scientific method, applied to program failures, 466
scope, 138-140
      functions, 143
      new scope for a function or a block, 140
      OO framework, 434
scripting language (MATLAB), 233
scrolling in eLocutor, 498
searches, 41-57
      binary search, 52
            advantages and disadvantages, 54
      content-addressable storage, 46-49
      emacspeak-websearch module for task-oriented search, 517-520
      escaping the loop, 54
      optimizing program that reports most popular articles, 49
      postings, 55
      ranking results, 56
      regular expressions, 43-46
            using in program that prints article-fetch lines, 43-46
      time involved in running and programming, 41
      web searches, 56
      weblog data, 42
      writing search algorithm, 50
secure communications, 161-186
      complexity of secure messaging, untangling, 163
      Cryptonite mail system, 162-184
      hacking the civilization, 185
      privacy protection for individual rights, 185
Seiwald, Christopher, 527-537
self-evaluating? predicate, 417
sequential concurrency models, implemented in logging servers, 439-444
serialization, Cryptonite messages, 170
Service class (Cryptonite), 170
Service class (example), 454
service-oriented architecture (see SOA)
services
      exposing to external clients, 452-455
      in multitiered service-oriented architecture, 320
Session class (Java), 78
session key, Gene Sorter, 220
sets, computing size for sets represented by bit strings, 158
s-expression, 412
      conversion to/from syntax object using datum->syntax, 424
      representing a quote form, 421
      representing an if form, 421
SGBSV routine (LAPACK library), 255-260
      implementation details, 261
shadow folder for mailbox messages, 176
shadowed folder for mailbox messages, 176
shards, 56
sharpness filter, 113
shift right immediates instruction, 151
short-circuiting logical operators (JavaScript), 136
shortest match, 5
side effects
      in Haskell, 389-391
            being explicit about, 391
      minimizing, 227
sideways sum (see population count)
Simple Object Access Protocol (SOAP), 452
SimpleItem property sheet, 343
simplicity in code, 261
      Ruby programming language, 480
Simplified JavaScript, 130
single binary input for eLocutor, 487
single-binding let forms, transforming with exp-let procedure, 422
single-binding letrec-syntax forms, 422
single-chip multi-core machines, 231
skipping bad records (MapReduce), 380
slicing, 304
slopes
      calculating, 542
      comparing to test collinearity, 544-545
      measurement with respect to the y-axis, 543
small pieces of code, practicing with, 40
smoke tests, 91
SMP (symmetric multiprocessing) machines, 231
SOA (service-oriented architecture)
      loose coupling of services with client applications, 324
      three-tiered, CIP implementation, 322
SOAP, using REST over, 452
SOCK_Acceptor type, 443
software
      bugs as "spoonful of sewage in the barrel of wine", 353
      correctness and purity of, 353
      operated with a single button, 483-501
software engineering principles, 368
software systems, 40
Software Transactional Memory (see STM)
Solaris
      development of critical kernel subsystem, 354
      interaction between kernel memory allocator and Zettabyte Filesystem (ZFS), 356
      priority inheritance for kernel synchronization primitives, 356
      user-level priority inheritance, debugging, 360-366
sorting
      distributed, performing with MapReduce, 376
      MapReduce, ordering guarantees, 380
      sort function, 31
      (see also Quicksort program)
source_project base category, 347
      retrieving tasks of a project, 348
sparse matrices, 230
specifications for code, incompleteness of, 260
speech delivery in eLocutor, 499
speech output, styling with Aural CSS (ACSS), 511-516
speech servers, 504
speech-enabling Emacs, 505-516
      advice tutorial, 507
      first-cut implementation, 505
      generating rich auditory output, 507-511
      implementing event queue in speech server, 505
spin lock (thread lock) in Solaris, 358
Spinellis, Diomidis, 279-291
splitting text into appropriate clauses (Emacspeak), 510
spoken output, producing, 504
"spoonful of sewage in the barrel of wine," software bugs as, 353
SQL
      code to fetch data for Gene Sorter association columns, 224
      mail storage backend (Cryptonite), 175
SQL database, integration with cookie and hidden variable mechanisms, 220
sqrt returning an irrational result, 546
standards-based applications, beauty of, 324
start position (genomic features), 190
stateful session beans, 323
      CIP streamer service, 326
stateless session beans, 323
      CIP streamer service provider, 326
statements (JavaScript), 140-143
std (statement denotation) method (JavaScript tokens), 140
Stein, Lincoln, 187-215
STM (Software Transactional Memory), 386, 388-405
      implementing transactional memory, 394
      Santa Claus problem (example program), 396-403
      side effects and I/O in Haskell, 388-391
      summary of basic operations, 396
      transactions in Haskell, 392-393
STM actions, 392
      forming a list and combining with orElse, 403
      giving functions STM types wherever possible, 400
storage and retrieval of data, 230
Store class (Java), 79
Strategy pattern, 437
streamer service (CIP), 325-336
      functionality, 325
      reliability, 328-336
            logging, 329-334
      service architecture, 326
streaminess (Subversion interface), 23
stress tests, 369
StretchBlt function (Windows 1.0), 106
      raster operations, 108
string-specialized dictionary type, 297
strip procedure, 415
structures
      base structure field defining pointer type, 272
      dictionary structures no longer in use, 300
      holding packed function arguments, 288
      inheritance and manipulation on Linux kernel, 269-272
      in multithreaded programs, reference counting, 273-276
      NumPy iterator, 312
      PyDictObject, 295
      PyObject, 298
      struct_inode and struct_dentry, putting in kernel caches, 277
subfeatures and sub-subfeatures (genomic features), 190
subroutines, logical division of tasks into, 265
substitutions, 413
      appearing in an identifier's wrap, determining associated label, 418
      mapping a symbolic name and list of marks to a label, 415
subsystem, same design assumptions for memory usage as main system, 261
subtracts instruction, 151
Subversion, delta editor, 11-28
summing factor technique, 37
SVG (Scalable Vector Graphics) images, 212
svn_delta_editor_t (see delta editor)
svn_error_t (Subversion error type), 17
svnsync functionality (Subversion), 27
switch statements (Java), 68
      problems with larger groups of cases, 70
symbol table (JavaScript parser), 131
symmetric multiprocessing (SMP) machines, 231
symmetry, exploiting in tuning Quicksort loop, 34
synchronization mechanisms
      ACE wrapper facades, 436
      associating concurrency strategy with, 437
synchronized methods, 386
synchronous event demultiplexing APIs (operating systems), 441
SyncML protocol, 341
syntactic abstraction, 407-428
syntax form, 411
      use by expander, 420
syntax objects, 414
      conversion of s-expressions to/from, using datum->syntax, 424
      nonatomic structure, determining, 416
      parsing and constructing, 423
      stripping, 415
syntax->datum procedure, 413
syntax-car operator, 423
syntax-case
      expander example, 425-427
      expansion algorithm, 413-425
            comparing identifiers, 423
            conversions, 424
            core transformers, 421-423
            creating wraps, 417
            expander, 419-421
            identifier resolution, 418
            manipulating environments, 418
            parsing and constructing syntax objects, 423
            producing expander output, 415
            representations, 414
            starting expansion, 424
            stripping syntax objects, 415
            structural predicates, 416
            syntax errors, 416
      introduction to, 411-413
            datum->syntax procedure, 413
            hygiene, bending or breaking, 412
            input or output form followed by ellipsis, 412
            macro definition, 411
            method form, 413
            with-syntax form, 413
syntax-case form, 411
      use by expander, 420
syntax-case system, 411
syntax-cdr operator, 423
syntax-error, 416
syntax-pair? operator, 423
syntax-rules system, 410
sysfs (Linux), 269
      excessive memory usage, 276
      rewriting code to put struct inode and struct dentry structures in kernel caches, 277
systematic debugging, 466
      further reading, 476

T[ Top ]
table lookup, 68
      using in population count, 149
tallying, history of, 50
Task Report workflow, 350
task reports (ERP5), 347
taskReport_notifyAssignee script, 350
tasks (ERP5), 347
      associated with a project, 347
            retrieving, 348
      task predecessors, 349
      Task workflow, 349
TCL language, implementation of Emacspeak speech servers, 504
template identifier, 412
Template Method pattern, 432
      in Logging_Server base class run( ) method, 450
      structure and application to logging server, 435
template specifying output in define-syntax form, 412
Templates (in eLocutor), 494
term vector per host, constructing with MapReduce, 376
termination conditions (regular expression matcher), 6
ternary operator (?:) in JavaScript, 135
ternary raster operation, 108
testing, 85-103
      beauty in tests, 86
      binary search, 87, 90-102
            boundary value tests, 92-95
            performance, 101
            random testing, 95-100
            smoke test, 91
      continuous, 467
      Cryptonite mail system, 172
      FIT (Framework for Integrated Test), 75-84
      importance of test programs, 260
      JUnit testing framework, 89
text delta (Subversion), 17
text preprocessing before sending to speech server (Emacspeak tts-speak), 510
text searches, 55
text, splitting into clauses for speech synthesis, 506
Text::Template module (Perl), 173
Thompson, Ken, 1
thread lock, 358
three-dimensional arrays, 303
time management (MER mission), 321
tokens
      JavaScript, 132
            arity, 132
            precedence decisions, 133
            std method, 140
      token-based C preprocessor macros, 408
Top Down Operator Precedence, 129
top mark, 416
Track class (Bio::Graphics), 198
tracks (Bio::Graphics module), 193-195
      configuration options, 196
      positions and relative strengths of DNA/protein binding site, 206
      subclass of Glyph, 199
Trade BT, 346
trailing 0s in a word, computing number of, 159
transaction log, 394
transactional memory, 386, 405
      (see also STM)
transactions (in Haskell), 392-393
transformers, 411
      core, 421-423
transposition operator ('), 233
transposons, 218
tree delta (Subversion editor), processing each piece upon creation, 23
tree structure presenting options in eLocutor, 487, 488
      dynamic repopulation, 491
tree transformation, version control and, 12-15
triangle inequality, testing collinearity by, 545
triangle-collinear function, 546
tts-format-text-and-speak function (Emacspeak), 510
tts-speak function, 507
tts-speak module (Emacspeak), 510
tts-speak-using-voice function, 511
turnstile_block( ) function, 354
turnstile_pi_waive( ) function, 366
turnstiles (Solaris), 354
      priority inversion, 355
two-dimensional arrays, 303
type (bindings), 415
type checking for pointers, 272
type signature (Haskell), 389
TypeAdapter class (Java), 77
typing in eLocutor, 493, 497
      speeding up, 485

U[ Top ]
UBM (Unified Business Model), 341
udev tool (Linux), 272
ufs filesystem (BSD 4.2), 283
umapfs filesystem, 282
      interposing over NFS implementation, 285
understandable code, keys to, 225-228
      brevity and simplicity of code, 261
      documentation, 227
      effect of indirection on comprehension of code, 291
      limits of human memory, 225
      minimizing side effects, 227
      single, consistent style for names, 227
      using scope as local as possible, 227
      well-chosen names, 226
unhygienic macro expansion, 410
Unicode code points in XML, 60
Unified Business Model (UBM), 341
Unix operating system
      input and output sources, uniform treatment of, 289
      read system call variants, 289
      socket API, 429
Unix-related operating systems, use of function pointers, 282
unordered hash (Perl), 195
unsigned modulus instruction, 152
URIs (Uniform Resource Identifiers), caching after verifying for XML input, 73
URL templates (Emacspeak), 520
      Google News searches via Atom feeds, 522
      retrieving weather for a city or state, 522
usability considerations in public-key cryptosystems, 166
USB devices in Linux sysfs, 269
USB sticks, FAT-32 filesystem, 279
usb_interface structure (Linux), 271
      pointer, getting with container_of macro, 272
      structures embedded within other structures, 276
user key for Gene Sorter, 220
user-defined control structures (in Haskell), 391
user-level priority inheritance bug, Solaris, 354-368

V[ Top ]
validation
      transaction log, 394
      user input, Cryptonite mail system, 179
      XML, 59
validity (XML), 60
value (bindings), 415
values
      Python dictionaries
            different data types in a single dictionary, 294
      searching for, 46
var statement (JavaScript), 141
variabilities in OO framework analysis, 434
variable capture problems, 408-411
      solving with hygienic macro expansion, 409
variable names, Perl, 195
variables
      CGI, 220
      defining in current block (JavaScript), 141
      naming, understanding purpose from the name, 226
      reading/writing a mutable variable, side effect in Haskell, 390
      scope in JavaScript, 138-140
VB (Visual Basic), 485
      TreeView control, 488
            indexing feature speeding up retrieval, 492
vector machines, 230
      vectorization of linear algebra algorithms, 237
vector of I/O requests, Unix read system calls, 289
vectorization and parallelism, algorithmic approach for exploiting, 230
vector-vector operations
      denoted by Level-1, 235
      expressing matrix algorithms as, 231
verifiers, XML (see XML verifiers)
version-control system (see Subversion, delta editor)
vertical line, y-intercept, 542
virtual evaluation stack (in IL), 120
virtual machines, 290
vnode call interface, FreeBSD version 6.1 implementation, 288
vnodeop_desc structure, 286
voice overlays (Emacspeak), 512
voice-lock (Emacspeak), 508
voice-monotone, ACSS setting corresponding to, 512
vop_generic_args structure (FreeBSD), 286
vop_vector structure (FreeBSD), 280
      filesystem layering support, 282
      pointer to a bypass function, 284
      pointer to vop_vector structure of underlying filesystem layer, 284
      populating bypass and default fields, filesystem choices resulting from, 284

W[ Top ]
waking up threads in Solaris, 354
Warren, Henry S., Jr., 147-160
web applications, use of Bio::Graphics output, 191, 210
web link graphs, constructing with MapReduce, 376
web of trust
      key authentication stronger than PKI, 186
      key management interface in Cryptonite, 177
      visibility of information in Cryptonite Key Ring view, 166
web page for this book, xxi
web searches, 55, 56
web services
      communication between client applications and middleware services, 324
      use by CIP streamer service for client requests and responses, 326
Web Services architecture, decision points for choosing, 452
web site for this book, 382
web.xml file for servlet providing user interface, 454
web-based genome browsers based on Bio::Graphics, 211
weblogs, searching, 42
web-oriented tools in Emacspeak, 516-522
      basic HTML with Emacs W3 and ACSS, 517
      feed readers, 522
      Web command line and URL templates, 520
      websearch module for task-oriented search, 517-520
webs of trust, 164
well-formedness (XML), 60
Wheeler, David, 290
while loop, 4
while statement (JavaScript), 142
wildcards
      in regular expressions, 1
      shell, modifying regular expressions to resemble, 8
window handler (Subversion), 17
Windows Forms code (ImageClip program), 114
Windows operating systems
      native filesystem, 279
      threading API, 429
Wingerd, Laura, 527-537
with-syntax form, 413
word completion in eLocutor, 485, 493
word count program (example), 371-374
      C++ implementation, 382
      division of problem into Map and Reduce functions, 374
      parallelized, 372
      parallelized word count program
            with partitioned processors, 373
            with partitioned storage, 372
word groupings in eLocutor, 486
words, common (eLocutor), 496
workflows (ERP5)
      implementing task behavior, 349
      Task Report, 350
working copy (Subversion), 15
Wrapper Facade pattern, 432, 436
wrapper facades, use in sequential logging server implementation, 444
wraps, 413
      creating, 417
      stripping, 415

X[ Top ]
XML
      assembling XML response, 462
      parsing data using XPath, 458-462
      request/response data via HTTP POST, 453
      Version 1.0 specification, 61
XML technologies, ERP5 reliance on, 341
XML verifiers, 59-74
      first optimization, Version 3, 64
      fourth optimization, caching namespace URIs after verification, 72
      name character verification, version 1, 62
      role of validation, 59
      second optimization, Version 4, 66
      third optimization, lookup table, 68-72
      XML-based named character verification, Version 2, 63
XMLObject class, 343

Y[ Top ]
yacc (parser generator), input of language grammar and production rules, 288
Yahoo! Maps, accessing directions with emacspeak-websearch tool, 518
y-intercept of a vertical line, 542

Z[ Top ]
Zeller, Andreas, 463-476
ZFS (Zettabyte Filesystem), 356
Zimmermann, Phil, 164
ZODB, 340
Zope platform, 339, 342-346
      CMF (Content Management Framework), 340, 342
      key components used by ERP5, 340
ZPT (Zope Page Templates), 340