Why must we learn Procedural programming before we learn Object-oriented programming

I would think that the analogy would be similar to math. You need to learn some basic concepts first (addition/subtraction/...) then move on to more complex topics (algebra/calculus). Procedural program is very linear and it's easier to grasp the flow of control while you're learning the syntax. OOP is perhaps thought to be more complex, it builds on the simpler constructs used in procedural languages but is more abstract and harder to understand. Starting out with languages such as C also puts you closer to the hardware and makes you deal with issues of memory allocation and pointers, which you do need to understand but don't really get to use in languages such as Java/C#. There's some real value in being exposed to this in school regardless of whether it comes first or second.

FWIW, it's bound to change eventually. When I started school we learned in Pascal and PL/1. We didn't get to C until the advanced languages class (that dates me). I didn't pick up Java until graduate school -- it hadn't been invented yet!

Object-oriented programming is a collection of procedural snippets in an organized fashion. I think the lesson you are learning is that object oriented methodology helps maintain organization and maintainability. There are a lot of programmers who cannot make this distinction and will claim their programs are object oriented when they are more procedural.

Quick Summary:

(1) Because in real world, sooner or later, you have to work with procedural code.

(2) Because O.O.P. is more complex than Procedural Programming, therefore its better to learn Procedural Programming, first.

(3) Because O.O.P. works like an extension of Procedural Language, not just an alternative.

(4) Because in real world, programmers work with, and combine several ways to solve problems, A.K.A. "multiparadigm programming".

Extended Boring Description:

Point 1 is very clear, not further explanation.

Point 2, Classes, Inheritance, Polymorphysm, Interfaces, so on...

Point 3, I code Procedural Pascal before I learnt Object Oriented Pascal, when I got there I said: "look, classes are like small procedural programs... ...and you can make them talk to each other, cool !!!".

I heard the same from people who went from plain C to C plus plus.

Point 4, Most of times programmers combine several programming techniques or paradigms, or ways to solve a problem. Functional, Procedural, O.O.P., logical.

Even Java "Pure O.O." is not as plain object programming as it says.

+1 point fo saying "Procedural Programming" instead of "Structured Programming". Or Modular Programming. These is important.

Altought, many times these terms are teach toghether and used interchangeably, they're not. Structured Programming, include many concepts, not just using procedures, and one of them is making program not to look like "Spaghetti Code".

Today I read several "pure" O.O. programs that look like "Object Oriented Spaghetti Code", meaning that the programmer used O.O.P., but its code looks like a mess.

Many times, I can read a O.O. code and tell that the programmer learnt Structured Programming before O.O.P., because the code is clear and arranged.

And for Modular Programming, I have seen several apps. in C++ and PHP that doesn't use modules.*

A language may be object oriented like C++, Java or C#. And you can start with these languages. But the point is, even with these OO languages, you have to learn the procedural programming first, then OOP. I think, the same was done by you to your brother.

You don't.

We learned functional programming first, with Scheme. Then we moved to procedural, then OOP, and then declarative programming. And believe it or not, while I already knew programming, I think it was actually easier for other people as well: because FP is just like math! So you know the basics already.

I've debated this with myself many times, and I've ultimately come to the conclusion that it really depends on how well your teacher teaches you the concepts.

There's no single answer because:

• Starting with something procedural like C (or even assembly) might be a good choice, because you learn how computers really work

• Starting with something object-oriented Java might be a good choice, because it's relatively easy to learn and apply OOP to real life, and because it teaches you about **forming

• Starting with functional programming like Scheme might be a good choice because it teaches you about thinking more abstractly (in terms of functions instead of variables), which ultimately makes you a better programmer

If your teacher doesn't teach it well, then it doesn't really matter what you start out with; they'll pretty much turn out the same.

Spacemoses and tvanfosson have mostly hit this nail on the head. So my hat to them and please read their answers as well.

Object Orientation is a tool to be applied properly. Students, should be taught not one tool but many. The goal, especially with new CS students, is to have them learn to look at problems from the mind required to program solutions. They should be taught to think, not to use a specific paradigm or language. The language of teaching should allow for exploration and understanding, it shouldn't go about hiding things from the programmer.

If you start them on Java then they will come out being able to program Java. But they will miss some integral concepts to programming. Java hides memory management, pointers, and to a large part recursion which leads to a weaker understanding of the mechanics of what you are actually doing. To top it off, it lacks any form of lambda abstraction and generally has a weak view of closures. If you start them at such a level and tool you are doing them a disservice.

Procedural programming, at least in a language like C, strips programming to a very bare bones practice: algorithms and data structures, and at a level of abstraction that's a happy medium between human understandable source code and assembly code.

In this way, students can learn a bit of science (algorithms, data structures) and a bit of engineering (source->object->machine compilation, von-neuman (likely) architecture) at the same time.

OOP, via C++/obj-C introduces a code organization pattern, which is just one more thing to learn. This could make learning the concepts above somewhat more difficult.

