Brukermanual for Norscode

1. Kom i gang

Det viktigste som nybegynner er å starte enkelt. Lag én fil, skriv én funksjon og kjør den. Ikke prøv å lære alt på én gang. I Norscode er det ofte best å lære ved å skrive små, konkrete programmer først.

1. Lag en fil med navnet hei.no.
2. Skriv et lite program i filen.
3. Kjør programmet med samme oppsett som brukes i prosjektet ditt.
4. Endre litt, kjør igjen, og se hva som skjer.

En god nybegynnerregel er: skriv litt, kjør litt, les feilmeldingen, prøv igjen.

Dette høres enkelt ut, men det er faktisk en av de viktigste arbeidsvanene i programmering. Mange nybegynnere venter for lenge med å kjøre koden, og da blir det vanskeligere å se hvilken liten endring som skapte problemet. Små runder gjør læringen raskere og tryggere.

2. Hvordan du kjører Norscode-kode

I språk-workspace brukes vanligvis bin/nc. Det er det enkleste stedet å starte.

bin/nc run hei.no
bin/nc check hei.no
bin/nc test tester.no
bin/nc build hei.no

De viktigste kommandoene for en nybegynner er:

• run: kjører programmet ditt.
• check: sjekker om koden er gyldig.
• test: kjører tester.
• build: bygger bytecode-artifakt når du trenger det.

Hvis du er usikker, start med run og check.

Et godt mønster er å bruke check først hvis du har skrevet litt ny kode og bare vil se om strukturen er gyldig. Bruk run når du vil se faktisk oppførsel. Etter hvert som du begynner med små tester, blir test et nyttig tredje steg.

3. Din første fil

Et veldig enkelt Norscode-program kan se slik ut:

funksjon start() -> heltall {
    skriv("Hei fra Norscode")
    returner 0
}

Her skjer tre ting:

• funksjon start() lager inngangspunktet i programmet.
• skriv(...) skriver tekst ut.
• returner 0 avslutter programmet med en enkel statuskode.

Hvis du bare skal lære én ting først, er det dette mønsteret: lag start(), skriv noe ut, og returner en verdi.

Når dette fungerer, kan du eksperimentere trygt. Endre teksten. Legg til en variabel. Kall en liten hjelpefunksjon. Hele poenget med den første filen er å få en enkel arbeidsflate der du kan se sammenhengen mellom kode og resultat uten for mye støy rundt.

4. Grunnleggende syntaks

la navn: tekst = "Ada"
la alder: heltall = 29

Tekst og sammenkobling

la fornavn: tekst = "Ada"
la melding: tekst = "Hei, " + fornavn
skriv(melding)

Du kan bygge opp tekst med +. Når du skal blande inn tall, må du ofte konvertere til tekst, for eksempel med tekst_fra_heltall(...).

Som nybegynner er det lurt å øve på korte eksempler her. Lag én tekstvariabel, skriv den ut, endre den og kjør på nytt. Når du ser hvordan typer og tekst fungerer i praksis, blir resten av språket mye enklere å lese.

5. Kontrollflyt

Du styrer programflyten med hvis, ellers, mens og sammenligninger.

la poeng: heltall = 12

hvis poeng > 10 da {
    skriv("Du har høy score")
} ellers {
    skriv("Du har lav score")
}

Løkker brukes når du vil gjenta noe:

la indeks: heltall = 0
mens (indeks < 3) {
    skriv("Runde " + tekst_fra_heltall(indeks))
    indeks = indeks + 1
}

Bruk hvis når programmet skal velge mellom to eller flere retninger. Bruk mens når noe skal gjentas.

Et godt øvetips er å endre verdiene selv. Sett poeng til noe annet. Endre hvor mange ganger løkken skal gå. Når du aktivt ser hvordan små endringer påvirker flyten, blir kontrollstrukturer lettere å forstå enn om du bare leser dem passivt.

6. Funksjoner

