9 | {HEIGHTS.map((value) => (
10 |
17 | ))}
18 |
19 | );
20 | };
21 |
22 | export default DivChart;
23 |
--------------------------------------------------------------------------------
/src/containers/AppContainer.tsx:
--------------------------------------------------------------------------------
1 | import { useState } from "react";
2 | import { Outlet } from "react-router";
3 |
4 | import { Navbar } from "../components";
5 | import { HistoryEntry } from "../interfaces";
6 | import { HistoryContext } from "../hooks/contexts";
7 |
8 | const App = () => {
9 | const [history, setHistory] = useState
14 |
17 |
22 |
26 | );
27 | };
28 |
29 | export default Jumbotron;
30 |
--------------------------------------------------------------------------------
/src/utils/index.ts:
--------------------------------------------------------------------------------
1 | import DOMPurify from "dompurify";
2 | import { Grade } from "../interfaces";
3 |
4 | export const COLORS = {
5 | A: "green",
6 | B: "blue",
7 | C: "purple",
8 | D: "yellow",
9 | E: "orange",
10 | F: "red",
11 | };
12 |
13 | export function formatPercentage(dividend: number, divisor: number): number {
14 | if (divisor === 0) return 0;
15 | return Math.round((10000 * dividend) / divisor) / 100;
16 | }
17 |
18 | export function percentageToGrade(percentage: number): Grade {
19 | const scale = [89, 77, 65, 53, 41];
20 | const grades: ArrayKramster!
23 |{subtitle()}
25 |
12 |
31 | );
32 | }
33 |
34 | export default Schools;
35 |
--------------------------------------------------------------------------------
/src/components/Navbar/index.tsx:
--------------------------------------------------------------------------------
1 | import { Link, useLocation } from "react-router";
2 | import styles from "./Navbar.module.css";
3 | import { FC } from "react";
4 |
5 | const Navbar: FC = () => {
6 | const location = useLocation();
7 |
8 | return (
9 |
32 | );
33 | };
34 |
35 | export default Navbar;
36 |
--------------------------------------------------------------------------------
/src/containers/Exams/Exams.module.css:
--------------------------------------------------------------------------------
1 | .wrapper {
2 | padding: 0;
3 | margin: 22px 1rem;
4 | }
5 |
6 | .categoriesRow {
7 | display: flex;
8 | flex-wrap: wrap;
9 | justify-content: space-around;
10 | margin: 1rem 0;
11 | gap: 1rem;
12 | }
13 |
14 | .examsGrid {
15 | display: grid;
16 | grid-gap: 1rem;
17 | grid-template-columns: repeat(4, auto);
18 | }
19 |
20 | .categoriesRow > div {
21 | flex: 1;
22 | }
23 |
24 | @media (max-width: 1200px) {
25 | .examsGrid {
26 | grid-template-columns: repeat(3, auto);
27 | }
28 | }
29 |
30 | @media (max-width: 800px) {
31 | .examsGrid {
32 | grid-template-columns: repeat(2, auto);
33 | }
34 | }
35 |
36 | @media (max-width: 800px) {
37 | .examsGrid {
38 | grid-template-columns: repeat(2, auto);
39 | }
40 | }
41 |
42 | @media (max-width: 500px) {
43 | .categoriesRow {
44 | flex-direction: column;
45 | }
46 |
47 | .examsGrid {
48 | grid-template-columns: repeat(1, auto);
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/components/Navbar/Navbar.module.css:
--------------------------------------------------------------------------------
1 | .navbar {
2 | font-family: var(--font-header);
3 | margin-bottom: 20px;
4 | background: none;
5 | border-radius: 0;
6 | border: none;
7 | height: 40px;
8 | letter-spacing: 1px;
9 | }
10 |
11 | .navbar a {
12 | color: var(--brand-color);
13 | }
14 |
15 | .navbar ul {
16 | list-style: none;
17 | margin: 0;
18 | }
19 |
20 | .logo {
21 | letter-spacing: 2px;
22 | text-decoration: none;
23 | font-size: 18px;
24 | height: 50px;
25 | }
26 |
27 | .logo:hover {
28 | text-decoration: underline;
29 | }
30 |
31 | .link {
32 | text-decoration: none;
33 | font-size: 14px;
34 | }
35 |
36 | .link:hover {
37 | text-decoration: underline;
38 | }
39 |
40 | .pullLeft {
41 | display: block;
42 | float: left;
43 | }
44 |
45 | .pullRight {
46 | display: block;
47 | float: right;
48 | }
49 |
50 | @media (max-width: 767px) {
51 | .navbar {
52 | padding: 8px 0;
53 | margin-bottom: 0;
54 | height: 20px;
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4160/Eksamen 2007 Kont.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "IJVM har ein multiplikasjonseining.\n
15 | {schools.map((school) => (
16 |
30 |
17 | {
22 | void navigate(`/${school.abbreviation.toLowerCase()}`, {
23 | viewTransition: true,
24 | });
25 | }}
26 | />
27 |
28 | ))}
29 | ![](\"images/58g4wh.webp\"/)
",
4 | "answers": [1],
5 | "options": ["Sant", "Usant"]
6 | },
7 | {
8 | "question": "RISC-prosessorar nyttar ofte \"hardwired\" styreeining.",
9 | "answers": [0],
10 | "options": ["Sant", "Usant"]
11 | },
12 | {
13 | "question": "I eit ”scoreboard” kan ein lese ut antal gonger eit register er brukt\nsom kilde av instruksjonane som er \"aktive\" (under utføring).",
14 | "answers": [0],
15 | "options": ["Sant", "Usant"]
16 | },
17 | {
18 | "question": "IJVM har meir til felles med CISC- enn RISC-maskiner.",
19 | "answers": [0],
20 | "options": ["Sant", "Usant"]
21 | },
22 | {
23 | "question": "Ein versjon av prosessoren 8051 har multipleksa 8 bit databuss og 16\nbit adressebuss. Denne versjonen av 8051 kan adressere 64KB minne.",
24 | "answers": [0],
25 | "options": ["Sant", "Usant"]
26 | }
27 | ]
28 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 18: Patterns and Tactics.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Which of these architectural patterns should be used for this scenario? ![](\"images/9ubka7.webp\"/)
",
4 | "answers": [3],
5 | "options": [
6 | "Map-Reduce Pattern",
7 | "Peer-to-Peer Pattern",
8 | "Broker Pattern",
9 | "Model-View-Controller Pattern"
10 | ]
11 | },
12 | {
13 | "question": "Which of these architectural patterns should be used for this scenario? ![](\"images/q7lag.webp\"/)
",
14 | "answers": [0],
15 | "options": [
16 | "Pipe-and-Filter Pattern",
17 | "Broker Pattern",
18 | "Model-View-Controller Pattern",
19 | "Peer-to-Peer Pattern"
20 | ]
21 | },
22 | {
23 | "question": "Which of these architectural patterns should be used for this scenario? ![](\"images/rgmrc.webp\"/)
",
24 | "answers": [2],
25 | "options": [
26 | "Broker Pattern",
27 | "Client-Server Pattern",
28 | "Peer-to-Peer Pattern",
29 | "Map-Reduce Pattern"
30 | ]
31 | }
32 | ]
33 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4160/Age of Computers: Digitalteknikk.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Hva blir utgang Y lik hvis S0=1, S1=0, D0= 1, D1=0, D2=0, D3=1?",
4 | "answers": [0],
5 | "options": ["0", "1", "10", "00"]
6 | },
7 | {
8 | "question": "Hva blir utgang Y lik hvis S0=0, S1=0, D0= 1, D1=0, D2=0, D3=1?",
9 | "answers": [0],
10 | "options": ["1", "0", "00", "11"]
11 | },
12 | {
13 | "question": "Hva er en multiplekser (MUX)?",
14 | "answers": [0],
15 | "options": [
16 | "En MUX er en kombinatorisk krets som velger en av inngangene og sender den ut på utgangen.",
17 | "En MUX er en kombinatorisk krets som tar inngangen og splitter den opp til flere utganger.",
18 | "En MUX er en sekvensiell krets som alltid tar inn to verdier og gir ut en kombinasjon av disse på utgangen.",
19 | "En MUX brukes til å dekode inngangen og gi riktig verdi til de ulike registrene."
20 | ]
21 | },
22 | {
23 | "question": "Hvis inngangene er D0D1D2D3=0100 og Y=1, hva må S1S0 være da?",
24 | "answers": [1],
25 | "options": ["00", "01", "10", "11"]
26 | }
27 | ]
28 |
--------------------------------------------------------------------------------
/src/components/DivChart/DivChart.module.css:
--------------------------------------------------------------------------------
1 | .divChart {
2 | display: flex;
3 | justify-content: space-around;
4 | align-items: flex-end;
5 | gap: 4px;
6 | height: 370px;
7 | }
8 |
9 | .divChartBar {
10 | flex: 1;
11 | background-color: var(--red-light);
12 | border-radius: 0.5rem;
13 | border-bottom: 4px solid var(--red);
14 | animation: 800ms slide-in ease-in-out forwards;
15 | }
16 |
17 | .divChartBar:nth-child(2) {
18 | animation-delay: 100ms;
19 | }
20 |
21 | .divChartBar:nth-child(3) {
22 | animation-delay: 200ms;
23 | }
24 |
25 | .divChartBar:nth-child(4) {
26 | animation-delay: 300ms;
27 | }
28 |
29 | .divChartBar:nth-child(5) {
30 | animation-delay: 400ms;
31 | }
32 |
33 | .divChartBar:nth-child(6) {
34 | animation-delay: 500ms;
35 | }
36 |
37 | .divChartBar:hover .divChartLabel {
38 | opacity: 1;
39 | }
40 |
41 | .divChartLabel {
42 | padding: 1rem;
43 | opacity: 0;
44 | transition: opacity 300ms;
45 | }
46 |
47 | @keyframes slide-in {
48 | from {
49 | height: 0;
50 | }
51 |
52 | to {
53 | height: 100%;
54 | }
55 | }
56 |
57 | @media (max-width: 767px) {
58 | .divChart {
59 | height: 200px;
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 16: CBAM.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "What is gained from doing a CBAM compared to doing an ATAM?",
4 | "answers": [0],
5 | "options": [
6 | "Economical analysis",
7 | "Less effort",
8 | "Tradeoff analysis",
9 | "Quality analysis"
10 | ]
11 | },
12 | {
13 | "question": "What is the ultimate resulting goal of doing a CBAM analysis?",
14 | "answers": [0, 3],
15 | "options": [
16 | "Maximize gains",
17 | "Maximize risk",
18 | "Minimize gains",
19 | "Minimize risk"
20 | ]
21 | },
22 | {
23 | "question": "In CBAM, A SET OF SCENARIOS are used by varying the values of...",
24 | "answers": [0],
25 | "options": ["Responses", "Stimuli", "Trade-offs", "Utilities"]
26 | },
27 | {
28 | "question": "What is the total benefit obtained from architectural strategy 2? ![](\"images/wfar98.webp\"/)
",
29 | "answers": [1],
30 | "options": ["600", "1050", "2225", "5000"]
31 | },
32 | {
33 | "question": "Which architectural strategy gives highest Value for Cost? ![](\"images/0gedy9.webp\"/)
",
34 | "answers": [1],
35 | "options": ["1", "2", "3", "4"]
36 | }
37 | ]
38 |
--------------------------------------------------------------------------------
/public/manifest.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Kramster!",
3 | "short_name": "Kramster!",
4 | "start_url": "/",
5 | "display": "standalone",
6 | "background_color": "#ecf0f1",
7 | "theme_color": "#ecf0f1",
8 | "description": "Cram for your exam with Kramster!",
9 | "orientation": "portrait",
10 | "lang": "no",
11 | "icons": [
12 | {
13 | "src": "icons/icon-72x72.png",
14 | "sizes": "72x72",
15 | "type": "image/png"
16 | },
17 | {
18 | "src": "icons/icon-96x96.png",
19 | "sizes": "96x96",
20 | "type": "image/png"
21 | },
22 | {
23 | "src": "icons/icon-128x128.png",
24 | "sizes": "128x128",
25 | "type": "image/png"
26 | },
27 | {
28 | "src": "icons/icon-144x144.png",
29 | "sizes": "144x144",
30 | "type": "image/png"
31 | },
32 | {
33 | "src": "icons/icon-152x152.png",
34 | "sizes": "152x152",
35 | "type": "image/png"
36 | },
37 | {
38 | "src": "icons/icon-192x192.png",
39 | "sizes": "192x192",
40 | "type": "image/png"
41 | },
42 | {
43 | "src": "icons/icon-384x384.png",
44 | "sizes": "384x384",
45 | "type": "image/png"
46 | },
47 | {
48 | "src": "icons/icon-512x512.png",
49 | "sizes": "512x512",
50 | "type": "image/png"
51 | }
52 | ]
53 | }
54 |
--------------------------------------------------------------------------------
/src/components/ProgressBar/index.tsx:
--------------------------------------------------------------------------------
1 | import styles from "./ProgressBar.module.css";
2 | import { Question } from "../../interfaces";
3 | import { FC } from "react";
4 |
5 | interface Props {
6 | history: boolean[];
7 | questions: Question[];
8 | }
9 |
10 | const ProgressBar: FC
30 |
43 | );
44 | };
45 |
46 | export default ProgressBar;
47 |
--------------------------------------------------------------------------------
/src/routes.tsx:
--------------------------------------------------------------------------------
1 | import { createBrowserRouter } from "react-router";
2 | import { RouterProvider } from "react-router/dom";
3 |
4 | import AppContainer from "./containers/AppContainer";
5 | import Schools from "./containers/Schools";
6 |
7 | export default function Routes() {
8 | const router = createBrowserRouter([
9 | {
10 | path: "/",
11 | element: 31 | {`${props.history.length.toString()}/${props.questions.length.toString()}`} 32 |
33 |
34 | {props.history.map((_answer, i) => (
35 |
40 | ))}
41 |
42 |
6 |
33 | );
34 |
35 | export const Component = About;
36 |
--------------------------------------------------------------------------------
/public/data/oslomet/syba1010/Sansene.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Luktesansen har sansecellene sine øverst i nesehulen. Hvilken type reseptorer har disse sansecellene?",
4 | "answers": [0],
5 | "options": [
6 | "Kjemoreseptorer",
7 | "Baroreseptorer",
8 | "Mekanoreseptorer",
9 | "Fotoreseptorer"
10 | ]
11 | },
12 | {
13 | "question": "Hvilket utsagn om hørselssansen er riktig?",
14 | "answers": [3],
15 | "options": [
16 | "Det ovale vinduet markerer overgangen mellom det ytre øret og mellomøret",
17 | "Den delen av hjernebarken som mottar lydsignaler er plassert i bakhodelappen (occipitallappen)",
18 | "Mellomøret ligger utenfor trommehinnen",
19 | "Hørselssansecellene (hårcellene) er plassert i sneglehuset"
20 | ]
21 | },
22 | {
23 | "question": "Hva er sklera (sclera)?",
24 | "answers": [2],
25 | "options": ["Årehinnen", "Netthinnen", "Senehinnen", "Hornhinnen"]
26 | },
27 | {
28 | "question": "Hvilket utsagn om hørselssansen er riktig?",
29 | "answers": [3],
30 | "options": [
31 | "Hørselssansecellene (hårcellene) er plassert i mellomøret",
32 | "Den delen av hjernebarken som mottar lydsignaler er plassert i bakhodelappen (occipitallappen)",
33 | "Mellomøret ligger utenfor trommehinnen",
34 | "Trommehinnen og mellomørebeina (øreknoklene) forsterker lyden før den treffer hørselsanseceller (hårcellene)"
35 | ]
36 | }
37 | ]
38 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 09: Design patterns II.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "What pattern can be used to ensure that single and multiple objects can be treated similarly?",
4 | "answers": [1],
5 | "options": ["Abstract Factory", "Composite", "Singleton", "Template Method"]
6 | },
7 | {
8 | "question": "What pattern can be used to implement/maintain several almost identical pieces of code?",
9 | "answers": [3],
10 | "options": ["Abstract Factory", "Composite", "Observer", "Template Method"]
11 | },
12 | {
13 | "question": "What pattern can be used to ensure that a change of one object influences other objects?",
14 | "answers": [2],
15 | "options": ["Abstract Factory", "Composite", "Observer", "Template Method"]
16 | },
17 | {
18 | "question": "What pattern can be used to ensure a single instance of a class?",
19 | "answers": [3],
20 | "options": ["Abstract Factory", "Composite", "Observer", "Singleton"]
21 | },
22 | {
23 | "question": "What are the keywords in the short pattern definition?",
24 | "answers": [0, 2, 3],
25 | "options": ["Context", "Observation", "Problem", "Solution"]
26 | },
27 | {
28 | "question": "What do you call a collection of patterns that build on each other to generate a system?",
29 | "answers": [2],
30 | "options": [
31 | "Architectural Pattern",
32 | "Idioms",
33 | "Pattern Languages",
34 | "Pattern Styles"
35 | ]
36 | }
37 | ]
38 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4160/Eksamen 2009 Høst.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Er det mogleg å kopiere innehalde i MAR til PC? Sjå figur 6.\n
7 |
32 | Cram with Kramster!
8 |9 | Kramster helps making exam preparation a little more fun. Select your 10 | school and course and cram for your exam by doing the multiple choice 11 | questions with instant feedback. 12 |
13 |14 | This is a Progressive Web App (PWA). Add the website to your home screen 15 | for offline support and a more app-like experience. Cram for your exam 16 | even without internet! 17 |
18 |19 | Want to add an exam? It requires some technical skills, but you can do 20 | this on GitHub. 21 | Create a JSON file for your exam on the expected format and submit a 22 | pull request. 23 |
24 |25 | Kramster is made by Mats Byrkjeland{" "} 26 | and it is{" "} 27 | open source. Do 28 | you enjoy Kramster? Star it on{" "} 29 | GitHub! 30 |
31 |![](\"images/dre3v.webp\"/)
",
4 | "answers": [1],
5 | "options": ["Ja", "Nei"]
6 | },
7 | {
8 | "question": "Kva påstand er ikkje korrekt for ein ein-brikke multiprosessor (CMP)?",
9 | "answers": [3],
10 | "options": [
11 | "Kan ha felles hovudminne.",
12 | "Kan dele cache.",
13 | "Er av type homogen eller heterogen.",
14 | "Kan berre nytte ILP som parallelliserings strategi."
15 | ]
16 | },
17 | {
18 | "question": "Figur 5(a) har ein funksjon som gitt i sanningstabellen i figur5(b).\n![](\"images/nv2mfi.webp\"/)
",
19 | "answers": [0],
20 | "options": ["Korrekt", "Ikkje korrekt"]
21 | },
22 | {
23 | "question": "Ved å auke mengda samlebandstrinn aukar ILP.",
24 | "answers": [0],
25 | "options": ["Korrekt", "Ikkje korrekt"]
26 | },
27 | {
28 | "question": "Under følgjer ein rekke påstandar om datamaskinkomponentar. Kva\npåstand er korrekt?",
29 | "answers": [1],
30 | "options": [
31 | "Multipleksa adresse/data buss halverar adresserommet saman-\nlikna med system med dedikerte adresse- og databusar.",
32 | "Ein prosessor som har ein ALU som kan utføre NAND-operasjon,\nkan programmerast til å utføre alle logiske operasjonar.",
33 | "PROM og flash-minne kan slettast og programmerast fleire gon-\nger.",
34 | "Ein dekodarkrets har fleire inngangar enn utgangar."
35 | ]
36 | }
37 | ]
38 |
--------------------------------------------------------------------------------
/src/components/Buttons/Alternative/Alternative.module.css:
--------------------------------------------------------------------------------
1 | .alternativeBase {
2 | composes: base from "../BaseButton.module.css";
3 | padding: 20px;
4 | display: inline-block;
5 | }
6 |
7 | .alternativeBase:focus {
8 | outline: 3px solid #2980b9;
9 | }
10 |
11 | .alternative {
12 | composes: alternativeBase;
13 | composes: darkGray from "../../../base-styles/colors.module.css";
14 | composes: whiteBackground from "../../../base-styles/colors.module.css";
15 | transition: all 300ms;
16 | }
17 |
18 | .alternativeBase:hover {
19 | background-color: #2980b9;
20 | color: white;
21 | }
22 |
23 | .correctAnswer {
24 | composes: alternativeBase;
25 | composes: greenLightBackground from "../../../base-styles/colors.module.css";
26 | composes: greenBackgroundHover from "../../../base-styles/colors.module.css";
27 | composes: white from "../../../base-styles/colors.module.css";
28 | composes: whiteHover from "../../../base-styles/colors.module.css";
29 | composes: darkGrayHover from "../../../base-styles/colors.module.css";
30 | }
31 |
32 | .wrongAnswer {
33 | composes: alternativeBase;
34 | composes: redLightBackground from "../../../base-styles/colors.module.css";
35 | composes: redBackgroundHover from "../../../base-styles/colors.module.css";
36 | composes: white from "../../../base-styles/colors.module.css";
37 | composes: whiteHover from "../../../base-styles/colors.module.css";
38 | composes: darkGrayHover from "../../../base-styles/colors.module.css";
39 | }
40 |
41 | @media (max-width: 767px) {
42 | .alternativeBase {
43 | padding: 10px;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 02: Structures and Views.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "The term for a representation of a coherent set of architectural elements is...",
4 | "answers": [3],
5 | "options": ["Architecture", "Module", "Structure", "View"]
6 | },
7 | {
8 | "question": "Structures that allow reasoning about how primary functionality is assigned to units are named",
9 | "answers": [2],
10 | "options": ["Allocation", "Component-and-Connector", "Module", "Nothing"]
11 | },
12 | {
13 | "question": "Structures that can answer which processors software elements are executed on are named...",
14 | "answers": [0],
15 | "options": ["Allocation", "Component-and-Connector", "Module", "Nothing"]
16 | },
17 | {
18 | "question": "Structures that can answer what parts of the system can run in parallel are...",
19 | "answers": [1],
20 | "options": ["Allocation", "Component-and-Connector", "Module", "Nothing"]
21 | },
22 | {
23 | "question": "Which stuctures can be classified as module structures?",
24 | "answers": [0, 3],
25 | "options": ["Class", "Concurrency", "Deployment", "Layer"]
26 | },
27 | {
28 | "question": "Which structures can be classified as Component-and-connector structures?",
29 | "answers": [0, 2],
30 | "options": ["Concurrency", "Decomposition", "Service", "Work assignment"]
31 | },
32 | {
33 | "question": "Which structures can be classified as allocation structures?",
34 | "answers": [1, 3],
35 | "options": ["Data model", "Implementation", "Uses", "Work assignment"]
36 | }
37 | ]
38 |
--------------------------------------------------------------------------------
/public/data/ntnu/mfel1050/2006 Høst.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Hvordan sikres maksimal sentralnervøs fyring i styrketrening?",
4 | "answers": [0],
5 | "options": [
6 | "Markert stopp i ytterposisjon og maksimal mobilisering",
7 | "Gjennomfør repetisjonene så hurtig som mulig",
8 | "Hurtig eksentrisk fase"
9 | ]
10 | },
11 | {
12 | "question": "Blodstrømmen til kapillærene blokkeres fullstendig ved:",
13 | "answers": [1],
14 | "options": [
15 | "Ca 15 % av maksimalkraft",
16 | "Ca. 70 % av maksimalkraft",
17 | "Blokkeres ikke etter en periode hvor man har trent maksimal styrketrening"
18 | ]
19 | },
20 | {
21 | "question": "Hva er viktigst for trening av maksimalt oksygenopptak?",
22 | "answers": [2],
23 | "options": [
24 | "Varighet",
25 | "Intensitet",
26 | "Intensitet - opp til maksimalt oksygenopptak"
27 | ]
28 | },
29 | {
30 | "question": "Bedret arbeidsøkonomi på en gitt belastning vises som:",
31 | "answers": [0],
32 | "options": [
33 | "Redusert oksygenopptak",
34 | "Økt oksygenopptak",
35 | "Uendret oksygenopptak"
36 | ]
37 | },
38 | {
39 | "question": "Hvis maksimal styrke (1-repetisjons maksimum) øker med 70% i 90 graders knebøy, hva vil du da forvente i en statisk (isometrisk) test?",
40 | "answers": [2],
41 | "options": ["0%", "50%", "20%"]
42 | },
43 | {
44 | "question": "Hvor stor framgang i maksimalt oksygenopptak er dokumentert på 70 åringer i løpet av 10 ukers trening, 3x pr uke?",
45 | "answers": [1],
46 | "options": ["2%", "13%", "40%"]
47 | }
48 | ]
49 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "kramster",
3 | "version": "3.0.0",
4 | "description": "Kramster is a quiz app for making exam preparation more fun",
5 | "main": "src/server/server.js",
6 | "type": "module",
7 | "engines": {
8 | "node": "22",
9 | "npm": ">=10"
10 | },
11 | "scripts": {
12 | "start": "vite",
13 | "build": "tsc && vite build",
14 | "eslint": "eslint 'src/**/*.{ts,tsx}'",
15 | "stylelint": "stylelint src/**/*.css",
16 | "format": "prettier . --write",
17 | "format:check": "prettier . --check",
18 | "ts": "tsc --noEmit",
19 | "lint": "npm run eslint && npm run stylelint && npm run format:check"
20 | },
21 | "repository": {
22 | "type": "git",
23 | "url": "git://github.com/draperunner/Kramster.git"
24 | },
25 | "author": "Mats Byrkjeland",
26 | "license": "Apache-2.0",
27 | "dependencies": {
28 | "dompurify": "^3.3.0",
29 | "react": "^19.2.1",
30 | "react-dom": "^19.2.1",
31 | "react-router": "^7.10.1"
32 | },
33 | "devDependencies": {
34 | "@types/node": "^22.19.1",
35 | "@types/qs": "^6.14.0",
36 | "@types/react": "^19.2.7",
37 | "@types/react-dom": "^19.2.3",
38 | "@vitejs/plugin-react-swc": "^3.11.0",
39 | "eslint": "^9.39.1",
40 | "eslint-plugin-jsx-a11y": "^6.10.2",
41 | "eslint-plugin-react": "^7.37.5",
42 | "eslint-plugin-react-hooks": "^5.2.0",
43 | "prettier": "^3.7.4",
44 | "stylelint": "^16.26.1",
45 | "stylelint-config-standard": "^37.0.0",
46 | "ts-node": "^10.9.2",
47 | "typescript": "^5.9.3",
48 | "typescript-eslint": "^8.48.1",
49 | "vite": "^6.4.1",
50 | "vite-plugin-pwa": "^0.21.2"
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/components/ProgressBar/ProgressBar.module.css:
--------------------------------------------------------------------------------
1 | .progress {
2 | height: 20px;
3 | border-radius: 0;
4 | border: 0;
5 | box-shadow: none;
6 | background-color: white;
7 | }
8 |
9 | .progressBar {
10 | float: left;
11 | height: 100%;
12 | border-radius: 0;
13 | border: 0;
14 | box-shadow: none;
15 | }
16 |
17 | .correct {
18 | composes: progressBar;
19 | composes: greenLightBackground from "../../base-styles/colors.module.css";
20 | -webkit-animation: fadein 400ms ease-out; /* Safari, Chrome and Opera > 12.1 */
21 | -moz-animation: fadein 400ms ease-out; /* Firefox < 16 */
22 | -ms-animation: fadein 400ms ease-out; /* Internet Explorer */
23 | -o-animation: fadein 400ms ease-out; /* Opera < 12.1 */
24 | animation: fadein 400ms ease-out;
25 | }
26 |
27 | .wrong {
28 | composes: progressBar;
29 | composes: redLightBackground from "../../base-styles/colors.module.css";
30 | -webkit-animation: fadein 400ms ease-out; /* Safari, Chrome and Opera > 12.1 */
31 | -moz-animation: fadein 400ms ease-out; /* Firefox < 16 */
32 | -ms-animation: fadein 400ms ease-out; /* Internet Explorer */
33 | -o-animation: fadein 400ms ease-out; /* Opera < 12.1 */
34 | animation: fadein 400ms ease-out;
35 | }
36 |
37 | .progressText {
38 | color: var(--brand-color);
39 | text-align: right;
40 | font-weight: bold;
41 | margin-bottom: 2px;
42 | }
43 |
44 | @keyframes fadein {
45 | from {
46 | opacity: 0;
47 | }
48 | to {
49 | opacity: 1;
50 | }
51 | }
52 |
53 | @media (max-width: 767px) {
54 | .wrapper {
55 | margin: 0;
56 | padding: 0 8px;
57 | }
58 |
59 | .progressText {
60 | margin: 5px 0 1px;
61 | font-size: 12px;
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/src/components/LoadingSpinner/LoadingSpinner.module.css:
--------------------------------------------------------------------------------
1 | .spinner {
2 | display: inline-block;
3 | position: fixed;
4 | top: 0;
5 | bottom: 0;
6 | left: 0;
7 | right: 0;
8 | margin: auto;
9 | height: 50px;
10 | width: 50px;
11 | border-radius: 50%;
12 | animation-name: loading-spinner;
13 | animation-duration: 4s;
14 | animation-iteration-count: infinite;
15 | }
16 |
17 | @keyframes loading-spinner {
18 | 0% {
19 | background-color: #c0392b;
20 | }
21 | 25% {
22 | background-color: #2ecc71;
23 | }
24 | 50% {
25 | background-color: #3498db;
26 | }
27 | 75% {
28 | background-color: #f1c40f;
29 | }
30 | 100% {
31 | background-color: #c0392b;
32 | }
33 | }
34 |
35 | @-moz-keyframes loading-spinner {
36 | 0% {
37 | background-color: #c0392b;
38 | }
39 | 25% {
40 | background-color: #2ecc71;
41 | }
42 | 50% {
43 | background-color: #3498db;
44 | }
45 | 75% {
46 | background-color: #f1c40f;
47 | }
48 | 100% {
49 | background-color: #c0392b;
50 | }
51 | }
52 |
53 | @-webkit-keyframes loading-spinner {
54 | 0% {
55 | background-color: #c0392b;
56 | }
57 | 25% {
58 | background-color: #2ecc71;
59 | }
60 | 50% {
61 | background-color: #3498db;
62 | }
63 | 75% {
64 | background-color: #f1c40f;
65 | }
66 | 100% {
67 | background-color: #c0392b;
68 | }
69 | }
70 |
71 | @-o-keyframes loading-spinner {
72 | 0% {
73 | background-color: #c0392b;
74 | }
75 | 25% {
76 | background-color: #2ecc71;
77 | }
78 | 50% {
79 | background-color: #3498db;
80 | }
81 | 75% {
82 | background-color: #f1c40f;
83 | }
84 | 100% {
85 | background-color: #c0392b;
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/containers/Exams/index.tsx:
--------------------------------------------------------------------------------
1 | import { useParams } from "react-router";
2 |
3 | import CategoryButton from "../../components/Buttons/CategoryButton";
4 | import StandardButton from "../../components/Buttons/StandardButton";
5 | import { LoadingSpinner } from "../../components";
6 |
7 | import styles from "./Exams.module.css";
8 |
9 | import examsIndex from "../../exams.json";
10 |
11 | function Exams() {
12 | const { school = "", course = "" } = useParams();
13 |
14 | const exams = examsIndex.filter(
15 | (exam) =>
16 | exam.school === school.toLowerCase() &&
17 | exam.course === course.toLowerCase(),
18 | );
19 |
20 | if (!exams.length) {
21 | return
26 |
55 | );
56 | }
57 |
58 | export const Component = Exams;
59 |
--------------------------------------------------------------------------------
/src/components/Kitem/index.tsx:
--------------------------------------------------------------------------------
1 | import { FC } from "react";
2 | import styles from "./Kitem.module.css";
3 |
4 | interface Props {
5 | body: string;
6 | head: number | string;
7 | color: string;
8 | minHeight?: boolean;
9 | onClick?: (
10 | event:
11 | | React.MouseEvent27 | {exams[0].course.toUpperCase()} – {exams[0].courseName} 28 |
29 | 30 |
31 |
42 |
43 |
32 |
33 | 10 Random
34 |
35 |
36 |
37 |
38 | 30 Random
39 |
40 |
41 |
44 | {exams.map(({ name }) => (
45 |
54 |
46 |
49 | {name}
50 |
51 |
52 | ))}
53 |
36 |
43 | );
44 | }
45 |
46 | return (
47 | {
52 | if (e.key === "Enter" && props.onClick) {
53 | props.onClick(e);
54 | }
55 | }}
56 | onClick={props.onClick}
57 | >
58 |
37 |
39 | {props.head}
38 |
40 |
42 | {props.body}
41 |
59 |
61 | {props.head}
60 |
62 |
64 |
65 | );
66 | };
67 |
68 | export default Kitem;
69 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 01: Introduction.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "What are the main elements in the definition of software architecture?",
4 | "answers": [0, 1, 2, 3],
5 | "options": [
6 | "Set of structures",
7 | "Software elements",
8 | "Relations",
9 | "Properties"
10 | ]
11 | },
12 | {
13 | "question": "What are the important categories of architectural structures in the book?",
14 | "answers": [1, 2, 3],
15 | "options": ["Hierarchy", "Module", "Component and Connector", "Allocation"]
16 | },
17 | {
18 | "question": "What SWA category focuses on mapping software structures to the system's environment?",
19 | "answers": [0],
20 | "options": ["Allocation", "Component and Connector", "Module", "None"]
21 | },
22 | {
23 | "question": "What SWA category focuses on dividing systems into implementation units?",
24 | "answers": [2],
25 | "options": ["Allocation", "Component and Connector", "Module", "None"]
26 | },
27 | {
28 | "question": "What SWA category focuses on how each module is implemented in detail?",
29 | "answers": [3],
30 | "options": ["Allocation", "Component and Connector", "Module", "None"]
31 | },
32 | {
33 | "question": "What SWA category focuses on how elements interact in runtime?",
34 | "answers": [1],
35 | "options": ["Allocation", "Component and Connector", "Module", "None"]
36 | },
37 | {
38 | "question": "A structure is architectural if it...",
39 | "answers": [3],
40 | "options": [
41 | "Specifies implementation details",
42 | "Specifies programming language",
43 | "Supports large structures",
44 | "Supports reasoning"
45 | ]
46 | }
47 | ]
48 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4160/Eksamen 2009 Kont.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Hvor mange mikroinstruksjoner kan ”control store” inneholde? (Se figur 6)\n{props.body}
63 |![](\"images/4ikhh.webp\"/)
",
4 | "answers": [0],
5 | "options": ["512", "36", "18432", "9"]
6 | },
7 | {
8 | "question": "Hvilken påstand er ikke korrekt for Instruksjonssetarkitektur (ISA).",
9 | "answers": [2],
10 | "options": [
11 | "Første nivå tilgjengelig for (ekspert-)brukere.",
12 | "Grense mellom maskinvare og programvare.",
13 | "Grense mellom mikroarkitekturnivå og digitaltlogisknivå.",
14 | "Opprinnelig det eneste nivået."
15 | ]
16 | },
17 | {
18 | "question": "Hva er skissert i Figur 4?\n![](\"images/mola09.webp\"/)
",
19 | "answers": [2],
20 | "options": [
21 | "Dynamisk RAM-celle.",
22 | "Halvadder.",
23 | "Statisk RAM-celle.",
24 | "Multiplekser."
25 | ]
26 | },
27 | {
28 | "question": "Hvilken påstand for mikrokontrollersystemet i Figur 5 er korrekt?\n![](\"images/cl1fqt.webp\"/)
",
29 | "answers": [1],
30 | "options": [
31 | "Prosessoren adresserer 28 minnelokasjoner.",
32 | "Systemet har multiplekset adresse- og databuss.",
33 | "Det er et system uten databuss.",
34 | "Det er et system med kun seriebuss."
35 | ]
36 | },
37 | {
38 | "question": "Under følger en rekke påstander om datamaskinkomponenter. Hvilken påstand er korrekt?",
39 | "answers": [1],
40 | "options": [
41 | "Superscalare prosessorer må være RISC-maskiner.",
42 | "Ved å innføre Superscalaritet øker ILP.",
43 | "PROM er en type dynamisk minne.",
44 | "EEPROM er en type dynamisk minne."
45 | ]
46 | }
47 | ]
48 |
--------------------------------------------------------------------------------
/src/containers/Result/index.tsx:
--------------------------------------------------------------------------------
1 | import { useParams } from "react-router";
2 |
3 | import { formatPercentage, percentageToGrade, COLORS } from "../../utils";
4 | import { Kitem } from "../../components";
5 | import { useHistory } from "../../hooks/contexts";
6 | import ResultButton from "../../components/Buttons/ResultButton";
7 | import { HistoryEntry } from "../../interfaces";
8 |
9 | import styles from "./Result.module.css";
10 |
11 | function Result() {
12 | const { school, course, exam, number } = useParams();
13 |
14 | const [history] = useHistory();
15 |
16 | const score = history.filter((q: HistoryEntry) => q.wasCorrect).length;
17 | const percentage = formatPercentage(score, history.length);
18 | const grade = percentageToGrade(percentage);
19 |
20 | const colorFromUser = COLORS[grade];
21 |
22 | if (!school || !course || !exam) {
23 | return null;
24 | }
25 |
26 | return (
27 |
28 |
52 | );
53 | }
54 |
55 | export const Component = Result;
56 |
--------------------------------------------------------------------------------
/src/api/index.ts:
--------------------------------------------------------------------------------
1 | import { Question } from "../interfaces";
2 |
3 | import examIndex from "../exams.json";
4 |
5 | async function getExam(
6 | school: string,
7 | course: string,
8 | examName: string,
9 | ): PromiseYour results
29 |
30 |
42 |
43 |
31 |
33 |
34 |
35 |
37 |
38 |
39 |
41 |
44 |
47 | Try again
48 |
49 | Try another
50 |
51 | ![](\"images/rhth3d.webp\"/)
",
4 | "answers": [0],
5 | "options": [
6 | "Adressa til neste mikroinstruksjon i control store.",
7 | "Inneheld kun gyldig adresse viss det skal gjerast eit betinga hopp, aktivt J-bit.",
8 | "Til ei kvar tid ein kopi av innhaldet i MBR.",
9 | "Control store start- og sluttadresse for aktiv mikroinstruksjon."
10 | ]
11 | },
12 | {
13 | "question": "Kva påstand er korrekt for ein ein-brikke mulitiprosessorer (CMP)?",
14 | "answers": [2],
15 | "options": [
16 | "Er ein \"Array computer\".",
17 | "Er type SIMD.",
18 | "Er av type homogen eller heterogen.",
19 | "Er av type MIMD og nyttar alltid ein \"crossbar\" for kommunikasjon mellom prosessorkjernane."
20 | ]
21 | },
22 | {
23 | "question": "Kva er skissert i figur 3?\n![](\"images/6vh8m.webp\"/)
",
24 | "answers": [0],
25 | "options": [
26 | "Fulladder.",
27 | "Halvadder.",
28 | "Statisk RAM-celle.",
29 | "Multipleksar."
30 | ]
31 | },
32 | {
33 | "question": "Korleis er einingane i figur 4 prioritert? Nivå 1 (level 1 er prioritert\nover nivå 2 (level 2). Rekkefølgja er gitt frå høgaste til lågaste.\n![](\"images/0xvaj.webp\"/)
",
34 | "answers": [1],
35 | "options": ["1, 2, 3, 4", "2, 3, 1, 4.", "1, 4, 2, 3.", "3, 2, 4, 1."]
36 | },
37 | {
38 | "question": "Under følgjer ei rekke påstandar om datamaskinkomponentar. Kva påstand er korrekt?",
39 | "answers": [1],
40 | "options": [
41 | "Asynkron bussoverføring må nytte ei global klokke.",
42 | "Ein ALU som kan utføre addisjon og invertere kan utføre subtraksjon.",
43 | "EPROM og flash-minne har ekvivalent funksjonalitet.",
44 | "EEPROM og flash-minne har ekvivalent funksjonalitet."
45 | ]
46 | }
47 | ]
48 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4117/2007 Vår.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Fargehistogrammer er ikke nyttig for gjenfinning av videosnutter.",
4 | "answers": [1],
5 | "options": ["Rett", "Galt"]
6 | },
7 | {
8 | "question": "«E-measure» kan sees som en generalisering av «Harmonic Means».",
9 | "answers": [0],
10 | "options": ["Rett", "Galt"]
11 | },
12 | {
13 | "question": "Søkemotorer med «Harvest»-arkitektur er en variant av sentralisert web-søkemotorarkitektur.",
14 | "answers": [1],
15 | "options": ["Rett", "Galt"]
16 | },
17 | {
18 | "question": "Thesaurus er et verktøy til å forbedre spørringer og brukes ofte i forbindelse med «automatic local analysis».",
19 | "answers": [0],
20 | "options": ["Rett", "Galt"]
21 | },
22 | {
23 | "question": "«Gatherer» brukes som en «crawler» i distribuerte web-søkemotorer.",
24 | "answers": [0],
25 | "options": ["Rett", "Galt"]
26 | },
27 | {
28 | "question": "Bilde-features kan ikke brukes i videogjenfinningsprosesser.",
29 | "answers": [1],
30 | "options": ["Rett", "Galt"]
31 | },
32 | {
33 | "question": "En SQL-database er godt egnet til innholdsbasert bildegjenfinning (content-based image retrieval).",
34 | "answers": [1],
35 | "options": ["Rett", "Galt"]
36 | },
37 | {
38 | "question": "Entropi er et konsept som brukes ofte til å karakterisere innholdet i informasjon.",
39 | "answers": [0],
40 | "options": ["Rett", "Galt"]
41 | },
42 | {
43 | "question": "I en Ordbokbasert (Dictionary-based) metode oppnås komprimering ved å bytte grupper av etterfølgende symboler (eller fraser) med peker til et innslag i ordboka.",
44 | "answers": [0],
45 | "options": ["Rett", "Galt"]
46 | },
47 | {
48 | "question": "Micon er en viktig feature for bilder og brukes i bildegjenfinning, og kan sees som en analogi av r-frames innen videogjenfinning.",
49 | "answers": [1],
50 | "options": ["Rett", "Galt"]
51 | }
52 | ]
53 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4117/2009 Vår.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Piksel-til-piksel-sammenligning av to bilder er godt egnet til å beregne/evaluere bildenes likheter.",
4 | "answers": [1],
5 | "options": ["Rett", "Galt"]
6 | },
7 | {
8 | "question": "To lydfiler kan sammenlignes ved å bruke frekvensspektrene til lydene.",
9 | "answers": [0],
10 | "options": ["Rett", "Galt"]
11 | },
12 | {
13 | "question": "R-frame og R-precision er to mål som brukes i evaluering av søkesystemer.",
14 | "answers": [1],
15 | "options": ["Rett", "Galt"]
16 | },
17 | {
18 | "question": "Statistisk Thesaurus er et thesaurus som brukes til å forbedre søk eller utvidelse av spørringer når man tar i bruk «local automatic analysis».",
19 | "answers": [1],
20 | "options": ["Rett", "Galt"]
21 | },
22 | {
23 | "question": "Harvest og Crawler har samme funksjon, men brukes i to forskjellige web-søkemotorarkitekturer.",
24 | "answers": [0],
25 | "options": ["Rett", "Galt"]
26 | },
27 | {
28 | "question": "Videoinformasjon kan ikke gjenfinnes ved hjelp av gjenfinningsmetoder som er laget for bilder og lyd.",
29 | "answers": [1],
30 | "options": ["Rett", "Galt"]
31 | },
32 | {
33 | "question": "Rangering av resultater i vektorbaserte og sannsynlighetsbaserte søkesystemer bruker samme prinsipp.",
34 | "answers": [1],
35 | "options": ["Rett", "Galt"]
36 | },
37 | {
38 | "question": "Audiogjenfinningssystemer kan bruke teknikker kjent fra tekstgjenfinningsystemer.",
39 | "answers": [0],
40 | "options": ["Rett", "Galt"]
41 | },
42 | {
43 | "question": "Bevegelsesinformasjon er ganske nyttig som feature til videogjenfinning.",
44 | "answers": [0],
45 | "options": ["Rett", "Galt"]
46 | },
47 | {
48 | "question": "Bildehistogram kan brukes til å gjenfinne bilder. I tillegg kan det brukes i videogjenfinning.",
49 | "answers": [0],
50 | "options": ["Rett", "Galt"]
51 | }
52 | ]
53 |
--------------------------------------------------------------------------------
/vite.config.ts:
--------------------------------------------------------------------------------
1 | import { defineConfig } from "vite";
2 | import react from "@vitejs/plugin-react-swc";
3 | import { VitePWA } from "vite-plugin-pwa";
4 |
5 | // https://vitejs.dev/config/
6 | export default defineConfig({
7 | plugins: [
8 | react(),
9 | VitePWA({
10 | registerType: "autoUpdate",
11 | devOptions: {
12 | enabled: true,
13 | },
14 | includeAssets: ["**"],
15 | manifest: {
16 | name: "Kramster!",
17 | short_name: "Kramster!",
18 | start_url: "/",
19 | display: "standalone",
20 | background_color: "#ecf0f1",
21 | theme_color: "#ecf0f1",
22 | description: "Cram for your exam with Kramster!",
23 | orientation: "portrait",
24 | lang: "no",
25 | icons: [
26 | {
27 | src: "icons/icon-72x72.png",
28 | sizes: "72x72",
29 | type: "image/png",
30 | },
31 | {
32 | src: "icons/icon-96x96.png",
33 | sizes: "96x96",
34 | type: "image/png",
35 | },
36 | {
37 | src: "icons/icon-128x128.png",
38 | sizes: "128x128",
39 | type: "image/png",
40 | },
41 | {
42 | src: "icons/icon-144x144.png",
43 | sizes: "144x144",
44 | type: "image/png",
45 | },
46 | {
47 | src: "icons/icon-152x152.png",
48 | sizes: "152x152",
49 | type: "image/png",
50 | },
51 | {
52 | src: "icons/icon-192x192.png",
53 | sizes: "192x192",
54 | type: "image/png",
55 | },
56 | {
57 | src: "icons/icon-384x384.png",
58 | sizes: "384x384",
59 | type: "image/png",
60 | },
61 | {
62 | src: "icons/icon-512x512.png",
63 | sizes: "512x512",
64 | type: "image/png",
65 | },
66 | ],
67 | },
68 | }),
69 | ],
70 | });
71 |
--------------------------------------------------------------------------------
/src/courses.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "code": "bev1012",
4 | "school": "ntnu",
5 | "name": "Forskningsmetoder i bevegelsesvitenskap"
6 | },
7 | {
8 | "code": "bi1001",
9 | "school": "ntnu",
10 | "name": "Celle- og molekylærbiologi"
11 | },
12 | {
13 | "code": "hls0001",
14 | "school": "ntnu",
15 | "name": "Helsepsykologi og helsefremming"
16 | },
17 | {
18 | "code": "mfel1010",
19 | "school": "ntnu",
20 | "name": "Medisin for ikke-medisinere"
21 | },
22 | {
23 | "code": "mfel1050",
24 | "school": "ntnu",
25 | "name": "Innføring i idrettsfysiologi"
26 | },
27 | {
28 | "code": "mfel3010",
29 | "school": "ntnu",
30 | "name": "Medicine for Students of Natural Sciences and Technology"
31 | },
32 | {
33 | "code": "syba1010",
34 | "school": "oslomet",
35 | "name": "Anatomi, fysiologi og biokjemi"
36 | },
37 | {
38 | "code": "tdt4110",
39 | "school": "ntnu",
40 | "name": "Informasjonsteknologi Grunnkurs"
41 | },
42 | {
43 | "code": "tdt4117",
44 | "school": "ntnu",
45 | "name": "Informasjonsgjenfinning"
46 | },
47 | {
48 | "code": "tdt4136",
49 | "school": "ntnu",
50 | "name": "Introduction to Artificial Intelligence"
51 | },
52 | {
53 | "code": "tdt4160",
54 | "school": "ntnu",
55 | "name": "Datamaskiner grunnkurs"
56 | },
57 | {
58 | "code": "tdt4171",
59 | "school": "ntnu",
60 | "name": "Artificial Intelligence Methods"
61 | },
62 | {
63 | "code": "tdt4240",
64 | "school": "ntnu",
65 | "name": "Software Architecture"
66 | },
67 | {
68 | "code": "tfy4125",
69 | "school": "ntnu",
70 | "name": "Fysikk"
71 | },
72 | {
73 | "code": "tiø4258",
74 | "school": "ntnu",
75 | "name": "Teknologiledelse"
76 | },
77 | {
78 | "code": "ttm4100",
79 | "school": "ntnu",
80 | "name": "Communication Services and Networks"
81 | },
82 | {
83 | "code": "ttm4137",
84 | "school": "ntnu",
85 | "name": "Wireless Security"
86 | }
87 | ]
88 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4117/2013 Høst.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "«F-measure» eller «Harmonic Means» er en god måte å kombinere precision og recall på.",
4 | "answers": [0],
5 | "options": ["Rett", "Galt"]
6 | },
7 | {
8 | "question": "Thesaurus er et verktøy til å utvide spørringer og brukes ofte i forbindelse med «automatic global analysis».",
9 | "answers": [0],
10 | "options": ["Rett", "Galt"]
11 | },
12 | {
13 | "question": "«Signature Files» er en metode for å signere et informasjonsgjenfinningsdokument på.",
14 | "answers": [1],
15 | "options": ["Rett", "Galt"]
16 | },
17 | {
18 | "question": "Multimedia-informasjonsgjenfinning er ofte enklere enn tekstgjenfinning, da man ikke trenger å utføre tekstoperasjoner.",
19 | "answers": [1],
20 | "options": ["Rett", "Galt"]
21 | },
22 | {
23 | "question": "Micon er en viktig feature for bilder og brukes i bildegjenfinning, og kan sees på som en analogi av r-frames innen videogjenfinning.",
24 | "answers": [1],
25 | "options": ["Rett", "Galt"]
26 | },
27 | {
28 | "question": "User Relevance Feedback (URF) er ofte brukt til å redefinere spørringer slik at man får økt søkehastighet.",
29 | "answers": [1],
30 | "options": ["Rett", "Galt"]
31 | },
32 | {
33 | "question": "R-Precision er en forkortelse for Recall-Precision.",
34 | "answers": [1],
35 | "options": ["Rett", "Galt"]
36 | },
37 | {
38 | "question": "MRR (Mean Reciprocal Rank) er veldig godt egnet til å evaluere systemer der man er mest opptatt av å finne relevante resultater i en topp-k (f.eks. topp-10) resultatliste.",
39 | "answers": [0],
40 | "options": ["Rett", "Galt"]
41 | },
42 | {
43 | "question": "«Vocabulary Trie» og «Suffix Trie» er to begrep som beskriver samme indekseringsmetode.",
44 | "answers": [1],
45 | "options": ["Rett", "Galt"]
46 | },
47 | {
48 | "question": "Fjerning av stoppord kan ha negative påvirkninger på Recall.",
49 | "answers": [0],
50 | "options": ["Rett", "Galt"]
51 | }
52 | ]
53 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 05: Influences.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "How can an architecture affect business goals of a system?",
4 | "answers": [0, 2],
5 | "options": [
6 | "Add value",
7 | "Support cloud computing",
8 | "Faster to market",
9 | "Less system crash"
10 | ]
11 | },
12 | {
13 | "question": "What are the main influences of the stakeholders related to software architectures?",
14 | "answers": [0, 2, 3],
15 | "options": ["Business", "Frameworks", "Project", "Technical"]
16 | },
17 | {
18 | "question": "What influences the architect's regarding the SWA according to the text book?",
19 | "answers": [1, 3],
20 | "options": [
21 | "Software process",
22 | "Stakeholders",
23 | "Programming language",
24 | "Professional background"
25 | ]
26 | },
27 | {
28 | "question": "How can the architecture influence the technical context?",
29 | "answers": [0, 3],
30 | "options": [
31 | "Affect the next system",
32 | "Help the project manager",
33 | "Provide rules for coding",
34 | "Result in a better system"
35 | ]
36 | },
37 | {
38 | "question": "How can the architecture influence the project context?",
39 | "answers": [3],
40 | "options": [
41 | "Increase architect's knowledge",
42 | "Make system faster",
43 | "Shorter time to market",
44 | "Structure the dev organization"
45 | ]
46 | },
47 | {
48 | "question": "How can the architecture influence the business context?",
49 | "answers": [0, 3],
50 | "options": [
51 | "Efficient production",
52 | "Form teams",
53 | "Prescribe what to implement",
54 | "Take market share"
55 | ]
56 | },
57 | {
58 | "question": "How can the architecture influence the professional context?",
59 | "answers": [2, 3],
60 | "options": [
61 | "Affect stakeholders reqs",
62 | "Affect business goals",
63 | "Improve experience",
64 | "Learn patterns"
65 | ]
66 | }
67 | ]
68 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4136/2012 Fall.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Simple reflex agents often use situation-actions rules for their reasoning.",
4 | "answers": [0],
5 | "options": ["True", "False"]
6 | },
7 | {
8 | "question": "Simple reflex agents have an internal model of the current state of the world.",
9 | "answers": [1],
10 | "options": ["True", "False"]
11 | },
12 | {
13 | "question": "An agent's utility function is essentially internalization of the performance measure.",
14 | "answers": [0],
15 | "options": ["True", "False"]
16 | },
17 | {
18 | "question": "In order to be rational an agent should have a utility function.",
19 | "answers": [1],
20 | "options": ["True", "False"]
21 | },
22 | {
23 | "question": "In a learning agent the learning element is responsible for selecting the external action to be executed next.",
24 | "answers": [1],
25 | "options": ["True", "False"]
26 | },
27 | {
28 | "question": "Taxi driving happens in a stochastic, sequential, partially observable, and continuous environment.",
29 | "answers": [0],
30 | "options": ["True", "False"]
31 | },
32 | {
33 | "question": "Agents need an internal model to cope with partially observable environments.",
34 | "answers": [0],
35 | "options": ["True", "False"]
36 | },
37 | {
38 | "question": "An agent system has an agent function that selects the next action and a state transition function which computes what the next state of the environment would be when an action is executed.",
39 | "answers": [0],
40 | "options": ["True", "False"]
41 | },
42 | {
43 | "question": "The action selection in model based agents uses as input the currently sensed data as well as the internal representation of the environment.",
44 | "answers": [0],
45 | "options": ["True", "False"]
46 | },
47 | {
48 | "question": "In goal-based agents, rationality of the agents is measured based on the utility function.",
49 | "answers": [1],
50 | "options": ["True", "False"]
51 | }
52 | ]
53 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4160/Age of Computers: Primærlager.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Gitt følgende verdier: D1 = 0, D2 = 0, D3 = 1, D4 = 1, H1 = 1, H2 = 1, H3 = 0. Koden har også et ekstra bit, H4=0 (ikke vist på figuren), slik at koden kan brukes til å detektere dobbeltbitfeil. Hvilket utsagn er riktig?",
4 | "answers": [4],
5 | "options": [
6 | "Bit D1 er feil.",
7 | "Bit D2 er feil.",
8 | "Bit D3 er feil.",
9 | "Bit H3 er feil.",
10 | "Det finnes ingen korrigerbare enkeltbitfeil."
11 | ]
12 | },
13 | {
14 | "question": "Gitt følgende verdier: D1 = 1, D2 = 1, D3 = 1, D4 = 1, H1 = 0, H2 = 1, H3 = 0. Hvilket utsagn er da riktig?",
15 | "answers": [2],
16 | "options": [
17 | "Bit D1 er feil.",
18 | "Bit D2 er feil.",
19 | "Bit D3 er feil.",
20 | "Bit H3 er feil.",
21 | "Det finnes ingen korrigerbare enkeltbitfeil."
22 | ]
23 | },
24 | {
25 | "question": "Hva er fordelen ved å bruke Hamming-kode fremfor bruk av paritetsbit?",
26 | "answers": [4, 3],
27 | "options": [
28 | "Den er enklere å beregne",
29 | "Den kan brukes til å detektere enkeltbit-feil",
30 | "Ingen -Hamming-kode implementeres vha. paritetsbit",
31 | "Bedre sikkerhet mot uautorisert aksess",
32 | "Den kan brukes til å korrigere enkeltbit-feil",
33 | "Den er enklere å beregne.",
34 | "Den kan brukes til å detektere enkeltbit-feil.",
35 | "Bedre sikkerhet mot uautorisert aksess.",
36 | "Den kan brukes til å korrigere enkeltbit-feil."
37 | ]
38 | },
39 | {
40 | "question": "Hva er et paritetsbit?",
41 | "answers": [2],
42 | "options": [
43 | "Et bit man bruker for å bestemmer om tallet er et oddetall eller et partall. 0 for partall og 1 for odde.",
44 | "Et bit man bruker for å sjekke at innholdet er riktig i forholdt til om man skal ha et oddetall eller et partall. Metoden fungerer alltid.",
45 | "Et bit som man legger til en mengde bit slik at summen av bit-ene og paritets bit-et alltid blir partall eller alltid oddetall."
46 | ]
47 | }
48 | ]
49 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 23: Cloud.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Categorize the following characteristics: \"Single point of failure\"",
4 | "answers": [1],
5 | "options": ["Cloud", "Not cloud"]
6 | },
7 | {
8 | "question": "Categorize the following characteristics: \"Fixed Capacity\"",
9 | "answers": [1],
10 | "options": ["Cloud", "Not cloud"]
11 | },
12 | {
13 | "question": "Categorize the following characteristics: \"HDFS file system\"",
14 | "answers": [0],
15 | "options": ["Cloud", "Not cloud"]
16 | },
17 | {
18 | "question": "Categorize the following characteristics: \"Support multi-tenancy\"",
19 | "answers": [0],
20 | "options": ["Cloud", "Not cloud"]
21 | },
22 | {
23 | "question": "Categorize the following characteristics: \"Location dependent\"",
24 | "answers": [1],
25 | "options": ["Cloud", "Not cloud"]
26 | },
27 | {
28 | "question": "Categorize the following characteristics: \"FAT file system\"",
29 | "answers": [1],
30 | "options": ["Cloud", "Not cloud"]
31 | },
32 | {
33 | "question": "Categorize the following characteristics: \"Heterogeneous clients\"",
34 | "answers": [0],
35 | "options": ["Cloud", "Not cloud"]
36 | },
37 | {
38 | "question": "Categorize the following characteristics: \"Fixed IP-addresses\"",
39 | "answers": [1],
40 | "options": ["Cloud", "Not cloud"]
41 | },
42 | {
43 | "question": "Categorize the following characteristics: \"Improved utilization\"",
44 | "answers": [0],
45 | "options": ["Cloud", "Not cloud"]
46 | },
47 | {
48 | "question": "Categorize the following characteristics: \"Redundancy\"",
49 | "answers": [0],
50 | "options": ["Cloud", "Not cloud"]
51 | },
52 | {
53 | "question": "Categorize the following characteristics: \"Private hardware\"",
54 | "answers": [1],
55 | "options": ["Cloud", "Not cloud"]
56 | },
57 | {
58 | "question": "Categorize the following characteristics: \"Improved scalability\"",
59 | "answers": [0],
60 | "options": ["Cloud", "Not cloud"]
61 | }
62 | ]
63 |
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | ![](\"images/k7mc09.webp\"/)
",
14 | "answers": [3],
15 | "options": ["Allocation", "Component-and-Connector", "Fictive", "Modular"]
16 | },
17 | {
18 | "question": "What TYPE of architectural pattern can this be classified as? ![](\"images/7svst.webp\"/)
",
19 | "answers": [0],
20 | "options": ["Allocation", "Component-and-Connector", "Modular", "None"]
21 | },
22 | {
23 | "question": "What TYPE of architectural pattern can this be classified as? ![](\"images/w3wqr7.webp\"/)
",
24 | "answers": [1],
25 | "options": ["Allocation", "Component-and-Connector", "Modular", "None"]
26 | },
27 | {
28 | "question": "A well-designed architecture is usually a product of...",
29 | "answers": [1],
30 | "options": [
31 | "All stakeholders",
32 | "Few or one architect",
33 | "Many architects",
34 | "Interdisciplinary group"
35 | ]
36 | },
37 | {
38 | "question": "Important aspects to include to help the design of an architecture are...",
39 | "answers": [2],
40 | "options": [
41 | "Merge procedure/consume models",
42 | "Single view",
43 | "Multiple views",
44 | "Code standards"
45 | ]
46 | },
47 | {
48 | "question": "Important aspects to include to help the design of an architecture are...",
49 | "answers": [1, 2],
50 | "options": [
51 | "Design for specific hardware",
52 | "Information hiding",
53 | "Limit ways of interaction",
54 | "Design for a specific programming language"
55 | ]
56 | },
57 | {
58 | "question": "What are the main elements in the definition of software architecture?",
59 | "answers": [0, 1, 2, 3],
60 | "options": [
61 | "Set of strutures",
62 | "Software elements",
63 | "Relations",
64 | "Properties"
65 | ]
66 | }
67 | ]
68 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 12: Modeling and Analysis II.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "What are Quality Attribute Checklists used for?",
4 | "answers": [0, 1],
5 | "options": [
6 | "Auditing",
7 | "Checking requirements",
8 | "Modeling system",
9 | "Restrict coding"
10 | ]
11 | },
12 | {
13 | "question": "Quality attribute checklists have typically two types of requirements:",
14 | "answers": [1, 2],
15 | "options": [
16 | "Performance requirements",
17 | "Product requirements",
18 | "Process requirements",
19 | "Pretty good requirements"
20 | ]
21 | },
22 | {
23 | "question": "What is the purpose of checking software architecture thought experiments?",
24 | "answers": [0],
25 | "options": [
26 | "Analyze scenarios",
27 | "Choose patterns",
28 | "Find requirements",
29 | "Sketch design"
30 | ]
31 | },
32 | {
33 | "question": "How would you classify the Cost and Confidence of doing a Back-of-the-envelope analysis?",
34 | "answers": [0, 1],
35 | "options": ["Low, Low", "Low, Medium", "Medium, Medium", "Medium, High"]
36 | },
37 | {
38 | "question": "How would you classify the Cost and Confidence of doing a Checklist analysis?",
39 | "answers": [1],
40 | "options": ["Low, Low", "Low, Medium", "Medium, Medium", "Medium, High"]
41 | },
42 | {
43 | "question": "How would you classify the Cost and Confidence of doing a Simulation analysis?",
44 | "answers": [2],
45 | "options": ["Low, Low", "Low, Medium", "Medium, Medium", "Medium, High"]
46 | },
47 | {
48 | "question": "How would you classify the Cost and Confidence of doing a Analytic model analysis?",
49 | "answers": [1, 3],
50 | "options": ["Low, Low", "Low, Medium", "Medium, Low", "Medium, Medium"]
51 | },
52 | {
53 | "question": "How would you classify the Cost and Confidence of doing a Prototype analysis?",
54 | "answers": [1, 2],
55 | "options": ["Medium, Low", "Medium, Medium", "Medium, High", "High, High"]
56 | },
57 | {
58 | "question": "How would you classify the Cost and Confidence of doing an Experiment analysis?",
59 | "answers": [0, 1, 2, 3],
60 | "options": ["Medium, Medium", "Medium, High", "High, Medium", "High, High"]
61 | }
62 | ]
63 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 22: Edge.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "What is an Edge dominant system?",
4 | "answers": [1],
5 | "options": [
6 | "System depending on bleeding edge technology",
7 | "System that depends on users to succeed",
8 | "System that can find dominant edges in pixel-based images",
9 | "System that operates at the edge (outer bounds) of a network"
10 | ]
11 | },
12 | {
13 | "question": "Which of these are not a typical Edge dominant system?",
14 | "answers": [1, 3],
15 | "options": ["Facebook", "Microsoft Office", "Eclipse", "Netflix"]
16 | },
17 | {
18 | "question": "What is a Prosumer?",
19 | "answers": [0],
20 | "options": [
21 | "Both content consumer and producer",
22 | "Professional consumer",
23 | "Developer of core of an edge dominant system",
24 | "Man playing an accordion"
25 | ]
26 | },
27 | {
28 | "question": "Assumptions normally not ture in an Edge dominant system compared to traditional:",
29 | "answers": [0, 1, 2],
30 | "options": [
31 | "Requirements can be known in advance",
32 | "Software developed, tested & released in planned increments",
33 | "Projects have dedicated finite resources",
34 | "Users will contribute to the value of the system"
35 | ]
36 | },
37 | {
38 | "question": "What are some important requirements for the core of a Edge dominant system?",
39 | "answers": [0, 2],
40 | "options": [
41 | "Highly robust with respect to errors",
42 | "Developed by End Users",
43 | "Core provides services & quality attributes for periphery",
44 | "Developed by Prosumers"
45 | ]
46 | },
47 | {
48 | "question": "What are some implications of the Metropolis model?",
49 | "answers": [0, 3],
50 | "options": [
51 | "Indifference to development phases",
52 | "Requirements from interviewing users",
53 | "Indifference to crowd management",
54 | "Distributed testing"
55 | ]
56 | },
57 | {
58 | "question": "The software architecture of an Edge dominant system is divided into:",
59 | "answers": [1],
60 | "options": [
61 | "Users and Prosumers",
62 | "Core and Periphery",
63 | "Basic layer and User layer",
64 | "Developers and Prosumers"
65 | ]
66 | }
67 | ]
68 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 06: Requirements and Quality Attributes.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "System requirements can be categorized as:",
4 | "answers": [1, 2, 3],
5 | "options": [
6 | "Architectural tactics",
7 | "Constraints",
8 | "Functional requirements",
9 | "Quality attribute requirements"
10 | ]
11 | },
12 | {
13 | "question": "A quality attribute scenario is used to...",
14 | "answers": [1],
15 | "options": [
16 | "Describe quality assurance",
17 | "Describe quality requirements",
18 | "Describe quality system design",
19 | "Evaluate software architecture"
20 | ]
21 | },
22 | {
23 | "question": "Which part of a quality attribute scenario is used to specify how the system reacts?",
24 | "answers": [2],
25 | "options": ["Artefact", "Environment", "Response", "Response measure"]
26 | },
27 | {
28 | "question": "Which part of a quality attribute scenario is used to specify the state of the system?",
29 | "answers": [1],
30 | "options": ["Artefact", "Environment", "Source of stimulus", "Stimulus"]
31 | },
32 | {
33 | "question": "Which part of a quality attribute scenario specifies the part of the system being affected?",
34 | "answers": [0],
35 | "options": [
36 | "Artefact",
37 | "Environment",
38 | "Response measure",
39 | "Source of stimulus"
40 | ]
41 | },
42 | {
43 | "question": "Tactics are in a software architecture context...",
44 | "answers": [3],
45 | "options": [
46 | "Architectural design process",
47 | "Architectural patterns",
48 | "Design patterns",
49 | "Primitive design techniques"
50 | ]
51 | },
52 | {
53 | "question": "Which category does the identification of important functionality and infrastructure belong to?",
54 | "answers": [0],
55 | "options": [
56 | "Allocation of responsibilities",
57 | "Binding time decisions",
58 | "Choice of technology",
59 | "Data model"
60 | ]
61 | },
62 | {
63 | "question": "Which category does the selection of data abstractions, operations and properties belong to?",
64 | "answers": [2],
65 | "options": [
66 | "Binding time decisions",
67 | "Coordination model",
68 | "Data model",
69 | "Mapping of resources"
70 | ]
71 | }
72 | ]
73 |
--------------------------------------------------------------------------------
/src/containers/Courses/index.tsx:
--------------------------------------------------------------------------------
1 | import { useNavigate, useParams } from "react-router";
2 |
3 | import { Kitem, LoadingSpinner } from "../../components";
4 | import styles from "./Courses.module.css";
5 |
6 | import courseIndex from "../../courses.json";
7 | import schoolIndex from "../../schools.json";
8 |
9 | function Courses() {
10 | const { school } = useParams();
11 | const navigate = useNavigate();
12 |
13 | if (!school) {
14 | return null;
15 | }
16 |
17 | const courses = courseIndex.filter(
18 | (course) => course.school === school.toLowerCase(),
19 | );
20 | const schoolData = schoolIndex.find(
21 | (s) => s.abbreviation.toLowerCase() === school,
22 | );
23 |
24 | if (!courses.length) {
25 | return
55 |
74 | );
75 | }
76 |
77 | export const Component = Courses;
78 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 14: Evaluation.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Which groups typically perform different forms of SWA evaluation?",
4 | "answers": [0, 1, 3],
5 | "options": ["External team", "Peers", "The customers", "The designers"]
6 | },
7 | {
8 | "question": "What are the recommendations regarding how much should be analyzed in a SWA evaluation?",
9 | "answers": [0, 1, 3],
10 | "options": [
11 | "Importance of decision",
12 | "Number of alternatives",
13 | "Ensure perfect analysis",
14 | "Ensure sufficient analysis"
15 | ]
16 | },
17 | {
18 | "question": "What is the starting point to drive a peer software architecture review?",
19 | "answers": [0],
20 | "options": [
21 | "Quality attribute scenarios",
22 | "The architectural tactics",
23 | "The software architecture",
24 | "The stakeholders"
25 | ]
26 | },
27 | {
28 | "question": "What primary reasons exist for doing a software architectural evaluation by outsiders?",
29 | "answers": [0, 3],
30 | "options": [
31 | "Get manager's approval",
32 | "Save money",
33 | "Save time",
34 | "Utilize specialized knowledge"
35 | ]
36 | },
37 | {
38 | "question": "What is the TA in ATAM an abbreviation for?",
39 | "answers": [3],
40 | "options": [
41 | "Testability Attributes",
42 | "Testability Analysis",
43 | "Traceability Analysis",
44 | "Tradeoff Analysis"
45 | ]
46 | },
47 | {
48 | "question": "What is the motivation for doing an ATAM evaluation?",
49 | "answers": [0, 2],
50 | "options": [
51 | "Assurance",
52 | "Faster design",
53 | "Find problems early",
54 | "Optimize algorithms"
55 | ]
56 | },
57 | {
58 | "question": "When should an architecture be evaluated?",
59 | "answers": [1, 2],
60 | "options": [
61 | "Before requirements",
62 | "Before arch fully specified",
63 | "For existing systems",
64 | "When starting a project"
65 | ]
66 | },
67 | {
68 | "question": "What questions do ATAM produce answers to?",
69 | "answers": [0, 2],
70 | "options": [
71 | "Is architecture suitable?",
72 | "Which architecture is best?",
73 | "Which of architectures are most suitable?",
74 | "Which architecture gives best cost/benefit?"
75 | ]
76 | }
77 | ]
78 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 20: Implementation and Testing.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Term: \"The implementation drifts away from the planned architecture to no longer be consistent\"",
4 | "answers": [1],
5 | "options": [
6 | "Architectural drift",
7 | "Architectural erosion",
8 | "Architectural potential",
9 | "Architectural view"
10 | ]
11 | },
12 | {
13 | "question": "What technique \"Using a reusable set of classes organized around a particular theme\"",
14 | "answers": [2],
15 | "options": [
16 | "Code templates",
17 | "Embedding the design in the code",
18 | "Frameworks",
19 | "Keeping code and architecture consistent"
20 | ]
21 | },
22 | {
23 | "question": "How can performance be tested in unit tests?",
24 | "answers": [3],
25 | "options": [
26 | "Assigning changes to test teams",
27 | "Injecting faults",
28 | "Test system full-scale with users",
29 | "Using synthetic loads"
30 | ]
31 | },
32 | {
33 | "question": "What technique \"Collection of code where the programmer provides application specific portions\"",
34 | "answers": [0],
35 | "options": [
36 | "Code templates",
37 | "Embedding the design in the code",
38 | "Frameworks",
39 | "Keeping code and architecture consistent"
40 | ]
41 | },
42 | {
43 | "question": "Integration tests can test....",
44 | "answers": [0, 1, 2, 3],
45 | "options": ["Availability", "Functionability", "Performance", "Security"]
46 | },
47 | {
48 | "question": "What technique \"Mark documentation as out of date when erosion occurs\"",
49 | "answers": [3],
50 | "options": [
51 | "Code templates",
52 | "Embedding the design in the code",
53 | "Frameworks",
54 | "Keeping code and architecture consistent"
55 | ]
56 | },
57 | {
58 | "question": "The architect should be involved in...",
59 | "answers": [0, 1, 2, 3],
60 | "options": [
61 | "Test Development",
62 | "Test Interpretation",
63 | "Test Harness Creation",
64 | "Test Planning"
65 | ]
66 | },
67 | {
68 | "question": "What technique? \"Architecture acts as a blueprint for implementation\"",
69 | "answers": [2],
70 | "options": [
71 | "Keeping code and architecture consistent",
72 | "Framework",
73 | "Embedding the design in the code",
74 | "Code templates"
75 | ]
76 | }
77 | ]
78 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4240/2015 Kahoot 13: 4+1 View Model.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "What are the keywords in the definition of software architecture in the textbook?",
4 | "answers": [0, 1, 2, 3],
5 | "options": [
6 | "Software components",
7 | "Properties",
8 | "Structures",
9 | "Relationships"
10 | ]
11 | },
12 | {
13 | "question": "A representation of a whole system from the perspective of a related set of concerns is called?",
14 | "answers": [3],
15 | "options": [
16 | "Architectural description",
17 | "Architectural pattern",
18 | "Software architecture",
19 | "Architectural view"
20 | ]
21 | },
22 | {
23 | "question": "What standard is used for software architectural documentation in this course?",
24 | "answers": [1],
25 | "options": ["ISO 900", "IEEE 1471", "IEEE 1990", "ARCH 1400"]
26 | },
27 | {
28 | "question": "What types of views are described in the textbook?",
29 | "answers": [0, 1, 3],
30 | "options": ["Allocation", "Component-and-Connector", "Dynamic", "Module"]
31 | },
32 | {
33 | "question": "What view mainly addresses the developers and the project managers?",
34 | "answers": [0],
35 | "options": ["Development", "Logical", "Process", "Physical"]
36 | },
37 | {
38 | "question": "What view is most relevant for the end user?",
39 | "answers": [1],
40 | "options": [
41 | "Developer view",
42 | "Logical view",
43 | "Process view",
44 | "Physical view"
45 | ]
46 | },
47 | {
48 | "question": "What view represents an abstraction of the most important requirements?",
49 | "answers": [3],
50 | "options": ["Development", "Logical", "Process", "Scenario"]
51 | },
52 | {
53 | "question": "In what view can ER-modelling typically be used?",
54 | "answers": [1],
55 | "options": ["Development", "Logical", "Physical", "Scenario"]
56 | },
57 | {
58 | "question": "What view has the main focus on non-functional requirements such as availability & scalability?",
59 | "answers": [2, 3],
60 | "options": [
61 | "Development view",
62 | "Logical view",
63 | "Process view",
64 | "Physical view"
65 | ]
66 | },
67 | {
68 | "question": "What characteristics should be identified when going from the logical to process view?",
69 | "answers": [0, 1, 2, 3],
70 | "options": ["Autonomy", "Distribution", "Persistance", "Subordination"]
71 | }
72 | ]
73 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4160/Age of Computers: Tallsystemer.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Anta tre flyttall , og . Anta at og . Da vil alltid være lik .",
4 | "answers": [1],
5 | "options": ["Sant", "Usant"]
6 | },
7 | {
8 | "question": "Hva er «sign and magnitude system»?",
9 | "answers": [1],
10 | "options": [
11 | "I dette systemet endrer man det mest signifikante bit-et fra en til null for å lage negative verdier.",
12 | "I dette systemet endrer man det mest signifikante bit-et fra null til en for å lage negative verdier.",
13 | "I dette systemet bruker man enerkomplement for å lage negative tall",
14 | "I dette systemet bruker man toerkomplement for å lage negative tall"
15 | ]
16 | },
17 | {
18 | "question": "Hva er underflyt (underflow) i forbindelse med flyttallsregning?",
19 | "answers": [3],
20 | "options": [
21 | "Det samme som normalisering",
22 | "At et tall er mindre enn 1",
23 | "En av avrundingsmetodene i IEEE754-standarden",
24 | "At et tall er for lite til å representeres",
25 | "Tap av bit i forbindelse med divisjon"
26 | ]
27 | },
28 | {
29 | "question": "Hvilken metode under er ikke en metode for å representere både negative og positive binære tall?",
30 | "answers": [2],
31 | "options": ["sign and magnitude", "toerkomplement", "treerkomplement"]
32 | },
33 | {
34 | "question": "Hvis du har ti fingre, hva er det meste du kan telle til i totallsystmet? (Holder du fingeren opp betyr det 1 og holder du fingen nede betyr det 0.)",
35 | "answers": [2],
36 | "options": ["32", "64", "1023", "1024"]
37 | },
38 | {
39 | "question": "Normalisering av flyttall",
40 | "answers": [1],
41 | "options": [
42 | "benyttes for å kunne representere større tall enn med ikke-normaliserte flyttall",
43 | "innebærer en standardisert justering av mantisse og eksponent for å oppnå maksimal utnyttelse av den presisjon som er mulig med det aktuelle flyttallsformat.",
44 | "innebærer å justere flyttallet slik at det mest signifikante bit i eksponenten alltid er lik verdien 1."
45 | ]
46 | }
47 | ]
48 |
--------------------------------------------------------------------------------
/public/data/oslomet/syba1010/Fordøyelsessystemet.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "Hvor har bukspytt og galle felles utførselsgang?",
4 | "answers": [0],
5 | "options": ["I duodenum", "I jejunum", "I ileum", "I coecum (cøkum)"]
6 | },
7 | {
8 | "question": "Enzymet amylase finnes i spytt og bukspytt. Hva spalter amylase?",
9 | "answers": [2],
10 | "options": [
11 | "Proteiner til aminosyrer",
12 | "Fett til fettsyrer",
13 | "Karbohydrater til korte sukkerkjeder",
14 | "Nukleinsyrer til nukleotider"
15 | ]
16 | },
17 | {
18 | "question": "Hvilket utsagn om sekresjon i ventrikkelen er riktig?",
19 | "answers": [0],
20 | "options": [
21 | "Parietalcellene skiller ut saltsyre som gir lav pH",
22 | "Parietalcellene skiller ut mucin",
23 | "Hovedcellene skiller ut lipase som gir lav pH",
24 | "Hovedcellene skiller ut bikarbonat (HCO3 – ) for å senke høy pH"
25 | ]
26 | },
27 | {
28 | "question": "Hvilket utsagn om fordøyelsesenzymer er riktig?",
29 | "answers": [2],
30 | "options": [
31 | "Lipase og amylase produseres i leveren",
32 | "Pepsin produseres i leveren",
33 | "Lipase, amylase og proteaser produseres i pankreas",
34 | "Pepsin produseres i pankreas"
35 | ]
36 | },
37 | {
38 | "question": "Hvilke deler består tynntarmen av?",
39 | "answers": [1],
40 | "options": [
41 | "Øsofagus og pylorus",
42 | "Duodenum, jejunum og ileum",
43 | "Cøkum, colon og sigmoideum",
44 | "Rektum og anus"
45 | ]
46 | },
47 | {
48 | "question": "Hvor skjer hovedsakelig absorbsjon av næringsstoffer?",
49 | "answers": [1],
50 | "options": ["I magesekken", "I tynntarmen", "I tykktarmen", "I endetarmen"]
51 | },
52 | {
53 | "question": "Hvor blir galle tømt ut i mage/tarm-kanalen?",
54 | "answers": [1],
55 | "options": ["I ventrikkelen", "I duodenum", "I jejunum", "I ileum"]
56 | },
57 | {
58 | "question": "Hvilket utsagn om enzymer som kan spalte næringsstoffer er riktig?",
59 | "answers": [2],
60 | "options": [
61 | "I leveren produseres enzymene lipase og amylase",
62 | "I leveren produseres enzymene sekretin og pepsin",
63 | "I bukspyttkjertelen produseres enzymene lipase og amylase",
64 | "I bukspyttkjertelen produseres enzymene sekretin og pepsin"
65 | ]
66 | },
67 | {
68 | "question": "Hva spaltes av enzymet amylase?",
69 | "answers": [1],
70 | "options": ["Lipider", "Karbohydrater", "Proteiner", "Nukleinsyrer"]
71 | }
72 | ]
73 |
--------------------------------------------------------------------------------
/public/data/ntnu/tdt4136/2016 Fall.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "question": "The formula would be treated as a validity.",
4 | "answers": [2],
5 | "options": [
6 | "Under all possible circumstances",
7 | "By an inference engine that implements occurs check as Skolem functions",
8 | "By an inference engine that implements occurs check as Skolem constants",
9 | "Under no possible circumstances"
10 | ]
11 | },
12 | {
13 | "question": "Universal Instantiation is built on Skolemization.",
14 | "answers": [1],
15 | "options": ["True", "False"]
16 | },
17 | {
18 | "question": "The Backward Chaining Algorithm can be described as follows:\n56 | {schoolData?.abbreviation} – {schoolData?.name} 57 |
58 |
59 | {courses.map(({ code, name }) => (
60 |
73 |
61 | {
67 | void navigate(`/${school}/${code}`, { viewTransition: true });
68 | }}
69 | />
70 |
71 | ))}
72 | - \n
- i. Pose the original query as a goal. \n
- ii. Find every clause in the knowledge base whose right-hand side unifies with the goal under some substitution. \n
- iii. Prove in turn every conjunct on the left-hand sides of each of these clauses, keeping track of the accumulated substitutions. \n
![](\"images/w6pe0e.webp\"/)
",
109 | "answers": [3],
110 | "options": [
111 | "Risk themes",
112 | "Sensitivity points",
113 | "Tradeoff points",
114 | "QA Utility Tree"
115 | ]
116 | },
117 | {
118 | "question": "What is this? ![](\"images/vaahds.webp\"/)
",
119 | "answers": [0],
120 | "options": [
121 | "Analysis of arch approaches",
122 | "Quality replication",
123 | "Risk theme list",
124 | "Sensitivity review"
125 | ]
126 | }
127 | ]
128 |
--------------------------------------------------------------------------------