OOP via Java (amongst others) goes even further by abstracting away hardware and environment. Now the underlying product isn't machine code, but some sort of intermediary that doesn't reveal how the underlying hardware works, but the effect is that it allows the student to concentrate on code organization patterns.

In the end I think it's a trade off between learning how the hardware works or learning a code organization pattern. As for which is more important, I don't really know. The real world requires knowledge of both, at least to some degree.

I'm going to guess that an undergraduate program that starts with low-level procedural programming likely produces computer scientists / computer engineers, and a program that starts with higher-level concepts produces software engineers / developers / programmers.

There is no reason other than institutional inertia. Look at CMU, they threw out their entire OOP curriculum and replaced it with functional programming. So once again, the answer to your question is that it is an arbitrary choice made by the administrators of whatever school you are attending. In case anyone is wondering about the factual statements I've made here is the post about changing the curriculum at CMU by one professor/administrator: Teaching FP to freshmen.

The guts of OOP objects are made up of procedural programming.

If you can't do a for loop, use pointers properly, declare your types and functions you won't be able to write interfaces for your classes much less make the insides do anything worth doing.

You really wouldn't be learning OOP in a introductory class anyway, it would just be syntax - jumping straight into OOP would make things more complicated to grasp (at first) than it already is.

OOP isn't about some declaring syntax to form classes, it's about data structures, design patterns, polymorphism, inheritance, and composition.

To do all of those things you need to know procedural programming, something easily done in C. You can carry most everything you learn with C over into Java or C++ anyway, you may have to rethink some things you took for granted in C, BUT... You gotta know the grammar (where you're at in introductory C) to write sentences (must write procedures to define interfaces) then paragraphs (gotta know data structures) then and then know some design patterns (tragedy, comedy, flawed hero, how they interact; and when not to use them) before you can write complete novels (complete OOP system).

If I were you I'd pick up some of the following books: The C Programming Language, The Java Programming Language, Design Patterns, Gang of Four, and Pattern Hatching. I would definitely pick up a copy of The C Programming Language if I was serious about C/C++.

If you just want to go all the way Java (and doing it for the $) id pick up some books on Java design patterns and how to use Java with the Apache and Tomcat web servers and some books on SQL database programming. Java kicks so much ass on the web, I'm sorry but PHP has had a history of tons of security holes making it as much as a pain in the ass as Windows to keep from getting your server rooted or you SQL databases injected.

You should also take the time to learn SQL, Oracle MySQL Postgresql and MSSQL have much in common regarding syntax but if I had to just pick learning one for myself id pick Postgresql just because it's BSD licensed instead of GPL (you should look up a compare and contrast on GPL / BSD licenses too)

Same reason most of us learn to crawl before we walk.

To be overly blunt about it, I think the momentum for this comes primarily from old programmers wishing for old times.

Before saying anything else, I absolutely do not hold any contention for older programmers, many many of them are simply amazingly skilled. Unfortunately sometimes those who aren't, who become washed up and never really were truly good at programming to begin with..become professors when they can't hack it in the 'real world'. (Not all professors either...but...MANY)

OOP is not the holy grail of programming it is made out to be, neither is procedural programming a relic. It's good to know at least some of both, but I think the general practice of what ends up being taught as procedural programming tends to be a giant waste of time and effort. We need to learn programming in academia, not just one style or the other. I attribute quite a bit of terrible code and misconceptions to this, including my own.

I would have to say that most code written in object-oriented languages like Java isn't actually object-oriented. Really understanding the ideas behind OO is hard, as a result most supposedly OO code is really mostly procedural.

However, this is nothing really wrong with writing procedural code in Java. Yes, there are benefits to doing OO, but its not something I'd want to confuse a beginning programmer with. So on that basis, I see nothing wrong with teaching Java. Don't expect real OO from it, but it works.

However, Java hides a lot of the low level details about what is going on inside the computer. C leaves these much more out in the open. One can make a good case that students should learn how these low level details work before using a language that takes care of these for them. But you can also make a case that you should ignore those details and learn them later.

Two reasons for me: One OO programming came to solve problems of procedural programming. So by writing some procedural coding and then same things in OO, makes it easier to understand the difference.

There is also an additional element here: The two approaches to educate on Programming topics. One can start with as low as it gets (example assembly, in many places procedural, some others start with circuits) and then go up (towards OO/Functional/Managed). The other approach is to start from the physical world (eg. Browser/Windows 7 etc) and then start to go deeper. There are pros and cons to each approach. Your university chose the first and to start with procedural. There might be some rationale or they just copied someone else :-).

Several others have already answered along this theme, but I think it's worth stating this more explicitly.

Even if you begin learning programming with an object-oriented language like Java, you start by learning procedural programming techniques before you get to the OO concepts. When teaching a new programmer Java, you don't introduce them to objects and classes first, you introduce them to statements and variables. By the time the student is in a position to be taught much about objects and classes, they already have at least the basics of procedural programming.

So at the least, you have to learn procedural programming in Java and then learn object-oriented programming in Java. Whether you spend a whole year on procedural programming or you just spend the first few weeks of the programming course, and whether you use a different language for it or not, is just arguing about the details.