What are the characteristics of procedure-oriented programming?

Answer 1

1. No security for data. If we declare a variable before main function then it can be accessed freely from any function present in the program.
2. No better memory management.
3. Difficult to implement today's client requirements.
4. No structure or code reusability. Hence time of development, testing and length of program increases.
5. As length of application increases it causes slow performance.
6. Code maintenance and enhancements are difficult.
7. No proper way method for Exception handling.

Previous answer is incorrect. Procedural programming languages derive from structured programming and primarily introduce the concept of the procedure call (function call). All imperative object-oriented languages are procedural languages and therefore structured languages, thus they address all the issues mentioned in the previous answer.

We use declarative (non-procedural) programming languages when we know what is to be solved and use imperative programming languages when we know how to solve it. Some languages such as Lisp and SQL are both declarative and imperative.

There are no advantages/disadvantages as such since they are used for entirely different purposes.

For example, HTML is imperative and we use to specify what is to be rendered while JavaScript is declarative and we use it to specify how it is to be rendered and/or provide user-interaction.

Answer 2

Procedure oriented programming does not use structured loops nor procedure calls. It is known as "spaghetti code" due to prevalent use of goto and jump statements. Machine code and assembler language are procedure-oriented languages. All modern high-level languages are structured.

Answer 3

A procedure(function or subroutine) is a piece of code which completes a specific task. Procedure oriented programming language involves breaking down a given programming task into a set of procedures rather than coding it all in one function. This is also known as a modular approach.

For more information, visit the link below.

Answer 4

Procedural programming is often thought of as a collection of functions that act upon a given set of data. Structured programming concepts allow the functions to be systematically organised, reducing larger problems into smaller problems, allowing much larger data sets to be managed. However the separation between the actual data and the procedures that act upon that data quickly becomes more difficult to comprehend and maintain as the amount of data expands. The more you want to do with the data the more confusion you introduce.

To use an analogy, no self-respecting electrician would ever consider inventing a new light switch every time they needed one. They simply select an existing one that'll do the job, perhaps even modifying it to suit (changing the faceplate, for instance). He is not concerned with how the switch actually works, only that it does a clearly defined job -- to isolate an electrical supply. Changing the faceplate does not alter its functionality in any way.

And yet a procedural programmer will quite happily write a whole new procedure to do an existing job rather than modify an existing procedure to suit his needs. The reason is simply because he cannot risk breaking code that relies on the existing version. Thus his code quickly becomes replete with large amounts of duplicate code that is difficult to maintain.

All of these problems are addressed with object-oriented programming. This treats the data and the procedures that act upon it as a single entity, an "object". Completely self-contained, with its own set of characteristics and known properties, and completely modifiable to suit any purpose. They can be likened to mini-programs in their own right -- they take complete care of themselves and can be plugged into any other objects that require their specific characteristics. And their implementation can be modified at will because consumers are not concerned with how they work, only in what they do. And what they do is clearly defined by the interfaces they expose.

In truth, object-oriented programming is really a mixture of procedural, structured and object-oriented approaches, however the major emphasis of OOP is on the objects themselves. By encapsulating small portions of data and the procedures that act upon that data into self-contained entities, code reusability becomes the norm, rather than the exception.

Answer 5

Procedural programming languages are those languages where all instructions are written in a procedural manner. That is, we start at the beginning of the code and work our way down, one instruction after the other (hence the term procedural). When we encounter a control statement (a goto), execution immediately jumps to the specified code point and we continue from there. Control statements are often used with conditional statements, allowing the program to branch (or not) depending on whether the condition evaluates true or false.

All languages incorporate procedural programming, but procedural languages are entirely procedural. As a result of the intertwining branches, procedural code is often described as being "spaghetti" in nature -- because it is difficult to see the logic without reading the code procedurally. Both machine code and assembly language are procedural languages.

Structured languages make code easier to read through the concept of procedure calls. With procedure calls, code can be divided up into discrete procedures, also known as subroutines or functions, that can be invoked much like a goto but where the subroutine can return control to the statement that immediately followed the call that invoked it. Subroutines can invoke other subroutines, including themselves (recursive subroutines). Unlike a goto, we can also pass values to subroutines. These values define the parameters of the subroutine, allowing the same code to operate upon different sets of data, as determined by the callers. In this way we increase the reusability of code and thus reduce the need for code duplication. Moreover, subroutines can also (optionally) return a single value to the caller, typically used to indicate the result of the subroutine.

Since there is always a clear return path back to the caller, procedure calls make code much easier to read because once we know what a subroutine does there is no need to follow every call to that subroutine. More importantly, complex procedures can be written in a more algorithmic manner, where the procedure is expressed as a specific sequence of procedure calls. Since each procedure has a unique name, choosing appropriate names exposes the logic of the algorithm.

Object oriented programming is an extension of structured programming. Rather than expressing code as a set of global procedures and variables that are accessible to any code, code is discretely packaged into self-contained "objects" along with the data those procedures specifically require. Objects are responsible for initialising their own data and for ensuring the data is manipulated in a controlled manner, thus ensuring its validity at all times. This is achieved by limiting direct access to the data and exposing specific methods that may operate upon the data. Thus each object has an "interface" composed of procedures.

Answer 6

Emphasis is on functions..

Functions share global data..

Data values can keep floating from one function to another..

Uses top down approach of programming..

Answer 7

Procedure oriented programming focuses more on the process than on the data that the program is acting upon. It contains a list of steps to be performed in order.