Perangkat lunak sistem

Sebuah komputer memiliki banyak sumber daya (waktu CPU, memori, disk, I/O) dan banyak program yang bersaing untuk mendapatkannya. OS membaginya secara adil dan efisien agar setiap sumber digunakan dengan baik dan sistem tetap responsif:

• multi-tasking — beralihkan CPU dengan cepat antar proses sehingga beberapa tampak berjalan bersamaan.
• memory management — berikan setiap proses memori yang dibutuhkan; gunakan disk paging ketika RAM habis.
• spooling dan buffering — antrian pekerjaan print di disk agar CPU tidak pernah menunggu printer.
• caching — simpan data disk yang baru saja digunakan di cache / RAM.

Antarmuka pengguna menyembunyikan perangkat keras di balik abstraksi yang ramah: pengguna melihat jendela, menu, dan folder, bukan alamat atau sektor. Satu klik pada ikon membuat sistem operasi menemukan program di disk, mengalokasikan memori, memuatnya, dan menjalankannya. CLI (baris perintah) sangat kuat dan dapat diskriptkan untuk para ahli; GUI (grafis) lebih mudah dipelajari. Sebagian besar sistem menawarkan keduanya.

"Jelaskan dua cara bagaimana kompleksitas perangkat keras disembunyikan dari pengguna." (1) Pengguna bekerja dengan file dan folder berdasarkan nama, dan OS menerjemahkannya menjadi trek, sektor, dan blok disk; (2) pengguna menjalankan program dengan klik atau perintah, dan OS memuatnya, mengalokasikan memori, dan menjadwalkannya tanpa pengguna mengetahui alamat apa pun; (3) driver perangkat memungkinkan pengguna mencetak atau menyimpan tanpa harus tahu bagaimana printer atau disk dikendalikan; (4) antarmuka grafis menggantikan perintah tingkat mesin dengan ikon, jendela, dan menu. Manfaat bagi seorang siswa, beserta contohnya: OS membuat perangkat keras dapat digunakan tanpa pengetahuan teknis, misalnya menyimpan dokumen ke flashdisk dengan menyeret ikonnya.

"Tunjukkan bagaimana OS memaksimalkan penggunaan sumber daya." OS menjadwalkan prosesor agar tidak pernah menganggur selama ada proses yang siap; OS mengelola memori, mengalokasikannya ke proses, merebutnya kembali, dan memperluasnya dengan memori virtual; OS mengelola input dan output, menggunakan buffer dan spooling agar perangkat cepat dan lambat dapat saling menumpuk pekerjaannya; serta OS mengelola penyimpanan, melacak ruang kosong dan file. Setiap poin menyebutkan satu sumber daya dan apa yang dilakukan OS terhadapnya.

Sebuah proses adalah program yang sedang dieksekusi — kode, keadaan saat ini, memori, dan file yang terbuka.

Penjadwalan

Penjadwal memilih proses mana yang siap akan dijalankan selanjutnya, dan selama berapa lama:

• round robin — setiap proses mendapat time slice tetap, lalu berpindah ke belakang antrean.
• first-come-first-served; shortest job first; shortest remaining time (jalankan pekerjaan dengan sisa kerja paling sedikit); prioritas; antrean umpan balik bertingkat.

Trade-off-nya adalah responsivitas vs throughput vs keadilan.

"Jelaskan makna multitasking dan manfaatnya bagi manajemen proses." Beberapa proses disimpan dalam memori secara bersamaan dan prosesor beralih di antara mereka dengan sangat cepat sehingga tampak berjalan bersamaan, masing-masing diberi bagian waktu prosesor secara bergiliran. Manfaatnya: prosesor tidak pernah dibiarkan menganggur saat satu proses menunggu input atau output, sehingga throughput meningkat dan pengguna dapat bekerja pada beberapa program sekaligus. "Jelaskan kebutuhan akan penjadwalan." Ada lebih banyak proses daripada prosesor, sehingga keputusan harus dibuat tentang proses mana yang akan dijalankan selanjutnya dan selama berapa lama; penjadwalan memastikan setiap proses berlangsung maju, bahwa prosesor digunakan sepenuhnya, bahwa waktu respons dapat diterima, dan bahwa prioritas dapat dihormati.

Rutin penjadwalan, sebagaimana diminta dalam ujian.

Contoh pengerjaan. Tiga proses tiba bersamaan dengan waktu CPU 8, 4, dan 2 ms. Bandingkan waktu tunggu rata-rata di bawah FCFS (sesuai urutan kedatangan A, B, C) dan shortest job first.

