20TD02U Programmering - itnett/FTD02H-N GitHub Wiki

20TD02U Programmering

Oppstart

Velkommen til 20TD02U Programmering! Dette emnet gir deg en grunnleggende innføring i programmering, og dekker viktige konsepter, teknikker og verktøy som du vil bruke i din karriere innen IT-drift og sikkerhet.

Emnebeskrivelse

Fagområde: Datateknikk Emnekode: 20TD02U Studieprogram: IT-drift og sikkerhet Studiepoeng: 10 Studienivå: Fagskole, nivå 5.2 Startsemester: 2024 Høst

Tema: Programmering

Emnets innhold:

  • Programstrukturer: Sekvenser, valg (if-else), løkker (for, while).
  • Datastrukturer: Lister, tabeller, mengder, dictionaries.
  • Bibliotek: Forståelse av hvordan man bruker eksterne biblioteker for å utvide funksjonalitet.
  • Funksjoner og metoder: Modularisering av kode og gjenbruk.
  • Objektorientert programmering (OOP): Klasser, objekter, arv, polymorfisme.
  • Debugging, testing og unntaksbehandling: Finne og rette feil, skrive tester for å sikre kodekvalitet, håndtere uventede situasjoner.
  • API (Application Programming Interface): Forståelse av hvordan man samhandler med eksterne tjenester og systemer.
  • GUI (Graphical User Interface): Grunnleggende prinsipper for å lage brukervennlige grensesnitt.
  • UML (Unified Modeling Language): Modellering av programvare og systemer.
  • Filbehandling: Lese fra og skrive til filer.
  • Datasikkerhet: Grunnleggende prinsipper for å sikre applikasjoner og data.

Læringsutbytte

Kunnskap:

  • Grunnleggende programmeringskonsepter: Variabler, datatyper, operatorer, uttrykk.
  • Programmeringsteknikker: Kontrollstrukturer, løkker, funksjoner, OOP.
  • Brukergrensesnitt: Prinsipper for design og utvikling av GUI.
  • Kommunikasjon mellom programgrensesnitt: API-er, nettverksprotokoller.
  • Sikkerhet: Grunnleggende sikkerhetsprinsipper og trusler.
  • Selvlæring: Evne til å finne og bruke ressurser for å lære nye programmeringsspråk og teknologier.

Ferdigheter:

  • Utvikling: Skrive kode som løser problemer og implementerer funksjonalitet.
  • Lesing og tolkning: Forstå og analysere eksisterende kode.
  • Vedlikehold og forbedring: Oppdatere og forbedre eksisterende applikasjoner.
  • Sikkerhetsvurdering: Identifisere og diskutere potensielle sikkerhetsproblemer i kode.

Generell kompetanse:

  • Selvutvikling: Kontinuerlig læring og utvikling av programmeringsferdigheter.
  • Prosjektarbeid: Samarbeid med andre i prosjekter, kommunisere effektivt og levere resultater.
  • Faglig nettverk: Bygge relasjoner med andre IT-profesjonelle.

Relevante verktøy og ressurser:

  • Programmeringsspråk: Python, JavaScript (med fokus på Node.js og Svelte), eventuelt andre språk avhengig av studiets fokus.
  • Utviklingsmiljøer (IDE): Visual Studio Code, PyCharm, WebStorm.
  • Versjonskontroll: Git, GitHub.
  • Debugging-verktøy: De innebygde verktøyene i IDE-en din, nettleserens utviklerverktøy.
  • Nettressurser:

Grunnleggende introduksjon til språk, verktøy, metoder, ressurser og konsepter:

  • Python: Et allsidig språk som er mye brukt innen databehandling, automatisering og web-utvikling. Det er kjent for sin lesbarhet og enkle syntaks.
  • JavaScript: Det dominerende språket for web-utvikling, som brukes til å lage interaktive nettsider og webapplikasjoner. Node.js er en runtime-miljø for å kjøre JavaScript på serversiden.
  • Svelte: Et moderne JavaScript-rammeverk for å bygge brukergrensesnitt. Det er kjent for sin ytelse og enkle, men kraftige syntaks.
  • IDE: Et integrert utviklingsmiljø gir deg verktøy for å skrive, feilsøke og teste kode på en effektiv måte.
  • Versjonskontroll: Git lar deg spore endringer i koden din og samarbeide med andre utviklere. GitHub er en populær plattform for å lagre og dele Git-prosjekter.
  • Objektorientert programmering: En programmeringsparadigme som fokuserer på å organisere kode i gjenbrukbare objekter.
  • API: Et sett med regler og spesifikasjoner som lar ulike programmer kommunisere med hverandre.
  • Sikkerhet: Vurdering av potensielle trusler og sårbarheter i applikasjoner, og implementering av tiltak for å beskytte data og systemer.

Nettressurser for å lære programmering (20TD02U):

Grunnleggende programmering:

Programstrukturer og datastrukturer:

Bibliotek, funksjoner og metoder:

Objektorientert programmering (OOP):

Debugging, testing og unntaksbehandling:

API:

GUI:

UML:

Filbehandling og datasikkerhet:

Generelt:

Tips:

  • Start med det grunnleggende: Ikke hopp over det grunnleggende om programmering, selv om det virker enkelt.
  • Øv deg regelmessig: Programmering er en ferdighet som krever kontinuerlig øvelse.
  • Bygg prosjekter: Å bygge egne prosjekter er en fin måte å lære og anvende kunnskapen din på.
  • Spør om hjelp: Ikke vær redd for å stille spørsmål hvis du står fast. Det finnes mange ressurser og et stort fellesskap av utviklere som er villige til å hjelpe.

Lykke til med å lære programmering!

Absolutt! Her er kodeeksempler som demonstrerer læringsutbyttet, emnene og bruken av verktøyene og ressursene vi har diskutert, med fokus på Svelte for frontend-utvikling:

Emne: Programmering

Læringsmål:

  • Skrive kode med variabeldeklarasjoner, kontrollstrukturer, løkker og funksjoner.
  • Utvikle et brukergrensesnitt.
  • Kommunisere mellom ulike programgrensesnitt.
  • Ivareta sikkerheten til applikasjoner.

Kodeeksempel (Svelte):

