Översikt

Andra kursveckan och nu ska du börja skriva kod och fortsätta gå igenom fler grundläggande begrepp. Information om veckans upplägg annonseras löpande i kursens Zulip-kanal.

Veckostart och svar på frågor

Tisdagen i kursvecka 2 hölls en öppen frågestund där kursledningen gick igenom veckans upplägg och delade tips för hur du prioriterar när materialet känns tungt, och därefter besvarade inkommande frågor om allt från VS Code och GitLab till SSH-nycklar.

Video

2026-09-08 54:39

Sammanfattning

Om passet

Tisdagens öppna frågestund i kursvecka 2 hölls av Mats och Mikael tillsammans. Passet inleds med en genomgång av veckans upplägg och avslutas med att kursledningen besvarar frågor som studenter skickat in i förväg via handledningsformuläret.

Så hanterar du en tung vecka

Kursvecka 2 innehåller betydligt mer material än vecka 1, och risken att känna sig överväldigad lyfts fram direkt. Rådet är att, om det blir för mycket, prioritera övningsuppgifterna först — de är inte särskilt svåra och är den del av veckan som är viktigast att alltid klara av. Utmaningarna kommer i andra hand. Poängen med veckan är att gå från teori till praktik: det är nu den faktiska kodningen börjar.

Veckans innehåll

Veckan handlar om att installera Visual Studio Code och komma igång med Git, SSH och GitLab — något som historiskt sett skapat en del strul för enskilda studenter, vilket är väntat. Precis som föregående vecka finns ett introduktionsmeddelande i kursens Zulip-kanal som beskriver veckans innehåll i detalj, och studenter uppmanas att läsa det samt skicka in frågor i förväg. En äldre inspelning av samma introduktion från 2024 finns kvar för den som vill, men innehållet i den är daterat.

Stödjande inspelningar och läsning

Veckans tre stödjande inspelningar (variabler och konstanter, funktioner, moduler) är från 2021, men beskrivs som fortsatt högst aktuella — grundläggande programmeringskoncept som dessa har inte förändrats nämnvärt sedan dess. De tillhörande presentationerna reviderades i augusti 2026, dock med endast mindre justeringar. Saknar man kurslitteraturen går det bra att istället luta sig mot MDN (Mozilla Developer Network) för referensmaterial och Eloquent JavaScript för de inledande kapitlen om variabler och funktioner.

Nytt för i år är att varje inspelning kompletteras med en transkribering och en AI-genererad sammanfattning (denna text är ett exempel på just det) — tanken är att en sammanfattning ger en snabb, inledande förståelse (“en gran att hänga julgranskulorna på”) innan man ser hela videon eller läser hela kapitlet, och att eventuella felaktigheter i en inspelning flaggas i dess sammanfattning så att man inte lär sig fel saker.

Guider, övningsuppgifter och nyheter för i år

Tre guider ska arbetas igenom under veckan: installation av VS Code, Git-versionshantering och själva övningsuppgiftsguiden. Vilken editor man använder är valfritt (VS Code rekommenderas och fungerar bäst för de flesta, men inget hindrar t.ex. vim), men det är avgörande att komma igång med just guiderna — stöter man på problem med installationen, Git eller att komma igång med en övningsuppgift ska man höra av sig direkt, eftersom detta är en förutsättning för resten av kursen.

Veckans övningsuppgifter är Hello World (den klassiska första uppgiften i praktiskt taget alla programmeringskurser, med rötter hos Brian Kernighan och C), Enkel addition och en införingsuppgift, märkta med svårighetsgrad via badges (Uppvärmning, Träning, med flera). Samtliga har lösningsförslag tillgängliga i en separat branch på GitLab.

Två saker är nya för i år: dels skapar studenten numera själv en grupp vid namn Exercises via självbetjäningstjänsten ActionHub, dit övningsuppgifterna sedan klonas ner, dels finns nu en mer utförlig solution.md-fil till varje övningsuppgift, med både det exakta lösningsförslaget och en kortare förklarande text — värdefull att läsa igenom även efter att man löst uppgiften själv, eftersom den kan visa på en annan lösningsväg.

