Introduktion till programmering.

Moderator: Moderatorgruppen

JimmyAberg
Inlägg: 932
Blev medlem: 05 aug 2008 01:56

Introduktion till programmering.

Inläggav JimmyAberg » 19 dec 2008 00:48

Här kommer ett ganska långt inlägg. Jag ursäktar för blandad kvalite på inlägget, men jag skrev det i ett långt svep.

Syftet med detta inlägg är att förklara hur en dator arbetar och hur all typ av information kan representeras binärt genom 1: or och 0: or.


...

Så vad innebär programmering? Vad skiljer programmering från matematik, logik och fysik? Programmering innebär att implementera en logisk strukur som är exekverbar/"körbart". Syftet med ett program, är ofta att 1. automatisera triviala processer. 2. avlasta vårat minne (dvs förmåga att komma ihåg saker) 3. agera som besultsunderlag.

Till skillnad från matematik, logik och fysik etc, så är resultatet alltstå ett körbart program.


Syftet med att köra ett program är alltså att "kommunicera" något, och med kommunikation menar jag en process som är "överförande", och även "förändrande".

...

Nyckelbegrepp är: Beräkningen. Representation. Minne. Kommunikation. Program. Programkod. etc.

....

Så vart börjar vi?

Vi börjar med något ganska enkelt: Hur en dator arbetar...

Ni har kanske hört att datorer binärt, dvs "bara" arbetar med 1:or och 0:or, men vad betyder detta egentligen? Jo, det enklaste sättet att förklara vad detta innebär är jämföra med morsesignaler http://sv.wikipedia.org/wiki/Morsealfabetet

Anledningen att man bara pratar om 0 och 1, och inte t.ex. 0, 1 och 2, eller annan uppsättning nummer är för att 2 typer av "signaler" eller "symboler" är allt som behövs för att göra en distinktion. Egentligen är 0 och 1 inte "två olika signaler", 1:an är en signal medans 0:an mer korrekt är en frånvaro av signal.

Skulle du bara ha "en signal" skulle du aldrig kunna "poängtera någon skillnad".

Ett program är för en dator, ytterst sett, en serie med 0:or (dvs frånvaro av elektrisk signal) och en serie 1:or. dvs 00010101010111101101010110101001 osv.

Så hur snabbt kan en dator bearbeta 0:or och 1:or? Datorn har något som heter processor som beräknar inkommande instruktioner. En instruktion är en "typ av kod", dvs det är ytterst sätt ett packet med 0:or och 1:or. Hur stora dessa instruktioner är beror på "aktuell specifikation" den kan alltså vara av variabel längd eller fixed längd, men vi skulle teoretiskt stipulera att en instruktion alltid är 6 st 1:or och 0:or: tex: "010110". då har vi plats för 2 ^ 6 (upphöjt till 6) antal instruktioner. Man mäter dators kapacitet att beräkna instuktioner genom s.k. "klockfrekvens", som mäts i enheten "hertz" -dvs "svängningar per sekund". Nuförtiden är nya hemdatorers processorer ofta på  runt 2 gigahertz, dvs 2 000 000 000 instruktioner per sekund. Det är alltså en "klocka" med en regelbunden intervall. Ju snabbar klockfrekvens, desto mer information per sekund kan behandlas.

Vi kan skapa ett teoretiskt instuktions-set, där instruktionerna är 4 bitar (1 bit = 1 st "1":a eller 1 st "0":a), vilket ger oss plats för 16 instruktioner:
0000,0001,0010,00110100,0101,0110,0111,1000,1001,1010,1011,1100,1101,1110,1111

Om vi antar att det är "vi" som är processorn, så kan skulle vi kunna ge instruktionerna en mening för oss, vi definierar alltså instruktionerna i vårat hypotetiska instuktions-set: (detta är alltså inget en programmerare gör, utan jag förklarar nu bara hur en dator arbetar...)

0000 = hämta
0001 = lägg
0010 = ät
0011 = kom ihåg
0100 = öppna
osv.

