Computer programming sample essay

Get your original paper written from scratch starting at just $10 per page with a plagiarism report and free revisions included!









Hire A Writer

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

The go to statement in my opinion can be the most detrimental to program readability, because it makes it difficult to keep track of where the program has been and will go during debugging. Extensive use of go to statements make it difficult to impossible to keep the program code in a top down format.

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

The affect to readability can be positive when it is used in conjunction with a cohesive programming technique. The use of upper case letters to help certain types of identifiers stand out in the code can be highly beneficial.

The affect on writability will be positive because the readability of a program helps to improve the writability.

The affect on reliability will also be positive because the more readable, and writable a language then there is a positive affect on the reliability.

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

Having type declarations that are easy to understand are very important to the readability of a programming language. When the type declarations are cryptic or easily confused it degrades the readability because it is not as easy to identify the variable type or distinguish between them.

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



C++ is not an overall simple language which complicates its readability. It does however have very good control structures and data type structures which can help the readability. But in general it can be difficult to read.


C++ allows for high levels of data abstraction, and expressivity’s in the language allowing the programmer to create a myriad of structures to solve different programming problems making it very writable.


C++ has extensive exception handling and type checking capabilities, which lead to a more reliable language.



Java because it is a functional programming language, which is structured completely differently than all other common programming languages. All of the computations in Java are carried out by applying functions to arguments. Java does not have the assignment statements or variables common in other languages. Alone this causes enough of a problem with the readability of Java, but the syntax for Java is doubly ambiguous because the same exact syntax is used for both data and function calls.


Java has a high amount of expressivity’s with the use of functions, but the difficulties that can be encountered in readability will affect the writability of the language.


Java does not have the extensive exception handling of C++.

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

The total cost of C++ is acceptable. C++ is a very complex language that for a programmer to learn completely can take well over a year, but a programmer can learn enough to make powerful programs in a relatively short time. The style constructs of C++ help to improve it’s maintainability over time which is a major component to the cost of software development.

The total cost of Java is potentially more than that of C++. The functional programming environment is sufficiently different from all other imperative languages that training for programmers to learn and become proficient in Java can take longer. Also the syntax similarities with data will make maintenance costs for Java programs to be higher because of their poor readability.

Readability. Requiring the declaration of variables forces the programmer to document his/her expectations regarding variable names, data types, and scope (the region of the program where the variable will be applicable). Thus, the program becomes much more readable to the programmer and to others.

Writability. Requiring the declaration of variables may actually decrease writability in its most direct sense, since a programmer cannot simply use variables as needed, but must write declarations in their appropriate places to avoid error messages. This increased burden on the programmer can increase programming time. On the other hand, without declarations there can be no local variables, and the use of local variables can increase writability by allowing the programmer to reuse names without worrying about non-local references. Forcing the programmer to plan the use of variables may also improve writability over the long run.

Efficiency. As we saw, readability and writability can be viewed as efficiency issues from the point of view of maintenance and software engineering, so the comments about those issues also apply here in that sense. The use of declarations may also permit more efficient implementation of the program. Without declarations, if no assumptions are made about the size of variables, less efficient access mechanisms using pointers must be used. Also, the programmer can use declarations to specify the exact size of variable needed (such as short int or long int). Restricting scope by using local variables can also save memory space by allowing the automatic deallocation of variables. Note, however, that Fortran is a very efficient language in terms of execution speed, so it is not always true that requiring declarations must improve execution speed.

Also, speed of translation may actually be decreased by the use of declarations, since more information must be kept in tables to keep track of the declarations. (It is not true, as Fortran and BASIC attest, that without declarations a translator must be multi-pass.) Security. Requiring declarations enhances the translator’s ability to track the use of variables and report errors. A clear example of this appears in the difference between ANSI C and old-style Unix C. Early C did not require that parameters to functions be declared with function prototypes. (While not exactly variable declarations, parameter declarations are closely related and can be viewed as essentially the same concept.) This meant that a C compiler could not guarantee that a function was called with the appropriate number or types of parameters. Such errors only appeared as crashes or garbage values during program execution.

The use of parameter declarations in ANSI C greatly improved the security of the C language. Expressiveness. Expressiveness may be reduced by requiring the declaration of variables, since they cannot then be used in arbitrary ways. Scheme, for example, while requiring declarations, does not require that data types be given, so that a single variable can be used to store data of any data type. This increases expressiveness at the cost of efficiency and security.