Delkurs A-test och det öppna demotestet

Delkurs A-testet äger rum torsdagen den 17 september, kl. 13.15–15.00, och täcker innehållet från kursvecka 1–3 (men inte moduler). Man måste vara registrerad och inloggad för att kunna genomföra det, och har en halvtimme på sig från det att man startar. Ett separat demotest öppnas tre dagar efter detta pass (den 11 september) och stänger strax innan det riktiga testtillfället — det innehåller medvetet nonsensfrågor och är enbart till för att man ska bekanta sig med verktygets gränssnitt i förväg, inte för att förbereda sig på testets innehåll. Åtkomsten till testgruppen sätts upp manuellt av kursledningen efter att kursregistreringen stängt, så den dyker upp något försenat för sent registrerade/reservantagna studenter.

GitLab, GitHub och versionshantering

En students fråga om att aldrig ha använt GitLab tidigare besvaras med att Git är samma verktyg oavsett vilken tjänst man använder — GitLab och GitHub skiljer sig bara i terminologi kring vissa funktioner (t.ex. heter det en merge request på GitLab och en pull request på GitHub för samma sak). Kursen använder GitLab och terminalbaserade instruktioner genomgående.

En uppföljande fråga gäller om samma inloggningsmejl på GitHub och GitLab gör att en push hamnar på båda samtidigt — det gör den inte. Vart en push går styrs av den dolda .git-katalogen som skapas när ett repo klonas, specifikt av vilken remote (vanligtvis kallad origin) som är konfigurerad för det lokala repot. git remote -v visar vilken URL ett repo faktiskt är kopplat mot.

Öppna ett projekt i VS Code

Två vanliga sätt att öppna ett kloningsprojekt i VS Code visas: antingen högerklicka på projektkatalogen i Utforskaren (Windows) och välja “Open with VS Code”, eller navigera till katalogen i en terminal och köra code .. Det viktiga är att öppna själva projektkatalogen — inte en överliggande förälderkatalog — så att VS Code bara arbetar med ett projekt i taget.

SSH-nycklar: ED25519 kontra RSA

Vid uppsättning av SSH mot GitLab kan man välja mellan att generera en ED25519- eller en RSA-nyckel. ED25519 rekommenderas: den är modernare, baseras på elliptisk kurvkryptografi (inte primtal som RSA), blir betydligt mer kompakt och stöds av GitLab. RSA fungerar också, men måste sättas till 4096 bitar för motsvarande säkerhetsnivå, vilket gör nyckeln betydligt större och mer otymplig att hantera. Vilken av dem man väljer spelar i praktiken ingen roll för kursen, men ED25519 är förstahandsvalet.

Logiska uttryck — bordlagt till nästa vecka

En fråga om hur logiska uttryck (&&, ||) beter sig och skiljer sig åt, inklusive begrepp som short-circuit evaluation, bedöms kräva mer grundläggande kunskap (bland annat styrstrukturer) för att kunna besvaras fullständigt. Frågan skjuts därför upp till nästa vecka, då studenterna har egen kod att experimentera med i en Node-interpretator.

Går det att lära sig programmera utan förkunskaper?

Svaret är ett tydligt ja — inga förkunskaper krävs. Om man lyckas beror enligt kursledningen mer på intresse, om man tycker det är roligt, och om man studerar konsekvent, än på tidigare erfarenhet. Att följa varje kursveckas material och göra det som beskrivs där är i sig tillräckligt för att lära sig programmera.

En students dator “tillåter” bara en gammal Node-version

En fråga om en ny dator som påstås endast godkänna Node.js 23.11.1, och om det går att vänta två månader med att köpa en ny dator, besvaras tydligt: det är tekniskt omöjligt att en dator bara skulle tillåta en specifik gammal version av Node.js utifrån hårdvaran. Den mest sannolika förklaringen är ett installationsfel — till exempel att en Node-binär byggd för fel processorarkitektur (t.ex. fel variant för Mac- eller Intel-baserade system) har installerats av misstag, vilket kan ge obskyra felmeddelanden som lätt misstolkas. Slutsatsen: köp ingen ny dator, felsök installationen istället.