Nu har vi en uppsättning instruktioner. Men vi har inga "objekt" så att säga att utföra instruktionerna på.

För att kunna utföra instruktioner på "något" så måste detta "något" även definieras. Här kommer datorns "minne" in i bilden.

Vad är ett "minne", jo datorns minne är egentligen inget "konstigt", minnet är återigen, en uppsättning 0:or och 1:or. Ett minne på 1 byte (1 byte = 8 bitar = 8 st 0/1 or) skulle kunna vara: 01011100 eller 10011001.

Datorn har olika typer av minnen, men vi kan här prata om tre olika minnen: primär (arbets) minne och sekundär (lagrings) minne. Primär minne är dels "registret" och dels "ram-minne" och dessa arbetar datorn på under beräkningar. Registret ligger på processorn och är såledess ett minne som går väldigt snabbt att nå - men det är begränsat i sin mängd/kapacitetet. Ram minnet är det vi ofta pratar om när vi menar datorns "minne", ram minne ligger ofta på 2 gigabyte i dagens datorer vilket innebär 2 000 000 000 bytes vilket innebär 2 000 000 000 * 8 bitar (dvs 0/1 or). Men minnet har även en del till, och det är den s.k. "adressen". Vi kan jämföra minnet med en gata med fyra hus: h1, h2, h3, h4. Är någon hemma i huset, så representerar vi detta med en 1:a, är ingen hemma i huset så representerar vi detta med en 0:a. Här har vi alltså status för hela gatan H1(0), H2(1), H3(1), H4(0) - det är alltså någon hemma i hus 2 och 3. Minnet har alltså dels en address (dvs: H1, H2, H3, H4), och dels ett värde (dvs: 0, 1, 1, 0). Addressen är således den "fysiska strukturen" för minnet, och värdet är den "logiska strukturen" för minnet. ("Struktur" var bara ett godyckligt ordval här, "aspekt", "plats", eller annat ord funkar också att använda)


Sekundärminne är sådant som hårddiskar och cd skivor, poängen med sekundärminnet är att det är "mer permanent", dvs det lagras mellan körningar - primärminnet däremot "nollställs" varje gång datorn startas om.

Om vi återgår till minnet.
Vi antar att vårat hypotetiska program har tillgång till ett typ av arbetsminne, vi kallar detta helt enkelt för "arbetsminnet", vi kan säga att det består av 8 st adress och varje adress är 4 bitar stor. Vi kallar dessa för M0, M1, M2... till M7.

Vi kan alltså representera vårat minne på flera sätt:
1. 00000000000000000000000000000000

2. 0000 0000 0000 0000 0000 0000 0000 0000

3. M0(0000), M1(0000), M2(0000), M3(0000), M4(0000), M5(0000).. osv

4. (M0 0000) (M1 0000), (M2 0000) osv....


...

Våran processor har en uppsättning instruktioner, som kan representeras på flera olika sätt:

för datorn
0000 = plocka upp
0001 = lägg
0010 = ät
0011 = kom ihåg
0100 = öppna
...

för oss, genom "mnemonics"
P0 = plocka upp
P1 = lägg
P2 = ät
P3 = kom ihåg
P4 = öppna
...

Den tredje saken vi behöver är ett program. I datorer så läses programmen in i arbetsminnet av en s.k. "loader". Det som händer sedan, är att processorn exekverar programmet i arbetsminnet - och detta program ändrar i sin tur arbetsminnet på andra ställen när programmet arbetar.

Vårat hypotetiska program kan bestå av följande:
Först deklareras alla objekt i minnet:

Kod: Markera allt

"mnemonic"/adress
M0/0000 = stol
M1/0001 = kylskåp
M2/0010 = banan
M3/0011 = i
M4/0100 = på
M5/0101 = minnet
M6/0110 = under


Sedan deklareras alla instruktioner som ska köras, och på vilka objekt de ska operera på:
Mnemoniskkod:

Kod: Markera allt