FCFS: A menunggu 0, B menunggu 8, C menunggu 12; rata-rata $(0 + 8 + 12)/3 = 6.7\ \text{ms}$. SJF menjalankan C, B, A: C menunggu 0, B menunggu 2, A menunggu 6; rata-rata $2.7\ \text{ms}$. Total pekerjaan sama yaitu 14 ms baik cara mana pun; urutan menentukan siapa yang menunggu. Round robin dengan time slice 2 ms akan memberikan giliran kepada A, B, dan C masing-masing dalam 6 ms pertama, sehingga C selesai pada 6 ms, B pada 12 ms, dan A pada 14 ms: paling responsif, bukan tercepat secara rata-rata.

Keadaan proses

Suatu proses dapat berada dalam status baru, siap (menunggu CPU), berjalan, terblokir (menunggu I/O atau kunci), atau selesai. Ketika time slice-nya berakhir, proses tersebut berubah dari berjalan → siap; ketika ia meminta I/O, berubah dari berjalan → terblokir; dan ketika I/O selesai, berubah dari terblokir → siap.

Tiga status dan alasan perpindahan proses. Berjalan: proses memiliki prosesor. Siap: proses bisa berjalan tetapi menunggu prosesor. Terblokir: proses tidak bisa berjalan sampai hal lain terjadi. Alasan untuk setiap transisi, yang diuji satu per satu: berjalan ke siap ketika time slice-nya habis, atau ketika proses dengan prioritas lebih tinggi menjadi siap dan melakukan preempsi (sebuah interrupt); berjalan ke terblokir ketika ia meminta input atau output atau menunggu sumber daya atau proses lain; terblokir ke siap ketika I/O yang ditunggunya selesai (ditandai oleh interrupt); siap ke berjalan ketika scheduler melancearkannya. Proses yang terblokir tidak pernah bisa langsung berjalan: harus menjadi siap terlebih dahulu.

Blok kontrol proses dan pergantian konteks

Untuk setiap proses, OS menyimpan blok kontrol proses (PCB) — program counter yang tersimpan, register, status, dan info memori.

• sebuah pergantian konteks menunda satu proses dan memulai yang lain: ia menyimpan status ke satu PCB dan memulihkannya dari yang lain. Biaya kecil ini dibayarkan pada setiap pergantian.
• kernel (inti OS) bertindak sebagai handler interrupt. Ketika perangkat atau timer memicu interrupt, penanganan interrupt menyimpan proses yang sedang berjalan dan menjalankan routine yang tepat — inilah yang menggerakkan penjadwalan tingkat rendah.

"Jelaskan bagaimana kernel bertindak sebagai handler interrupt (dua nilai)." Ketika interrupt dipicu, kernel menyimpan status proses yang berjalan (register dan program counter-nya, di blok kontrol proses), mengidentifikasi sumber dan prioritas interrupt, menjalankan routine layanan interrupt yang sesuai, lalu memulihkan proses yang terinterupsi (atau yang berprioritas lebih tinggi) agar eksekusi berlanjut. Inilah cara timer mengakhiri time slice dan cara operasi I/O yang selesai membuka blokir pada proses.

Komunikasi antar-proses

Proses terisolasi, sehingga OS menyediakan komunikasi antar-proses: pipa (output satu program masuk ke input program lain), memori bersama (area yang bisa digunakan beberapa proses), dan pengiriman pesan.

Setiap proses mendapat ruang alamat virtual sendiri — rentang alamat bersih dan kontigu yang dipetakan OS ke memori fisik. Ini memberikan ruang sederhana bagi setiap proses, melindungi proses dari saling mengganggu, dan memungkinkan total memori melebihi RAM fisik.

Dalam paging, ruang virtual dibagi menjadi halaman berukuran tetap dan memori fisik menjadi bingkai berukuran sama. Tabel halaman memetakan setiap halaman ke bingkai. Jika halaman yang diakses tidak ada di RAM — sebuah kesalahan halaman — OS membacanya dari file swap ke bingkai, menggantikan halaman lain jika RAM penuh. Kesalahan yang sering menyebabkan thrashing (thrashing disk), di mana OS menghabiskan sebagian besar waktunya menukar halaman alih-alih melakukan pekerjaan berguna.

Dalam segmentasi, memori dibagi menjadi segmen logis berukuran variabel (kode, tumpukan, tumpukan data), masing-masing dengan izin sendiri. Banyak sistem menggunakan paging di dalam segmen.

