पब्लिश किया गया: 31 जनवरी, 2025
अपने ब्राउज़र में पूरी तरह से काम करने वाला ब्लॉग चलाने की कल्पना करें. इसमें न सिर्फ़ फ़्रंटएंड, बल्कि बैकएंड भी शामिल है. इसमें कोई सर्वर या क्लाउड शामिल नहीं है—सिर्फ़ आप, आपका ब्राउज़र, और… WebAssembly! WebAssembly, सर्वर-साइड फ़्रेमवर्क को स्थानीय तौर पर चलाने की अनुमति देकर, क्लासिक वेब डेवलपमेंट की सीमाओं को धुंधला कर रहा है. साथ ही, नई संभावनाओं के द्वार खोल रहा है. इस पोस्ट में, Evil Martians के बैकएंड हेड व्लादिमीर डेमेंटयेव ने Ruby on Rails को Wasm और ब्राउज़र के लिए तैयार करने की प्रोग्रेस के बारे में बताया है:
- 15 मिनट में ब्राउज़र में Rails को शामिल करने का तरीका.
- Rails wasmification के बारे में जानकारी.
- Rails और Wasm का भविष्य.
Ruby on Rails का मशहूर "15 मिनट में ब्लॉग" अब आपके ब्राउज़र में चल रहा है
Ruby on Rails एक वेब फ़्रेमवर्क है, जो डेवलपर की प्रोडक्टिविटी और तेज़ी से शिपिंग करने पर फ़ोकस करता है. इस टेक्नोलॉजी का इस्तेमाल, इंडस्ट्री के लीडर, जैसे कि GitHub और Shopify करते हैं. इस फ़्रेमवर्क की लोकप्रियता कई साल पहले, डेविड हेनिमियर हंसन (या डीएचएच) के पब्लिश किए गए "15 मिनट में ब्लॉग बनाने का तरीका" वाले मशहूर वीडियो के रिलीज़ होने के साथ शुरू हुई. साल 2005 में, इतने कम समय में पूरी तरह से काम करने वाला वेब ऐप्लिकेशन बनाना, सोचने के भी बाहर था. ऐसा लगा कि जादू हो गया है!
आज, मैं एक ऐसा Rails ऐप्लिकेशन बनाना चाहता हूं जो आपके ब्राउज़र में पूरी तरह से काम करे. इससे, आपको उस जादुई अनुभव को फिर से महसूस करने का मौका मिलेगा. सबसे पहले, सामान्य तरीके से एक बुनियादी Rails ऐप्लिकेशन बनाएं. इसके बाद, उसे Wasm के लिए पैकेज करें.
बैकग्राउंड: कमांड लाइन पर "15 मिनट में ब्लॉग लिखना"
मान लें कि आपने अपनी मशीन पर Ruby और Ruby on Rails इंस्टॉल किया है, तो आपको सबसे पहले एक नया Ruby on Rails ऐप्लिकेशन बनाना होगा. साथ ही, कुछ फ़ंक्शन को स्कैफ़ोल्ड करना होगा. यह ठीक वैसा ही है जैसा कि "15 मिनट में ब्लॉग बनाना" वाले ओरिजनल वीडियो में दिखाया गया है:
$ rails new --css=tailwind web_dev_blog
create .ruby-version
...
$ cd web_dev_blog
$ bin/rails generate scaffold Post title:string date:date body:text
create db/migrate/20241217183624_create_posts.rb
create app/models/post.rb
...
$ bin/rails db:migrate
== 20241217183624 CreatePosts: migrating ====================
-- create_table(:posts)
-> 0.0017s
== 20241217183624 CreatePosts: migrated (0.0018s) ===========
अब कोडबेस में बदलाव किए बिना भी, ऐप्लिकेशन को चलाया जा सकता है और उसे काम करते हुए देखा जा सकता है:
$ bin/dev
=> Booting Puma
=> Rails 8.0.1 application starting in development
...
* Listening on http://127.0.0.1:3000
अब अपना ब्लॉग http://localhost:3000/posts पर खोला जा सकता है और पोस्ट लिखना शुरू किया जा सकता है!
आपके पास कुछ ही मिनटों में बनाया गया, बहुत ही आसान लेकिन काम का ब्लॉग ऐप्लिकेशन है. यह एक फ़ुल-स्टैक, सर्वर से कंट्रोल किया जाने वाला ऐप्लिकेशन है: आपके पास अपना डेटा सेव करने के लिए एक डेटाबेस (SQLite), एचटीटीपी अनुरोधों (Puma) को मैनेज करने के लिए एक वेब सर्वर, और अपने कारोबार के लॉजिक को सेव करने, यूज़र इंटरैक्शन को प्रोसेस करने, और यूज़र इंटरफ़ेस (यूआई) देने के लिए एक Ruby प्रोग्राम है. आखिर में, ब्राउज़िंग अनुभव को बेहतर बनाने के लिए, JavaScript (Turbo) की एक छोटी लेयर होती है.
Rails का आधिकारिक डेमो, इस ऐप्लिकेशन को बेर मेटल सर्वर पर डिप्लॉय करने की दिशा में आगे बढ़ रहा है. इससे, इसे प्रोडक्शन के लिए तैयार किया जा सकेगा. आपकी प्रोसेस, उल्टी दिशा में जारी रहेगी: अपने ऐप्लिकेशन को किसी दूर की जगह पर डालने के बजाय, आपको उसे स्थानीय तौर पर "डिप्लॉय" करना होगा.
अगला लेवल: Wasm में "15 मिनट में ब्लॉग"
WebAssembly के जुड़ने के बाद, ब्राउज़र में न सिर्फ़ JavaScript कोड, बल्कि Wasm में कंपाइल किया जा सकने वाला कोई भी कोड चलाया जा सकता है. रूबी भी इससे अलग नहीं है. ज़रूर, Rails, Ruby से ज़्यादा है, लेकिन अंतरों के बारे में जानने से पहले, चलिए हम डेमो जारी रखते हैं और Rails ऐप्लिकेशन को wasmify (wasmify-rails लाइब्रेरी से लिया गया एक क्रियापद) करते हैं!
अपने ब्लॉग ऐप्लिकेशन को Wasm मॉड्यूल में कंपाइल करने और उसे ब्राउज़र में चलाने के लिए, आपको कुछ निर्देशों को पूरा करना होगा.
सबसे पहले, Bundler (Ruby का npm
) का इस्तेमाल करके wasmify-rails लाइब्रेरी इंस्टॉल करें और Rails सीएलआई का इस्तेमाल करके उसका जनरेटर चलाएं:
$ bundle add wasmify-rails
$ bin/rails wasmify:install
create config/wasmify.yml
create config/environments/wasm.rb
...
info ✅ The application is prepared for Wasm-ificaiton!
wasmify:rails
कमांड, डिफ़ॉल्ट "डेवलपमेंट", "टेस्ट", और "प्रोडक्शन" एनवायरमेंट के अलावा, खास "wasm" एक्सीक्यूशन एनवायरमेंट को कॉन्फ़िगर करता है. साथ ही, ज़रूरी डिपेंडेंसी इंस्टॉल करता है. नए Rails ऐप्लिकेशन को Wasm के साथ काम करने के लिए तैयार करने के लिए, यह काफ़ी है.
इसके बाद, Ruby रनटाइम, स्टैंडर्ड लाइब्रेरी, और ऐप्लिकेशन की सभी डिपेंडेंसी वाला मुख्य Wasm मॉड्यूल बनाएं:
$ bin/rails wasmify:build
==> RubyWasm::BuildSource(3.3) -- Building
...
==> RubyWasm::CrossRubyProduct(ruby-3.3-wasm32-unknown-wasip1-full-4aaed4fbda7afe0bdf4e22167afd101e) -- done in 47.37s
INFO: Packaging gem: rake-13.2.1
...
INFO: Packaging gem: wasmify-rails-0.2.0
INFO: Packaging setup.rb: bundle/setup.rb
INFO: Size: 73.77 MB
इस चरण में कुछ समय लग सकता है: तीसरे पक्ष की लाइब्रेरी से नेटिव एक्सटेंशन (C में लिखे गए) को सही तरीके से लिंक करने के लिए, आपको सोर्स से Ruby बनाना होगा. इस पोस्ट में, इस (कुछ समय के लिए) नुकसान के बारे में बाद में बताया गया है.
कंपाइल किया गया Wasm मॉड्यूल, आपके ऐप्लिकेशन के लिए सिर्फ़ एक बुनियाद है. आपको ऐप्लिकेशन कोड और सभी एसेट (उदाहरण के लिए, इमेज, सीएसएस, JavaScript) को भी पैक करना होगा. पैक करने से पहले, एक बुनियादी लॉन्चर ऐप्लिकेशन बनाएं. इसका इस्तेमाल, ब्राउज़र में wasmified Rails को चलाने के लिए किया जा सकता है. इसके लिए, जनरेटर का एक निर्देश भी है:
$ bin/rails wasmify:pwa
create pwa
create pwa/boot.html
create pwa/boot.js
...
prepend config/wasmify.yml
पिछला निर्देश, Vite की मदद से बनाया गया एक छोटा PWA ऐप्लिकेशन जनरेट करता है. इसका इस्तेमाल, कंपाइल किए गए Rails Wasm मॉड्यूल की जांच करने के लिए स्थानीय तौर पर किया जा सकता है या ऐप्लिकेशन को डिस्ट्रिब्यूट करने के लिए स्टैटिक तौर पर डिप्लॉय किया जा सकता है.
अब लॉन्चर की मदद से, आपको पूरे ऐप्लिकेशन को एक ही Wasm बाइनरी में पैक करना होगा:
$ bin/rails wasmify:pack
...
Packed the application to pwa/app.wasm
Size: 76.2 MB
हो गया! लॉन्चर ऐप्लिकेशन चलाएं और ब्राउज़र में अपने Rails ब्लॉगिंग ऐप्लिकेशन को पूरी तरह से काम करते हुए देखें:
$ cd pwa/
$ yarn dev
VITE v4.5.5 ready in 290 ms
➜ Local: http://localhost:5173/
http://localhost:5173 पर जाएं. इसके बाद, "लॉन्च करें" बटन के चालू होने का इंतज़ार करें और उस पर क्लिक करें. अब अपने ब्राउज़र में स्थानीय तौर पर चल रहे Rails ऐप्लिकेशन का आनंद लें!
क्या आपको यह अद्भुत नहीं लगता कि एक ही प्रोग्राम के तौर पर काम करने वाला सर्वर साइड ऐप्लिकेशन, न सिर्फ़ आपकी मशीन पर बल्कि ब्राउज़र के सैंडबॉक्स में भी चल सकता है? भले ही, मैं "जादूगर" हूं, लेकिन मेरे लिए यह अब भी एक फ़ैंटेसी जैसा लगता है. हालांकि, इसमें कोई जादू नहीं है. यह सिर्फ़ टेक्नोलॉजी की प्रगति है.
डेमो
लेख में एम्बेड किए गए डेमो को आज़माया जा सकता है या डेमो को अलग विंडो में लॉन्च किया जा सकता है. GitHub पर मौजूद सोर्स कोड देखें.
Wasm पर Rails के बारे में जानकारी
इस पोस्ट के बाकी हिस्से में, इस आर्किटेक्चर के कॉम्पोनेंट के बारे में बताया गया है. इससे, सर्वर-साइड ऐप्लिकेशन को Wasm मॉड्यूल में पैक करने से जुड़ी समस्याओं (और उनके समाधानों) को बेहतर तरीके से समझा जा सकता है.
वेब ऐप्लिकेशन, ऐप्लिकेशन कोड लिखने के लिए इस्तेमाल की गई प्रोग्रामिंग भाषा के अलावा कई और चीज़ों पर निर्भर करता है. हर कॉम्पोनेंट को ब्राउज़र में भी लाना होगा, जो आपके _लोकल डिप्लॉयमेंट एनवायरमेंट_ है. "15 मिनट में ब्लॉग" डेमो की दिलचस्प बात यह है कि इसे ऐप्लिकेशन कोड को फिर से लिखे बिना किया जा सकता है. क्लासिक, सर्वर-साइड मोड, और ब्राउज़र में ऐप्लिकेशन को चलाने के लिए, एक ही कोड का इस्तेमाल किया गया था.
Ruby on Rails जैसे फ़्रेमवर्क, आपको एक इंटरफ़ेस और इन्फ़्रास्ट्रक्चर कॉम्पोनेंट के साथ कम्यूनिकेट करने के लिए एक ऐब्सट्रैक्ट देते हैं. इस सेक्शन में, स्थानीय तौर पर विज्ञापन दिखाने से जुड़ी कुछ खास ज़रूरतों को पूरा करने के लिए, फ़्रेमवर्क के आर्किटेक्चर का इस्तेमाल करने के तरीके के बारे में बताया गया है.
फ़ाउंडेशन: ruby.wasm
Ruby को आधिकारिक तौर पर 2022 में Wasm के लिए तैयार माना गया है. इसका मतलब है कि C सोर्स कोड को Wasm में कंपाइल किया जा सकता है और Ruby VM को कहीं भी लाया जा सकता है. ruby.wasm प्रोजेक्ट, ब्राउज़र (या किसी अन्य JavaScript रनटाइम) में Ruby को चलाने के लिए, पहले से संकलित मॉड्यूल और JavaScript बाइंडिंग उपलब्ध कराता है. ruby:wasm प्रोजेक्ट में ऐसे बिल्ड टूल भी होते हैं जिनकी मदद से, अतिरिक्त डिपेंडेंसी के साथ कस्टम Ruby वर्शन बनाया जा सकता है. यह C एक्सटेंशन वाली लाइब्रेरी पर निर्भर प्रोजेक्ट के लिए बहुत ज़रूरी है. हां, नेटिव एक्सटेंशन को भी Wasm में संकलित किया जा सकता है! (अभी तक कोई एक्सटेंशन नहीं, लेकिन उनमें से ज़्यादातर).
फ़िलहाल, Ruby, WebAssembly सिस्टम इंटरफ़ेस, WASI 0.1 के साथ पूरी तरह काम करता है. WASI 0.2, जिसमें कॉम्पोनेंट मॉडल शामिल है, पहले से ही अल्फा स्टेटस में है और इसे पूरा करने में कुछ ही चरण बाकी हैं.WASI 0.2 के उपलब्ध होने के बाद, हर बार नई नेटिव डिपेंडेंसी जोड़ने के लिए, पूरी भाषा को फिर से कंपाइल करने की ज़रूरत नहीं होगी: उन्हें कॉम्पोनेंट में बदला जा सकता है.
इसकी वजह से, कॉम्पोनेंट मॉडल की मदद से बंडल का साइज़ भी कम किया जा सकता है. ruby.wasm के डेवलपमेंट और प्रोग्रेस के बारे में ज़्यादा जानने के लिए, WebAssembly पर Ruby की मदद से क्या-क्या किया जा सकता है टॉक देखें.
इसलिए, Wasm समीकरण का Ruby हिस्सा हल हो गया है. हालांकि, वेब फ़्रेमवर्क के तौर पर Rails को, पिछले डायग्राम में दिखाए गए सभी कॉम्पोनेंट की ज़रूरत होती है. ब्राउज़र में अन्य कॉम्पोनेंट डालने और उन्हें Rails में एक-दूसरे से लिंक करने का तरीका जानने के लिए, आगे पढ़ें.
ब्राउज़र में चल रहे डेटाबेस से कनेक्ट करना
SQLite3, आधिकारिक Wasm डिस्ट्रिब्यूशन और उससे जुड़े JavaScript रैपर के साथ आता है. इसलिए, इसे ब्राउज़र में एम्बेड किया जा सकता है. Wasm के लिए PostgreSQL, PGlite प्रोजेक्ट के ज़रिए उपलब्ध है. इसलिए, आपको सिर्फ़ यह पता लगाना होगा कि Rails on Wasm ऐप्लिकेशन से, ब्राउज़र में मौजूद डेटाबेस से कैसे कनेक्ट किया जाए.
डेटा मॉडलिंग और डेटाबेस इंटरैक्शन के लिए ज़िम्मेदार, Rails के कॉम्पोनेंट या सब-फ़्रेमवर्क को ऐक्टिव रिकॉर्ड कहा जाता है. हां, इसका नाम ओआरएम डिज़ाइन पैटर्न के नाम पर रखा गया है. Active Record, डेटाबेस अडैप्टर की मदद से, ऐप्लिकेशन कोड से एसक्यूएल वाले डेटाबेस को लागू करने की प्रोसेस को अलग रखता है. Rails में, SQLite3, PostgreSQL, और MySQL अडैप्टर पहले से मौजूद होते हैं. हालांकि, ये सभी नेटवर्क पर उपलब्ध असल डेटाबेस से कनेक्ट होने का अनुमान लगाते हैं. इस समस्या को हल करने के लिए, ब्राउज़र में मौजूद लोकल डेटाबेस से कनेक्ट करने के लिए, खुद के अडैप्टर लिखे जा सकते हैं!
Wasmify Rails प्रोजेक्ट के हिस्से के तौर पर लागू किए गए SQLite3 Wasm और PGlite अडैप्टर को इस तरह बनाया जाता है:
- अडैप्टर क्लास, उससे जुड़े पहले से मौजूद अडैप्टर (उदाहरण के लिए,
class PGliteAdapter < PostgreSQLAdapter
) से इनहेरिट करती है, ताकि क्वेरी तैयार करने और नतीजों को पार्स करने के लॉजिक का फिर से इस्तेमाल किया जा सके. - लो-लेवल डेटाबेस कनेक्शन के बजाय, JavaScript रनटाइम में मौजूद बाहरी इंटरफ़ेस ऑब्जेक्ट का इस्तेमाल किया जाता है. यह Rails Wasm मॉड्यूल और डेटाबेस के बीच एक ब्रिज की तरह काम करता है.
उदाहरण के लिए, यहां SQLite3 Wasm के लिए ब्रिज लागू करने का तरीका बताया गया है:
export function registerSQLiteWasmInterface(worker, db, opts = {}) {
const name = opts.name || "sqliteForRails";
worker[name] = {
exec: function (sql) {
let cols = [];
let rows = db.exec(sql, { columnNames: cols, returnValue: "resultRows" });
return {
cols,
rows,
};
},
changes: function () {
return db.changes();
},
};
}
ऐप्लिकेशन के हिसाब से, असल डेटाबेस से ब्राउज़र में मौजूद डेटाबेस पर स्विच करना, सिर्फ़ कॉन्फ़िगरेशन का मामला है:
# config/database.yml
development:
adapter: sqlite3
production:
adapter: sqlite3
wasm:
adapter: sqlite3_wasm
js_interface: "sqliteForRails"
लोकल डेटाबेस के साथ काम करने के लिए, ज़्यादा मेहनत की ज़रूरत नहीं होती. हालांकि, अगर किसी सेंट्रल सोर्स ऑफ़ ट्रूथ के साथ डेटा सिंक करना ज़रूरी है, तो आपको ज़्यादा मुश्किल का सामना करना पड़ सकता है. यह सवाल इस पोस्ट के दायरे से बाहर है (सलाह: PGlite और ElectricSQL डेमो पर Rails देखें).
वेब सर्वर के तौर पर सर्विस वर्कर
किसी भी वेब ऐप्लिकेशन का एक और ज़रूरी कॉम्पोनेंट वेब सर्वर है. उपयोगकर्ता, एचटीटीपी अनुरोधों का इस्तेमाल करके वेब ऐप्लिकेशन के साथ इंटरैक्ट करते हैं. इसलिए, आपको नेविगेशन या फ़ॉर्म सबमिशन से ट्रिगर किए गए एचटीटीपी अनुरोधों को अपने Wasm मॉड्यूल पर भेजने का तरीका चाहिए. हालांकि, ब्राउज़र में इसका जवाब है—सेवा वर्कर.
सर्विस वर्कर एक खास तरह का वेब वर्कर है, जो JavaScript ऐप्लिकेशन और नेटवर्क के बीच प्रॉक्सी के तौर पर काम करता है. यह अनुरोधों को इंटरसेप्ट कर सकता है और उनमें बदलाव कर सकता है. उदाहरण के लिए: कैश मेमोरी में सेव किया गया डेटा दिखाना, दूसरे यूआरएल पर रीडायरेक्ट करना या… Wasm मॉड्यूल पर रीडायरेक्ट करना! यहां Wasm में चल रहे Rails ऐप्लिकेशन का इस्तेमाल करके, अनुरोधों को पूरा करने वाली सेवा का स्केच दिया गया है:
// The vm variable holds a reference to the Wasm module with a
// Ruby VM initialized
let vm;
// The db variable holds a reference to the in-browser
// database interface
let db;
const initVM = async (progress, opts = {}) => {
if (vm) return vm;
if (!db) {
await initDB(progress);
}
vm = await initRailsVM("/app.wasm");
return vm;
};
const rackHandler = new RackHandler(initVM});
self.addEventListener("fetch", (event) => {
// ...
return event.respondWith(
rackHandler.handle(event.request)
);
});
जब भी ब्राउज़र से कोई अनुरोध किया जाता है, तब "फ़ेच" ट्रिगर होता है. आपके पास अनुरोध की जानकारी (यूआरएल, एचटीटीपी हेडर, कोड) पाने और अपना अनुरोध ऑब्जेक्ट बनाने का विकल्प होता है.
Rails, ज़्यादातर Ruby वेब ऐप्लिकेशन की तरह, एचटीटीपी अनुरोधों के साथ काम करने के लिए Rack इंटरफ़ेस पर निर्भर करता है. Rack इंटरफ़ेस, अनुरोध और रिस्पॉन्स ऑब्जेक्ट के फ़ॉर्मैट के साथ-साथ, एचटीटीपी हैंडलर (ऐप्लिकेशन) के इंटरफ़ेस के बारे में बताता है. इन प्रॉपर्टी को इस तरह दिखाया जा सकता है:
request = {
"REQUEST_METHOD" => "GET",
"SCRIPT_NAME" => "",
"SERVER_NAME" => "localhost",
"SERVER_PORT" => "3000",
"PATH_INFO" => "/posts"
}
handler = proc do |env|
[
200,
{"Content-Type" => "text/html"},
["<!doctype html><html><body>Hello Web!</body></html>"]
]
end
handler.call(request) #=> [200, {...}, [...]]
अगर आपको अनुरोध का फ़ॉर्मैट जाना-पहचाना लगा, तो हो सकता है कि आपने पहले कभी CGI का इस्तेमाल किया हो.
RackHandler
JavaScript ऑब्जेक्ट, अनुरोधों और जवाबों को JavaScript और Ruby रीलम के बीच बदलने के लिए ज़िम्मेदार होता है. Rack का इस्तेमाल ज़्यादातर
Ruby वेब ऐप्लिकेशन करते हैं. इसलिए, इसे Rails के बजाय यूनिवर्सल तौर पर लागू किया जाता है.
हालांकि, असल में लागू करने का तरीका बहुत लंबा है, इसलिए इसे यहां पोस्ट नहीं किया जा सकता.
सर्विस वर्कर, ब्राउज़र में काम करने वाले वेब ऐप्लिकेशन के मुख्य हिस्सों में से एक है. यह सिर्फ़ एक एचटीटीपी प्रॉक्सी नहीं है, बल्कि यह कैश मेमोरी लेयर और नेटवर्क स्विचर भी है. इसका मतलब है कि लोकल-फ़र्स्ट या ऑफ़लाइन काम करने वाला ऐप्लिकेशन बनाया जा सकता है. यह एक ऐसा कॉम्पोनेंट भी है जिसकी मदद से, उपयोगकर्ताओं की अपलोड की गई फ़ाइलों को दिखाया जा सकता है.
ब्राउज़र में फ़ाइलें अपलोड करना
आपके नए ब्लॉग ऐप्लिकेशन में लागू की जाने वाली पहली अतिरिक्त सुविधाओं में, फ़ाइल अपलोड करने की सुविधा या खास तौर पर, पोस्ट में इमेज अटैच करने की सुविधा शामिल हो सकती है. ऐसा करने के लिए, आपको फ़ाइलों को सेव और दिखाने का तरीका चाहिए.
Rails में, फ़्रेमवर्क के उस हिस्से को Active Storage कहा जाता है जो फ़ाइल अपलोड से जुड़ी प्रोसेस को मैनेज करता है. Active Storage की मदद से, डेवलपर को फ़ाइलों के साथ काम करने के लिए, एब्स्ट्रैक्शन और इंटरफ़ेस मिलते हैं. इससे उन्हें स्टोरेज के लो-लेवल मशीनरी के बारे में सोचने की ज़रूरत नहीं पड़ती. फ़ाइलों को हार्ड ड्राइव या क्लाउड में सेव करने पर, ऐप्लिकेशन को इसकी जानकारी नहीं मिलती.
Active Record की तरह ही, कस्टम स्टोरेज का इस्तेमाल करने के लिए, आपको सिर्फ़ उससे जुड़ा स्टोरेज सेवा अडैप्टर लागू करना होगा. ब्राउज़र में फ़ाइलें कहां सेव करें?
डेटाबेस का इस्तेमाल करना, एक पारंपरिक तरीका है. हां, डेटाबेस में फ़ाइलों को ब्लॉब के तौर पर सेव किया जा सकता है. इसके लिए, किसी अन्य इन्फ़्रास्ट्रक्चर कॉम्पोनेंट की ज़रूरत नहीं होती. Rails में, इसके लिए पहले से ही एक प्लग इन मौजूद है, जिसका नाम Active Storage Database है. हालांकि, WebAssembly में चल रहे Rails ऐप्लिकेशन के ज़रिए, डेटाबेस में सेव की गई फ़ाइलें दिखाना सही नहीं है. इसकी वजह यह है कि इसमें (डि-)सीरियलाइज़ेशन के राउंड शामिल होते हैं, जो बिना किसी शुल्क के नहीं होते.
फ़ाइल सिस्टम एपीआई का इस्तेमाल करना, ब्राउज़र के लिए बेहतर और ऑप्टिमाइज़ किया गया समाधान होगा. साथ ही, इससे फ़ाइल अपलोड और सर्वर से अपलोड की गई फ़ाइलों को सीधे तौर पर, सेवा वर्कर्स से प्रोसेस किया जा सकेगा. इस तरह के इन्फ़्रास्ट्रक्चर के लिए, OPFS (ऑरिजिन प्राइवेट फ़ाइल सिस्टम) सबसे सही विकल्प है. यह हाल ही में लॉन्च किया गया ब्राउज़र एपीआई है, जो आने वाले समय में ब्राउज़र में काम करने वाले ऐप्लिकेशन के लिए अहम भूमिका निभाएगा.
Rails और Wasm एक साथ क्या कर सकते हैं
हमें पूरा भरोसा है कि लेख पढ़ना शुरू करने के बाद से ही, आपके मन में यह सवाल आ रहा होगा: ब्राउज़र में सर्वर-साइड फ़्रेमवर्क क्यों चलाया जाता है? किसी फ़्रेमवर्क या लाइब्रेरी को सर्वर-साइड (या क्लाइंट-साइड) कहना सिर्फ़ एक लेबल है. अच्छा कोड और खास तौर पर, अच्छा एब्स्ट्रैक्शन हर जगह काम करता है. लेबल की वजह से, आपको नई संभावनाओं को एक्सप्लोर करने और फ़्रेमवर्क (उदाहरण के लिए, Ruby on Rails) और रनटाइम (WebAssembly) की सीमाओं को आगे बढ़ाने से नहीं रोकना चाहिए. इन असामान्य इस्तेमाल के उदाहरणों से, दोनों को फ़ायदा मिल सकता है.
इसके अलावा, सामान्य या काम के कई उदाहरण भी हैं.
सबसे पहले, फ़्रेमवर्क को ब्राउज़र पर लाने से, सीखने और प्रोटोटाइप बनाने के बहुत सारे अवसर मिलते हैं. कल्पना करें कि आपके पास अपने ब्राउज़र में, लाइब्रेरी, प्लग इन, और पैटर्न के साथ-साथ, दूसरे लोगों के साथ काम करने का विकल्प हो. Stackblitz ने JavaScript फ़्रेमवर्क के लिए, ऐसा करना मुमकिन बनाया. WordPress प्लेग्राउंड एक और उदाहरण है. इसकी मदद से, वेब पेज पर ही WordPress थीम को आज़माया जा सकता है. Wasm की मदद से, Ruby और उसके इकोसिस्टम के लिए भी ऐसा किया जा सकता है.
ब्राउज़र में कोडिंग करने का एक खास मामला है, जो खास तौर पर ओपन सोर्स डेवलपर के लिए फ़ायदेमंद है. यह मामला समस्याओं को प्राथमिकता के हिसाब से तय करने और उन्हें डीबग करने से जुड़ा है. फिर से, StackBlitz ने इसे JavaScript प्रोजेक्ट के लिए उपलब्ध कराया है: आपको समस्या को दोहराने वाली कम से कम स्क्रिप्ट बनानी होगी और GitHub समस्या में लिंक देना होगा. इससे, समस्या को ठीक करने वाले लोगों को आपकी समस्या को दोहराने में लगने वाला समय बचेगा. असल में, RunRuby.dev प्रोजेक्ट की मदद से, Ruby में यह सुविधा पहले से ही उपलब्ध है. यहां ब्राउज़र में समस्या को दोहराकर हल करने का एक उदाहरण दिया गया है.
इस्तेमाल का एक और उदाहरण, ऑफ़लाइन काम करने वाले (या ऑफ़लाइन काम करने की सुविधा वाले) ऐप्लिकेशन हैं. ऑफ़लाइन काम करने वाले ऐसे ऐप्लिकेशन जो आम तौर पर नेटवर्क का इस्तेमाल करके काम करते हैं. हालांकि, नेटवर्क कनेक्शन न होने पर भी इनका इस्तेमाल किया जा सकता है. उदाहरण के लिए, ऐसा ईमेल क्लाइंट जिसकी मदद से ऑफ़लाइन रहते हुए अपने इनबॉक्स में खोजा जा सकता है. इसके अलावा, आपके पास "डिवाइस पर सेव करें" सुविधा वाला कोई संगीत लाइब्रेरी ऐप्लिकेशन भी हो सकता है. इससे, नेटवर्क कनेक्शन न होने पर भी आपका पसंदीदा संगीत चलता रहेगा. दोनों उदाहरण, लोकल स्टोरेज में सेव किए गए डेटा पर निर्भर करते हैं. इनमें, क्लासिक PWA की तरह कैश मेमोरी का इस्तेमाल नहीं किया जाता.
आखिर में, Rails की मदद से लोकल (या डेस्कटॉप) ऐप्लिकेशन बनाना भी सही है, क्योंकि फ़्रेमवर्क से मिलने वाली प्रोडक्टिविटी, रनटाइम पर निर्भर नहीं करती. सभी सुविधाओं वाले फ़्रेमवर्क, निजी डेटा और लॉजिक पर आधारित ऐप्लिकेशन बनाने के लिए सही होते हैं. इसके अलावा, Wasm को पोर्टेबल डिस्ट्रिब्यूशन फ़ॉर्मैट के तौर पर इस्तेमाल करना भी एक सही विकल्प है.
यह Wasm पर Rails के सफ़र की शुरुआत भर है. WebAssembly पर Ruby on Rails वाली ई-बुक में, इन समस्याओं और उनके समाधानों के बारे में ज़्यादा जानें. यह ई-बुक, ऑफ़लाइन काम करने वाला Rails ऐप्लिकेशन है.