Pengantar Algoritma dan Berpikir Komputasional

Setelah menyelesaikan modul ini, mahasiswa diharapkan mampu:

1. Menjelaskan definisi algoritma dan membedakan algoritma dari sekadar urutan tindakan biasa.
2. Menyebutkan dan menerapkan lima ciri algoritma menurut Knuth: finiteness, definiteness, input, output, dan effectiveness.
3. Menjelaskan empat pilar berpikir komputasional serta menerapkannya pada masalah sederhana sehari-hari.
4. Membandingkan tiga bentuk representasi algoritma beserta kelebihan dan kekurangannya.
5. Menggambar flowchart menggunakan simbol standar ISO 5807 untuk masalah berurutan (sequence).
6. Menulis pseudocode yang konsisten dan tidak ambigu untuk masalah sederhana.
7. Mengidentifikasi bagian-bagian struktur program Pascal: judul program, blok deklarasi, dan blok pernyataan.
8. Menulis, mengompilasi, dan menjalankan program Pascal sederhana yang melibatkan input, proses, dan output.

Capaian Pembelajaran Mata Kuliah

Mahasiswa mampu merancang algoritma penyelesaian masalah sederhana dalam bentuk pseudocode dan flowchart, kemudian mengimplementasikannya menjadi program Pascal yang benar secara sintaks dan logika.

Indikator Ketercapaian Modul

3.1 Apakah Algoritma Itu

Kata algoritma berasal dari nama seorang matematikawan Persia abad ke-9, Abu Ja'far Muhammad ibn Musa al-Khwarizmi (sekitar 780-850 M). Ketika karyanya diterjemahkan ke bahasa Latin pada abad ke-12, namanya dilafalkan menjadi Algoritmi, dan dari situlah istilah ini lahir.

Secara formal, algoritma adalah urutan langkah logis, terdefinisi dengan jelas, dan berhingga yang digunakan untuk menyelesaikan suatu masalah atau melakukan suatu komputasi. Definisi yang sering dikutip dari Rosen:

Perhatikan kata kunci pada definisi tersebut: finite (berhingga), precise (tepat, tidak ambigu), dan instructions (instruksi atau langkah). Ketiganya menjadi syarat mutlak. Resep masakan yang berbunyi "tambahkan garam secukupnya" bukan algoritma yang baik, karena kata "secukupnya" bersifat ambigu dan tidak dapat dieksekusi secara mekanis.

3.2 Lima Ciri Algoritma Menurut Knuth

Donald E. Knuth dalam The Art of Computer Programming merumuskan lima ciri yang harus dimiliki sebuah algoritma. Kelima ciri ini menjadi daftar periksa wajib ketika Anda merancang penyelesaian masalah.

Sebagian penulis menambahkan ciri keenam, yaitu generality: algoritma sebaiknya bekerja untuk seluruh himpunan masukan yang sesuai, bukan hanya untuk satu kasus khusus.

3.3 Berpikir Komputasional

Computational thinking atau berpikir komputasional adalah cara memformulasikan masalah dan solusinya sehingga solusi tersebut dapat dieksekusi secara efektif oleh manusia maupun mesin. Jeannette Wing mempopulerkan istilah ini pada 2006. Terdapat empat pilar utama.

a. Dekomposisi

Memecah masalah besar menjadi sub-masalah yang lebih kecil dan lebih mudah dikelola. Contoh: masalah "membuat aplikasi kasir" dipecah menjadi sub-masalah "membaca data barang", "menghitung subtotal", "menghitung pajak", dan "mencetak struk". Dalam Pascal, setiap sub-masalah ini nantinya menjadi prosedur atau fungsi tersendiri (Modul 11 dan 12).

b. Pengenalan Pola

Menemukan kesamaan atau keteraturan yang berulang. Contoh: baik perhitungan luas persegi panjang maupun luas segitiga sama-sama mengikuti pola terima input, hitung, tampilkan output. Pola inilah yang membuat kita tidak perlu memulai dari nol setiap kali menghadapi masalah baru.

c. Abstraksi

Menyaring detail yang tidak relevan dan fokus pada informasi penting. Ketika menghitung luas persegi panjang, kita tidak peduli warna kertas, ketebalan garis, atau jenis pensil yang digunakan. Yang relevan hanya dua besaran: panjang dan lebar. Kemampuan memilih detail yang relevan inilah inti abstraksi.