Funksjoner er byggesteinene i Norscode. Del opp programmet i små funksjoner som gjør én ting hver.

funksjon hils(navn: tekst) -> tekst {
    returner "Hei, " + navn
}

funksjon start() -> heltall {
    skriv(hils("Ada"))
    returner 0
}

Dette er en god vane for nybegynnere, fordi koden blir lettere å lese og enklere å feilsøke.

Når bør du lage en ny funksjon?

• Når den samme logikken begynner å gjenta seg.
• Når en del av koden har ett tydelig ansvar.
• Når start() begynner å bli for stor.

Dette er en vane som gir mye tilbake senere. Små funksjoner gjør det lettere å teste, lettere å lese og lettere å bruke samme logikk flere steder. Hvis du merker at én blokk kode gjør mange ting samtidig, er det ofte et godt tegn på at noe bør deles opp.

7. Lister og tekst

Når du jobber videre vil du ofte bruke tekstbehandling og lister.

la navn: liste_tekst = ["Ada", "Per", "Sara"]
skriv(tekst_fra_heltall(lengde(navn)))

Du kan også dele opp tekst og sette sammen nye verdier. Det brukes mye i både små verktøy og større apper.

Eksempel med enkel iterasjon

la navn: liste_tekst = ["Ada", "Per", "Sara"]
la indeks: heltall = 0

mens (indeks < lengde(navn)) {
    skriv("Hei " + navn[indeks])
    indeks = indeks + 1
}

Lister og tekst er to av de viktigste byggeklossene i små verktøy og webapplikasjoner. Når du er komfortabel med å iterere over en liste og bygge ny tekst, begynner du å få nok kontroll til å lage programmer som faktisk gjør noe nyttig.

8. Moduler og større filer

Når programmet ditt vokser, er det smart å dele koden i flere filer. Norscode er laget for moduler og handler-filer, slik du også ser i større prosjekter.

Som nybegynner holder det å tenke slik:

• Én fil for oppstart.
• Én fil for hjelpefunksjoner hvis prosjektet blir større.
• Én tydelig funksjon per ansvar.

Du trenger ikke tenke “stor arkitektur” med en gang. Det holder å vite at når én fil begynner å bli tung å lese, er det lov å dele ut deler av ansvaret. Det gjør ikke prosjektet mer avansert. Det gjør det mer oversiktlig.

9. Prosjekter og filstruktur

Når du går fra små øvingsfiler til et faktisk prosjekt, er det nyttig å tenke i mapper og ansvar. Et enkelt prosjekt kan for eksempel se slik ut:

mitt-prosjekt/
  norscode.toml
  main.no
  helpers.no
  pages/
    hjem.html

Den vanlige tankegangen er:

• main.no eller tilsvarende er inngangspunktet.
• hjelpefunksjoner flyttes ut når programmet blir større.
• statiske filer og HTML kan ligge i egne mapper.

Som nybegynner trenger du ikke å starte med mange filer. Men det er smart å vite hvordan prosjekter kan vokse senere.

En enkel struktur tidlig gjør det også lettere å dele prosjektet med andre senere. Hvis du allerede har et tydelig inngangspunkt og vet hvor hjelpefiler hører hjemme, blir neste steg mindre forvirrende.

10. Standardbibliotek

Når du jobber videre vil du bruke standardbiblioteket til ting som tekst, lister, IO og web. Du trenger ikke lære alt med én gang, men det er nyttig å vite hva som finnes.

11. Web-ruter i Norscode

Når du begynner å lage nettsider og tjenester, handler mye om ruter. En rute bestemmer hva som skal skje når en bruker går til en bestemt adresse.

I større Norscode-prosjekter brukes egne funksjoner som handlere for sider og API-endepunkter.

funksjon hjem_handler(method: tekst, path: tekst, query: tekst, body: tekst) -> tekst {
    returner http_respons_tekst(200, "text/html; charset=utf-8", "<h1>Hei</h1>")
}