<script>
  import { onMount } from 'svelte';

  let name = '';
  let greeting = '';
  let apiData = [];

  async function fetchGreeting() {
    try {
      const response = await fetch('/api/greet?name=' + encodeURIComponent(name));
      const data = await response.json();
      greeting = data.greeting;
    } catch (error) {
      console.error('API-feil:', error);
      greeting = 'Noe gikk galt. Prøv igjen senere.';
    }
  }

  onMount(async () => {
    try {
      const response = await fetch('/api/data');
      apiData = await response.json();
    } catch (error) {
      console.error('API-feil:', error);
    }
  });
</script>

<input type="text" bind:value={name} placeholder="Skriv inn navnet ditt">
<button on:click={fetchGreeting}>Hent hilsen</button>

{#if greeting}
  <p>{greeting}</p>
{/if}

<h2>Data fra API:</h2>
<ul>
  {#each apiData as item}
    <li>{item.id}: {item.value}</li>
  {/each}
</ul>

Forklaring:

  • Variabler: name, greeting, apiData brukes til å lagre data.
  • Kontrollstrukturer: if-blokken viser hilsenen kun hvis den er tilgjengelig.
  • Løkker: each-blokken brukes til å iterere over data fra API-et og vise dem i en liste.
  • Funksjoner: fetchGreeting henter en hilsen fra en API basert på brukerinput.
  • Brukergrensesnitt: En enkel input-boks og knapp lar brukeren samhandle med applikasjonen.
  • API-kommunikasjon: fetch brukes til å hente data fra en API.
  • Feilhåndtering: try...catch brukes for å håndtere potensielle feil under API-kall.

Verktøy og ressurser:

  • Svelte: Rammeverk for å lage brukergrensesnittet.
  • Node.js og Express (eller annet backend-rammeverk): For å lage API-en som leverer dataene.
  • Visual Studio Code: En populær IDE for å skrive og feilsøke koden.
  • Git og GitHub: For versjonskontroll og samarbeid.

Emne: Nettverk

Læringsmål:

  • Forstå grunnleggende nettverkskonsepter (OSI-modellen, TCP/IP, etc.).
  • Visualisere nettverkstopologier.

Kodeeksempel (Svelte + vis.js):

<script>
  import { onMount } from 'svelte';
  import { Network } from 'vis-network/standalone';

  let nodes = [
    { id: 1, label: 'Router' },
    { id: 2, label: 'Switch' },
    { id: 3, label: 'PC1' },
    { id: 4, label: 'PC2' }
  ];

  let edges = [
    { from: 1, to: 2 },
    { from: 2, to: 3 },
    { from: 2, to: 4 }
  ];

  onMount(() => {
    new Network(document.getElementById('network'), { nodes, edges }, {});
  });
</script>

<div id="network"></div>

Forklaring:

  • Visualisering: Bruker vis.js for å lage et interaktivt nettverksdiagram.
  • Nettverkskonsepter: Diagrammet illustrerer en enkel nettverkstopologi med en ruter, en switch og to PC-er.

Verktøy og ressurser:

  • vis.js: JavaScript-bibliotek for nettverksvisualisering.
  • Packet Tracer (Cisco): Simuleringsverktøy for å øve på nettverkskonfigurasjon.

Emne: Datasikkerhet

Læringsmål:

  • Forstå grunnleggende sikkerhetsprinsipper.
  • Identifisere og håndtere sikkerhetsrisikoer.

Kodeeksempel (Svelte):

<script>
  let password = '';
  let passwordStrength = 'Svak';

  $: if (password.length >= 12 && /\d/.test(password) && /[A-Z]/.test(password)) {
    passwordStrength = 'Sterk';
  } else if (password.length >= 8) {
    passwordStrength = 'Middels';
  }
</script>

<input type="password" bind:value={password}>
<p>Passordstyrke: {passwordStrength}</p>

Forklaring:

  • Sikkerhet: Sjekker passordstyrken basert på lengde og kompleksitet.
  • Reaktivitet: Oppdaterer passordstyrken i sanntid mens brukeren skriver.

Verktøy og ressurser:

  • OWASP Top 10: En liste over de 10 mest kritiske sikkerhetsrisikoene for webapplikasjoner.

Dette er bare noen få eksempler på hvordan Svelte kan brukes til å lære og demonstrere IT-kompetanse. Mulighetene er uendelige, og du kan tilpasse disse eksemplene eller lage dine egne prosjekter for å utforske de ulike emnene i dybden.

20TD02U Programmering: En grundig innføring

Del 2: Avanserte Programmeringsteknikker og Verktøy

Kapittel 1: Funksjoner og Metoder

Læringsutbytte:

  • Kunnskap: Forståelse av hvordan man definerer og bruker funksjoner og metoder i programmering.
  • Ferdigheter: Kunne skrive og bruke funksjoner for å modularisere og gjenbruke kode.
  • Generell kompetanse: Evne til å strukturere kode på en effektiv og vedlikeholdbar måte.

Blooms Taksonomi:

  1. Huske: Liste opp syntaksen for funksjonsdefinisjoner i Python og JavaScript.
  2. Forstå: Forklare forskjellen mellom funksjoner og metoder.
  3. Anvende: Skrive funksjoner og metoder som løser spesifikke problemer.
  4. Analysere: Vurdere når det er hensiktsmessig å bruke funksjoner for å unngå duplisert kode.
  5. Evaluere: Teste og feilsøke funksjoner for å sikre at de fungerer som forventet.
  6. Skape: Utvikle komplekse applikasjoner ved hjelp av funksjoner og metoder.

Metoder og Verktøy:

  • IDE: Bruk av Visual Studio Code for å skrive og teste funksjoner.
  • Debugging-verktøy: Innebygde verktøy i IDE for å feilsøke funksjoner.
  • Praktiske Øvelser: Skrive og teste funksjoner i Python og JavaScript.

Kapittel 2: Objektorientert Programmering (OOP)

Læringsutbytte:

  • Kunnskap: Forståelse av grunnleggende prinsipper i objektorientert programmering.
  • Ferdigheter: Kunne definere klasser og objekter, samt bruke arv og polymorfisme.
  • Generell kompetanse: Evne til å strukturere kode på en modulær og gjenbrukbar måte ved bruk av OOP.

Blooms Taksonomi:

  1. Huske: Definere begreper som klasse, objekt, arv og polymorfisme.
  2. Forstå: Forklare hvordan OOP skiller seg fra prosedyreorientert programmering.
  3. Anvende: Implementere enkle klasser og objekter i Python og JavaScript.
  4. Analysere: Vurdere fordeler og ulemper ved å bruke OOP i ulike scenarioer.
  5. Evaluere: Teste og feilsøke OOP-baserte programmer for å sikre korrekt funksjonalitet.
  6. Skape: Utvikle komplekse applikasjoner ved hjelp av OOP-konsepter.

Metoder og Verktøy:

  • IDE: Bruk av PyCharm for Python og WebStorm for JavaScript.
  • Versjonskontroll: Bruk av Git for å spore endringer i kodebasen.
  • Praktiske Øvelser: Skrive og teste OOP-kode i Python og JavaScript.

Kapittel 3: Debugging, Testing og Unntaksbehandling

Læringsutbytte:

  • Kunnskap: Forståelse av teknikker for debugging, testing og unntaksbehandling.
  • Ferdigheter: Kunne bruke debugging-verktøy og skrive enhetstester.
  • Generell kompetanse: Evne til å skrive robust kode som håndterer feil på en elegant måte.

Blooms Taksonomi:

  1. Huske: Liste opp vanlige debugging-teknikker og verktøy.
  2. Forstå: Forklare viktigheten av testing og unntaksbehandling.
  3. Anvende: Skrive tester ved hjelp av rammeverk som pytest og Jest.
  4. Analysere: Identifisere og rette feil ved hjelp av debugging-verktøy.
  5. Evaluere: Vurdere testdekningen og kvaliteten på testene.
  6. Skape: Utvikle et testmiljø og skrive omfattende tester for et prosjekt.

Metoder og Verktøy:

  • Debugging-verktøy: Bruk av pdb for Python og innebygde verktøy i IDE for JavaScript.
  • Testing-rammeverk: pytest for Python, Jest for JavaScript.
  • Praktiske Øvelser: Skrive og kjøre enhetstester, samt bruke debugging-verktøy for å finne og rette feil.

Kapittel 4: API (Application Programming Interface)

Læringsutbytte:

  • Kunnskap: Forståelse av hvordan API-er fungerer og hvordan de kan brukes.
  • Ferdigheter: Kunne samhandle med eksterne API-er og integrere dem i applikasjoner.
  • Generell kompetanse: Evne til å bruke API-er for å utvide funksjonaliteten i applikasjoner.

Blooms Taksonomi:

  1. Huske: Forklare hva et API er og hvordan det fungerer.
  2. Forstå: Beskrive de forskjellige typene API-er (REST, SOAP).
  3. Anvende: Skrive kode som kommuniserer med et eksternt API.
  4. Analysere: Vurdere fordeler og ulemper ved å bruke eksterne API-er.
  5. Evaluere: Teste API-integrasjoner for å sikre pålitelighet og ytelse.
  6. Skape: Utvikle et API for å tilby tjenester til andre applikasjoner.

Metoder og Verktøy:

  • API-verktøy: Bruk av Postman for å teste API-er.
  • Utviklingsmiljøer: Visual Studio Code for å skrive kode som bruker API-er.
  • Praktiske Øvelser: Integrere eksterne API-er i enkle applikasjoner.

Kapittel 5: GUI (Graphical User Interface)

Læringsutbytte:

  • Kunnskap: Forståelse av prinsippene for design og utvikling av GUI.
  • Ferdigheter: Kunne utvikle enkle grafiske brukergrensesnitt.
  • Generell kompetanse: Evne til å skape brukervennlige og intuitive grensesnitt.

Blooms Taksonomi:

  1. Huske: Forklare grunnleggende konsepter i GUI-utvikling.
  2. Forstå: Beskrive prinsippene for godt GUI-design.
  3. Anvende: Utvikle enkle GUI-er ved hjelp av rammeverk som Svelte.
  4. Analysere: Vurdere brukervennligheten av et GUI.
  5. Evaluere: Teste og forbedre GUI-basert på tilbakemeldinger.
  6. Skape: Utvikle komplekse GUI-er som del av større prosjekter.

Metoder og Verktøy:

  • GUI-rammeverk: Bruk av Svelte for å utvikle GUI.
  • Utviklingsmiljøer: Visual Studio Code for å skrive og teste GUI-kode.
  • Praktiske Øvelser: Utvikle og teste enkle GUI-applikasjoner.

Viktige tips for videre arbeid:

  • Praktisk anvendelse: Fokuser på å anvende det du lærer i praktiske prosjekter.
  • Kontinuerlig læring: Hold deg oppdatert på nye teknologier og beste praksis.
  • Samarbeid: Delta i faglige diskusjoner og samarbeid med andre for å utvide din kunnskap og erfaring.
  • Ressursbruk: Benytt deg av de anbefalte verktøyene og ressursene for å forbedre din forståelse og ferdigheter.

Lykke til med studiet av programmering!

20TD02U Programmering: En grundig innføring

Del 2: Programstrukturer, Datastrukturer og Bibliotek

Kapittel 1: Programstrukturer

Læringsutbytte:

  • Kunnskap: Forståelse av grunnleggende programstrukturer som sekvenser, valg og løkker.
  • Ferdigheter: Skrive og bruke grunnleggende kontrollstrukturer for å styre flyten i programmer.
  • Generell kompetanse: Evne til å lage logiske og strukturerte programmer.

Blooms Taksonomi:

  1. Huske: Definere konsepter som sekvenser, valg (if-else) og løkker (for, while).
  2. Forstå: Beskrive hvordan kontrollstrukturer påvirker programflyten.
  3. Anvende: Implementere kontrollstrukturer i enkle programmer.
  4. Analysere: Vurdere effektiviteten av ulike kontrollstrukturer.
  5. Evaluere: Optimalisere programflyt ved bruk av passende kontrollstrukturer.
  6. Skape: Utvikle komplekse algoritmer som bruker kontrollstrukturer effektivt.

Metoder og Verktøy:

  • IDE: Bruk av Visual Studio Code for å skrive og teste kontrollstrukturer.
  • Debugging-verktøy: Bruk av innebygde verktøy i IDE for å feilsøke kontrollstrukturer.
  • Praktiske Øvelser: Skrive programmer som bruker sekvenser, valg og løkker for å løse problemer.

Eksempel (Python):

# En enkel løkke for å skrive ut tall fra 1 til 5
for i in range(1, 6):
    print(i)

# If-else for å sjekke om et tall er positivt, negativt eller null
num = int(input("Skriv inn et tall: "))
if num > 0:
    print("Positivt tall")
elif num == 0:
    print("Null")
else:
    print("Negativt tall")

Kapittel 2: Datastrukturer

Læringsutbytte:

  • Kunnskap: Forståelse av grunnleggende datastrukturer som lister, tabeller, mengder og dictionaries.
  • Ferdigheter: Kunne manipulere datastrukturer for å lagre og hente data effektivt.
  • Generell kompetanse: Evne til å velge passende datastrukturer for ulike programmeringsoppgaver.

Blooms Taksonomi:

  1. Huske: Liste opp forskjellige datastrukturer som lister, tabeller, mengder og dictionaries.
  2. Forstå: Forklare forskjellen mellom de ulike datastrukturene.
  3. Anvende: Implementere og bruke datastrukturer i programmer.
  4. Analysere: Vurdere effektiviteten til ulike datastrukturer for spesifikke oppgaver.
  5. Evaluere: Optimalisere bruk av datastrukturer for å forbedre ytelsen.
  6. Skape: Utvikle komplekse datastrukturer for å løse spesifikke problemer.

Metoder og Verktøy:

  • IDE: Bruk av Visual Studio Code for å skrive og teste kode med datastrukturer.
  • Praktiske Øvelser: Implementere ulike datastrukturer og bruke dem til å løse problemer.

Eksempel (Python):

# Liste
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits)

# Dictionary
person = {
    "name": "John",
    "age": 30,
    "city": "New York"
}
print(person["name"])

# Mengde
numbers = {1, 2, 3, 4, 5}
numbers.add(6)
print(numbers)

Kapittel 3: Bibliotek

Læringsutbytte:

  • Kunnskap: Forståelse av hvordan man bruker eksterne biblioteker for å utvide funksjonalitet.
  • Ferdigheter: Kunne finne, installere og bruke eksterne biblioteker i programmer.
  • Generell kompetanse: Evne til å integrere biblioteker for å løse spesifikke problemer og forbedre effektiviteten.

Blooms Taksonomi:

  1. Huske: Forklare hva et bibliotek er og hvordan det brukes i programmering.
  2. Forstå: Beskrive fordeler og ulemper ved å bruke eksterne biblioteker.
  3. Anvende: Installere og bruke biblioteker i egne programmer.
  4. Analysere: Vurdere hvilke biblioteker som er mest passende for spesifikke oppgaver.
  5. Evaluere: Teste og sikre at bibliotekene fungerer som forventet.
  6. Skape: Utvikle egne biblioteker for gjenbruk i ulike prosjekter.

Metoder og Verktøy:

  • Pakkehåndtering: Bruk av pip for å installere Python-biblioteker.
  • Praktiske Øvelser: Finne og bruke biblioteker til å løse spesifikke oppgaver i programmer.

Eksempel (Python):

# Installere et bibliotek (requests)
# pip install requests

# Bruke requests-biblioteket til å gjøre et HTTP-anrop
import requests

response = requests.get("https://api.github.com")
print(response.status_code)
print(response.json())

Viktige tips for videre arbeid:

  • Praktisk anvendelse: Fokuser på å anvende det du lærer i praktiske prosjekter.
  • Kontinuerlig læring: Hold deg oppdatert på nye teknologier og beste praksis.
  • Samarbeid: Delta i faglige diskusjoner og samarbeid med andre for å utvide din kunnskap og erfaring.
  • Ressursbruk: Benytt deg av de anbefalte verktøyene og ressursene for å forbedre din forståelse og ferdigheter.

20TD02U Programmering: En grundig innføring

Del 3: Funksjoner og metoder, Objektorientert programmering, Debugging, testing og unntaksbehandling

Kapittel 1: Funksjoner og metoder

Læringsutbytte:

  • Kunnskap: Forstå modularisering av kode og gjenbruk ved hjelp av funksjoner og metoder.
  • Ferdigheter: Skrive funksjoner og metoder for å løse problemer og organisere kode.
  • Generell kompetanse: Evne til å strukturere programmer ved hjelp av funksjoner og metoder.

Blooms Taksonomi:

  1. Huske: Forklare hva funksjoner og metoder er.
  2. Forstå: Beskrive hvordan funksjoner og metoder kan brukes for å forbedre kodeorganisasjonen.
  3. Anvende: Implementere funksjoner og metoder i egne programmer.
  4. Analysere: Vurdere effektiviteten av funksjoner og metoder i kode.
  5. Evaluere: Optimalisere bruk av funksjoner og metoder for bedre ytelse.
  6. Skape: Utvikle komplekse funksjoner og metoder for spesifikke oppgaver.

Metoder og Verktøy:

  • IDE: Bruk av Visual Studio Code for å skrive og teste funksjoner og metoder.
  • Praktiske Øvelser: Skrive programmer som bruker funksjoner og metoder for å løse problemer.

Eksempel (Python):

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)
print(result)