Stödjande inspelningar

Kurslitteraturen är en av de delar som driver kursen framåt, men det kan vara svårt att själv strukturera upp innehållet. Vad är relevant? Vad ska jag fokusera på i kursen? De stödjande inspelningarna är gjorda för att ge detta sammanhang. Det är av yttersta vikt att du tar del av dessa!

Variabler och konstanter

Variabler och konstanter är några av de absolut viktigaste byggstenarna i programmering. Hur skapar du dessa och vad ska du tänka på när det kommer till namngivning?

Presentation

Reviderad augusti 2026

En variabel låter ett program komma ihåg ett värde genom att binda ett namn till det, och deklareras med nyckelordet let följt av namnet. let är standarden sedan ES6 (2015) — före det användes var, som ersattes eftersom det tillät variabler att läcka ut ur block, omdeklareras utan varning och läsas innan de deklarerats. Ges ingen initiering får variabeln automatiskt värdet undefined, annars kan värdet användas direkt i uttryck och ändras i efterhand.

Namngivning bör vara beskrivande och på engelska. Namn som består av flera ord skrivs med camelCasing (varje ord utom det första inleds med versal). Rekommenderade tecken är a–z, A–Z, 0–9, _ och $, men namnet får inte inledas med en siffra och får inte vara ett nyckelord eller reserverat ord (let, const, class, return med flera) — det ger annars ett syntaxfel.

En konstant fungerar som en variabel med två skillnader: den måste ges ett värde redan när den deklareras, med nyckelordet const, och det värdet kan sedan inte ändras — ett försök kastar ett TypeError. Namngivningen skiljer sig åt beroende på värdets ursprung: när värdet redan är känt när koden skrivs används SCREAMING_SNAKE_CASE (MY_FAVORITE_NUMBER), medan camelCase används när värdet istället tilldelas dynamiskt vid körning.

Video

2021-09-03 36:27 · Presentation (kopplad till inspelningen)

Sammanfattning

Varför variabler?

Hittills har vi skrivit lösa uttryck – 12 + 13 ger 25, men vi kan inte jobba vidare med det värdet. Variabler löser det: de låter programmet komma ihåg värden genom att binda ett namn till ett värde. Vi säger att vi tilldelar variabeln ett värde.

En variabel deklareras med nyckelordet let följt av ett namn. Sedan ES6 (2015) är let standarden – tidigare användes var, som fortfarande förekommer i äldre kod och har väsentliga skillnader mot let (bl.a. i hur scope och hoisting fungerar).

let count             // undefined – inget värde tilldelat ännu
let result = (4 + 8) * 3 + 8  // 44

Om ingen initiering görs får variabeln automatiskt värdet undefined. När ett värde väl är tilldelat kan det ändras, och variabeln kan användas i nya uttryck:

let count = 4 * 12    // 48
count = count + 12    // 60

JavaScript är löst typat, vilket betyder att en variabel kan tilldelas ett värde av en annan typ än den ursprungliga. Det är möjligt men sällan en bra idé – välj istället separata variabler med tydliga namn.

Namngivning

Bra variabelnamn är centralt. Håll dig till engelska, välj beskrivande namn, och tillämpa camelCasing när namnet består av flera ord – varje ord utom det första inleds med versal:

let bestBookEver = 'The Hitchhiker\'s Guide to the Galaxy'
let theMeaningOfLife = 42

Tillåtna tecken är a–z, A–Z, 0–9, _ och $. Första tecknet får inte vara en siffra. I praktiken håller man sig till a–z och A–Z. Namn får inte vara nyckelord eller reserverade ord (som let, const, class, return m.fl.) – annars uppstår syntaxfel.

