programming languages : design principles, implementation constructs
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
contents
>>
  1. programming languages : design principles, implementation constructs
    1. why, how, what to study
      1. abstraction: low-level machine, high-level human
      2. translation: compilation, interpretation
      3. programming environments
    2. programming language paradigms
    3. programming languages reference books

  2. programming language syntax
    1. specifying syntax: regular expressions and context-free grammars
    2. recognizing syntax: scanners and parsers
    3. theoretical foundations

  3. names, scopes, and binding
    1. binding time
    2. object lifetime and storage management
      1. stack-based allocation
      2. heap-based allocation
      3. garbage collection
    3. scope rules
      1. static scope
      2. dynamic scope
      3. symbol tables
      4. association lists and central reference tables
    4. the binding of referencing environments
    5. overloading and related concepts
    6. namespace problems

  4. control flow
    1. expression evaluation
      1. precedence and associativity
      2. assignments
      3. ordering within expressions
      4. short-circuit evaluation
    2. structured and unstructured flow
    3. sequencing
    4. selection
    5. iteration
    6. recursion
    7. nondeterminancy

  5. data types
    1. type systems
      1. the definition of types
      2. the classification of types
    2. type checking
      1. type equivalence
      2. type conversion and casts
      3. type compatibility and coercion
      4. type inference
    3. records(structures) and variants(unions)
    4. arrays
    5. strings
    6. pointers and recursive types
    7. lists
    8. files and i/o

  6. programming units: control abstractions
    1. stack layout
    2. calling sequences
      1. in-line expansion
    3. parameter passing
      1. parameter modes
      2. special-purpose parameters
      3. function returns
    4. generic units
    5. exception handling
      1. definition of exceptions
      2. exception propagation
    6. coroutines

  7. data abstraction and object orientation
    1. object-oriented programming
    2. encapsulation and inheritance
      1. modules
      2. classes
      3. type extension
    3. initialization and finalization
      1. constructor
      2. references and values
      3. execution order
      4. destructor/garbage collection
    4. dynamic method binding - polymorphism
      1. virtual and nonvirtual methods
      2. abstract classes
    5. multiple inheritance

  8. nonimperative programming models: functional and logical languages
    1. historical origins
    2. functional programming
      1. review/overview of lisp/scheme
      2. evaluation order
      3. higher-order functions
      4. theoretical foundations
      5. functional programming in perspective
    3. logic programming
      1. prolog
      2. theoretical foundations
      3. logic programming in perspective

  9. concurrency
    1. background and motivation
      1. the case for multithreaded programs
      2. multiprocessor architecture
    2. concurrent programming fundamentals
      1. communication and synchronization
      2. languages and libraries
    3. shared memory
      1. busy-wait synchronization
      2. scheduler implementation
      3. scheduler-based synchronization
      4. implicit synchronization
    4. message passing
      1. naming communication partners
      2. sending/receiving
      3. remote procedure call

  10. special languages
    1. shell
    2. postscript
    3. sql
    4. tex, latex
    5. perl
    6. tcl/tk
    7. javascript
    8. html, dhtml, xhtml, xml, css, xsl

>> programming languages: design principles, implementation constructs
dr.salih yurttas | computer science