"Jelaskan arti memori virtual (tiga nilai)." Penyimpanan sekunder (disk) digunakan untuk memperluas RAM, sehingga memori yang tersedia tampak lebih besar dari memori fisik; ruang alamat proses dibagi menjadi halaman, dan hanya halaman yang saat ini dibutuhkan yang disimpan di RAM sementara sisanya menunggu di disk; halaman ditukar antara RAM dan disk sesuai kebutuhan, dan OS menerjemahkan setiap alamat virtual menjadi alamat fisik. Mengapa OS membutuhkannya: program yang berjalan mungkin membutuhkan lebih banyak memori daripada RAM yang terpasang; memungkinkan lebih banyak (atau lebih besar) program berjalan bersamaan; program bisa lebih besar dari memori fisik; memori digunakan secara efisien karena hanya bagian aktif dari program yang menempati RAM.

Paging dibandingkan segmentasi: perbedaan yang ingin diuji. Paging membagi memori menjadi blok berukuran tetap (halaman dan bingkai) yang dipilih oleh hardware, tanpa memperhatikan struktur program, dan pemetaannya tak terlihat oleh programmer; segmentasi membagi program menjadi unit logis berukuran variabel (prosedur, array, tumpukan) yang ukuran dan batasnya mengikuti program, sehingga segmen bisa dilindungi atau dibagikan sebagai satu kesatuan. "Jelaskan proses segmentasi: program dibagi menjadi segmen dengan ukuran berbeda, masing-masing diberi nomor segmen; tabel segmen mencatat di mana setiap segmen dimulai dalam memori dan berapa lamanya; alamat logis adalah nomor segmen ditambah offset, dan OS menambahkan offset ke alamat dasar segmen untuk menemukan lokasi fisik.

"Jelaskan apa yang dimaksud dengan thrashing disk" dan kapan hal itu terjadi. Thrashing disk adalah kondisi di mana halaman-halaman dipindah masuk dan keluar dari RAM terlalu sering sehingga pemroses menghabiskan lebih banyak waktu untuk memindahkan halaman daripada mengeksekusi instruksi, dan sistem melambat hampir hingga berhenti. Hal ini terjadi ketika RAM terlalu kecil untuk halaman-halaman yang dibutuhkan proses yang sedang berjalan (set kerja mereka): halaman yang baru saja dipindahkan keluar dibutuhkan lagi hampir seketika, sehingga diambil kembali, yang mendorong keluar halaman lain yang segera dibutuhkan, dan seterusnya. Terlalu banyak proses, atau program yang mengakses memori secara tidak terprediksi, menyebabinya; penambahan RAM atau pengurangan proses dapat mengatasinya.

Sebuah interpreter menerjemahkan dan menjalankan sumbernya secara bersamaan. Untuk setiap pernyataan, ia membaca baris, melakukan analisis leksikal dan sintaks, memeriksa tipe, lalu mengeksekusi aksi tersebut, dan beralih ke berikutnya. Error dilaporkan segera dan biasanya berhenti; tidak ada file eksekusi yang dihasilkan. Penerjemahan dilakukan ulang setiap kali dijalankan (lebih lambat), tetapi memberikan umpan balik pengembangan yang cepat dan bersifat portabel.

"Jelaskan bagaimana interpreter mengeksekusi program tanpa menghasilkan versi terjemahan" (tiga poin). Interpreter mengambil satu pernyataan (baris) pada satu waktu, menerjemahkan (menganalisis)nya, dan mengeksekusinya segera, sebelum beralih ke berikutnya; tidak ada versi terjemahan dari seluruh program yang dibuat atau disimpan, sehingga setiap pernyataan diterjemahkan setiap kali dieksekusi, termasuk setiap kali melalui sebuah loop; jika suatu pernyataan mengandung error, eksekusi berhenti di sana dan error tersebut dilaporkan. Inilah yang membuat interpreter baik untuk pengembangan dan pengujian (error ditemukan saat mencapai titik tersebut, dan perubahan dapat dicoba segera) tetapi lebih lambat untuk menjalankan program yang sudah selesai.

Sebuah compiler mengubah sumber menjadi kode mesin dalam fase-fase:

1. analisis leksikal — lexer mengelompokkan karakter menjadi token (kata kunci, identifikasi, operator, literal), membuang spasi putih dan komentar.
2. analisis sintaks (parsing) — periksa apakah token sesuai dengan tata bahasa dan bangun pohon sintaks abstrak. Kurung yang hilang menyebabkan kesalahan sintaks.
3. analisis semantik — periksa apakah program memiliki makna (variabel dideklarasikan, tipe cocok).
4. generasi kode — jelajahi pohon dan hasilkan kode target, memilih register dan tata letak.
5. optimisasi kode — hilangkan pekerjaan redundan, lipat konstanta, urai ulang untuk pipeline.

Outputnya adalah file yang dapat dieksekusi.

Tujuan dari setiap tahap, menggunakan kata-kata yang bernilai skor. Analisis leksikal: menghapus spasi putih dan komentar; mengonversi karakter kode sumber menjadi token (kata kunci, identifikasi, operator, konstanta), memeriksa bahwa setiap token valid dalam bahasa tersebut; memasukkan identifikasi ke dalam tabel simbol. Analisis sintaks: memeriksa apakah urutan token mematuhi tata bahasa (aturan sintaks) bahasa tersebut; membangun pohon parsing (pohon sintaks abstrak); melaporkan kesalahan sintaks; pemeriksaan tipe dan pemeriksaan deklarasivariabel terkadang dihitung di sini sebagai analisis semantik. Generasi kode: mengonversi pohon yang telah diperiksa menjadi kode objek atau kode mesin (mungkin melalui kode perantara), mengalokasikan memori dan register. Optimisasi: membuat kode berjalan lebih cepat atau menggunakan memori lebih sedikit, dengan menghapus instruksi redundan, menggabungkan atau menyederhanakan perhitungan, dan mengatur ulang loop, tanpa mengubah apa yang dilakukan program. Pertanyaan menjodohkan mencocokkan setiap tahap dengan salah satu deskripsi ini.

Sebuah tata bahasa menyatakan urutan token mana yang merupakan program valid.

Backus-Naur Form- (BNF) bersifat teksual. Sebuah aturan produksi memiliki bentuk:

<symbol> ::= alternative1 | alternative2 | ...

Setiap alternatif adalah urutan simbol terminal (teks literal) dan simbol non-terminal (nama aturan lain):

<digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<identifier> ::= <letter> | <identifier> <letter> | <identifier> <digit>

Aturan rekursif ketiga mengungkapkan "sebuah huruf diikuti oleh sejumlah huruf atau angka". Sebuah pernyataan IF:

<if-statement> ::= IF <condition> THEN <statement> ENDIF
                 | IF <condition> THEN <statement> ELSE <statement> ENDIF

Sebuah diagram sintaks (diagram rel kereta api) menunjukkan hal yang sama secara grafis: kotak untuk non-terminal, kotak bulat untuk terminal, panah untuk jalur valid, lingkaran untuk pengulangan. Kedua notasi setara. Parser menggunakan tata bahasa untuk memutuskan apakah suatu program valid.

Membaca diagram ujian. Setiap diagram mendefinisikan satu non-terminal; ikuti panah dari entry ke exit, dan setiap jalur yang dapat Anda telusuri adalah string yang valid. Pilihan kotak-kotak berdampingan adalah himpunan alternatif; loop kembali adalah "ulang sebanyak yang Anda inginkan"; kotak untuk non-terminal lain berarti "masukkan apa pun yang diizinkan aturan". "Sebutkan mengapa string tersebut tidak valid" meminta aturan yang dilanggar, dalam kata-kata: 9K tidak valid sebagai variabel karena karakter pertama harus berupa huruf, bukan digit; JJ90 adalah passcode yang tidak valid jika aturan hanya mengizinkan satu huruf sebelum digit, atau jika J tidak berada dalam himpunan huruf yang terdaftar. Selalu periksa string terhadap himpunan karakter yang sebenarnya diizinkan oleh diagram, bukan terhadap apa yang akan diterima bahasa nyata.

Menulis BNF dari diagram. Setiap diagram menjadi satu aturan <name> ::= ...; alternatif dipisahkan oleh |; urutan ditulis satu simbol setelah simbol lainnya; dan pengulangan ditulis dengan rekursi, karena BNF tidak memiliki simbol lingkaran: "satu atau lebih huruf" adalah <word> ::= <letter> | <letter><word>, dan "nol atau lebih digit setelah huruf" adalah <variable> ::= <letter> | <letter><digits> dengan <digits> ::= <digit> | <digit><digits>.

