NOTE: Free essay sample provided on this page should be used for references or sample purposes only. The sample essay is available to anyone, so any direct quoting without mentioning the source will be considered plagiarism by schools, colleges and universities that use plagiarism detection software. To get a completely brand-new, plagiarism-free essay, please use our essay writing service.
One click instant price quote
Let me say at the start that, as I write this, my experience is not that diverse, nor am I highly skilled in all the languages I've come into contact with yet. In the order I learned them, I know QBASIC, C, Dr Scheme, and Java. And, uh, Tierra. So when I say "imperative", I'm speaking from my C experience; "functional" refers to my Dr Scheme night... , er, experience, and "object-oriented" means Java, along with what I've heard about C++. My background in particular: QBASIC from early childhood to middle school or so. C starting after high school senior year.
Dr Scheme in Caltech CS 1 and CS 2, freshman year. Java in CS 3 the final third of freshman year. So, what programming philosophy is best? One of the main things we desire in a programming language is being able to do stuff. Raw assembly offers no structure and is quite cock and non portable, but it's fast and powerful, and for this reason tight inner loops are often coded in assembler. (Whether they need to be is a topic for another time. ) It's said that C combines all the power of assembly language with all the ease of use of assembly language, and C is indeed not a very high level language. It does offer much richer structure than assembler, of course, which is why I like C, and I haven't been daring enough to learn real assembly let.
The problem is, of course, that computers and their programming languages are too powerful. Computers work with so much input and data (which you usually can't make very many assumptions about), so quickly, and can do so many things to them, that humans really can't picture all at once everything that happens. What happens when we overdose on power? Bugs. Memory leaks, general protection faults, crashing, instability - all of these are due to programs doing stuff they shouldn't. A programmer is at fault if he causes this stuff to happen, but a good language ought to guide the programmer into using power carefully, without restricting (too much) his abilities.
We can see the simplest example of imperative programming in QBASIC. BASIC is much maligned for being sucky. And it is, for a number of reasons. Writing programs in BASIC leads to messy code devoid of form or structure, peppered with goto statements. And as we all know, goto statements are considered harmful. This is actually a good point.
The "goto" itself is unambiguous and unconditional. However, when we see a line number or label, we have no clue where control is coming from! We have no context by which to judge the contents of variables or the states of other things in the program. While we can, of course, theoretically figure this out by reading the entire source, we " re all too lazy to do this, and even so reading the entire source scales badly with program size.
Goto statements are not intrinsically evil in and of themselves, but overuse leads to dreaded spaghetti code, which is hard to understand and hard to maintain. While hard-to-understand and hard-to-maintain code might actually work, there is ample justification for just declaring the code bad to start with and avoiding it all together. Code that makes minimal assumptions and is well-structured, concise, tight, easy to understand, easy to maintain, and is written defensively to guard against common mistakes is a Good Thing. While something may be cock and yet work, it's still a crock, and we ought to avoid such things. This leads to fewer bugs, greater understanding, maintainability, and - dare I say it - code reuse.
Which is a whole other topic I won't get into here. Goto statements are still useful in places, of course - but generally, only for jumps that occur on a single page of code, only when masses of flags and tests would have to serve otherwise, and only when well-documented. Actually, all code should be well-documented. Therefore, the occasional goto is not bad, and it's probably overly nasty of Java to not have a working goto at all. (Goto is reserved by Java, though, but not actually used. ) So, we have C. An imperative programming language.
Perhaps THE imperative programming language. Horrible C code can be written, and often is, but it is quite possible and usually easy to write portable, clean, and elegant C. There's plenty of structure in C, and it has its defects too (for example, default fall-through), but overall I consider C a good language, the golden standard by which to judge all other languages. I'll probably write an essay wholly dedicated to C later. Now, functional programming languages were developed with the philosophy that proving that a function works perfectly is a good thing. However, if you want to get anything done in a functional programming language, it's generally hard and nasty.
Computers operate in an imperative manner: completely sequentially, doing one thing right after another. Humans think in an imperative manner: Do action X, check condition Y, and then possibly perform action Z. Neither humans nor computers think in a functional manner, and it's unnatural to force either into doing so. Additionally, functional programming languages are so obsessed with the "pure function" (one that makes no assignments, checks no variables not given to it as parameters, and performs no actions other than returning a value) that their languages actually limit programmer power in the attempt to restrain its harmful effects. This is a Bad Thing. I don't really need to say much more about this.
C and C++ are used the world over for all real programming projects, and LISP and Dr Scheme not at all. Pardon my Caltech bias, but LISP-derived languages seem to be MIT-isms, and not used much of anywhere else. The marketplace has made my point already. Now, let's turn to object-oriented programming. Right now I have to say I prefer imperative programming (as in, C) more than object-oriented (as in, Java). OOP provides additional structure, but at the cost of making languages baroque and large (as in, C++) without really fixing the problems associated with imperative programming. (Generally, violating restraints on behavior such as checking memory that doesn't belong to you, and making assumptions that should not be made. ) C++ is basically allergic to garbage collection (so is C), an...
Free research essays on topics related to: object oriented, freshman year, programming languages, programming, good thing
Research essay sample on Object Oriented Programming Languages