Utöver camelCasing finns PascalCasing (versalt första bokstav i varje ord, används senare för klasser) och snake_casing (understreck mellan ord, vanligt i t.ex. Python). JavaScript-konventionen och kursens kodstandard kräver camelCasing.

Deklarera en variabel per rad – det underlättar läsbarhet och dokumentation.

Konstanter

En konstant fungerar som en variabel med två skillnader: den måste ges ett värde när den deklareras, och värdet kan sedan inte ändras. Försök att ändra det kastar ett TypeError.

const firstName = 'Johan'
firstName = 'Mats'  // TypeError: Assignment to constant variable.

Däremot går det bra att använda värdet för att skapa nya värden:

const firstName = 'Johan'
const fullName = firstName + ' Doe'  // Skapar en ny sträng – ändrar inte firstName

Det här fungerar eftersom strängar är immutabla – man kan inte ändra en befintlig sträng, bara skapa nya utifrån den.

Namngivning av konstanter diskuteras i kurslitteraturen: vissa föredrar MY_FAVORITE_NUMBER (versaler med understreck) för värden som är hårdkodade och aldrig förändras, medan camelCasing används för konstanter som tilldelas dynamiskt vid körning. I kursen används camelCasing genomgående för enkelhetens skull.

Räckvidd (scope)

En variabels scope är det kodblock där den kan användas. Variabler och konstanter deklarerade med let och const har block scope – de existerar bara inom de klammerparenteser där de skapades.

{
  let bestBookEver = 'The Hitchhiker\'s Guide to the Galaxy'
  console.log(bestBookEver)  // Fungerar
}
console.log(bestBookEver)    // ReferenceError: bestBookEver is not defined

Det är möjligt att ha variabler med samma namn i ett yttre och ett inre block – de är då två separata variabler. Inom ett och samma block däremot kan ett namn bara deklareras en gång.

Observera att klammerparenteser i JavaScript har dubbel betydelse: de skapar block, men används också för objektliteraler ({ name: 'Johan' }). Sammanhanget avgör tolkningen, och det lär man sig snabbt.

Nyansering: await som variabelnamn

I föreläsningen provas let await och det verkar gå igenom utan fel. Det beror på att await är ett reserverat ord i moduler och strikt läge, men inte i vanligt (icke-strikt) skriptläge. I modern JavaScript som körs som ES-modul – vilket är standard i kursen – ska await behandlas som ett nyckelord och inte användas som variabelnamn.

Funktioner

För att kunna dela upp din kod i mindre, logiska stycken så behöver du använda funktioner. Men hur fungerar detta?

Presentation

Reviderad augusti 2026

Redan när ett JavaScript-program startar finns inbyggda funktioner tillgängliga, som console.log och Math.min. Det finns dock inte inbyggda funktioner för allt, så förr eller senare måste du skriva egna. Att dela upp ett program i funktioner strukturerar koden, ger överblick och undviker att identisk kod upprepas — bryt aldrig mot principen DRY (Don’t Repeat Yourself).

En funktion anropas genom att skriva dess namn följt av parenteser, som alltid krävs oavsett om det finns argument eller inte. Argument är värdena som skickas med vid anropet. En funktion returnerar alltid ett värde — saknas en return-sats returneras undefined.

Det finns tre sätt att skapa en funktion. En funktionsdeklaration består av nyckelordet function, ett namn, en parameterlista och en kropp inom klammerparenteser. Ett funktionsuttryck tilldelar istället en funktion till en variabel eller konstant (använd const för att undvika att den skrivs över), och behöver inget eget namn. Sedan ES6 (2015) kan funktioner också skapas med arrow function-syntax (=>) — innehåller kroppen bara en sats kan klammerparenteser och return uteslutas, men saknar funktionen parametrar måste tomma parenteser ändå anges. Alla tre sätten beter sig likadant vad gäller anrop, argument, parametrar och returvärden.

Variabler, konstanter och parametrar som skapas inuti en funktion är lokala i den — let och const ger block scope (bara tillgängligt inom klammerparenteserna), medan var ger function scope. En parameter kan tilldelas ett standardvärde som används om inget argument skickas med vid anropet.