Kapittel 2: Objektorientert programmering (OOP)

Læringsutbytte:

  • Kunnskap: Forstå konseptene klasser, objekter, arv og polymorfisme.
  • Ferdigheter: Skrive og bruke klasser og objekter for å strukturere kode.
  • Generell kompetanse: Evne til å utvikle gjenbrukbare og vedlikeholdbare programmer ved hjelp av OOP.

Blooms Taksonomi:

  1. Huske: Definere grunnleggende OOP-konsepter som klasser og objekter.
  2. Forstå: Forklare hvordan OOP forbedrer kodeorganisasjonen.
  3. Anvende: Implementere klasser og objekter i programmer.
  4. Analysere: Vurdere bruken av arv og polymorfisme i kode.
  5. Evaluere: Optimalisere OOP-design for bedre vedlikeholdbarhet.
  6. Skape: Utvikle komplekse OOP-systemer for spesifikke oppgaver.

Metoder og Verktøy:

  • IDE: Bruk av Visual Studio Code for å skrive og teste OOP-kode.
  • Praktiske Øvelser: Skrive programmer som bruker klasser, arv og polymorfisme for å løse problemer.

Eksempel (Python):

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subklasser må implementere denne metoden")

class Dog(Animal):
    def speak(self):
        return f"{self.name} sier woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} sier meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())