d. Algoritma

Merancang langkah-langkah penyelesaian secara sistematis dan terurut. Pilar ini adalah muara dari tiga pilar sebelumnya: setelah masalah dipecah, pola dikenali, dan detail disaring, kita menyusun langkah penyelesaiannya.

3.4 Tiga Representasi Algoritma

Sebuah algoritma dapat dinyatakan dalam beberapa bentuk. Masing-masing memiliki kelebihan dan konteks penggunaan yang berbeda.

3.5 Simbol Standar Flowchart

Simbol flowchart distandarkan oleh ANSI dan ISO 5807. Berikut simbol-simbol yang paling sering digunakan beserta bentuk dan fungsinya.

3.6 Tiga Struktur Dasar Algoritma

Pada 1966, Corrado Bohm dan Giuseppe Jacopini membuktikan sebuah teorema penting: setiap algoritma dapat dituliskan hanya dengan tiga struktur kontrol. Inilah dasar dari pemrograman terstruktur, dan Pascal dirancang khusus untuk mendukungnya.

1. Sequence (urutan) - langkah dikerjakan satu per satu secara berurutan dari atas ke bawah. Ini adalah struktur yang dibahas pada modul ini.
2. Selection (pemilihan) - memilih salah satu jalur berdasarkan kondisi. Dibahas pada Modul 6 (IF-THEN-ELSE) dan Modul 7 (CASE-OF).
3. Iteration (perulangan) - mengulang langkah selama kondisi tertentu terpenuhi. Dibahas pada Modul 8 (FOR) dan Modul 9 (WHILE/REPEAT).

3.7 Mengapa Belajar Pascal

Pascal dirancang oleh Niklaus Wirth pada 1970 dan dinamai menurut matematikawan Prancis Blaise Pascal. Tujuan awalnya adalah menyediakan bahasa yang bersih untuk mengajarkan pemrograman terstruktur. Beberapa alasan Pascal tetap relevan sebagai bahasa pengantar:

• Sintaksnya tegas. Aturan blok begin...end dan titik koma memaksa mahasiswa disiplin menuliskan struktur.
• Deklaratif. Variabel harus dideklarasikan lebih dulu, sehingga mahasiswa terbiasa berpikir tentang tipe data sejak awal.
• Kaya tipe data. Pascal memiliki set, subrange, record, dan enumerasi yang mendorong pemodelan data yang baik.
• Evolusinya nyata. Turbo Pascal menjadi fenomena industri pada era 1980-an, dan warisannya berlanjut pada Delphi serta Free Pascal hingga hari ini.

3.8 Free Pascal dan Turbo Pascal

Modul-modul dalam kursus ini menggunakan Free Pascal sebagai acuan utama, dengan catatan perbedaan ketika berhadapan dengan Turbo Pascal.

3.9 Struktur Umum Program Pascal

Setiap program Pascal memiliki kerangka yang baku. Memahami urutan bagian-bagian ini sangat penting karena kompiler Pascal sangat ketat terhadap tata letak.

program NamaProgram;          { judul program, opsional }

uses NamaUnit;                { daftar unit yang dipakai }

const                         { blok konstanta }
  NAMA_KONSTANTA = nilai;

type                          { blok definisi tipe bentukan }
  NamaTipe = ...;

var                           { blok deklarasi variabel }
  namaVariabel : tipeData;

begin                         { AWAL blok pernyataan utama }
  pernyataan_1;
  pernyataan_2;
end.                          { AKHIR program, diakhiri titik }

Urutan blok const, type, lalu var bersifat mengikat. Menukar urutannya akan menghasilkan kesalahan kompilasi. Perhatikan juga perbedaan penting antara end. (dengan titik) yang mengakhiri program dan end; (dengan titik koma) yang mengakhiri blok di dalam program.

3.10 Kesalahan Umum Pemula

