CS 2040, Hasker's Section: Midterm review

• Note 1: yes, there are languages besides Java; goals for Ruby
  • Which is the best? Java? Ruby? C++?
• Note 2: Ruby goals, basics, functions, simple loops
• Note 3: Ruby ranges, arrays, classes, attributes, methods, inheritance, iterating with map and each, symbols, hashes
  • Note iteration is done with Ruby blocks
  • Type Systems
    • Java design goal: run anywhere
      • Type system: ensure computation gives same result regardless of hardware
      • Depend on just-in-time compiler to make things as efficient as possible
      • Side-effect: runtime checks for array accesses, pointers, undefined values
    • C/C++ design goal: efficient computation at hardware level
      • Type, runtime system: maximize efficiency, keeping programming in control of any resources used
      • Do you know another language/environment that has this goal?
    • Ruby design goal: flexibility
      • Type system: duck typing
      • Example:

                def f(a, b, c)
                  (a + b) * c
                end
        
                f(1, 2, 3)
                f('x', 'y', 3)
          

        • Can apply to any data type responding to +, *
        • Win: can reuse computations on almost any sort of data, not just those predicted by the implementer
        • Win: can use an out-of-band value like nil to return "no value"
        • Loss: might apply function in non-meaningful cases, leading to errors
        • Practical win: can load data from database, web, treat the data as underlying types
    • Is Ruby "weakly typed"?
      • Used as a catch-all for "unsafe"
      • Problem: restrictive types lead to errors:

                // Java
                double ave(int[] nums) { ... }
        
                ...
                   int x = (int)ave(xs); // reduced checking
        

      • And what if we want to guarantee a property like primeness? How to capture that in the type system?
      • Issue: can't deliver untested code; types just simplify certain testing
      • Javascript is weakly typed: all numeric data stored as doubles (from the programmer's point of view), objects as associative arrays
      • Other win of typing: more efficient code generation
  • Standard input; standard output; redirection with <, >, |
• Note 4 (Ruby): instance and class methods, class variables
• Note 5: C++ benefits, basic types, operations, auto, constants, arrays, pointers
  • Terms: functions, scope, lifetime
• Note 6: C++ class introduction, std::string, linked lists in C++
  • Not: C-style strings
  • Memory maps
• Note 7: declaring vs. defining variables, classes, methods, functions; namespaces, exceptions, assertions
  • Terms: declaration, definition, initialization, function prototype
  • Declare identifier before can use it
  • Separating method definitions from declarations
  • Separate compilation with #include, linkers
  • Why exceptions are important to modularity
• IDE, if presented in class: breakpoints, stepping, general project structure
• If get this far: Note 8: key language feature of C++; creating your own built-in types

Exercises

• Implement a growable Queue class in Ruby, C++
  • Ruby: use Array
  • C++: use an array of integers
  • C++: implement a linked list using

            class Node {
              Node *nextNode;
            public:
              Node(Node *next = nullptr) : nextNode(next) { }
              Node* next() { return nextNode; }
            };
    

• Add a method to remove all items matching some target
• Write Ruby, C++ functions to take a list of items and return every other item
  • In Ruby: use .select
• Using pointers, not indices, write C++ code to return a pointer to the first positive number in an array of doubles