print(cat.speak())

Kapittel 3: Debugging, testing og unntaksbehandling

Læringsutbytte:

  • Kunnskap: Forstå metoder for å finne og rette feil i programmer, skrive tester for å sikre kodekvalitet, og håndtere uventede situasjoner.
  • Ferdigheter: Bruke debugging-verktøy, skrive enhetstester og håndtere unntak i kode.
  • Generell kompetanse: Evne til å utvikle robust og pålitelig kode gjennom systematisk testing og feilhåndtering.

Blooms Taksonomi:

  1. Huske: Forklare begrepene debugging, testing og unntaksbehandling.
  2. Forstå: Beskrive hvordan disse teknikkene forbedrer programkvaliteten.
  3. Anvende: Implementere debugging, testing og unntaksbehandling i programmer.
  4. Analysere: Vurdere effektiviteten av debugging- og testingsteknikker.
  5. Evaluere: Optimalisere feilhåndtering for bedre robusthet.
  6. Skape: Utvikle omfattende testplaner og feilhåndteringsstrategier.

Metoder og Verktøy:

  • IDE: Bruk av innebygde debugging-verktøy i Visual Studio Code.
  • Testing Rammeverk: Bruk av unittest for å skrive og kjøre tester.
  • Praktiske Øvelser: Skrive programmer som bruker debugging, testing og unntaksbehandling for å sikre kvalitet.