1. Lupa titik koma. Setiap pernyataan di dalam blok begin...end diakhiri titik koma. Pengecualian: pernyataan terakhir sebelum end boleh tanpa titik koma, tetapi membiasakan menulisnya lebih aman.
2. Titik koma setelah end terakhir. Program diakhiri dengan end. bukan end;. Kesalahan ini sangat sering terjadi.
3. Memakai = untuk penugasan. Dalam Pascal, = adalah operator pembanding, sedangkan penugasan memakai :=.
4. Tidak mendeklarasikan variabel. Semua variabel wajib muncul di blok var sebelum dipakai.
5. Salah menuliskan tipe data. integer dan real berbeda; menuliskan int atau float akan ditolak kompiler.
6. Mengabaikan tanda kurung siku untuk array. Indeks array memakai [ ] bukan ( ).
7. Menganggap Pascal case-sensitive. Sebenarnya Pascal tidak membedakan huruf besar-kecil, tetapi konsistensi penulisan tetap penting untuk keterbacaan.

Pada bagian ini disajikan tiga flowchart. Flowchart pertama menggambarkan proses berpikir dalam menyusun program, sedangkan dua flowchart berikutnya menggambarkan algoritma konkret yang akan kita implementasikan dalam Pascal.

4.1 Flowchart Alur Berpikir Komputasional dalam Membuat Program

Diagram ini memperlihatkan bahwa menulis program bukan kegiatan sekali jadi. Terdapat dua titik umpan balik: ketika kompilasi gagal, dan ketika hasil pengujian tidak sesuai harapan.