Det viktigste å forstå er at en handler tar imot informasjon om requesten og returnerer et svar.

Når du kommer hit i læringsløpet, begynner du å se hvordan Norscode går fra små konsollprogrammer til faktiske nettsider og tjenester. Du trenger ikke forstå alle detaljer på én gang. Det holder å se at en rute er en funksjon som mottar input og sender tilbake respons.

12. JSON og API

Norscode kan også brukes til små API-er. Da returnerer du ofte JSON i stedet for HTML.

funksjon api_handler(method: tekst, path: tekst, query: tekst, body: tekst) -> tekst {
    returner http_respons_tekst(200, "application/json; charset=utf-8", "{\"ok\":true}")
}

Når du blir mer komfortabel kan du lage ruter som leser inn data fra body, henter ut felt og bygger respons tilbake.

Det er også dette som gjør Norscode interessant for interne verktøy, dashboards og små tjenester.

Det nyttige å lære her er forskjellen mellom HTML og JSON som svarformat. HTML er for sider mennesker leser i nettleseren. JSON er for data som frontend eller andre systemer skal bruke videre.

13. Testing

Testing er nyttig selv i små prosjekter. I Norscode kan du skrive enkle tester for å sjekke at funksjonene gjør det du forventer.

funksjon legg_sammen(a: heltall, b: heltall) -> heltall {
    returner a + b
}

test "legg sammen to tall" {
    assert_eq(legg_sammen(2, 3), 5)
}

Som nybegynner er det nok å teste små funksjoner først.

Testing er spesielt nyttig når du begynner å dele opp koden i flere funksjoner. Da kan du sjekke at hver lille del oppfører seg riktig, uten å måtte kjøre hele programmet manuelt hver gang.

14. Vanlige feil for nybegynnere

Hvis du får en feil, er det ofte smartest å gå tilbake til siste versjon som fungerte og endre én ting om gangen. På den måten blir det lettere å se hva som faktisk skapte problemet.

15. Mini-prosjekt for nybegynnere

Her er et lite prosjekt du kan bygge selv: et enkelt program som vurderer om et tall er stort eller lite.

funksjon vurder(tall: heltall) -> tekst {
    hvis tall >= 10 da {
        returner "stort"
    }
    returner "lite"
}

funksjon start() -> heltall {
    la resultat: tekst = vurder(12)
    skriv("Tallet er " + resultat)
    returner 0
}

Når du har fått dette til, kan du bygge videre:

• legg til flere regler
• skriv en test
• del logikken i flere funksjoner
• lag en versjon som jobber med en liste av tall

Dette mini-prosjektet er nyttig fordi det samler flere grunnprinsipper på ett sted: input, betingelser, returverdier og utskrift. Når du klarer å bygge videre på et sånt eksempel selv, har du begynt å gå fra å følge manualen til å bruke språket aktivt.

16. Neste steg for en nybegynner

Når du har forstått fil, variabler, kontrollflyt og funksjoner, er dette en god vei videre:

1. Lag små programmer som skriver ut tekst og bruker enkle valg.
2. Øv på funksjoner som tar inn argumenter og returnerer verdier.
3. Bruk lister og tekst for å lære databehandling.
4. Prøv en enkel test så du lærer hvordan du sjekker funksjoner.
5. Prøv å bygge en liten rute eller en enkel HTML-respons.
6. Se på språksiden og web-eksemplene for å forstå hvordan Norscode brukes i større prosjekter.
7. Bygg én liten ting selv, for eksempel en kalkulator, en tekstbehandler eller en enkel webside.

Den beste måten å lære Norscode på er fortsatt å skrive små programmer, kjøre dem ofte og gradvis gjøre dem litt større.

Hvis du vil ha en enkel rekkefølge å følge, kan du tenke slik: konsollprogram først, deretter funksjoner og tester, så en enkel HTML-rute, og til slutt et lite JSON-endepunkt. Da bygger du opp ferdigheter i en naturlig rekkefølge uten å hop