Eksempel (Python):

# Unntaksbehandling
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Feil: {e}")

# Enhetstesting
import unittest

def add_numbers(a, b):
    return a + b

class TestAddNumbers(unittest.TestCase):
    def test_add_numbers(self):
        self.assertEqual(add_numbers(3, 4), 7)

if __name__ == '__main__':
    unittest.main()

Viktige tips for videre arbeid:

  • Praktisk anvendelse: Fokuser på å anvende det du lærer i praktiske prosjekter.
  • Kontinuerlig læring: Hold deg oppdatert på nye teknologier og beste praksis.
  • Samarbeid: Delta i faglige diskusjoner og samarbeid med andre for å utvide din kunnskap og erfaring.
  • Ressursbruk: Benytt deg av de anbefalte verktøyene og ressursene for å forbedre din forståelse og ferdigheter.

20TD02U Programmering: En grundig innføring

Del 4: API, GUI, UML

Kapittel 1: API (Application Programming Interface)

Læringsutbytte:

  • Kunnskap: Forståelse av API-konsepter og deres betydning for programvareutvikling.
  • Ferdigheter: Kunne integrere og bruke API-er i egne prosjekter.
  • Generell kompetanse: Evne til å designe og dokumentere egne API-er.

Blooms Taksonomi:

  1. Huske: Definere API og beskrive dets funksjon.
  2. Forstå: Forklare hvordan API-er muliggjør kommunikasjon mellom forskjellige programvarekomponenter.
  3. Anvende: Implementere API-kall i programmer.
  4. Analysere: Vurdere effektiviteten og sikkerheten til API-integrasjoner.
  5. Evaluere: Optimalisere bruken av API-er i applikasjoner.
  6. Skape: Utvikle og dokumentere egne API-er.

Metoder og Verktøy:

  • Verktøy: Postman for testing og dokumentasjon av API-er.
  • Biblioteker: Axios for API-kall i JavaScript, Requests for API-kall i Python.

Eksempel (Python):

import requests

def get_data_from_api():
    response = requests.get('https://api.example.com/data')
    if response.status_code == 200:
        return response.json()
    else:
        return None

data = get_data_from_api()
print(data)

Kapittel 2: GUI (Graphical User Interface)

Læringsutbytte:

  • Kunnskap: Forståelse av prinsippene for GUI-design og utvikling.
  • Ferdigheter: Kunne lage enkle GUI-applikasjoner.
  • Generell kompetanse: Evne til å utvikle brukervennlige grensesnitt.

Blooms Taksonomi:

  1. Huske: Beskrive grunnleggende GUI-komponenter.
  2. Forstå: Forklare prinsippene for godt GUI-design.
  3. Anvende: Implementere GUI-komponenter i applikasjoner.
  4. Analysere: Vurdere brukervennligheten til et grensesnitt.
  5. Evaluere: Optimalisere GUI for bedre brukeropplevelse.
  6. Skape: Designe og utvikle komplette GUI-applikasjoner.

Metoder og Verktøy:

  • Verktøy: Visual Studio Code med relevante plugins.
  • Biblioteker: Tkinter for Python, Svelte for JavaScript.

Eksempel (Svelte):

<script>
  let name = '';
  let greeting = '';

  function greet() {
    greeting = `Hello, ${name}!`;
  }
</script>

<input type="text" bind:value={name} placeholder="Enter your name">
<button on:click={greet}>Greet</button>

