Assignment #7
Pengajar : Tri Djoko Wahjono

Review Question :
11. What is an overloaded operator?
=> An overloaded operator if use of an operator for more than one
              purpose.

12. Define narrowing and widening conversions.
=>Narrowing conversion is one that converts an object to a type that
             cannot include all of the values of the original type, example: float
             to int. Widening conversions is one in which an object is converted
             to a type that can include at least approximations to all of the
             values of the original type, example: int to float.

13. In JavaScript, what is the difference between == and ===?
=> “==”  means  equal,
But “===”  means  same type and equal.

14. What is a mixed-mode expression?
=>Mixed-mode expression is one that has operands of different types.

15. What is referential transparency?
=>Referential transparency is a property whereby an expression
            can be replaced by its value without affecting the program.

Problem Set :

11. Write a BNF description of the precedence and associativity rules
      defined for the expressions in Problem 9. Assume the only operands are
      the names a,b,c,d, and e.
=> Assume the only operands are the names a, b, c, d, and e.
<expr> → <expr> or <e1> | <expr> xor <e1> | <e1>
<e1> → <e1> and <e2> | <e2>
<e2> → <e2> = <e3> | <e2> /= <e3> | <e2> < <e3>
| <e2> <= <e3> | <e2> > <e3> | <e2> >= <e3>  | <e3>
<e3> → <e4> <e4> → <e4> + <e5> | <e4> – <e5> | <e4> & <e5>  | <e4> mod <e5> | <e5>
<e5> → <e5> * <e6> | <e5> / <e6> | not <e5>  | <e6>
<e6> → a | b | c | d | e | const | ( <expr> )

12. Using the grammar of Problem 11, draw parse trees for the expressions of Problem 9.
=>

13. Let the function fun be defined as
      int fun(int *k) {
      *k += 4;
      return 3 * (*k) - 1;
      }
      Suppose fun is used in a program as follows:
      void main() {
      int i = 10, j = 10, sum1, sum2;
      sum1 = (i / 2) + fun(&i);
      sum2 = fun(&j) + (j / 2);
      }
     What are the values of sum1 and sum2
     a. if the operands in the expressions are evaluated left to right?
     b. if the operands in the expressions are evaluated right to left?
=> (a) (left -> right) sum1 is 46; sum2 is 48
(b) (right -> left) sum1 is 48; sum2 is 46

14. What is your primary argument against (or for) the operator precedence rules of APL?
=>  I think the operator precedence rules of the common imperative
              languages are nearly all the same, because they are based on those
              of mathematics.

15. Explain why it is difficult to eliminate functional side effects in C.
=>  There’s one reason functional side effects would be difficult to
              remove from C is that all of C’s subprograms are functions,
              providing the ability of returning only a single data value (though
              it could be an array). The problem is that in many cases it is
              necessary (or at least convenient) to return more than one data
              value, which is done through the use of pointer actual parameters,
              which are a means of creating functional side effects

ASSIGNMENT  #6

Pengajar : Tri Djoko Wahjono

Review Question :

11. How does JavaScript support sparse arrays?

       =>Javascript objects are sparse, and arrays are just specialized 

           objects with an auto-maintained length property (which is 

           actually one larger than the largest index, not the number of 

           defined elements) and some additional methods.

12. What languages support negative subscripts?

       => Ruby and Lua support negative subscripts.

13. What languages support array slices with stepsizes?

       =>Ruby, Python, Perl.

14. What array initialization feature is available in Ada that is not 

      available in other common imperative languages?

       =>Ada provides two mechanisms for initializing arrays in the 

           declarations statements : by listing them the order in which 

           they are to be stored, or by directly assigning them to an index 

           position using the => operator, which in Ada is called an arrow.

15. What is an aggregate constant?

       =>A parenthesized lists of values.

Problem Set :

11.  In the Burroughs Extended ALGOL language, matrices are stored 

       as single-dimensioned array of pointers to the rows of the matrix, 

       which are treated as single-dimensioned arrays of values. What 

       are the advantages and disadvantages of such a scheme?

       =>The advantage of this scheme is that accesses that are done in 

           order of the rows can be made very fast; once the pointer to a 

           row is gotten, all of the elements of the row can be fetched very 

           quickly. If, however, the elements of a matrix must be 

           accessed in column order, these accesses will be much slower; 

           every access requires the fetch of a row pointer and an address 

           computation from there. Note that this access technique was 

           devised to allow multidimensional array rows to be segments in 

           a virtual storage management technique. Using this method, 

           multidimensional arrays could be stored  and manipulated that 

           are much larger than the physical memory of the computer.

12.  Analyze and write a comparison of C’s malloc and free functions 

       with C++’s new and delete operators. Use safety as the primary 

       consideration in the comparison.

       =>New and Delete is a safe type. Malloc can return void value
            to pointer access which is  appropriate. New return pointer 
            type with itself. And for malloc, you must tell it how many bite
            to allocate it. New will produce that value its self.

13.  Analyze and write a comparison of using C++ pointers and Java 

       reference variables to refer to fixed heap-dynamic variables. Use 

       safety and convenience as the primary considerations in the 

       comparison.

       => In c and C++ pointer can be use the same way as addresses. 

            This design offer no solutions to the dangling pointer or lost 

            heap-dynamic variable problems. Reference types, such as 

            those in Java and C#, provide heap management without the 

            dangers of pointers. so its clear that Java has more safety for 

            the heap-dynamic variables.

14. Write a short discussion of what was lost and what was gained in 

      Java’s designers’ decision to not include the pointers of C++.

       => With Java, however, there’s a lot of those same programmers 

             felt that the security that was gained was offset by the 

            decreases in speed and the fact that a lot of the earlier JIT 

            compilers were pretty pokey didn't help that. For all their 

            faults, Sun's been pretty adamant about listening to the 

            community so they've made a lot of improvements regarding 

            in-place optimization, HotSpot, conditional compilation, etc. 

15. What are the arguments for and against Java’s implicit 

       heap storage recovery, when compared with the explicit heap 

       storage recovery required in C++? Consider real-time systems.

       => Implicit eliminates the creation of dangling pointers. Disadv: 

            cpu-time to do recovery, sometimes when there’s plenty of 

            heap storage so recovery isn’t necessary.