Programmeringsparadigm | ett sätt att gruppera programmeringsspråk efter vad de gör

Imperativ programmering

I imperativa program ger programmerarna datorn en uppsättning ordnade steg som måste utföras för att göra något. Om någon vill att datorn ska rita ett kattansikte kan han eller hon ge instruktioner som "rita en cirkel här, rita två mindre cirklar där, rita två trianglar ovanpå" och så vidare. Imperativa program har ibland många bieffekter.

Det finns två stora imperativa paradigm, och ofta har ett språk båda:

• Strukturerad - Datorn får anvisningar som alltid är i en viss ordning. Steg som "gå tillbaka till steg 3" (så kallade goto-anvisningar) är inte tillåtna.
• Procedurell - Programmet låter programmeraren ge en lista med order ett namn, vilket gör dessa order till en "procedur" som kan användas senare. De flesta strukturerade språk är också procedurella.
• Objektorienterad - Idéer förklaras för datorn med hjälp av objekt, kodbitar som har en uppsättning order som de kan få och viss information om dem.

 

Deklarativ programmering

I deklarativa paradigmer talar programmeraren om för datorn vad den ska göra i stället för hur den ska göra det. Om de vill att datorn ska rita ett kattansikte kan de ge instruktioner som "Rita ett ansikte, rita två ögon, två öron och en mun".

De mest kända deklarativa paradigmen är:

• Funktionell - Det mesta av arbetet utförs av funktioner utan några bieffekter.
• Logik - En uppsättning fakta anges och sedan ställs en eller flera "frågor".
• Händelsestyrd - Koddelar ställs in för att köras när vissa saker händer (t.ex. när datorn slås på).

 

Andra paradigmer

Vissa paradigmer finns i både imperativa och deklarativa språk. Dessa paradigm finns vanligtvis tillsammans med något av ovanstående paradigm i stället för att vara fristående.

• Parallell: Flera kodstycken körs samtidigt.
• Meta: Särskilda saker i språket låter programmeraren ändra hur språket självt agerar.

 

Översikt

Programmeringsspråk grupperas efter paradigm på samma sätt som maskiner kan grupperas efter vad de används till.

Några få språk passar in i ett enda huvudparadigm, t.ex:

• Smalltalk (objektorienterad)
• Assembly (tvingande, men inte strukturerad eller objektorienterad).
• Haskell (funktionell)
• Prolog (logik)

De flesta språk har dock mer än ett paradigm. Några av de som utmärker sig genom att ha mer än ett paradigm är:

• Scala (objektorienterad, funktionell, parallell)
• Visual Basic (händelsestyrd, objektorienterad)
• Common Lisp (procedurell, funktionell, objektorienterad, meta)
• Schema (funktionellt, procedurellt, meta)
• Perl (funktionell, procedurell, meta, objektorienterad, händelsestyrd)
• Python (funktionell, objektorienterad, procedurell)
• Ruby (funktionell, objektorienterad, procedurell)
• Wolfram Language (funktionellt, procedurellt, i allmänhet deklarativt)
• Oz (logik, funktionell, imperativ, objektorienterad)
• F# (funktionell, imperativ, objektorienterad, meta)

Det är inte alltid bra att ha fler paradigmer. Ett tillfälle då det kan vara bra att ha färre paradigm är när det finns ett språk som endast är funktionellt. En funktion i ett sådant språk gör ibland mindre arbete (t.ex. går den bara igenom de delar av en grupp av saker som den faktiskt behöver) än vad den skulle ha behövt göra om språket också var procedurellt.

Många programmeringsparadigm är lika kända för de saker de inte låter folk göra som för de saker de låter folk göra. Ett exempel på detta är funktionella språk. När ett funktionellt språk endast eller huvudsakligen är funktionellt tillåter det vanligtvis inga sidoeffekter. Det skiljer sig från vanliga imperativa språk eftersom det inte tillåter programmerare att använda "goto-satser" (uttalanden som säger åt programmet att gå till ett tidigare steg). På grund av detta och andra orsaker anser människor ibland att nya paradigm inte tillåter tillräckligt mycket. Ibland är det dock okej att datorn inte låter människor göra saker: den kan hjälpa människor att undvika problem med sin kod och låta datorn göra gissningar så att den kan köra koden snabbare, eller till och med kontrollera koden för problem innan den körs!

 
Översikt över de olika programmeringsparadigmen enligt Peter Van Roy  