{#if greeting}
  <p>{greeting}</p>
{/if}

Kapittel 3: UML (Unified Modeling Language)

Læringsutbytte:

  • Kunnskap: Forståelse av UML og dets bruk i programvareutvikling.
  • Ferdigheter: Kunne lage UML-diagrammer for å modellere systemer.
  • Generell kompetanse: Evne til å bruke UML for å planlegge og dokumentere programvareprosjekter.

Blooms Taksonomi:

  1. Huske: Definere UML og dets komponenter.
  2. Forstå: Forklare hvordan UML kan brukes til å modellere programvare.
  3. Anvende: Lage UML-diagrammer for programvareprosjekter.
  4. Analysere: Vurdere kvaliteten på UML-diagrammer.
  5. Evaluere: Optimalisere UML-diagrammer for bedre klarhet og effektivitet.
  6. Skape: Utvikle komplette UML-diagrammer for komplekse systemer.

Metoder og Verktøy:

  • Verktøy: draw.io for å lage UML-diagrammer.
  • Teknikker: Bruk case-diagrammer, klassediagrammer, aktivitetsdiagrammer.

Eksempel (Klassediagram i UML):

+----------------+
|    Person      |
+----------------+
| - name: String |
| - age: int     |
+----------------+
| + greet(): void|
+----------------+

Viktige tips for videre arbeid:

  • Praktisk anvendelse: Lag prosjekter som bruker API-er, GUI-er og UML for å øve på det du har lært.
  • Kontinuerlig læring: Utforsk videre ressurser og hold deg oppdatert på beste praksis.
  • Samarbeid: Delta i faglige diskusjoner og prosjekter med medstudenter og fagfolk.

Lykke til med studiet av programmering!

20TD02U Programmering: En grundig innføring

Del 5: Filbehandling og Datasikkerhet

Kapittel 1: Filbehandling

Læringsutbytte:

  • Kunnskap: Forståelse av grunnleggende filoperasjoner som lesing, skriving og sletting.
  • Ferdigheter: Kunne lese fra og skrive til filer ved hjelp av forskjellige programmeringsspråk.
  • Generell kompetanse: Evne til å håndtere filer effektivt og sikkert i applikasjoner.

Blooms Taksonomi:

  1. Huske: Definere filoperasjoner og deres formål.
  2. Forstå: Forklare hvordan filer kan manipuleres i forskjellige programmeringsspråk.
  3. Anvende: Implementere kode som leser fra og skriver til filer.
  4. Analysere: Vurdere effektiviteten og sikkerheten til filbehandlingsrutiner.
  5. Evaluere: Optimalisere filoperasjoner for bedre ytelse og sikkerhet.
  6. Skape: Utvikle applikasjoner som krever avansert filbehandling.

Metoder og Verktøy:

  • Verktøy: Teksteditorer og IDE-er som Visual Studio Code, PyCharm.
  • Biblioteker: Innebygde biblioteker i Python, JavaScript og andre språk.

Eksempel (Python):

# Åpne en fil for lesing
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

# Åpne en fil for skriving
with open('example.txt', 'w') as file:
    file.write('Dette er en test.')

Eksempel (JavaScript Node.js):

const fs = require('fs');

// Lese fra en fil
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Skrive til en fil
fs.writeFile('example.txt', 'Dette er en test.', (err) => {
  if (err) throw err;
  console.log('Filen er oppdatert.');
});

Kapittel 2: Datasikkerhet

Læringsutbytte:

  • Kunnskap: Forståelse av grunnleggende sikkerhetsprinsipper og trusler mot data.
  • Ferdigheter: Kunne implementere sikkerhetstiltak for å beskytte data i applikasjoner.
  • Generell kompetanse: Evne til å identifisere og mitigere sikkerhetsrisikoer i kode og systemer.

Blooms Taksonomi:

  1. Huske: Definere viktige sikkerhetsbegreper som konfidensialitet, integritet og tilgjengelighet.
  2. Forstå: Forklare vanlige trusler mot datasikkerhet.
  3. Anvende: Implementere grunnleggende sikkerhetstiltak i kode.
  4. Analysere: Vurdere sikkerhetsrisikoer i programvare.
  5. Evaluere: Optimalisere sikkerhetstiltak for å beskytte data.
  6. Skape: Utvikle sikre applikasjoner og systemer.

Metoder og Verktøy:

  • Verktøy: Sikkerhetsscannere som OWASP ZAP, Burp Suite.
  • Biblioteker: Kryptografibiblioteker som PyCryptodome i Python, Crypto i Node.js.

Eksempel (Python - hashing):

import hashlib

password = 'mysecretpassword'
hashed_password = hashlib.sha256(password.encode()).hexdigest()
print(hashed_password)

Eksempel (JavaScript Node.js - kryptering):

const crypto = require('crypto');
const algorithm = 'aes-256-ctr';
const secretKey = 'mysecretkey';
const iv = crypto.randomBytes(16);

const encrypt = (text) => {
  const cipher = crypto.createCipheriv(algorithm, secretKey, iv);
  const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);
  return `${iv.toString('hex')}:${encrypted.toString('hex')}`;
};

const encryptedText = encrypt('Sensitive data');
console.log(encryptedText);

Viktige tips for videre arbeid:

  • Eksperimenter: Test ulike filbehandlingsmetoder og sikkerhetstiltak i praksis.
  • Hold deg oppdatert: Følg med på nyheter og oppdateringer innen datasikkerhet.
  • Samarbeid: Del erfaringer og løsninger med medstudenter og fagfolk.

20TD02U Programmering: Kunnskap og Læringsmål

Programstrukturer, Datastrukturer, Bibliotek, Funksjoner og metoder, Objektorientert programmering, Debugging, testing og unntaksbehandling, API, GUI, UML, Filbehandling, Datasikkerhet

Kunnskap

Kandidaten har kunnskap om:

  1. Grunnleggende programmering og programmeringsverktøy:

    • Forståelse av programmeringskonsepter som variabler, datatyper og operasjoner.
    • Kunnskap om vanlige programmeringsverktøy og utviklingsmiljøer (IDEs).

  2. Grunnleggende programmeringsteknikker:

    • Variabeldeklarasjoner: Forståelse av hvordan variabler brukes til å lagre data.
    • Kontrollstrukturer: Kunnskap om if-else, switch-case, og hvordan disse styrer flyten i et program.
    • Løkker: Forståelse av for-løkker, while-løkker og do-while-løkker for gjentagende oppgaver.
    • Funksjoner: Evne til å definere og bruke funksjoner for å modularisere og gjenbruke kode.

  3. Utvikling av brukergrensesnitt:

    • Kunnskap om GUI-verktøy og biblioteker som Svelte, React eller Tkinter.
    • Forståelse av grunnleggende prinsipper for design og utvikling av brukervennlige grensesnitt.

  4. Kommunikasjon mellom ulike programgrensesnitt:

    • Forståelse av API-er og hvordan de brukes til å integrere og kommunisere med eksterne tjenester.
    • Kunnskap om HTTP-protokollen og JSON-formatet for datautveksling.

  5. Viktigheten av å ivareta sikkerheten av applikasjoner:

    • Bevissthet om vanlige sikkerhetsrisikoer som SQL-injeksjon, XSS, og CSRF.
    • Kunnskap om teknikker for å beskytte applikasjoner, som inputvalidering og bruk av sikkerhetsbiblioteker.

  6. Grunnleggende sikkerhet relatert til programmering:

    • Forståelse av kryptering, hashing og autentiseringsteknikker.
    • Kunnskap om hvordan man sikrer datalagring og kommunikasjon.

  7. Tilegne seg ny kunnskap innen programmering:

    • Evne til å bruke relevant faglitteratur, nettbaserte ressurser, og faglige nettverk for å lære nye teknologier og språk.

  8. Innsikt i egne utviklingsmuligheter innenfor programmering:

    • Selvrefleksjon på egen kompetanse og identifisere områder for forbedring og videre læring.

