*All page number references are from the Sebesta text

1. What common programming language statement, in your opinion, is most beneficial to readability and why do you think that?

If one statement defines readability, then it must be the “if…then” statement. The “if…then” statement resembles spoken language in both syntax and semantics. It's meaning is simple and straightforward: if something is true do this, otherwise do something else. Programmers do not overload the “if…then” statement, thereby adding to its simplicity and universality. Not only is it simple, the “if…then” statement best represents orthogonality. After the “if” is a statement that is either true or false. If true, one statement happens. There is no maybe. There is no exception to the rule. This is about as straightforward as programming gets.

The “if…then” is simple, orthogonal and intuitive. It is the first programming statement many aspiring programmers learn. The “if…then” statement occurs, in one form or another, in almost all programming languages. Because of its general appeal, similarity to spoken grammar and simple, orthogonal design, the “if…then” is the most readable programming statement.

2. How does distinguishing between upper-and lowercase identifiers affect the three criteria?

Readability: Distinguishing between lower-and uppercase diminishes readability. The number of allowable characters doubles, thereby increasing the number of basic components. “A language that has a large number of basic components is more difficult to learn.”(9). Not only are case-distinguishing languages less simple, they are less orthogonal. Orthogonality involves a high degree of regularity in the design with few exceptions to the rules. A programmer using a case sensitive language might spell a word right and use it appropriately in the syntax, but still create problems because of a misused capital letter. This creates both irregularity in the syntax and exceptions to the rule (the rule being if you spell it right, it works). Take the word “and.” There is only one way to spell the word in a non-case sensitive language. However, in a language that distinguishes between capitals and lowercase, there are eight (and, And, aNd, anD, ANd, AnD, aND, AND).

Writability: Distinguishing between upper and lower case identifiers both hinders and helps writability. Because it is less readable, less simple and less orthogonal, case-sensitive languages hurt writability. (15-16) However, expressivity is greatly enhanced, as is support for abstraction. In C/C++, an identifier in all caps is usually a global variable or macro. Structs and classes often start with a capital letter. These are not rules, but are more akin to common law among programmers. Having these understood rules makes writing easier. The variables enjoy abstractions because variable tags such as in “glbl_Myglobal” or “tag_struct_Mystruct” do not need to be included. Case sensitive syntax also allows the programmer more expressivity. One can declare an identifier with

            Myclass myclass

The myclass is an instance of the class Myclass. This type of expressivity would not be allowed without case-sensitive syntax.

Reliability: Case sensitive grammars are less reliable than those that do not differentiate between case. A programmer can easily use a lowercase instead of a capital and the compiler will not pick up the discrepancy, especially if both have been declared. Just as a language that does not type check floats and integers can cause problems, so can a language that does not capital check a program. For example, if I declared

And uses Myclass when I wanted to use myclass, some compilers would not recognize the problem. This produces less reliable code. Also, because case-sensitive languages are less readable, they are in turn less reliable.

3 How do type declaration statements for simple variables affect the readability of a language?

The more closely a type resembles spoken language, the more readable it is for a programming language. “For example, suppose a numeric type is used for an indicator flag because there is not Boolean …timeout = 1.”(13) That type of syntax does not make a lot of sense. Timeout really means true, not one. But with a language that supports Boolean types, the statement can be written “timeout  = true.” (13). Type declaration statements are more readable if they mirror written language. They are less readable if they (like using an int for a bool) feign similarity to spoken language by substituting one type where another would be better.

4. Write an evaluation of Java and C, using the criteria described in this chapter. Please be thorough and provide a reason/justification for your evaluation.

Java is more readable, easier to write far more reliable than C. Java’s use of object-oriented design brings the language more closely in tune with adjective-noun syntax in spoken language. Java and C both have similar data types and structures. However, C has “two kinds of structure data types, arrays and records … records can be returned from functions but arrays cannot.” (11) This is an orthogonal discrepancy, and diminishes the readability. Java and C both enjoy control statements such as the “for” and “while” loop, which increase readability. Java and C are similar in how they read, but Java is a bit more orthogonal and the object-orientation makes it far more readable.

Java is a little easier to write than C. Both share common writability features. For example, both allow abstraction through functions. One need only write a function once and then call it multiple times. Both allow expressivity by conveniently allowing multiple ways to do things. “The notation count ++ is more convenient and shorter than count =  count +1.” (17). Sometimes “for” loops are more convenient than “while” loops even though both can be written to do the same thing. Java does not have the confusing pointer syntax that C has. Also in C, one must allocate and deallocate memory with _alloc() functions that really make no sense. C++ remedied this with the “new” and “delete” keywords, but Java is easier to write than either C or C++ due to garbage collection.

Java is far more reliable than C. First, Java has strong type checking, thereby identifying any mistypes before it creates logical errors. Failure to type check "has led to countless program errors ... in the original C language." (17) Java has excellent exception handling, which “take(s) corrective measures, and then continue(s).” (17) While C++ has exception handling, C does not, which greatly reduces reliability. Part of C’s power is to directly access memory with pointers. However, the same memory location can be accessed with different pointers, thereby creating aliasing, which is another detriment to reliability.

It is easy to see that Java has many advantages over C. First, Java is more readable. It has all of the control statements, data types and simplicity of C without much the confusing syntax, making it more readable. Both Java and C are share similar grammar, although C’s memory allocation and pointers make it less writable than Java. Java is far superior to C in reliability because of its exception handling, type checking and lack of pointer-aliasing. So why would anyone use C over Java? See the next question

5. Evaluate both Java and C with respect to the ultimate cost (as discussed in Chapter 1 of the Sebesta text). Again, please be thorough and provide a reason/justification for your evaluation.

Java is far superior to C in almost all regards. It is more simple, easier to write and far more reliable. The only benefit C has over Java is cost. The cost of a language has many dimensions. There is the cost of training programmers, the cost of writing the language, the cost of compiling and executing, the cost of the implementation system and the cost of maintenance. (18-19)

Many programmers are trained in Java. However, the C/C++ language is extremely popular in academia and most programmers are at least familiar with it. Many people choose Java because of the variety of free compilers. C has just as many, if not more free compilers. Java is often chosen because of its portability to different platforms. C is even more portable than Java. C is used on platforms from UNIX to Windows and has been standardized longer than Java has been a language (ANSI C circa 1989, Java  circa 1994). (39)

But the most noticeable cost hit in Java is the very long compilation, debugging and execution time. Java has excellent type checking, garbage collection and object oriented design that improves the language, but it comes at the cost of time. For example, “Java … demands that all references to array elements be checked to ensure that the index or indices are in their legal ranges.”(24). C does not have any sort of index checking. It is common that “C programs execute faster than semantically equivalent Java programs” (24) due to the lack of checking and the low-level access with pointers and dynamic memory. C usually has fewer hardware requirements. Because Java uses more physical memory, one must have more memory available, potentially increasing the cost of hardware.