{"id":476419,"date":"2023-08-09T07:29:55","date_gmt":"2023-08-09T07:29:55","guid":{"rendered":""},"modified":"2023-09-05T11:12:43","modified_gmt":"2023-09-05T11:12:43","slug":"continuation-passing-style-cps","status":"publish","type":"wiki","link":"https:\/\/oneproxy.pro\/id\/wiki\/continuation-passing-style-cps\/","title":{"rendered":"Gaya passing lanjutan (CPS)"},"content":{"rendered":"<p>Gaya penerusan lanjutan (CPS) adalah metode penanganan aliran kontrol dalam pemrograman komputer yang melibatkan penerusan kontrol secara eksplisit melalui parameter fungsi.<\/p>\n<h2>Evolusi Gaya Continuation-passing (CPS)<\/h2>\n<p>Asal usul gaya passing-lanjutan dapat ditelusuri kembali ke perkembangan ilmu komputer teoretis, dan konsep kelanjutan itu sendiri berakar pada kalkulus lambda. Penyebutan eksplisit pertama dari \u201cGaya passing lanjutan\u201d sebagai frasa dan penggunaannya dalam praktik diperkenalkan oleh ilmuwan komputer Christopher Strachey pada tahun 1960an. Pada periode inilah dia dan rekan-rekannya mengeksplorasi semantik denotasi, sebuah kerangka kerja untuk mendefinisikan makna bahasa pemrograman.<\/p>\n<h2>Membuka Gaya Continuation-passing (CPS)<\/h2>\n<p>Gaya penerusan lanjutan (CPS) adalah bentuk organisasi program yang melibatkan penggunaan kelanjutan secara eksplisit. Kelanjutan adalah representasi keadaan program komputer pada titik waktu tertentu, termasuk tumpukan panggilan dan nilai variabel.<\/p>\n<p>Dalam CPS, setiap fungsi menerima argumen tambahan, biasanya bernama \u201ccont\u201d atau \u201ck\u201d, yang mewakili kelanjutan program\u2014apa yang harus terjadi setelah fungsi menyelesaikan komputasinya. Ketika fungsi telah menghitung hasilnya, ia \u201cmengembalikan\u201d hasil ini dengan meneruskannya ke kelanjutan, alih-alih mengembalikannya dengan cara biasa.<\/p>\n<p>Konsep ini dapat dilihat sebagai cara untuk membuat aliran kontrol menjadi eksplisit: alih-alih secara implisit meneruskan kontrol ke pemanggil ketika selesai, fungsi CPS meneruskan kontrol dengan memanggil kelanjutan.<\/p>\n<h2>Struktur Gaya Passing Lanjutan (CPS)<\/h2>\n<p>Dalam konvensi pemanggilan fungsi tradisional, ketika suatu fungsi dipanggil, fungsi tersebut mengeksekusi dan mengembalikan kontrol ke pemanggil dengan nilai kembalian. Namun, dalam gaya penerusan lanjutan, kontrol diteruskan secara eksplisit melalui parameter fungsi, yang sering disebut sebagai \u201ckelanjutan\u201d.<\/p>\n<p>Kelanjutannya mewakili sisa perhitungan. Artinya, ketika suatu fungsi menerima kelanjutan, ia melakukan beberapa operasi dan kemudian meneruskan hasilnya ke kelanjutan yang diterima. Jadi, dalam gaya passing lanjutan, pengembalian tidak pernah dilakukan secara implisit.<\/p>\n<p>Fungsi CPS tipikal dalam bahasa semu mungkin terlihat seperti:<\/p>\n<pre><div class=\"bg-black rounded-md mb-4\"><div class=\"flex items-center relative text-gray-200 bg-gray-800 px-4 py-2 text-xs font-sans justify-between rounded-t-md\"><span>css<\/span><button class=\"flex ml-auto gap-2\"><svg stroke=\"currentColor\" fill=\"none\" stroke-width=\"2\" viewbox=\"0 0 24 24\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"h-4 w-4\" height=\"1em\" width=\"1em\" ><path d=\"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2\"><\/path><rect x=\"8\" y=\"2\" width=\"8\" height=\"4\" rx=\"1\" ry=\"1\"><\/rect><\/svg>Salin kode<\/button><\/div><div class=\"p-4 overflow-y-auto\"><code class=\"!whitespace-pre hljs language-css\" data-no-translation=\"\">function add(<span class=\"hljs-selector-tag\">a<\/span>, <span class=\"hljs-selector-tag\">b<\/span>, continuation) {\n    result = <span class=\"hljs-selector-tag\">a<\/span> + <span class=\"hljs-selector-tag\">b<\/span>;\n    continuation(result);\n}\n<\/code><\/div><\/div><\/pre>\n<p>Fungsi \u201ctambah\u201d ini melakukan operasi penambahan dan kemudian meneruskan hasilnya ke kelanjutan.<\/p>\n<h2>Fitur Utama Gaya Pengoperan Lanjutan (CPS)<\/h2>\n<ol>\n<li>\n<p><strong>Aliran Kontrol Eksplisit<\/strong>: Di CPS, alur kontrol bersifat eksplisit. Tidak ada jejak tumpukan tersembunyi, dan Anda dapat melihat urutan eksekusi dengan jelas di kode.<\/p>\n<\/li>\n<li>\n<p><strong>Fleksibilitas<\/strong>: Karena CPS memisahkan komputasi dari aliran kontrol, hal ini memberikan lebih banyak fleksibilitas untuk memanipulasi aliran kontrol.<\/p>\n<\/li>\n<li>\n<p><strong>Operasi Non-Pemblokiran<\/strong>: CPS sangat berguna dalam mengelola operasi non-pemblokiran atau asinkron. Ini dapat digunakan untuk menghindari panggilan balik dan mengelola skenario aliran kontrol yang kompleks dalam kode non-pemblokiran.<\/p>\n<\/li>\n<li>\n<p><strong>Optimasi Panggilan Ekor<\/strong>: Bahasa yang mendukung pengoptimalan panggilan ekor dapat memperoleh manfaat dari CPS karena CPS mengubah semua panggilan menjadi panggilan ekor, sehingga dapat lebih efisien dalam hal penggunaan memori.<\/p>\n<\/li>\n<\/ol>\n<h2>Jenis Gaya Pengoperan Lanjutan (CPS)<\/h2>\n<p>Pada dasarnya ada dua jenis kelanjutan, <strong>gaya langsung<\/strong> Dan <strong>gaya passing lanjutan<\/strong>. Berikut perbandingan keduanya:<\/p>\n<table>\n<thead>\n<tr>\n<th>Gaya<\/th>\n<th>Keterangan<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Gaya Langsung<\/td>\n<td>Dalam gaya langsung, suatu fungsi menyelesaikan eksekusinya dan mengembalikan kontrol ke fungsi pemanggil. Nilai yang dikembalikan seringkali merupakan hasil komputasi.<\/td>\n<\/tr>\n<tr>\n<td>Gaya penerusan-kelanjutan<\/td>\n<td>Di CPS, fungsi menerima argumen tambahan, kelanjutan, dan meneruskan hasilnya ke kelanjutan ini. Aliran kontrol bersifat eksplisit.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Kegunaan, Masalah, dan Solusi<\/h2>\n<p>CPS banyak digunakan dalam bahasa pemrograman fungsional dan dalam mengelola operasi asinkron.<\/p>\n<ol>\n<li>\n<p><strong>JavaScript Asinkron<\/strong>: JavaScript, khususnya di Node.js, menggunakan CPS untuk mengelola operasi non-pemblokiran asinkron. Callback dalam JavaScript adalah contoh CPS.<\/p>\n<\/li>\n<li>\n<p><strong>Pemrograman Fungsional<\/strong>: Bahasa seperti Scheme dan Haskell menggunakan CPS untuk menangani struktur kontrol seperti loop dan penanganan pengecualian.<\/p>\n<\/li>\n<\/ol>\n<p>Namun, CPS dapat menimbulkan beberapa masalah:<\/p>\n<ul>\n<li><strong>Keterbacaan<\/strong>: CPS terkadang dapat menyebabkan kode yang sulit dibaca dan dipahami karena callback yang buruk, terutama jika ada banyak callback yang bersarang.<\/li>\n<li><strong>Efisiensi<\/strong>: Transformasi CPS berpotensi meningkatkan ukuran kode karena parameter tambahan dan pemanggilan fungsi.<\/li>\n<\/ul>\n<p>Solusi dari permasalahan tersebut adalah:<\/p>\n<ul>\n<li>Menggunakan <strong>Janji<\/strong> atau <strong>async\/menunggu<\/strong> dalam JavaScript untuk menghindari panggilan balik dan meningkatkan keterbacaan.<\/li>\n<li>Menggunakan bahasa pemrograman yang mendukung optimasi tail-call dapat mengurangi masalah efisiensi.<\/li>\n<\/ul>\n<h2>Perbandingan<\/h2>\n<p>Berikut perbandingan CPS dengan paradigma pemrograman lainnya:<\/p>\n<table>\n<thead>\n<tr>\n<th>Paradigma Pemrograman<\/th>\n<th>Aliran Kontrol<\/th>\n<th>Kasus Penggunaan<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Gaya Pengoperan Lanjutan (CPS)<\/td>\n<td>Eksplisit, dengan kelanjutan.<\/td>\n<td>Operasi non-pemblokiran\/asinkron, optimasi panggilan ekor.<\/td>\n<\/tr>\n<tr>\n<td>Gaya Langsung<\/td>\n<td>Secara implisit, fungsi kembali ke pemanggil.<\/td>\n<td>Operasi sinkron\/pemblokiran.<\/td>\n<\/tr>\n<tr>\n<td>Coroutine<\/td>\n<td>Lakukan banyak tugas secara kooperatif dengan mengizinkan fungsi untuk menjeda dan melanjutkan eksekusi.<\/td>\n<td>Aliran kontrol yang kompleks, multitasking kooperatif.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Perspektif Masa Depan<\/h2>\n<p>CPS terus memainkan peran penting dalam menyusun kode asinkron, terutama dalam JavaScript. Pengenalan async\/await, yang merupakan gula sintaksis dibandingkan Promises, dapat dilihat sebagai pengembangan dari CPS tradisional, memberikan sintaksis yang lebih baik dan menghindari callback hell.<\/p>\n<p>Ketika aplikasi web dan server menjadi lebih kompleks dan konkurensi menjadi lebih penting, CPS dan paradigma pemrograman asinkron lainnya cenderung menjadi lebih penting. Ada penelitian yang sedang berlangsung dalam meningkatkan bahasa pemrograman dan sistem runtime untuk lebih mendukung paradigma ini.<\/p>\n<h2>Server Proksi dan CPS<\/h2>\n<p>Server proxy bertindak sebagai perantara permintaan dari klien yang mencari sumber daya dari server lain. Saat menangani permintaan klien secara bersamaan, server proksi mungkin menggunakan CPS atau paradigma pemrograman asinkron serupa untuk mengelola permintaan ini tanpa pemblokiran, sehingga meningkatkan throughput dan kinerja.<\/p>\n<h2>tautan yang berhubungan<\/h2>\n<ol>\n<li><a href=\"https:\/\/en.wikipedia.org\/wiki\/Continuation-passing_style\" target=\"_new\" rel=\"noopener nofollow\">Gaya penerusan lanjutan di Wikipedia<\/a><\/li>\n<li><a href=\"https:\/\/www.cs.utah.edu\/plt\/publications\/icfp07-fyff.pdf\" target=\"_new\" rel=\"noopener nofollow\">Seni Kontinuator<\/a><\/li>\n<li><a href=\"https:\/\/www.microsoft.com\/en-us\/research\/publication\/a-history-of-haskell-being-lazy-with-class\/\" target=\"_new\" rel=\"noopener nofollow\">Sejarah Haskell: Malas Dengan Kelas<\/a><\/li>\n<\/ol>","protected":false},"featured_media":468006,"menu_order":0,"template":"","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"footnotes":""},"class_list":["post-476419","wiki","type-wiki","status-publish","has-post-thumbnail","hentry"],"acf":{"faq_title":"Frequently Asked Questions about <mark>A Deep Dive into Continuation-passing Style (CPS)<\/mark>","faq_items":[{"question":"What is Continuation-passing Style (CPS)?","answer":"<p>Continuation-passing Style (CPS) is a method of managing control flow in computer programming. Instead of returning a value to the caller in the usual way, functions in CPS receive an extra argument (often termed as \"continuation\") representing what should happen after the function finishes its computation.<\/p>"},{"question":"When was Continuation-passing Style (CPS) first mentioned?","answer":"<p>The concept of Continuation-passing Style (CPS) was first introduced by computer scientist Christopher Strachey in the 1960s when exploring denotational semantics, a framework for defining the meanings of programming languages.<\/p>"},{"question":"How does a Continuation-passing Style (CPS) function work?","answer":"<p>In CPS, every function receives an extra argument, representing the continuation of the program. When the function has computed its result, it \"returns\" this result by passing it to the continuation, making control flow explicit.<\/p>"},{"question":"What are the key features of Continuation-passing Style (CPS)?","answer":"<p>The key features of CPS include explicit control flow, increased flexibility, improved handling of non-blocking or asynchronous operations, and enhanced tail call optimization.<\/p>"},{"question":"What types of Continuation-passing Style (CPS) exist?","answer":"<p>There are mainly two types of continuations: direct style and continuation-passing style. In direct style, a function completes its execution and returns control to the calling function. In continuation-passing style, the function passes the result to a received continuation, making the control flow explicit.<\/p>"},{"question":"What are the main uses and problems related to CPS?","answer":"<p>CPS is mostly used in functional programming languages and for managing asynchronous operations. It's useful in JavaScript, particularly in Node.js, and languages like Scheme and Haskell. However, it can lead to problems like reduced code readability (due to callback hell) and increased code size. These can be mitigated by using Promises or async\/await in JavaScript and tail-call optimization in other languages.<\/p>"},{"question":"What is the future perspective of Continuation-passing Style (CPS)?","answer":"<p>CPS continues to be essential in structuring asynchronous code, with developments like async\/await in JavaScript improving upon traditional CPS. As web and server applications become more complex and concurrent, CPS and other asynchronous programming paradigms are likely to become more important.<\/p>"},{"question":"How are proxy servers related to Continuation-passing Style (CPS)?","answer":"<p>Proxy servers, acting as intermediaries for requests from clients seeking resources from other servers, might use CPS or similar asynchronous programming paradigms to manage concurrent client requests without blocking, thereby improving throughput and performance.<\/p>"}]},"_links":{"self":[{"href":"https:\/\/oneproxy.pro\/id\/wp-json\/wp\/v2\/wiki\/476419","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/oneproxy.pro\/id\/wp-json\/wp\/v2\/wiki"}],"about":[{"href":"https:\/\/oneproxy.pro\/id\/wp-json\/wp\/v2\/types\/wiki"}],"version-history":[{"count":0,"href":"https:\/\/oneproxy.pro\/id\/wp-json\/wp\/v2\/wiki\/476419\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/oneproxy.pro\/id\/wp-json\/wp\/v2\/media\/468006"}],"wp:attachment":[{"href":"https:\/\/oneproxy.pro\/id\/wp-json\/wp\/v2\/media?parent=476419"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}