Eksempler og Ressurser

Programstrukturer

# Python
for i in range(5):
    print(i)

if True:
    print("True!")

Datastrukturer

# Python
my_list = [1, 2, 3]
my_dict = {"key": "value"}

Bibliotek

# Python - Bruk av requests biblioteket
import requests
response = requests.get("https://api.example.com/data")
print(response.json())

Funksjoner og metoder

# Python
def greet(name):
    return f"Hello, {name}!"

Objektorientert programmering

# Python
class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print("Woof!")

my_dog = Dog("Fido")
my_dog.bark()

Debugging, testing og unntaksbehandling

# Python
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero.")

API

# Python - Flask API eksempel
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/data', methods=['GET'])
def get_data():
    return jsonify({"data": "value"})

if __name__ == '__main__':
    app.run()

GUI

# Svelte
<script>
  let count = 0;
  function increment() {
    count += 1;
  }
</script>

<button on:click={increment}>
  Count: {count}
</button>

UML

+----------------------+
|       Dog            |
+----------------------+
| - name: String       |
+----------------------+
| + bark(): void       |
+----------------------+

Filbehandling

# Python
with open('file.txt', 'r') as file:
    content = file.read()
    print(content)

Datasikkerhet

# Python - Hashing med hashlib
import hashlib
password = "mypassword"
hashed_password = hashlib.sha256(password.encode()).hexdigest()
print(hashed_password)

Viktige Tips:

  • Praktiske Prosjekter: Implementer små prosjekter for å anvende det du har lært.
  • Samarbeid: Delta i gruppeprosjekter for å lære av andre.
  • Hold deg Oppdatert: Følg med på nyheter og oppdateringer innen programmering og sikkerhet.

20TD02U Programmering: Ferdigheter

Kandidaten kan:

  1. Utvikle et brukergrensesnitt ved hjelp av kode og utviklingsverktøy:

    • Bruke moderne rammeverk og biblioteker for å lage interaktive og brukervennlige grensesnitt.
    • Eksempel (Svelte): 
      <script>
  let count = 0;
  function increment() {
    count += 1;
  }
</script>

<button on:click={increment}>
  Count: {count}
</button>

  2. Skrive kode med variabeldeklarasjoner, kontrollstrukturer, løkker og funksjoner:

    • Variabeldeklarasjoner: 
      # Python
x = 5
y = "Hello"
    • Kontrollstrukturer: 
      if x > 3:
  print("x is greater than 3")
    • Løkker: 
      for i in range(5):
  print(i)
    • Funksjoner: 
      def greet(name):
  return f"Hello, {name}!"

  3. Lese og tolke kode:

    • Analysere eksisterende kode for å forstå funksjonalitet og struktur.
    • Eksempel: 
      def factorial(n):
  if n == 0:
    return 1
  else:
    return n * factorial(n-1)

  4. Utføre vedlikehold og forbedre eksisterende applikasjoner:

    • Identifisere og rette feil i koden, samt legge til nye funksjoner.
    • Eksempel: 
      # Legge til logging i en funksjon
import logging

logging.basicConfig(level=logging.DEBUG)

def add(a, b):
  logging.debug(f"Adding {a} and {b}")
  return a + b

  5. Drøfte grunnleggende sikkerhet til en applikasjon:

    • Identifisere vanlige sikkerhetstrusler som SQL-injeksjon, XSS, CSRF og foreslå tiltak for å beskytte applikasjonen.
    • Eksempel: 
      # Beskytte mot SQL-injeksjon
import sqlite3

def get_user(username):
  conn = sqlite3.connect('example.db')
  cursor = conn.cursor()
  cursor.execute("SELECT * FROM users WHERE username=?", (username,))
  return cursor.fetchone()

Detaljert Forklaring av Hver Ferdighet

  1. Utvikle et brukergrensesnitt:

    • Kandidaten skal kunne designe og utvikle interaktive brukergrensesnitt ved hjelp av moderne rammeverk som Svelte, React eller Angular.
    • De skal forstå prinsippene for brukeropplevelse (UX) og hvordan man lager intuitive og effektive grensesnitt.

  2. Skrive kode:

    • Kandidaten skal beherske grunnleggende programmeringsteknikker som variabeldeklarasjoner, kontrollstrukturer, løkker og funksjoner.
    • De skal kunne skrive ren, lesbar og effektiv kode.

  3. Lese og tolke kode:

    • Kandidaten skal kunne lese eksisterende kode for å forstå hvordan den fungerer og hva den gjør.
    • De skal kunne tolke algoritmer og datastrukturer som brukes i koden.

  4. Vedlikeholde og forbedre applikasjoner:

    • Kandidaten skal kunne identifisere og rette feil i koden, samt forbedre eksisterende funksjonalitet.
    • De skal kunne legge til nye funksjoner og optimalisere koden for bedre ytelse.

  5. Grunnleggende sikkerhet:

    • Kandidaten skal ha forståelse for grunnleggende sikkerhetsprinsipper og kunne identifisere vanlige sikkerhetstrusler.
    • De skal kunne implementere sikkerhetstiltak for å beskytte applikasjoner mot trusler som SQL-injeksjon og XSS.

Anbefalte Verktøy og Ressurser

Praktiske Tips

  • Bygg Prosjekter: Lag små prosjekter for å praktisere ferdighetene dine.
  • Delta i Kodegjennomganger: Få og gi tilbakemeldinger på kode for å lære best practices.
  • Hold deg Oppdatert: Følg med på de nyeste trendene og verktøyene i programmeringsverdenen.

20TD02U Programmering: Generell Kompetanse

