\entry{reusable code}{1}{reusable code} \entry{code, reusable}{1}{code, reusable} \entry{shared library}{1}{shared library} \entry{library, shared}{1}{library, shared} \entry{maintainable code}{1}{maintainable code} \entry{code, maintainable}{1}{code, maintainable} \entry{system programming}{1}{system programming} \entry{programming, system-}{1}{programming, system-} \entry{application programming}{1}{application programming} \entry{programming, application-}{1}{programming, application-} \entry{symbolic programming}{1}{symbolic programming} \entry{programming, symbolic}{1}{programming, symbolic} \entry{real world objects}{1}{real world objects} \entry{objects, real world}{1}{objects, real world} \entry{computer science objects}{1}{computer science objects} \entry{objects, of computer science}{1}{objects, of computer science} \entry{C language}{2}{C language} \entry{language, C}{2}{language, C} \entry{static keyword}{2}{\code {static} keyword} \entry{keyword, static}{2}{keyword, \code {static}} \entry{encapsulation of information}{2}{encapsulation of information} \entry{header file}{2}{header file} \entry{automatic memory management}{2}{automatic memory management} \entry{memory management, automatic}{2}{memory management, automatic} \entry{garbage collection}{2}{garbage collection} \entry{hiding implementation details}{2}{hiding implementation details} \entry{implementation details, hiding}{2}{implementation details, hiding} \entry{shared object}{2}{shared object} \entry{object, shared}{2}{object, shared} \entry{reusability}{3}{reusability} \entry{software component}{3}{software component} \entry{structured programming}{3}{structured programming} \entry{programming, structured}{3}{programming, structured} \entry{function, module as}{3}{function, module as} \entry{module, functional}{3}{module, functional} \entry{numeric problems}{3}{numeric problems} \entry{symbolic programming}{3}{symbolic programming} \entry{programming, symbolic}{3}{programming, symbolic} \entry{parameters of software component}{3}{parameters of software component} \entry{object, module as}{3}{object, module as} \entry{module, object-}{3}{module, object-} \entry{modular programming}{3}{modular programming} \entry{programming, modular}{3}{programming, modular} \entry{evolution of a program}{3}{evolution of a program} \entry{program, evolution of a}{3}{program, evolution of a} \entry{bug fixes, time spent on}{3}{bug fixes, time spent on} \entry{function, module as}{4}{function, module as} \entry{module, functional}{4}{module, functional} \entry{object, module as}{4}{object, module as} \entry{module, object-}{4}{module, object-} \entry{abstract data type}{4}{abstract data type} \entry{data type, abstract}{4}{data type, abstract} \entry{top-down design}{4}{top-down design} \entry{design, top-down}{4}{design, top-down} \entry{bottom-up design}{4}{bottom-up design} \entry{design, bottom up}{4}{design, bottom up} \entry{hiding implementation details}{4}{hiding implementation details} \entry{implementation details, hiding}{4}{implementation details, hiding} \entry{interface of a module}{5}{interface of a module} \entry{implementation of a module}{5}{implementation of a module} \entry{header file}{5}{header file} \entry{functional interface}{6}{functional interface} \entry{interface, functional}{6}{interface, functional} \entry{imperative interface}{6}{imperative interface} \entry{interface, imperative}{6}{interface, imperative} \entry{functional implementation}{6}{functional implementation} \entry{implementation, functional}{6}{implementation, functional} \entry{cgc garbage collector}{6}{\code {cgc} garbage collector} \entry{imperative implementation}{6}{imperative implementation} \entry{implementation, imperative}{6}{implementation, imperative} \entry{preserving equality}{6}{preserving equality} \entry{equality, preservation of}{6}{equality, preservation of} \entry{header of an object}{6}{header of an object} \entry{object, header of}{6}{object, header of} \entry{arbitrary limitation}{7}{arbitrary limitation} \entry{limitation, arbitrary}{7}{limitation, arbitrary} \entry{complexity of algorithm}{7}{complexity of algorithm} \entry{algorithm, complexity of}{7}{algorithm, complexity of} \entry{soft limitation}{7}{soft limitation} \entry{limitation, soft}{7}{limitation, soft} \entry{parameter of software component}{8}{parameter of software component} \entry{precompilation of module}{8}{precompilation of module} \entry{module, precompilation of}{8}{module, precompilation of} \entry{library, shared}{8}{library, shared} \entry{shared library}{8}{shared library} \entry{parameter, compile-time-}{8}{parameter, compile-time-} \entry{container module}{9}{container module} \entry{module, container-}{9}{module, container-} \entry{genericity}{9}{genericity} \entry{generic module}{9}{generic module} \entry{module, generic}{9}{module, generic} \entry{type variable}{9}{type variable} \entry{variable, type-}{9}{variable, type-} \entry{instantiation of type variable}{9}{instantiation of type variable} \entry{type variable, instantiation of}{9}{type variable, instantiation of} \entry{genericity, in C}{9}{genericity, in C} \entry{polymorphism}{9}{polymorphism} \entry{polymorphic module}{9}{polymorphic module} \entry{module, polymorphic}{9}{module, polymorphic} \entry{size of object in polymorphic module}{9}{size of object in polymorphic module} \entry{polymorphic module, size of object in}{9}{polymorphic module, size of object in} \entry{qsort function}{10}{qsort function} \entry{pointer abstraction}{10}{pointer abstraction} \entry{abstraction, pointer-}{10}{abstraction, pointer-} \entry{hiding implementation details}{10}{hiding implementation details} \entry{implementation details, hiding}{10}{implementation details, hiding} \entry{container module}{10}{container module} \entry{module, container-}{10}{module, container-} \entry{polymorphic module}{10}{polymorphic module} \entry{module, polymorphic}{10}{module, polymorphic} \entry{polymorphic container}{10}{polymorphic container} \entry{container, polymorphic}{10}{container, polymorphic} \entry{header file}{10}{header file} \entry{heap memory}{10}{heap memory} \entry{memory, heap-}{10}{memory, heap-} \entry{memory, dynamically allocated}{10}{memory, dynamically allocated} \entry{garbage collection}{10}{garbage collection} \entry{garbage collector}{10}{garbage collector} \entry{cgc garbage collector}{10}{\code {cgc} garbage collector} \entry{type safe module}{10}{type safe module} \entry{module, type-safe.}{10}{module, type-safe.} \entry{type cast}{10}{type cast} \entry{cast, type-}{10}{cast, type-} \entry{encapsulation}{10}{encapsulation} \entry{data-driven programming}{10}{data-driven programming} \entry{programming, data-driven}{10}{programming, data-driven} \entry{event loop}{10}{event loop} \entry{switch statment}{11}{\code {switch} statment} \entry{hash table, alternative to switch}{11}{hash table, alternative to \code {switch}} \entry{switch statment}{11}{\code {switch} statment} \entry{defensive programming}{11}{defensive programming} \entry{programming, defensive}{11}{programming, defensive} \entry{programming, by contract}{11}{programming, by contract} \entry{contract, programming by}{11}{contract, programming by} \entry{assert clause}{12}{\code {assert} clause} \entry{error}{12}{error} \entry{termination of program execution}{12}{termination of program execution} \entry{program execution, termination of}{12}{program execution, termination of} \entry{error, fatal}{12}{error, fatal} \entry{error message}{13}{error message} \entry{exception}{13}{exception} \entry{FORTRAN}{14}{FORTRAN} \entry{Turbo Pascal}{14}{Turbo Pascal} \entry{goto instruction, nonlocal}{14}{\code {goto} instruction, nonlocal} \entry{nonlocal goto instruction}{14}{nonlocal \code {goto} instruction} \entry{function return code, to indicate error}{14}{function return code, to indicate error} \entry{error, indicated by function return code}{14}{error, indicated by function return code} \entry{setjmp library routine}{14}{\code {setjmp} library routine} \entry{longjmp library routine}{14}{\code {longjmp} library routine} \entry{exception, handled by setjmp and longjmp}{14}{exception, handled by \code {setjmp} and \code {longjmp}} \entry{open-closed principle}{15}{open-closed principle} \entry{module, closed}{15}{module, closed} \entry{closed module}{15}{closed module} \entry{complete interface}{15}{complete interface} \entry{interface, complete}{15}{interface, complete} \entry{open module}{15}{open module} \entry{module, open}{15}{module, open} \entry{naming convention}{15}{naming convention} \entry{naming convention, Hungarian}{15}{naming convention, Hungarian} \entry{Hungarian naming convention}{15}{Hungarian naming convention} \entry{hiding implementation details}{15}{hiding implementation details} \entry{implementation details, hiding}{15}{implementation details, hiding} \entry{prefixing fields of a structure}{16}{prefixing fields of a structure} \entry{prefixing names of a module}{16}{prefixing names of a module} \entry{cgc garbage collector}{16}{\code {cgc} garbage collector} \entry{naming convention, traditional}{16}{naming convention, traditional} \entry{file descriptor}{16}{file descriptor} \entry{file pointer}{16}{file pointer} \entry{identifier, length of}{16}{identifier, length of} \entry{length of identifier}{16}{length of identifier} \entry{loop counter}{17}{loop counter} \entry{indentation, consistent}{17}{indentation, consistent} \entry{visibility of names}{17}{visibility of names} \entry{static keyword}{17}{\code {static} keyword} \entry{keyword, static}{17}{keyword, \code {static}} \entry{duplication, of information}{18}{duplication, of information} \entry{information, duplication of}{18}{information, duplication of} \entry{cut-and-paste, source of duplication}{19}{cut-and-paste, source of duplication} \entry{functional abstraction}{19}{functional abstraction} \entry{abstraction, functional}{19}{abstraction, functional} \entry{macro abstraction}{19}{macro abstraction} \entry{abstraction, macro-}{19}{abstraction, macro-} \entry{cache memory, size of}{19}{cache memory, size of} \entry{comment, may duplicate information}{19}{comment, may duplicate information} \entry{heap memory}{20}{heap memory} \entry{memory, heap-}{20}{memory, heap-} \entry{memory, dynamically allocated}{20}{memory, dynamically allocated} \entry{garbage collection}{20}{garbage collection} \entry{garbage collector}{20}{garbage collector} \entry{reference, to an object}{20}{reference, to an object} \entry{cgc garbage collector}{21}{\code {cgc} garbage collector} \entry{idiom}{21}{idiom} \entry{idiomatic expression}{21}{idiomatic expression} \entry{expression, idiomatic}{21}{expression, idiomatic} \entry{idiom, foreign}{22}{idiom, foreign} \entry{idiom, of C}{22}{idiom, of C} \entry{useless code}{22}{useless code} \entry{code, useless}{22}{code, useless} \entry{header file}{24}{header file} \entry{hiding implementation details}{24}{hiding implementation details} \entry{implementation details, hiding}{24}{implementation details, hiding} \entry{ANSI function prototype}{24}{ANSI function prototype} \entry{function prototype}{24}{function prototype} \entry{abstract data type}{26}{abstract data type} \entry{data type, abstract}{26}{data type, abstract} \entry{operation, on an abstract data type}{26}{operation, on an abstract data type} \entry{functional interface}{26}{functional interface} \entry{interface, functional}{26}{interface, functional} \entry{imperative interface}{26}{imperative interface} \entry{interface, imperative}{26}{interface, imperative} \entry{referential transparency}{26}{referential transparency} \entry{garbage collector}{26}{garbage collector} \entry{header file}{27}{header file} \entry{prefixing names of a module}{27}{prefixing names of a module} \entry{hiding implementation details}{27}{hiding implementation details} \entry{implementation details, hiding}{27}{implementation details, hiding} \entry{pointer abstraction}{27}{pointer abstraction} \entry{abstraction, pointer-}{27}{abstraction, pointer-} \entry{polymorphism}{27}{polymorphism} \entry{parameter, compile-time}{27}{parameter, compile-time} \entry{complexity of algorithm}{27}{complexity of algorithm} \entry{algorithm, complexity of}{27}{algorithm, complexity of} \entry{ANSI function prototype}{27}{ANSI function prototype} \entry{function prototype}{27}{function prototype} \entry{complexity of algorithm}{27}{complexity of algorithm} \entry{algorithm, complexity of}{27}{algorithm, complexity of} \entry{idiom, of C}{27}{idiom, of C} \entry{static keyword}{27}{\code {static} keyword} \entry{keyword, static}{27}{keyword, \code {static}} \entry{duplication, of information}{27}{duplication, of information} \entry{information, duplication of}{27}{information, duplication of} \entry{naming convention}{27}{naming convention} \entry{indentation}{28}{indentation} \entry{comment}{28}{comment} \entry{heap memory}{28}{heap memory} \entry{memory, heap-}{28}{memory, heap-} \entry{memory, dynamically allocated}{28}{memory, dynamically allocated} \entry{cgc garbage collector}{28}{\code {cgc} garbage collector} \entry{bottom-up design}{29}{bottom-up design} \entry{design, bottom up}{29}{design, bottom up} \entry{container module}{29}{container module} \entry{module, container-}{29}{module, container-} \entry{shared object}{29}{shared object} \entry{object, shared}{29}{object, shared} \entry{imperative interface}{29}{imperative interface} \entry{interface, imperative}{29}{interface, imperative} \entry{imperative implementation}{29}{imperative implementation} \entry{implementation, imperative}{29}{implementation, imperative} \entry{prefixing names of a module}{29}{prefixing names of a module} \entry{comment}{29}{comment} \entry{C++ programming language}{32}{C++ programming language} \entry{inheritance}{32}{inheritance} \entry{documentation}{33}{documentation} \entry{project documentation}{33}{project documentation} \entry{documentation, project-}{33}{documentation, project-} \entry{maintenance documentation}{33}{maintenance documentation} \entry{documentation, maintenance-}{33}{documentation, maintenance-} \entry{user documentation}{33}{user documentation} \entry{documentation, user-}{33}{documentation, user-} \entry{project documentation}{33}{project documentation} \entry{documentation, project-}{33}{documentation, project-} \entry{maintenance documentation}{33}{maintenance documentation} \entry{documentation, maintenance-}{33}{documentation, maintenance-} \entry{code as documentation}{33}{code as documentation} \entry{maintenance manual}{33}{maintenance manual} \entry{manual, maintenance-}{33}{manual, maintenance-} \entry{user documentation}{34}{user documentation} \entry{documentation, user-}{34}{documentation, user-} \entry{reference manual}{34}{reference manual} \entry{manual, reference-}{34}{manual, reference-} \entry{user manual}{34}{user manual} \entry{manual, user-}{34}{manual, user-} \entry{reference card}{34}{reference card} \entry{tutorial}{34}{tutorial} \entry{user manual}{34}{user manual} \entry{manual, user-}{34}{manual, user-} \entry{tutorial}{34}{tutorial} \entry{reference card}{34}{reference card}