P4M1
P0M2
P2M2

Skriver vi en s.k. "kompilator", så kan vi översätta den "mnemoniskakoden" till ren maskinkod:

Kod: Markera allt

01000001
00000010
00100010


För oss innebär detta:

Kod: Markera allt

öppna kylskåp
plocka upp banan
ät banan


I assemblerspråk består instruktioner av två delar: "instruktion" (våra P0, P1, P2) och "objekt" (M0, M1) eller mer korrekt: "opcode" (operationskod) och "operand".

Ett exempel på ett hypotetisk programmeringsspråk där vi kan göra en enkel matematisk operation, där + är opcode och 1, 2 är operander:
(+ 1 2)
Vilket ger oss svaret 3.

Lägger vi till en operand: (+ 1 2 9), så kommer detta, vid översättning till maskinkod att bli följande: (+ 1 (+ 2 9 ) ), eftersom opcoden alltid tar två operander....










...

Ok, nu har vi alltså gått igenom både datorns processor och minne.

Men är allt detta verkligen relevant för en programmmerare? Ja - om du programmerar lågnivå språk som assembler tex. (något jag själv aldrig gjort). Nej - om du programmerar på högre nivå så kan det vara så att detta inte är lika viktigt att har koll på.

Poängen är hur som helst detta: Genom att vi nu har gått igenom hur vi skapar ett grundläggande system för minne och processering, så kan vi bygga all annan kommunikation på denna grund.

....

Nu ska jag tillåta mig själv att börja pratat om själva programmet.

Ett program är något som skrivs i ett programmeringsspråk, detta språk är på en mycket högre nivå än 0:or och 1:or, vilket gör att vi människor kan förstå det.

Här har vi t.ex. ett teoretiskt programmeringsspråk (syntaxen är faktiskt liknande något jag själv tagit fram till mitt egna programmering/skriptsspråk):

Kod: Markera allt