Kandidaten kan:

  1. Vedlikeholde og utvikle sin egen kompetanse innenfor emnet:

    • Eksempel: Bruke online læringsplattformer som Coursera eller Udemy for kontinuerlig læring.
    • Python-kode: 
      # Lese en bok om avanserte Python-konsepter
def read_book(title):
    print(f"Reading book: {title}")

read_book("Advanced Python Programming")

  2. Delta aktivt i prosjekter:

    • Eksempel: Bidra til open-source prosjekter på GitHub.
    • Git-kommandoer: 
      git clone https://github.com/opensource/project.git
cd project
git checkout -b new-feature
# Gjør endringer i koden
git add .
git commit -m "Added new feature"
git push origin new-feature

  3. Utføre arbeid etter oppdragsgivers behov, etablere fagnettverk og samarbeide med mennesker på kryss av fagfelt:

    • Eksempel: Bruke Agile metoder som Scrum for prosjektledelse og samarbeid.
    • Scrum-sprint board: Bruk verktøy som Jira eller Trello for å administrere oppgaver og samarbeid. 
      Task: Implement user authentication
- Create login page (In Progress)
- Set up backend authentication (To Do)
- Write unit tests for authentication (To Do)

  4. Utveksle bransjerelaterte synspunkter og informasjon:

    • Eksempel: Delta i faglige diskusjoner på forum som Stack Overflow eller Reddit.
    • API-kode: Bruke API-er for å hente bransjerelatert informasjon. 
      import requests

def get_latest_tech_news():
    response = requests.get("https://api.technews.com/latest")
    if response.status_code == 200:
        news = response.json()
        for article in news:
            print(article['title'])

get_latest_tech_news()

  5. Bygge relasjoner, både internt, eksternt og på tvers av fagfelt:

    • Eksempel: Delta i nettverksarrangementer og faglige konferanser.
    • JavaScript-kode for nettverksapp: Lage en enkel applikasjon for å administrere nettverkskontakter. 
      const contacts = [];

function addContact(name, email) {
  contacts.push({ name, email });
}

function listContacts() {
  contacts.forEach(contact => console.log(`${contact.name}: ${contact.email}`));
}

addContact("John Doe", "[email protected]");
listContacts();

Verktøy og Ressurser

  • Læringsplattformer: Coursera, Udemy, Khan Academy
  • Prosjektledelse: Jira, Trello
  • Versjonskontroll: Git, GitHub
  • Samarbeidsverktøy: Slack, Microsoft Teams
  • Nettverksbygging: LinkedIn, faglige konferanser

Praktiske Tips

  • Kontinuerlig læring: Hold deg oppdatert med de nyeste teknologiene og praksisene innen programmering.
  • Bidra til prosjekter: Engasjer deg i både interne og eksterne prosjekter for å bygge erfaring og nettverk.
  • Samarbeid og kommunikasjon: Bruk moderne verktøy og metoder for effektiv kommunikasjon og prosjektledelse.
  • Nettverksbygging: Delta i faglige diskusjoner, konferanser og nettverksarrangementer for å utvide ditt faglige nettverk.

Lykke til med å utvikle din kompetanse og bygge relasjoner innen programmering!

Ansvarsfraskrivelse:

Innholdet på denne wikisiden er generert helt eller delvis av kunstig intelligens (AI) og er ikke ment for informasjonsformål. Forfatteren fraskriver seg ethvert ansvar for nøyaktigheten, fullstendigheten eller påliteligheten av innholdet. Enhver handling du tar basert på informasjonen på denne siden er på eget ansvar og risiko.

Forfatteren fraskriver seg også ethvert ansvar for eventuelle likheter eller antydninger til likhet med annet publisert materiale. Enhver slik likhet er utilsiktet og uten ansvar. Det er leserens ansvar å gjennomføre plagiatkontroll og sikre at all bruk av innholdet fra denne siden er i samsvar med gjeldende regler og retningslinjer for opphavsrett og plagiering.

Det gis ingen garantier for at informasjonen på denne siden er i samsvar med gjeldende lover, regler eller retningslinjer. Leseren er selv ansvarlig for å verifisere nøyaktigheten og relevansen av informasjonen, og for å sikre korrekt kreditering av originale kilder.

Bruk av informasjonen på denne siden, inkludert risiko for plagiat eller brudd på opphavsrett, er på egen risiko.

Disklaimer 2

Alt innhold på denne plattformen er et resultat av en kreativ prosess som involverer både menneskelig input og generativ kunstig intelligens (AI). Tekstene er basert på bearbeidede prompts, og representerer en sammenslåing av publisistens tanker, ideer og AI-ens evne til å generere tekst.

Eventuelle likheter i rekkefølge, struktur, innhold, emnevalg, tematikk, avgrensninger eller oppstilling med annet materiale, enten kreditert eller ikke kreditert, publisert eller upublisert, er utilsiktet og tilfeldig.

Innholdet på denne plattformen er ikke ment å være en kilde til informasjon eller fakta, og skal ikke brukes som sådan. Dette er et eksperiment for å utforske potensialet og begrensningene ved generativ AI, både positive og negative, fordelaktige og ufordelaktige.

Vi oppfordrer leserne til å være kritiske og vurdere informasjonen i lys av dette. Vi tar ikke ansvar for eventuelle feil, unøyaktigheter eller misforståelser som kan oppstå som følge av bruk av innholdet på denne plattformen.

Disclaimer:

The information on this wiki page is generated entirely or partially by artificial intelligence (AI) and is not intended for informational purposes. The author disclaims any responsibility for the accuracy, completeness, or reliability of the content. Any action you take based on the information on this page is at your own responsibility and risk.

The author also disclaims any liability for any similarities or suggestions of similarity to other published material. Any such resemblance is unintentional and without liability. It is the reader's responsibility to conduct plagiarism checks and ensure that any use of the content from this page complies with applicable copyright and plagiarism rules and guidelines.

No guarantees are provided that the information on this page complies with applicable laws, rules, or guidelines. The reader is responsible for verifying the accuracy and relevance of the information and for ensuring proper crediting of original sources.

Use of the information on this page, including the risk of plagiarism or copyright infringement, is at your own risk.

⚠️ **GitHub.com Fallback** ⚠️