Video

2021-09-06 51:33 · Presentation (kopplad till inspelningen)

Sammanfattning

Inbyggda funktioner

När ett JavaScript-program startar finns ett stort antal inbyggda funktioner tillgängliga direkt. console.log är ett välbekant exempel – den skriver ut ett värde i konsolfönstret. Math.min returnerar det minsta av flera inmatade värden, och Math.random ger tillbaka ett slumpmässigt tal från och med 0 upp till (men inte inklusive) 1. Andra användbara matematikfunktioner är Math.max, Math.floor och Math.ceil.

Varför funktioner?

Det finns inte inbyggda funktioner för allt – förr eller senare måste man skriva sina egna. Att dela upp ett program i funktioner är centralt av flera skäl: det strukturerar koden, skapar överblick, och undviker att identisk kod upprepas på flera ställen. Det sistnämnda brukar sammanfattas som principen DRY – Don’t Repeat Yourself – ett begrepp som återkommer genom hela kursen. Funktioner gör dessutom koden enklare att testa.

En bra liknelse är matlagning: “laga mat” är en övergripande funktion som i sin tur innehåller delfunktioner som “koka potatis”, “steka kött” och “göra sås”. På samma sätt bryts ett program ner i lagom stora, namngivna delar.

Anropa en funktion

En funktion anropas genom att skriva dess namn följt av parenteser. Inuti parenteserna skickas eventuella argument – de värden som funktionen ska arbeta med:

console.log('Hello, World!')  // Skickar en sträng som argument
console.log()                 // Anrop utan argument – skriver ut en tom rad
let randomNumber = Math.random()  // Returvärdet sparas i en variabel

Parenteserna är obligatoriska – utan dem sker inget anrop. Varje funktion returnerar alltid ett värde. Saknas en explicit return-sats returneras undefined.

Tre sätt att skapa funktioner

Funktionsdeklaration

Det klassiska sättet: nyckelordet function, följt av ett namn, en parameterlista inom parenteser och en kropp inom klammerparenteser.

function sayHelloTo(name) {
  let greeting = 'Hello, ' + name + '!'
  return greeting
}

let whatIsSaid = sayHelloTo('Ellen Nu')
console.log(whatIsSaid)  // OUTPUT: Hello, Ellen Nu!

Funktioner skapade med funktionsdeklaration hoistas – JavaScript lyfter dem till toppen av programmet innan koden körs, vilket innebär att de kan anropas även innan de är skrivna i filen.

Funktionsuttryck

Här tilldelas en funktion till en variabel eller konstant. Funktionen behöver inget eget namn.

const anotherSayHelloTo = function (name) {
  let greeting = 'Hello, ' + name + '!'
  return greeting
}

let whatIsSaid = anotherSayHelloTo('Ellen Nu')
console.log(whatIsSaid)  // OUTPUT: Hello, Ellen Nu!

Använd const för funktionsuttryck – det förhindrar att referensen råkar skrivas över. Till skillnad från funktionsdeklarationer hoistas inte funktionsuttryck, och de kan inte anropas innan de initierats.

Arrow function-syntax

Sedan ES6 (2015) finns ett kortare skrivsätt med en pil (=>):

const yetAnotherSayHelloTo = (name) => {
  let greeting = 'Hello, ' + name + '!'
  return greeting
}

Innehåller kroppen bara en sats kan klammerparenteser och return utelämnas:

const yetAnotherSayHelloTo = (name) => 'Hello, ' + name + '!'

Saknar funktionen parametrar måste tomma parenteser ändå anges:

const getTheMeaningOfLife = () => 42

Alla tre sätten beter sig likadant när det gäller argument, parametrar och returvärden.

Räckvidd (scope)

Variabler och parametrar som deklareras inuti en funktion är lokala – de existerar bara inom funktionens kropp och är inte åtkomliga utifrån:

function getFullName(firstName, lastName) {
  let fullName = firstName + ' ' + lastName  // Lokal variabel
  return fullName
}