Contoh terpecahkan. Lengkapi BNF untuk registrasi kendaraan yang harus dimulai dengan dua huruf (dari A B C) diikuti oleh satu, dua, atau tiga digit (dari 0 1 2).

<letter>       ::= A | B | C
<digit>        ::= 0 | 1 | 2
<digits>       ::= <digit> | <digit><digit> | <digit><digit><digit>
<registration> ::= <letter><letter><digits>

AB12 valid; A12 tidak (hanya satu huruf); AB1234 tidak (empat digit); AD1 tidak (D bukan huruf yang terdaftar). Diminta menambahkan batasan seperti "karakter ketiga juga boleh berupa simbol", tambahkan alternatif tambahan pada aturan untuk posisi tersebut saja, dan definisikan <symbol> dengan aturannya sendiri.

Contoh terpecahkan. Tulis BNF untuk ekspresi yang merupakan variabel, diikuti oleh operator, diikuti oleh variabel atau angka, di mana variabel adalah huruf kecil tunggal dari a b c dan operator adalah + atau -.

<variable>   ::= a | b | c
<operator>   ::= + | -
<number>     ::= <digit> | <digit><number>
<expression> ::= <variable><operator><variable> | <variable><operator><number>

Aturan rekursif <number> memungkinkan jumlah digit berapa pun; dua alternatif dari <expression> mencakup kedua kasus yang disebutkan dalam definisi. Jaga setiap non-terminal dalam tanda kurung sudut dan setiap terminal tanpa tanda tersebut.

Dalam notasi infix operator berada di antara operand-nya (3 + 4 * 2), memerlukan tanda kurung dan aturan prioritas. Dalam Reverse Polish Notation (RPN, postfix) operator mengikuti operand-nya (3 4 2 * +), tidak memerlukan tanda kurung.

Mengubah infix ke RPN