nytt_tal('tal1,'10)
nytt_tal('tal2,@tal1)


Vad rad1 gör är följande: Leta upp en tom minnesplats, "sätt adress till tal1", samt "sätt värde för tal1 till 10".

Vad rad2 gör är följande: Leta upp en tom minnesplats, "sätt adress till tal2", samt "hämta värde från tal1 och sätt värde för tal2 till "det hämtade värdet från tal1" ".

Att jag skriver 'tal2 innebär att jag ska läsa "tal2" ordagrant till skillnad från om jag skriver @tal2 vilket innebär att jag ska hämta värdet från variabeln "tal2" vilket i detta fall är "10", eftersom tal2 kopierade värde från tal1.

Kod: Markera allt

skriv_ut(@tal2)
Detta skriver ut värdet för tal2 på skärmen, dvs ut kommer "10".


....

Men matematiska beräkningar och ord och sånt, hur behandlas det av datorn? Jo, nu börjar vi komma in på s.k. "datatyper". En datatyp är en viss mängd bitar - den har alltså en storlek - den är en alltså en gränsdragning i minnet, det är en "definition" på hur vi vill använda minnet.

Säg att vi har 4 bytes (4 * 8 bitar) rent minne: 00000000000000000000000000000000. Det vi vill göra nu för att räkna på heltal är att vi vill definiera upp en datatyp som vi kallar för "short int" (dvs litet heltal), denna datatyp har en storlek på 2 bytes  (2 *8 = 16 bitar) (den kan alltså lagra tal mellan 0 och 65535, dvs 2 upphöjt till 16). Definierar vi en short int i vårat minne, så letar vårat program upp en ledig plats i vårat minne, och avsätter 2 bytes för vårat heltal, detta innebär att vi bara har 2 bytes ledigt minne kvar, eftersom vi har deklarerat att vi vill använda 2 av våra totala 4 bytes till vårat lilla heltal.

Matematiska operationer som +, -, *, /, utför en slags "logisk operation" på två heltal. Har vi t.ex. två short ints:
ett som håller värdet 3: 0000000000000011 och ett som håller värdet 4: 00000000000000100, utför vi sedan operationen + på dessa så får vi svaret 7: 0000000000000111.
Är det så att en operation vi gör är större än vårat tal kan lagra, så är det ofta så att numret "går runt" och börjar om från 0, så att säga. Har vi t.ex. 65535: 1111111111111111 och adderar 3: 0000000000000011, får vi alltså 2: 0000000000000010.

Väldigt enkelt!



Men hur är det då med bokstäver? Jo, det finns olika typer av "encodings", dvs det finns olika standarder för att "numrera" alfabeten. En av de vanligaste är "ASCII",  http://en.wikipedia.org/wiki/Ascii#ASCII_printable_characters

Där ser du alltså hur de olika bokstäverna i alfabetet har binära representationer.

....





Hur är allt detta relevant till filosofi? Tja vad menar vi när vi t.ex.säger detta: "Jag har Sagan om ringen på datorn", eller "Jag har sett Sagan om ringen".

För en programmerare, så är "Sagan om ringen" lite olika saker. Har vi "Sagan om ringen" på vår dator, så innebär detta att vi på våran hårddisk har reserverat en viss mängd fysiska adresser, dvs evv viss mängd 0:or och 1:or på ett specicfikt ställe - och värdet på bitarna (0/1 or) är naturligtvis själva filmen, när du får fullt på hårddisken är alltså alla fysiska adresser upptagna, har du ledigt med utrymme så finns alltså fysiska adresser tillgängliga att spara logisk information. Du kanske även har Sagan om ringen på din dator för att du har kopierat den av mig. För en programmerare så har din "Sagan om ringen" en annan "fysisk adress", men den har samma "logiska struktur" som min Sagan om ringen. Fysisk och Logisk struktur är alltså två olika saker. Men det stannar inte där. Sagan om ringen är i sig själv kodad i ett filformat som även har en "encoding", detta betyder att jag, inte har "Sagan om ringen" "ren essentiellt logiskt" på datorn, utan jag har en logisk representation av "Sagan om ringen" inkodad i (t.ex.) en divx-encoding. Därför behöver jag en divx-decoder för att kunna se på filmen. Sagan om ringen kan alltså vara kodad på många olika sätt, beroende på encoding - men viktigt att komma ihåg är att det som kodas inte är "Sagan om Ringen" utan bild och ljud - bilderna är kodaded i "pixlar" dvs små "färgprickar". Och när filmen spelas upp på vår dator skärm, så är det så att datorskärmen i sin tur har en "upplösning" (kan t.ex. vara 1024 gånger 768, dvs 1024 pixlar/prickar i höjdled och 768 pixlar/prickar i lodrätt). Varje pixel på skärmen har även en fysisk adress som man "ritar på", dvs sätter färgen på - och färgen är naturligtvis "den logiska adressen"/"logiska värdet"/etc.

Det är först när vi genom våran "perception" decodar den logiska struktuen i bilden av pixlana som vi så att säga "ser" "Sagan om ringen".


Sagan om ringen - som en divx på min hårdisk existerar alltså - rent objektivt - som är ganska svårt att definiera. När vi talar om 0:or och 1:or - så måste vi komma ihåg att detta INTE är objektiva värden, utan dessa är i sin tur en logisk representation för oss programmerare, 0:or och 1:or, är i "den mest objektiva" representationen jag just nu kan komma på, "elektriska signaler". Men här bör vi även komma ihåg, att "elektiska signaler" är så långt vi kommit enligt våran nuvarande förståelse av fysik. Samtidigt kan man ju abstrahera och prata om elektricitet som en energiform, rent objektiv är inte sagan om ringen på min dator ens elektriska signaler, det är en fråga hur vi väljer att tolka det.

Uppenbarligen kan vi kostatera att det finns någon form av "fysiska lagar" som "upprätthåller" min Sagan om ringen i divx på datorn, men allt är i lager av fysisk och logisk "represenation". Den vi "möter" när vi ser på filmen är s.a.s. den fysiska adressen av pixlarna på skärmen, men rent fysiskt så är dessa fysiska material (beroende på vilken skärmtyp vi har), men det är då kanske mer egentligt att prata om de ljusstårlar som går från pixlarna och träffar vår hornhinna, men sen kan man dra det ännu lägre. Osv.

Hur som helst, så är det för en programmerare mer lämpligt att tala om fysiska och logiska adresser. Rent praktiskt så definieras subjektivitet och objektivitet väldigt olika beroende på situationen. Men logisk och fysisk adress är något som är väldigt konkret.

Användarvisningsbild
kWee
Inlägg: 425
Blev medlem: 10 jul 2008 22:06

Inläggav kWee » 19 dec 2008 10:06

jag är en novis vad gäller sådan här,but here goes:


Med andra ord kan man säga att föregångaren till nutidens dator, de första som hade hålstansade kort att mata i datorn,inte mycket har egentligen ändrats eller?
samma "kodnyckel" fanns i de datorerna bara att nutidens dator klarar av mera info på en gång tack vare primära minnet.
betyder det då att jag skulle kunna hyra ett hålstans-kort och se sagan om ringen?

JimmyAberg
Inlägg: 932
Blev medlem: 05 aug 2008 01:56

Inläggav JimmyAberg » 19 dec 2008 18:28

Jag tänkte här börjar presentera mitt egna språk.

....

Angående språkets grammatik: Jag tänkte börjar med att radda upp språkets grammatik. Alla programmeringsspråk har keyword, och dessa utgör formen eller definitionen av själva programmeringsspråket. Det resterande som inte är keywords i ett program är innehållet, dvs "semantiska innehåll" man kommunicerar. Man "implementerar" alltså ett "semantiskt innehåll" via ett språk, det är därför man kan skriva ett program i två olika språk som beter sig lika dant (dvs har "samma semantiska innehåll").

...

Angående tekniska begrepp: När jag skriver något inom två stycken understreck/_(exempel: _begrepp_), så vill jag med detta ord betona att det är ett "tekniskt begrepp", dvs att det är mer formellt än de andra ord jag använder i min förklaring, de tekniska begreppen är något jag hela tiden återkommer till.

Vi har olika grupper för keywords:
Först har vi _metatecken_, några exempel (som är _kommaspearerade_): *, ',  @
Sen har vi _metabegrepp_ (i _programmering_ även kallat: _funktioner_), alla _metabegrepp_ inleds med _metatecknet_ *: *nytt_begrepp (introducerar ett nytt _begrepp_ med tillskriven en _betydelse_), *nytt_ref_begrepp (introducerar ett nytt _begrepp_ som _refererar_ till ett annat _begrepp_, och således även till det refererande begreppets _betydelse_), *? (_uttryck_, vilket är något som _utvärderas_ och kan få olika _utfall_, det är alltså en "fråga" snarare än ett konstaterande. uttryck kallas på engelska för _expressions_, går i någon mån att jämföras med en "logisk implikation", dvs "om x, så y"), *= (_konstaterande_ (eng: _statment_), vilket är något som ändrar _betydelsen_ hos _begreppet_, detta är ett tillskridande, ett _konstaterande_/_statement_ är alltså "hårdare" än _expressions_/_uttryck_ och är mer "deterministiskt")

När jag ska introducera ett nytt begrepp gör jag detta genom ett/en metabegrepp/funktion, dvs *nytt_begrepp:

Kod: Markera allt

*nytt_begrepp('x,'y)
där:
'x - är begreppet (i programmering kallat _variabel_)
'y - är dess beydelse (även kallat mening, syftning, i prorammering kallat _värde_)
*nytt_begrepp - är funktionen (dvs ett metabegrepp) - som reserverar plats för det nya begreppet.
' - är ett metatecken för att tolka det efterkommande begreppet som "ordagrant" (som sträcker sig till det första kommat: , ). Dvs det som kommer efter metatecknet ska tolkas som en "rad med bokstäver/tecken", dvs (vad vi annars menar med) ett "ord", eller en "mening" (mening i betydelsen som en "rad/uppsättning av ord", inte mening i betydelsen: "betydelse" eller "semantiskt innehåll").
* - är ett metatecken för att tolka det eftersommande som ett/en metabegrepp/funktion (som sträcker sig till den första öppningsparentsen: ( )

Notera att alla metabegrepp/funktioner tar alltid ett antal begrepp. Dessa begrepp kallas för _argument_.
Ett exempel på en/ett matematiskt metabegrepp/funktion med tre _argument_: *+('1,'2,'4) ger oss svaret 7.

Ett till exempel:

Kod: Markera allt

*nytt_begrepp('x,'y)
*nytt_begrepp('z,@x)
där:
'z - är begreppet
@x - är en referens till x:s betydelse (betydelsen för x)

vilket gör att:
@x = y
@z = y

vilket innebär att betydelsen för @x och @z båda är y, vilket innebär att de skulle kunna beskrivas som "värdemässiga synonymer" men inte "begreppsmässiga synoymer", de har samma betydelse men är två olika begrepp.

Ett fel jag kan göra är ett så kallat _syntaktiskt fel_, vilket strider mot språkets grammatik:
*nytt_begrepp('x,y) (y saknar metatecken)
*nytt_begrepp('x'y) (metabegreppet saknar ett andra _argument_ eftersom argument är _kommaseparerade_)
*nytt_begrepp('x,'y (metabegreppet saknar en avslutande parentes)
*nytt_begrepp'x,'y) (metabegreppet saknar en första parentes)

Ett annat fel jag kan göra är ett så kallat _semantiskt fel_, vilket innebär att jag följer språkets grammatik, men är inkonsekvent i min egen begreppsapparat:
*nytt_begrepp('x,@y) (y saknar definition, vi har glömt)
*nytt_begrepp(@zxc,'y) (zxc saknar definition)

för att lösa detta behöver vi först göra:
*nytt_begrepp('y,'123)
*nytt_begrepp('x,@y)

@y = 123
@x = 123
eller:
*nytt_begrepp('y,'y)
*nytt_begrepp('x,@y)
@y = y
@x = y

...

För att referera till ett annat begrepp (snarare än till något ordagrant) behöver vi använda en annan metafunktion: *nytt_ref_begrepp('x,@y)

Exempel:
*nytt_begrepp('y,'y)
*nytt_ref_begrepp('x,@y)
@y = y
@x = @y

...

Följande är skillnaden mellan begrepp och ref_regrepp:

Kod: Markera allt

*nytt_begrepp('y,'y)
*nytt_begrepp('x,@y)
*nytt_ref_begrepp('ref_x,@y)
*skriv_ut(@y)
*skriv_ut(@x)
*skriv_ut(@ref_x)
*=(@y,'y2)
*skriv_ut(@y)
*skriv_ut(@x)
*skriv_ut(@ref_x)

vilket ger oss detta på skärmen:

Kod: Markera allt

@y = y
@x = y
@ref_x = y
@y = y2
@x = y
@ref_x = y2


vidare:

Kod: Markera allt

*nytt_begrepp('y,'sant)
*skriv_ut(@y)
*=(@y,'falskt)
*skriv_ut(@y)
*skriv_ut(*?=(@y,'falskt))
ger oss:

Kod: Markera allt

y = sant
y = falskt
sant


...

Så vad är nyttan med att formalisera enligt detta sätt?

Jo, denna formalisering är nödvändig om man vill närma sig "objektivitet" eller "determinism" i sitt beräknande.

Dvs, när man förljer denna specifikation så är det, vid normala omständigheter (om vi bortser från stömmavbrott, etc), så att det logiskt korrekta kommer att exekveras.

....

Fortsättnng följer.


Återgå till "Filosofi"

Vilka är online

Användare som besöker denna kategori: 22 och 0 gäster