Problem med paradigmer

Vissa personer som studerar programmeringsspråk tycker inte om att paradigm används för att gruppera programmeringsspråk, till exempel Harper och Krishnamurthi. Dessa personer menar att många programmeringsspråk inte bara kan grupperas i paradigm eftersom språken lånar saker och idéer från många paradigm.

 

Historia

Nya paradigmer har skapats med tiden, och människor har antingen påpekat dem då eller när de ser tillbaka på dem. Ett av de första paradigmen som erkändes som ett nytt sätt att programmera var strukturerad programmering från 1960-talet. Idén om ett "programmeringsparadigm" är från 1978, om inte tidigare, då Robert W. Floyd använde den när han undervisade. Ordet "paradigm" på det sätt som Robert menade det användes först av Thomas Kuhn i hans bok The Structure of Scientific Revolutions (1962).

Maskinkod

Den lägsta nivån (närmast hur datorn vill förstå saker och ting) och det äldsta programmeringsparadigmet är maskinkod, ett imperativt paradigm. Riktlinjerna i maskinkod är bara en uppsättning siffror i en viss ordning. Assembleringsspråk är lite mindre låg nivå (och lite mindre gammalt). I assemblerspråk ges anvisningarna för datorn mnemonik (namn som är lättare att komma ihåg), och minnesadresser (anvisningar för att hitta en information i datorn) kan ges namn. Dessa kallas ibland för första och andra generationens språk.

På 1960-talet förbättrades assemblerspråken genom att lägga till nya saker som bibliotek COPY, makron (bitar av "specialkod" som omvandlades till normal kod innan programmet började köras), körprocedurer (uppsättningar av anvisningar som ges ett namn och sparas för senare) och variabler (objekt som ges namn och sparas för senare) från utanför programmet. Detta gjorde att man kunde använda viss kod i mer än ett projekt och inte behöva oroa sig för hårdvaruspecifika problem (problem som bara uppstår på en viss typ av dator) tack vare kommandon (namn för anvisningar) som READ/WRITE/GET/PUT.

Assembly användes, och används ibland fortfarande, i system där det är viktigt att koden är snabb, och den används också mycket i inbyggda system eftersom den ger användaren exakt kontroll över vad maskinen gör.

Procedurella språk

I slutet av 1960-talet började folk uppfinnas procedurella språk. Dessa tredje generationens språk (de första av vad vi nu kallar högnivåspråk) hade ord som hade att göra med vad de försökte lösa. Till exempel,

• COBOL (COmmon Business Oriented Language) - använder ord som file, move och copy.
• FORmula TRANslation (FORTRAN) - använder matematiska ord och symboler (former som används vid skrivning och maskinskrivning). Det utvecklades främst för vetenskap och teknik.
• ALGOrithmic Language (ALGOL) - används för att skriva algoritmer (uppsättningar steg som talar om för datorn vad den ska göra). Det använder matematiska ord och symboler, precis som FORTRAN.
• Programming Language One (PL/I) - skulle vara användbart för alla.
• Beginners All purpose Symbolic Instruction Code (BASIC) - gjord för att hjälpa nybörjare att programmera.
• C - ett programmeringsspråk som kan göra många saker. Dennis Ritchie arbetade med det mellan 1969 och 1973 på AT&T Bell Labs.

Objektorienterad programmering

Efter att många människor hade börjat använda procedurella språk uppfann man objektorienterade programmeringsspråk. I dessa språk samlas data och dess "metoder" (sätt att hantera data) i ett "objekt". Vissa programmerare, som Richard Stallman, håller inte med om att objektorienterade språk är bättre än procedurspråk för att förklara idéer för en dator.

Eftersom objektorienterad programmering är ett paradigm, inte ett språk, har man skapat objektorienterade monteringsspråk som HLA (High Level Assembly).

Deklarativa paradigmer

Samtidigt började vissa människor skapa deklarativa programmeringsspråk. Ett språk som är välkänt för att vara deklarativt är SQL (ett språk för att lägga till och ta bort saker från tabeller).

 

Relaterade sidor