Gunakan stack operator. Scan dari kiri ke kanan: outputkan operand; untuk operator, pop dulu semua operator yang tersimpan yang memiliki prioritas setinggi atau lebih tinggi ke output, lalu push operator tersebut; push (; pada ) pop ke output hingga menemukan ( yang cocok. Di akhir, pop semua operator. Contoh: (3 + 4) * 2 → 3 4 + 2 *.

Mengevaluasi RPN

Gunakan stack operand. Scan dari kiri ke kanan: push setiap operand; pada operator, pop dua elemen teratas, terapkan operator tersebut, dan push hasilnya. Mengevaluasi 3 4 2 * +:

Hasil: 11. RPN tidak memerlukan tanda kurung saat evaluasi dan cocok untuk mesin stack — yang merupakan cara kerja JVM dan banyak interpreter bytecode.

"Jelaskan mengapa RPN digunakan untuk mengevaluasi ekspresi (dua nilai).

Mengubah infix menjadi RPN secara manual. (1) Kurung sepenuhnya ekspresi menggunakan aturan prioritas; (2) pindahkan setiap operator tepat setelah kurung tutup pasangannya sendiri; (3) hapus kurung. Jadi $(a - b) * (a + c) / 7$ menjadi $((a - b) * (a + c)) / 7$, lalu a b - a c + * 7 /. Perhatikan bahwa * dan / diterapkan dari kiri ke kanan, sehingga pembagian adalah operator terakhir, bukan perkalian. Konversi lebih lanjut: $((7 + 3) - (2 * 8)) / 6$ adalah 7 3 + 2 8 * - 6 /; $(7 - 2 + 8) / (9 - 5)$ adalah 7 2 - 8 + 9 5 - /; $a * b + b - d + 15$ adalah a b * b + d - 15 +; $(2 - 6) * (13 + 7) / 5$ adalah 2 6 - 13 7 + * 5 /.

Mengubah RPN kembali menjadi infix. Kerjakan RPN dengan tumpukan ekspresi: dorong setiap operand; untuk setiap operator pop dua, tulis keduanya di sisi operator tersebut dalam kurung, dan dorong hasilnya. Jadi a b / 4 * a b + - adalah $((a / b) * 4) - (a + b)$; 5 2 + 9 3 - / 3 * adalah $((5 + 2) / (9 - 3)) * 3$; b a c - + d b + * c / adalah $((b + (a - c)) * (d + b)) / c$; a b - c + c a - * d / adalah $(((a - b) + c) * (c - a)) / d$. Pertahankan tanda kurung: menghilangkannya dapat mengubah makna.

Contoh terpecahkan. Hitung a b - c d + * e / ketika $a = 17$, $b = 5$, $c = 7$, $d = 3$, dan $e = 10$, tunjukkan tumpukannya.

Hasil 12. Urutan popping penting untuk - dan /: nilai yang dipop kedua adalah operand kiri, jadi a b - adalah $a - b$, bukan $b - a$. Dua lagi, dengan cara yang sama: d a b + * c a - / dengan $a = 6, b = 12, c = 15, d = 5$ menghasilkan $5 \times (6 + 12) / (15 - 6) = 90 / 9 = 10$; c a - b d + * b c + / dengan $a = 4, b = 12, c = 24, d = 6$ menghasilkan $(24 - 4) \times (12 + 6) / (12 + 24) = 360 / 36 = 10$.

Contoh terpecahkan. Ubah $(A + B) \times (C - D)$ ke RPN, lalu evaluasi $(3 + 4) \times (5 - 2)$. Scan dari kiri ke kanan menggunakan stack operator. Dorong (; outputkan A; dorong +; outputkan B; saat bertemu ), pop kembali ke ( yang sesuai, menghasilkan A B + sejauh ini. Dorong ×, dan kurung kedua berperilaku sama, menghasilkan C D -. Di akhir, pop ×. Hasil: A B + C D - ×. Untuk mengevaluasi angka-angkanya, gunakan stack operand: dorong 3, dorong 4; + pop keduanya dan dorong 7; dorong 5, dorong 2; - pop keduanya dan dorong 3; × pop 7 dan 3 dan dorong 21. Dua hal membuat ini dapat diandalkan: operand mempertahankan urutan asli mereka selama konversi (hanya operator yang bergerak), dan setiap operator bekerja pada dua nilai tepat di bawahnya pada stack.

Soal definisi dinilai berdasarkan frasa tetap. Hafalkan ini persis, dan berikan hanya satu jawaban.

• Pertanyaan OS diberi nilai berdasarkan mekanisme yang dinamakan: penjadwalan, manajemen memori, buffering I/O dan spooling, manajemen file; untuk antarmuka, nama file bukan alamat, klik bukan perintah, driver, GUI.
• Status proses beserta transisinya dan alasan untuk setiap transisi; rutinitas penjadwalan sebagai fungsi plus manfaat plus kekurangan; kernel menyimpan status, mengidentifikasi interupsi, melayani, lalu memulihkan.
• Memori virtual: disk memperluas RAM, halaman ditukar, penerjemahan alamat; paging berukuran tetap dan tak terlihat, segmentation berukuran variabel dan logis; thrashing adalah pergantian halaman alih-alih aktivitas kerja.
• Interpreter: satu pernyataan pada satu waktu, diterjemahkan lalu dieksekusi, tidak ada yang disimpan. Tahapan Compiler: token dan tabel simbol, tata bahasa dan pohon parse, kode, optimisasi.
• BNF: satu aturan per diagram, | untuk pilihan, rekursi untuk pengulangan, terminal ditulis biasa dan non-terminal dalam kurung sudut. Sebutkan aturan mana yang dilanggar oleh sebuah string.
• RPN: operator setelah operand, evaluasi dengan stack, tunjukkan setiap langkah; konversi dengan memberikan tanda kurung penuh; saat dikonversi kembali, simpan tanda kurungnya.

Kesalahan umum

• Mendeskripsikan multi-tasking sebagai "menjalankan beberapa program pada waktu yang sama" tanpa menyebutkan prosesor beralih di antaranya.
• Mengirim proses yang diblokir langsung ke status running, atau memberikan "time slice berakhir" sebagai alasan perubahan dari running ke blocked.
• Membingungkan shortest job first (non-pre-emptive) dengan shortest remaining time (pre-emptive), atau round robin dengan prioritas.
• Mendefinisikan memori virtual sebagai "menggunakan hard disk sebagai RAM" tanpa menyebutkan halaman yang ditukar.
• Mengatakan bahwa interpreter "mengonversi program ke kode mesin dan kemudian menjalankannya"; itu adalah definisi compiler.
• Menempatkan pengecekan sintaksis dalam analisis leksikal, atau optimisasi sebelum generation kode dalam soal mencocokkan.
• Menulis pengulangan BNF sebagai <letter>* atau dengan titik tiga; gunakan rekursi. Meninggalkan kurung sudut pada non-terminal.
• Membalik urutan operand dari - atau / saat mengevaluasi RPN, atau menuliskan RPN dari $a * b + c$ sebagai a b c + *.