Programming languages provide tools to direct computers, but not all languages promote the same thinking approach by programmers. A programming paradigm is a general style of structuring code, of representing solutions and of structuring data and operations. A good knowledge of programming paradigms is essential for knowing why two programs may be very different, yet return the same answer for the same problem.
Developers will see many programming paradigms such as procedural, object-oriented, functional, declarative, logic and event-driven. Several languages have a high affinity to one style, and other languages have a moderate affinity for multiple styles. A programmer can, for instance, use different techniques in one program, depending on the needs of a project, using Python, Java, C++, JavaScript, and Haskell. These paradigms are useful to teach to the novices, as they help them understand the design and organization of software instead of just memorizing and copying the syntax.
What is Programming Paradigm?
A programming paradigm is any specific approach used to solve a problem when programming. A paradigm does not mean a specific programming language, but rather the concepts and principles that developers use when creating code to solve problems. For instance, procedural programming is structured around procedures or functions that implement specific operations, and object-oriented programming is structured around objects that are groups of data and behavior. While functional programming places a focus on functions and transformations on data, declarative programming places a greater focus on the desired result. These techniques affect the way very large problems are broken up into smaller ones, how information is managed, how state is handled, and how relationships between various components are handled. A programming language can support an individual paradigm or multiple paradigms, so it’s possible for developers to pick the best one for a specific problem.
Programming paradigms are a useful concept because software development is more than just writing some instructions. As applications grow in size, developers require consistent means of structuring thousands, and even millions of lines of code. A paradigm offers mental models and design principles that can be used for understanding complex problems. It can affect the development of functions, the storage and access of data, the communication between components, and the evolution of changes over time. Paradigms to a new programmer may appear as a bunch of jargon at first, but when related to some familiar programming tasks they make much more sense. For some developers, a program is something like a series of steps, so procedural programming might seem natural. Object-oriented programming might be more suitable if the developer considers their thinking in terms of independent entities that have properties and behaviours. These various views are not just alternative ways of practicing techniques, they are alternative ways of structuring computational solutions.
Procedural Programming
Procedural programming is one of the simplest programming paradigms as it structures a program into sequential instructions and procedures. A procedure is a special kind of program that usually is used as a function or routine; it can be called when the operation is needed. A typical procedural program is started with some input, then has a series of steps to process the input, and creates an output. Each function within a program is responsible for a specific task and developers divide large tasks into smaller functions. This style includes core concepts like variables, loops, conditionals, and functions. This is especially helpful where the problem can be naturally expressed as a series of actions. Languages like C are tightly coupled to procedural programming, and languages like Python, C++, etc. support multiparadigm programming, where programs are also written using a procedural paradigm.
The basic benefit of procedural programming is that it is directly structured and quite simple to understand. It is possible for a developer to follow the execution of the program from one instruction to another and to know how data moves and is manipulated during the execution. This can make procedural programming a good way to begin programming variables, loops, conditions, functions, and basic algorithms for beginning students. As an application grows, however, it may be more difficult to maintain procedural code because many functions can rely on shared data and interact with each other in complex ways. Unstructured procedural programs can have very tightly coupled components that are hard to modify without impacting other system elements. Nevertheless, procedural thinking is still valuable because many programming activities are inherently sequential, as well as the ideas of procedures and functions are used within programs written in other programming styles.
Object-Oriented Programming
Object-oriented programming is also known as OOP, which focuses on objects as entities, concepts, or components of a system. An object may have data, called its attributes or properties, and with it a set of functions, called its methods. Classes are often employed as templates to build new objects that have similar attributes and actions. Additionally, OOP concepts like abstraction, inheritance, and polymorphism can facilitate the organization of complex applications into reusable and manageable components. In an object-oriented paradigm an application is not simply a series of instructions, but a description of the key entities in the problem and how they interact. It is closely linked to object-oriented programming (OOP) languages, such as Java and C++. Python and JavaScript also have a good amount of support for OOP.
A key aim of OOP is to simplify the organization and maintenance of large software systems. Abstraction can enable the programmer to deal with the features he/she considers important while keeping the internal implementation of the object hidden, and encapsulation can separate the internal mechanism from the external interaction of other objects in the program. One class may inherit from another, but inheritance is not always the key to the design of modern software, and sometimes composition offers another alternative that is more flexible. When several objects are presented through the same interface or perform the same operation, they have different responses, this is called polymorphism. They can be helpful in scenarios with numerous similar elements, like business software, games, desktop apps, and enterprise systems with a lot of components. The success of an OOP system relies on good design as having too many classes, too much inheritance, or too complex of relationships can make the system more difficult to understand.
Functional Programming
Functional programming takes a computational approach focusing on functions and transformations instead of a series of changing program states. In a functional programming approach, functions are considered to be significant components and can be passed as arguments to functions, stored in variables and returned as output. An important concept is the use of pure functions – functions with the same output given the same input and which do not alter the external state. Another important characteristic of functional programming is immutability of data – that is, data is not changed directly once it is created. Operations, on the other hand, generate new values from other values. Haskell is known primarily as a functional language, while Python, Java, JavaScript and C++ have several functional programming features that can be used in addition to other styles.
A functional programming style can be particularly effective in reasoning about data transformations and avoiding undesirable side effects. Imagine a program that should take a set of customer records and selectively remove some, modify the data for some, and sum up the data for all of the customers. These operations can be represented as a sequence of data transformations in a functional approach. Pure functions can be more easily tested and reasoned about individually since there is no hidden external state. When developing concurrent and parallel software, functional techniques can also be useful as they can be used to minimize the shared mutable state, which can simplify some forms of coordination. Functional programming can bring concepts that are not familiar to beginners, however, where the developer has learned programming mostly with variables that vary over time and step-by-step instructions. Modern languages will sometimes employ both functional and non-functional techniques; programming can be done with the ideas that are most appropriate for solving a specific problem.
Declarative Programming
The declarative programming paradigm emphasizes specifying the desired output instead of specifying all steps that the computer must perform to generate the output. This is different from imperative programming in which the programmer typically supplies the instructions to the program that outline how the computation should be carried out. A common example is SQL, since a developer can define what information they want to be returned from a database without having to write the actual details of the search for that information in the database, how the database engine is supposed to search the storage structures, or how it should use indexes to search those structures or optimize the query itself. An idea that may be described declaratively can also be demonstrated by a markup and configuration system, which describes the intended structure or state of a system. The implementation then becomes responsible for deciding on how to get the desired effect. This separation can help keep declarative solutions short and can enable specialized systems to optimize execution without having developers worry about all of the execution details.
When a problem can be naturally stated in terms of rules, relationships, desired states, or results, then declarative programming can be of great value. The developer does not have to write the full algorithm for each operation, he can simply define the result and leave it to the underlying engine, framework, or runtime to decide how it is to be executed. This technique is used in things like database queries, user interface creation, configuration management and data processing. The computer doesn’t necessarily work less, but rather, the role of the description of the operation is transferred to another layer in declarative programming. For efficient solutions, especially if performance is an issue, developers must fully grasp the underlying system. The difference between declarative and imperative programming is therefore useful to comprehend how different technologies partition responsibility between the programmer and the software platform running instructions.
Logic Programming
Logic programming is based on formal logic, facts, relationships and rules and applies them to solve problems. The developer does not give the computer a traditional set of instructions, but rather describes information concerning a problem and specifies rules for how the relationships between the pieces of information can be tested. This programming system can then use the rules to deduce solutions to queries. One of the most popular logic programming languages is Prolog. A program based on logic can be used to create relationships among people, objects, places or other things, and then determine if a particular relationship is possible given a set of facts and rules. This is especially interesting for symbolic reasoning, knowledge representation, constraint solving and some types of artificial intelligence research.
Another important point of computation is logic programming in which the programmer focuses on the description of relationships instead of the manual control of each operation. For instance, a developer could describe a set of facts and rules about relationships between entities, and then let the language’s inference engine find solutions based on the set of rules. This can be effective in domains where dealing with relationships as a basis for reasoning is important. However, for many mainstream programmers, logic programming is not as “familiar” as either procedural or object-oriented programming, and thus may need a different mental model. Learning the paradigm however, provides the programmer with a more general understanding of the ability of programming languages to model knowledge, constraints, and problem solving processes.
Event-Driven Programming
Event-driven programming is based on the concept of program behavior being organised around events that happen during program run-time. An event could be a user clicking a button, pressing a key, hitting a form, receiving a message, completing a network request or setting a timer. An event-driven application waits for events and responds to them with handlers or callback functions, as opposed to performing a single, linear series of instructions from start to finish. This is especially relevant for applications with interactivity, GUI applications, Web applications and applications that are subject to external activity. Event-driven programming has a close connection with JavaScript because web apps often react to events like clicks, keyboard input, form submission, asynchronous network operations, etc. Event Driven Programming provides more details about the concept.
The order of actions in the event driven approach is different from that of procedural approach, as an action might occur depending on the outside of the program events. For instance, a graphical application can be kept running without any user interventions while waiting for users to interact with the interface. The application will call the associated code for an event and then wait for more events. In servers and asynchronous systems, where applications might be required to process lots of requests or messages without blocking while waiting for all the operations to complete, event driven programming also plays a crucial role. This is a common model that is seen in JavaScript, but is not a JavaScript exclusive. The approach makes interactive and responsive applications possible, but the developer needs to be aware of the asynchronous nature of the behavior, callbacks, event handlers, and possible timing problems to avoid confusing the behavior of the applications.
How Programming Languages Facilitate the Use of Multiple Paradigms
This course will describe how programming languages facilitate the use of multiple paradigms.
There are programming languages that are not limited to a single programming paradigm. For instance, Python provides support for procedural programming with functions and sequential instructions, and functional techniques with higher-order functions, comprehensions, and anonymous functions, as well as object-oriented programming with classes and objects. C++ is a procedural programming language with very strong object-oriented capabilities and functional programming features. Java is notably associated with object oriented development, but it has adapted some functional features, like lambda expressions and streams. JavaScript can be used in procedural, object-oriented and functional programming approaches, and has great flexibility in its application structure. Haskell, on the other hand, has as a core functional programming, and the design strongly favors functional ideas. The differences reveal that the programming models that a language promotes affect the identity of the language.
Multiple paradigms provide flexibility to the developers to work on various software types. An application can be implemented using object-oriented design to structure its major components, functional techniques to manipulate sets of data, and event-driven techniques to handle user actions. When the language and framework are able to support them, these styles can coexist in the same project. This flexibility also comes with a responsibility, though: a developer must know when a certain technique is applicable and when it isn’t, nor should the developer mix two techniques without a valid reason. The choice of paradigm may be influenced by the problem domain, team experience, current architecture, performance needs, maintainability objectives and the nature of the programming language. To learn a number of paradigms does not imply learning a number of sets of rules. Rather, it enables the programmer to build up a repertoire of problem solving points of view that can be used as required for each software project.
Comparing Major Programming Paradigms
The big paradigms are mostly distinguished by their problem representation and their organization of computation. Procedural Programming is useful for tasks that can be broken down into a sequence of steps and procedures, and it focuses on procedures and sequences of operations. OOP focuses on objects, classes, data, and behaviour; it is appropriate for applications made up of interacting objects and reusable objects. In functional programming, the focus is on functions, immutability and transformations; these are all useful tools to reason about data and eliminate some categories of state related complexity. Declarative programming is concerned with stating what one wants to happen; logic programming is about stating facts and rules from which conclusions can be drawn. Event driven programming is a paradigm where the flow of programs is event and response oriented and thus is especially well suited for interactive and asynchronous applications. These descriptions are not sets of mutually exclusive categories as actual languages often blend together a number of these concepts.
Therefore, the paradigm one should use for a program should not be determined by the assumption that a single paradigm is always suitable. A tiny bit of code might be simpler to write in a procedural fashion, and a large program may be more easily organized as objects. A data transformation task might be easier to understand with functional methods, and a query over a database is more naturally written as a declarative statement, like SQL. An interactive interface has to be able to respond to events and logic programming can be useful in a problem with formal relationships or inference. The current body of code, libraries, frameworks, tests, developer teams and deployment environments for a language should also be taken into account. However, it is better to understand paradigms so that the programmer can make better decisions since he can now identify the advantages and disadvantages of various approaches instead of assuming that every programming problem demands the same approach.
Why Learning Programming Paradigms Matters
The programming paradigms allow the programmer to take a step back from programming syntax and divide the programmer from the problem. An experienced programmer who knows the syntax of one language can learn to write a loop or a function, but when confronted with a large and unfamiliar problem, he may not be able to solve it. Constructed mental models for organizing such problems called paradigms. Having mastered these concepts of procedural thinking, object oriented design, functional transformations, declarative descriptions, logical reasoning and event-driven execution, a programmer can tackle new languages more easily as many concepts carry over from one language to another. While the syntax is subject to change, concepts like decomposition, abstraction, data transformation, state management, modularity and interaction are still relevant. One of the reasons that a skilled programmer may be able to pick up a programming language faster than a novice is that they are simply using their old conceptual ideas in a new syntax and new ecosystem.
Knowing paradigms also helps developers to communicate with each other as software projects often involve mixing programming styles. One member of the team will talk about an event-driven component, another will talk about an object-oriented design, etc. If one isn’t familiar with these terms, technical discussions can quickly become confusing. Developers, armed with this knowledge of paradigms, can use their understanding of the structure of code and the representation of computation to consider their design choices. The aim is not to select one paradigm and to ignore the others. Often, a combination of ideas from many different paradigms is used in a carefully thought out way for developing modern software. The most useful skill is being aware of what is a problem and what approaches can be taken to solve it and which techniques will ensure that the software produced is understandable, maintainable, testable, and suitable for the task.
Conclusion
Programming language paradigms are various approaches to organizing information, computation, and problem-solving within programs. Procedural programming structures solutions based on procedures and sequences of instructions, while object-oriented programming structures them around objects and their relationships, and functional programming structures them around functions, transformations and controlled state. Describing desired results is called declarative programming, using facts and rules for reasoning about relationships is logic programming, and structuring applications around responses to events is event-driven programming. For example, Python, Java, C++, JavaScript and Haskell are all modern languages and none of them fits into one of the two classes. Many languages are able to support multiple styles. Knowing these paradigms, programmers are able to develop a more flexible design in software and learn the reasons why various designs might be suitable to various problems.
The key point here is that programming paradigms are not just academic classification of programs. They affect the way developers divide up problems, arrange code, manage data, deal with state, communicate design concepts, and evolve software over time. Beginners can work with a programming style that is supported by their programming language of choice and then, as their skill increases, taste a little of other styles. An understanding of multiple paradigms is more than a knowledge of multiple languages: it is the ability to have a larger set of ways of thinking about computation. When software systems become more complex, it can be as important to know and use the right programming techniques as it is to know the syntax of any particular language.