flowchart TD
    A(["Mulai"]) --> B["Pahami Masalah"]
    B --> C["Dekomposisi
pecah menjadi sub-masalah"]
    C --> D["Abstraksi dan
Pengenalan Pola"]
    D --> E["Rancang Algoritma
pseudocode dan flowchart"]
    E --> F["Implementasi Kode Pascal"]
    F --> G["Kompilasi"]
    G --> H{"Ada error
kompilasi?"}
    H -- "Ya" --> I["Perbaiki Sintaks"]
    I --> F
    H -- "Tidak" --> J["Uji dengan Data Uji"]
    J --> K{"Hasil sesuai
spesifikasi?"}
    K -- "Tidak" --> E
    K -- "Ya" --> L(["Selesai"])
      

Perhatikan bahwa jalur Hasil sesuai - Tidak kembali ke tahap rancang algoritma, bukan ke tahap implementasi. Ini pesan penting: jika logika salah, memperbaiki kode tidak akan menolong. Yang harus diperbaiki adalah rancangan algoritmanya.

4.2 Flowchart Menghitung Luas Persegi Panjang

Algoritma ini murni menggunakan struktur sequence: tidak ada percabangan maupun perulangan. Inilah bentuk algoritma paling sederhana.

flowchart TD
    A(["Mulai"]) --> B[/"Baca panjang, lebar"/]
    B --> C["luas = panjang x lebar"]
    C --> D[/"Tampilkan luas"/]
    D --> E(["Selesai"])
      

4.3 Flowchart Menukar Nilai Dua Variabel

Algoritma pertukaran nilai adalah contoh klasik yang menunjukkan pentingnya variabel bantu. Tanpa variabel temp, nilai pertama akan tertimpa sebelum sempat disimpan.

flowchart TD
    A(["Mulai"]) --> B[/"Baca a dan b"/]
    B --> C[/"Tampilkan a dan b sebelum penukaran"/]
    C --> D["temp = a"]
    D --> E["a = b"]
    E --> F["b = temp"]
    F --> G[/"Tampilkan a dan b setelah penukaran"/]
    G --> H(["Selesai"])
      

Pseudocode ditulis dengan konvensi yang konsisten. Kursus ini menggunakan konvensi berikut secara seragam di seluruh 50 modul, sehingga Anda akan terbiasa dengan satu gaya penulisan.

5.1 Pseudocode Luas Persegi Panjang

PROGRAM LuasPersegiPanjang
{ Menghitung luas persegi panjang dari panjang dan lebar }

DEKLARASI
  panjang, lebar, luas : real

ALGORITMA
  write("Masukkan panjang: ")
  read(panjang)

  write("Masukkan lebar: ")
  read(lebar)

  luas <- panjang * lebar

  write("Luas persegi panjang = ", luas)
END

5.2 Pseudocode Tukar Nilai

PROGRAM TukarNilai
{ Menukar nilai dua variabel menggunakan variabel bantu }

DEKLARASI
  a, b, temp : integer

ALGORITMA
  write("Masukkan nilai a: ")
  read(a)
  write("Masukkan nilai b: ")
  read(b)

  write("Sebelum ditukar: a = ", a, ", b = ", b)

  temp <- a
  a    <- b
  b    <- temp

  write("Setelah ditukar: a = ", a, ", b = ", b)
END

5.3 Pseudocode Studi Kasus Kasir

PROGRAM KasirTokoBuku
{ Menghitung total pembayaran termasuk PPN }

KONSTANTA
  PPN = 0.11

DEKLARASI
  judul          : string
  hargaSatuan    : real
  jumlahBeli     : integer
  subtotal       : real
  nilaiPPN       : real
  totalBayar     : real

ALGORITMA
  write("Judul buku: ")
  read(judul)
  write("Harga satuan: ")
  read(hargaSatuan)
  write("Jumlah beli: ")
  read(jumlahBeli)

  subtotal   <- hargaSatuan * jumlahBeli
  nilaiPPN   <- subtotal * PPN
  totalBayar <- subtotal + nilaiPPN

  write("Subtotal      : ", subtotal)
  write("PPN 11 persen : ", nilaiPPN)
  write("Total bayar   : ", totalBayar)
END

6.1 Program Pertama: Halo Dunia

Program ini tidak menerima masukan dan hanya menampilkan dua baris teks. Tujuannya adalah memastikan rantai alat (kompiler dan IDE) Anda bekerja dengan benar sebelum melangkah lebih jauh.

program HaloDunia;
{ Program pertama: menampilkan sapaan ke layar }

begin
  writeln('Halo, dunia!');
  writeln('Saya sedang belajar Pemrograman Pascal.');
end.

Keluaran yang diharapkan:

Halo, dunia!
Saya sedang belajar Pemrograman Pascal.

6.2 Program Luas Persegi Panjang

Program ini sudah menerapkan pola lengkap input - proses - output dan menggunakan tipe data real agar dapat menerima bilangan desimal.

program LuasPersegiPanjang;
{ Menghitung luas persegi panjang dari panjang dan lebar }

var
  panjang, lebar, luas: real;

begin
  write('Masukkan panjang: ');
  readln(panjang);

  write('Masukkan lebar: ');
  readln(lebar);

  luas := panjang * lebar;

  writeln('Luas persegi panjang = ', luas:0:2);
end.

Contoh sesi interaksi:

Masukkan panjang: 7.5
Masukkan lebar: 4
Luas persegi panjang = 30.00

6.3 Program Tukar Nilai

Program ini mengimplementasikan algoritma pada Gambar 4.3. Perhatikan penggunaan tiga baris penugasan berurutan yang tidak boleh ditukar urutannya.

program TukarNilai;
{ Menukar nilai dua variabel menggunakan variabel bantu }

var
  a, b, temp: integer;

begin
  write('Masukkan nilai a: ');
  readln(a);
  write('Masukkan nilai b: ');
  readln(b);

  writeln('Sebelum ditukar: a = ', a, ', b = ', b);

  temp := a;
  a := b;
  b := temp;

  writeln('Setelah ditukar: a = ', a, ', b = ', b);
end.

Contoh sesi interaksi:

Masukkan nilai a: 15
Masukkan nilai b: 42
Sebelum ditukar: a = 15, b = 42
Setelah ditukar: a = 42, b = 15

7.1 Program LuasPersegiPanjang

7.2 Program TukarNilai

7.3 Jejak Eksekusi TukarNilai

Tabel jejak (trace table) adalah teknik penelusuran manual yang akan sangat sering Anda pakai mulai Modul 8. Berikut jejak untuk masukan a = 15 dan b = 42.

Perhatikan baris ke-4: setelah a := b, kedua variabel a dan b sama-sama bernilai 42. Nilai 15 hanya bertahan di temp. Inilah alasan variabel bantu tidak bisa dihilangkan.

9.1 Deskripsi Masalah

Toko Buku "Cendekia" memerlukan program sederhana untuk menghitung total pembayaran seorang pembeli. Kasir akan memasukkan judul buku, harga satuan, dan jumlah yang dibeli. Program kemudian menghitung subtotal, menambahkan PPN sebesar 11 persen, dan menampilkan struk ringkas.

Untuk sementara, program hanya menangani satu jenis buku per transaksi. Kemampuan menangani banyak item sekaligus akan ditambahkan pada Modul 8 setelah kita mempelajari perulangan.

9.2 Analisis dengan Berpikir Komputasional

9.3 Flowchart Studi Kasus

flowchart TD
    A(["Mulai"]) --> B[/"Baca judul, hargaSatuan, jumlahBeli"/]
    B --> C["subtotal = hargaSatuan x jumlahBeli"]
    C --> D["nilaiPPN = subtotal x 0.11"]
    D --> E["totalBayar = subtotal + nilaiPPN"]
    E --> F[/"Tampilkan judul, subtotal, nilaiPPN, totalBayar"/]
    F --> G(["Selesai"])
      

9.4 Pseudocode Studi Kasus

PROGRAM KasirTokoBuku
{ Menghitung total pembayaran satu item dengan PPN 11 persen }

KONSTANTA
  PPN = 0.11

DEKLARASI
  judul       : string
  hargaSatuan : real
  jumlahBeli  : integer
  subtotal    : real
  nilaiPPN    : real
  totalBayar  : real

ALGORITMA
  write("Judul buku          : ")
  read(judul)
  write("Harga satuan (Rp)   : ")
  read(hargaSatuan)
  write("Jumlah beli         : ")
  read(jumlahBeli)

  subtotal   <- hargaSatuan * jumlahBeli
  nilaiPPN   <- subtotal * PPN
  totalBayar <- subtotal + nilaiPPN

  write("========================================")
  write("STRUK PEMBAYARAN TOKO BUKU CENDEKIA")
  write("========================================")
  write("Judul buku    : ", judul)
  write("Harga satuan  : Rp ", hargaSatuan)
  write("Jumlah beli   : ", jumlahBeli)
  write("----------------------------------------")
  write("Subtotal      : Rp ", subtotal)
  write("PPN 11 persen : Rp ", nilaiPPN)
  write("----------------------------------------")
  write("Total bayar   : Rp ", totalBayar)
  write("========================================")
END

9.5 Implementasi dalam Pascal

program KasirTokoBuku;
{ Studi Kasus Modul 1 - Sistem kasir sederhana Toko Buku Cendekia }

const
  PPN = 0.11;

var
  judul: string;
  hargaSatuan, subtotal, nilaiPPN, totalBayar: real;
  jumlahBeli: integer;

begin
  write('Judul buku          : ');
  readln(judul);

  write('Harga satuan (Rp)   : ');
  readln(hargaSatuan);

  write('Jumlah beli         : ');
  readln(jumlahBeli);

  subtotal := hargaSatuan * jumlahBeli;
  nilaiPPN := subtotal * PPN;
  totalBayar := subtotal + nilaiPPN;

  writeln;
  writeln('========================================');
  writeln('STRUK PEMBAYARAN TOKO BUKU CENDEKIA');
  writeln('========================================');
  writeln('Judul buku    : ', judul);
  writeln('Harga satuan  : Rp ', hargaSatuan:0:2);
  writeln('Jumlah beli   : ', jumlahBeli);
  writeln('----------------------------------------');
  writeln('Subtotal      : Rp ', subtotal:0:2);
  writeln('PPN 11 persen : Rp ', nilaiPPN:0:2);
  writeln('----------------------------------------');
  writeln('Total bayar   : Rp ', totalBayar:0:2);
  writeln('========================================');
end.

9.6 Contoh Keluaran

Judul buku          : Algoritma dan Pemrograman
Harga satuan (Rp)   : 125000
Jumlah beli         : 3

========================================
STRUK PEMBAYARAN TOKO BUKU CENDEKIA
========================================
Judul buku    : Algoritma dan Pemrograman
Harga satuan  : Rp 125000.00
Jumlah beli   : 3
----------------------------------------
Subtotal      : Rp 375000.00
PPN 11 persen : Rp 41250.00
----------------------------------------
Total bayar   : Rp 416250.00
========================================

9.7 Pembahasan

Perhatikan beberapa keputusan perancangan pada program di atas.

1. PPN dijadikan konstanta. Bila suatu hari tarif pajak berubah menjadi 12 persen, cukup satu baris yang perlu diubah, bukan tiga tempat berbeda. Ini adalah penerapan prinsip single source of truth.
2. Tipe data dipilih sesuai kebutuhan. jumlahBeli bertipe integer karena jumlah buku selalu bilangan bulat. hargaSatuan bertipe real karena harga bisa mengandung sen.
3. Baris kosong sebelum struk. Pernyataan writeln; tanpa argumen menghasilkan satu baris kosong, sehingga struk terpisah rapi dari bagian masukan.
4. Format dua angka desimal. Seluruh nilai rupiah ditampilkan dengan :0:2 agar konsisten.

9.8 Pengembangan Selanjutnya

Program ini sengaja dibuat sederhana agar sesuai dengan cakupan Modul 1. Dalam modul-modul berikutnya, program yang sama akan berkembang:

1. Algoritma adalah urutan langkah logis, tepat, dan berhingga untuk menyelesaikan masalah. Istilah ini berasal dari nama matematikawan al-Khwarizmi.
2. Lima ciri algoritma menurut Knuth adalah finiteness, definiteness, input, output, dan effectiveness. Sebagian penulis menambahkan generality.
3. Berpikir komputasional memiliki empat pilar: dekomposisi, pengenalan pola, abstraksi, dan algoritma. Keempatnya bekerja bersama, bukan terpisah.
4. Algoritma dapat direpresentasikan sebagai narasi, pseudocode, flowchart, atau kode program. Masing-masing memiliki konteks penggunaan yang berbeda.
5. Flowchart menggunakan simbol standar ISO 5807: oval untuk terminator, persegi panjang untuk proses, jajar genjang untuk input/output, dan belah ketupat untuk keputusan.
6. Menurut teorema Bohm dan Jacopini, setiap algoritma dapat disusun dari tiga struktur dasar: sequence, selection, dan iteration. Modul ini fokus pada sequence.
7. Struktur program Pascal terdiri atas judul program, blok deklarasi (const, type, var), dan blok pernyataan di antara begin dan end.
8. Penugasan memakai :=, sedangkan = adalah operator pembanding. Program diakhiri end. dengan titik, bukan titik koma.
9. Variabel bantu diperlukan dalam algoritma penukaran nilai. Tanpa variabel bantu, nilai asli akan tertimpa sebelum sempat dipindahkan.
10. Free Pascal adalah acuan utama kursus ini, dengan Turbo Pascal sebagai pembanding historis. Sebagian besar kode berjalan di kedua kompiler.

Buku Teks

1. Knuth, D. E. (1997). The Art of Computer Programming, Volume 1: Fundamental Algorithms (3rd ed.). Addison-Wesley. Rujukan utama untuk lima ciri algoritma.
2. Rosen, K. H. (2019). Discrete Mathematics and Its Applications (8th ed.). McGraw-Hill. Bab 3 membahas algoritma, kompleksitas, dan notasi Big-O secara formal.
3. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2022). Introduction to Algorithms (4th ed.). MIT Press. Rujukan standar untuk analisis dan perancangan algoritma.
4. Wirth, N. (1971). "The Programming Language Pascal." Acta Informatica, 1(1), 35-63. Makalah asli perancangan bahasa Pascal.
5. Cooper, D., & Clancy, M. (1982). Oh! Pascal! W. W. Norton & Company. Buku pengantar klasik yang menekankan pemecahan masalah bertahap.

Dokumentasi dan Standar

1. Free Pascal Team. Free Pascal Reference Guide. Tersedia di freepascal.org/docs.html.
2. International Organization for Standardization. (1985). ISO 5807: Information processing - Documentation symbols and conventions for data, program and system flowcharts. Standar simbol flowchart yang digunakan pada modul ini.
3. IEEE Computer Society. (1990). IEEE Standard for Pascal (IEEE Std 770-1983). Standar bahasa Pascal sebelum era Object Pascal.

Artikel dan Sumber Daring

1. Wing, J. M. (2006). "Computational Thinking." Communications of the ACM, 49(3), 33-35. Artikel yang mempopulerkan istilah berpikir komputasional.
2. Bohm, C., & Jacopini, G. (1966). "Flow Diagrams, Turing Machines and Languages with Only Two Formation Rules." Communications of the ACM, 9(5), 366-371. Bukti bahwa tiga struktur kontrol sudah cukup untuk semua algoritma.
3. Dijkstra, E. W. (1968). "Go To Statement Considered Harmful." Communications of the ACM, 11(3), 147-148. Artikel klasik yang mendorong pemrograman terstruktur.