console.log(fullName)  // ReferenceError – fullName finns inte här

Parametrarna firstName och lastName räknas också som lokala variabler i funktionen.

Parametrar och standardvärden

En parameter kan ges ett standardvärde som används om inget argument skickas med vid anropet:

function getFullName(firstName, lastName = 'Doe') {
  let fullName = firstName + ' ' + lastName
  return fullName
}

getFullName('Ellen', 'Nu')  // → 'Ellen Nu'
getFullName('Nisse')        // → 'Nisse Doe' (standardvärdet används)
getFullName()               // → 'undefined Doe'

Standardvärden på parametrar signalerar till andra utvecklare vilka argument som är obligatoriska och vilka som är valfria. Parametrar utan standardvärde förväntas alltid skickas med.

Moduler

Jättebra att du kan dela upp din kod i funktioner, men hur gör du om du vill dela upp din kod i flera filer?

Presentation

Reviderad augusti 2026

När ett program växer och all kod ligger i en enda fil ökar risken för att den tappar struktur och blir svår att förändra. Genom att dela upp koden i flera filer, moduler, undviks det problemet — en modul är ett litet delprogram som kan ange vilka andra moduler den beror av, och framför allt vilken funktionalitet den erbjuder andra att använda.

Sedan ECMAScript 6 (2015) har JavaScript inbyggt stöd för moduler, så kallade ECMAScript-moduler (ES-moduler, ESM). En modul exporterar värden med nyckelordet export, och en annan modul laddar den med import — antingen som en namnrymdsimport (import * as x, importerar allt exporterat) eller en namngiven import (import { x }, importerar bara det angivna). Bara det som faktiskt exporterats kan anropas utifrån modulen.

Innan ESM var CommonJS ett av de populära modulsystemen, och används fortfarande mycket inom Node.js eftersom stödet för ESM där länge var experimentellt. CommonJS använder module.exports och require istället för export och import, men räknas idag som utdaterat till förmån för ESM. Node.js behandlar kod som CommonJS som standard — för att istället använda ES-moduler läggs fältet type med värdet "module" till i package.json, enklast skapad med npm init -y och sedan kompletterad.

npm-registret innehåller paket, och ett paket kan i sin tur innehålla flera moduler. Vilka paket en applikation använder beskrivs i package.json under dependencies och devDependencies. Paket installeras med npm install PAKETETS_NAMN och hamnar i katalogen node_modules — saknas den katalogen kan alla beroenden installeras i ett svep med npm install utan argument.

Video

2021-09-07 50:45 · Presentation (kopplad till inspelningen)

Sammanfattning

Varför moduler?

När ett program växer och all kod ligger i en enda fil ökar risken för att koden tappar struktur och blir svår att förändra. Genom att dela upp programmets kod i flera filer – moduler – undviks det problemet. En modul är ett litet delprogram som kan ange vilka andra moduler den beror av, och framför allt vilken funktionalitet den erbjuder andra moduler att använda.

ECMAScript-moduler

Sedan ECMAScript 6 (2015) har JavaScript inbyggt stöd för moduler – ECMAScript-moduler (ES-moduler, ESM). En modul exporterar värden med export:

my-greeting.js

function bye () {
  console.log('God bye!')  // exporteras inte – bara tillgänglig i modulen
}

export function hello () {
  console.log('Hello, World!')  // namngiven export ("named export")
}

En annan modul laddar den med import:

app.js

import * as myGreeting from './my-greeting.js'  // namnrymdsimport – importerar allt exporterat
import { hello } from './my-greeting.js'         // namngiven import – importerar bara hello

Bara det som faktiskt exporterats kan anropas utifrån:

myGreeting.hello()  // OUTPUT: Hello, World!
myGreeting.bye()    // ERROR: TypeError: myGreeting.bye is not a function

CommonJS – ett äldre sätt

Innan ESM var CommonJS ett av de populära modulsystemen, och används fortfarande mycket inom Node.js eftersom ESM-stödet där länge var experimentellt:

my-greeting.js

function hello () {
  console.log('Hello, World!')
}

module.exports.hello = hello

// app.js
const myGreeting = require('./my-greeting.js')
myGreeting.hello()

Det här sättet räknas idag som utdaterat till förmån för ESM.

Aktivera ECMAScript-moduler i Node.js

Node behandlar JavaScript-kod som CommonJS-moduler som standard. För att istället använda ES-moduler läggs fältet type med värdet "module" till i package.json – enklast skapad med npm init -y och sedan kompletterad:

{
  "name": "my-awesome-app",
  "type": "module",
  "main": "app.js"
}

Saknas den inställningen ger Node ett tydligt felmeddelande vid körning som talar om att ESM-syntax använts utan att den aktiverats.

npm – en samling paketerad kod

npm-registret innehåller paket, och ett paket kan i sin tur innehålla flera moduler. Vilka paket en applikation använder beskrivs i package.json, under dependencies och devDependencies (tillsammans med vilken version av respektive paket). Paket installeras med npm install PAKETETS_NAMN och hamnar i katalogen node_modules. Saknas den katalogen (till exempel efter en färsk git clone) installeras alla beroenden i ett svep med npm install utan argument.

Läsanvisningar

Under läsanvisningar hittar du veckans kapitel som ska läsas i kurslitteraturen. Planera upp och dela upp läsningen under veckan.

Guider

Under veckan behöver du komma igång med utvecklingsmiljön Visual Studio Code och versionshanteringsverktyget Git. Detta för att kunna genomföra de första övningsuppgifterna. Följ guiderna för detta och ta hjälp på handledningarna eller i kursens Zulip-kanal om du kör fast!

1. Guide - Installera Visual Studio Code
2. Guide - Git versionshantering
3. Guide - Övningsuppgift

Handledning

Kört fast? Strular Git? Problem med en övningsuppgift? Då ska du definitivt vara med på handledningen där du har möjlighet att fråga kursledning och amanuenser om vad som helst.

Campus har denna aktivitet i schemalagd sal och distans träffas i zoom och har därefter individuell handledning i Zulip.

Glöm inte att ställa frågor (i god tid) inför handledningen i formuläret:

• Frågor inför öppen handledning

Utmaningar

Även denna vecka finns ett antal utmaningar att lösa för att hjälpa dig i din lärprocess. Lägg lite tid på att läsa igenom dem. Det är inte omöjligt att det dyker upp några nya utmaningar på veckans fredagshäng.

Studiefrågor

Här är ett antal frågor som du kan försöka besvara och diskutera tillsammans med en AI-assistent. Tveka inte att lyfta någon av frågorna till handledningen för att fortsätta diskussionen med lärare och studiekamrater.

1. Berätta kort om utvecklingsverktyget vscode.
2. Berätta kort om historiken bakom vscode.
3. Stämmer det att vscode är byggt med teknikerna HTML, CSS och JavaScript?
4. Berätta kort om Git.
5. Berätta kort om GitLab.
6. Berätta kort om variabler och konstanter i JavaScript.
7. Berätta kort om funktioner i JavaScript.
8. Berätta kort om ESM moduler i JavaScript.
9. Hur kan ett program “Hello World” se ut om jag bygger det med variabler, funktioner och moduler i JavaScript och sedan kör det i Node?

Här är en utskrift från hur det kan se ut när frågorna ovan diskuterats med en AI-assistent.

Tips

Här följer tips till hur du kan prioritera bland kursmaterialet för att komma igång med veckan.

1. Börja med att installera vscode och bekanta dig med texteditorn/utvecklingsverktyget.
2. Jobba igenom guiden med Git & GitLab och bekanta dig med de båda verktygen.
3. Gör den första övningsuppgiften för att bekanta dig med hur man klonar ett repo och exekverar koden. Se även om du kan tjuvkika på lösningen.

Ett standardtips är alltid att titta igenom de inspelade föreläsningarna och läsanvisningarna.