Főnév

programming paradigm (tsz. programming paradigms)Kategória:angol lemmák#PROGRAMMING%20PARADIGMKategória:angol főnevek#PROGRAMMING%20PARADIGMKategória:angol megszámlálható főnevek#PROGRAMMING%20PARADIGMKategória:angol kifejezések#PROGRAMMING%20PARADIGM

1. (informatikaKategória:en:Informatika#PROGRAMMING%20PARADIGM) A programozási paradigma (angolul: programming paradigm) a programozás szemléletmódját jelenti, vagyis azt az elméleti és gyakorlati megközelítést, amely alapján a programozók struktúrálják és írják a kódot. A paradigma meghatározza, hogyan gondolkodunk a program működéséről: adatokról, vezérlésről, függvényekről, objektumokról.

A programozási paradigmák a programozás különböző “iskolái”, amelyek más-más elveken nyugszanak. Egy nyelv több paradigmát is támogathat.

A főbb programozási paradigmák

1. Imperatív programozás

• A program utasítások sorozata, amelyek módosítják az állapotot.

• Állapotváltozás, változók, ciklusok, feltételek.

• Példa:

  total = 0
  for i in range(10):
      total += i
  

2. Deklaratív programozás

• A végeredményt írjuk le, nem a lépéseket.

• A végrehajtási módot a rendszer dönti el.

• Példa (SQL):

  SELECT name FROM users WHERE age > 18;
  

3. Funkcionális programozás

• Program = függvények kombinációja.

• Nincs állapot, nincs mellékhatás.

• Rekurzió, map, filter, reduce.

• Példa (Haskell):

  sumList [] = 0
  sumList (x:xs) = x + sumList xs
  

4. Objektumorientált programozás (OOP)

• A program objektumokból épül fel: adatok + műveletek.

• OOP alapelvek: öröklés, kapszulázás, polimorfizmus, abstrakció.

• Példa (Python):

  class Dog:
      def __init__(self, name):
          self.name = name
      def bark(self):
          print(self.name + " says woof!")
  

5. Logikai programozás

• A program tényeket és szabályokat tartalmaz.

• A rendszer logikai következtetéssel oldja meg a problémát.

• Példa (Prolog):

  parent(alice, bob).
  parent(bob, carol).
  grandparent(X, Y) :- parent(X, Z), parent(Z, Y).
  

6. Procedurális programozás

• Az imperatív paradigmán alapul.

• A program eljárásokra (procedúrákra) van bontva.

• Eljárás = utasításcsoport.

• Példa (Pascal-szerűen):

  procedure SayHello;
  begin
    writeln('Hello, world!');
  end;
  

7. Párhuzamos és reaktív paradigmák

• Több szálon vagy eseményre reagálva futnak a folyamatok.

• Aszinkron, valós idejű feldolgozás.

• Példa (RxJS):

  fromEvent(button, 'click')
    .subscribe(() => console.log("Clicked!"));
  

Többparadigmás nyelvek

Sok modern nyelv több paradigma elemeit is támogatja. Például:

Paradigmák összehasonlítása

Melyik paradigma a „legjobb”?

Nincs egyetlen „legjobb” paradigma – a feladat dönti el, hogy melyik illeszkedik jobban.

• OOP – Alkalmazások, UI, játékszoftver
• Funkcionális – Adatfeldolgozás, párhuzamos programozás
• Deklaratív – Adatbázis-lekérdezés, HTML leírás
• Logikai – Problémakeresés, mesterséges intelligencia

Összegzés

A programozási paradigmák a szoftverfejlesztés filozófiai alapjai: meghatározzák, hogyan gondolkodunk a problémák megoldásáról és azok kódolásáról. Megértésük lehetővé teszi, hogy hatékonyabban, tudatosabban válasszunk nyelvet, struktúrát és megoldást.

A modern fejlesztők számára az ideális, ha ismerik és tudják kombinálni több paradigma erősségeit – ezzel biztosítva a tiszta, rugalmas és fenntartható kódot.

További információk

• programming paradigm - Szótár.net (en-hu)
• programming paradigm - Sztaki (en-hu)
• programming paradigm - Merriam–Webster
• programming paradigm - Cambridge
• programming paradigm - WordNet
• programming paradigm - Яндекс (en-ru)
• programming paradigm - Google (en-hu)
• programming paradigm - Wikidata
• programming paradigm - Wikipédia (angol)Kategória:en

• imperative - code directly controls execution flow and state change, explicit statements that change a program state
  • procedural - organized as procedures that call each other
  • object-oriented - organized as objects that contain both data structure and associated behavior, uses data structures consisting of data fields and methods together with their interactions (objects) to design programs
    • class-based – object-oriented programming in which inheritance is achieved by defining classes of objects, versus the objects themselves
    • prototype-based – object-oriented programming that avoids classes and implements inheritance via cloning of instances
• declarative - code declares properties of the desired result, but not how to compute it, describes what computation should perform, without specifying detailed state changes
  • functional - a desired result is declared as the value of a series of function evaluations, uses evaluation of mathematical functions and avoids state and mutable data
  • logic - a desired result is declared as the answer to a question about a system of facts and rules, uses explicit mathematical logic for programming
  • reactive - a desired result is declared with data streams and the propagation of change
• concurrent programming – has language constructs for concurrency, these may involve multi-threading, support for distributed computing, message passing, shared resources (including shared memory), or futures
  • actor programming – concurrent computation with actors that make local decisions in response to the environment (capable of selfish or competitive behaviour)
• constraint programming – relations between variables are expressed as constraints (or constraint networks), directing allowable solutions (uses constraint satisfaction or simplex algorithm)
• dataflow programming – forced recalculation of formulas when data values change (e.g. spreadsheets)
• distributed programming – has support for multiple autonomous computers that communicate via computer networks
• generic programming – uses algorithms written in terms of to-be-specified-later types that are then instantiated as needed for specific types provided as parameters
• metaprogramming – writing programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime
  • template metaprogramming – metaprogramming methods in which a compiler uses templates to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled
  • reflective programming – metaprogramming methods in which a program modifies or extends itself
• pipeline programming – a simple syntax change to add syntax to nest function calls to language originally designed with none
• rule-based programming – a network of rules of thumb that comprise a knowledge base and can be used for expert systems and problem deduction & resolution
• visual programming – manipulating program elements graphically rather than by specifying them textually (e.g. simulink); also termed diagrammatic programming'