કેવી રીતે ક્વાર્કસ આવશ્યક અને પ્રતિક્રિયાશીલ પ્રોગ્રામિંગને જોડે છે

આ વર્ષે અમે કન્ટેનર થીમ્સને ગંભીરતાથી વિકસાવવાની યોજના બનાવી છે, ક્લાઉડ-નેટિવ જાવા и ક્યુબર્નેટિસ. આ વિષયોનું તાર્કિક સાતત્ય એ ક્વાર્કસ ફ્રેમવર્ક વિશેની વાર્તા હશે, પહેલેથી જ ગણવામાં આવે છે હેબ્રે પર. આજનો લેખ "સબેટોમિક સુપરફાસ્ટ જાવા" ની ડિઝાઇન વિશે ઓછો છે અને ક્વાર્કસ એન્ટરપ્રાઇઝ માટે લાવે છે તે વચન વિશે વધુ છે.

જાવા અને JVM હજુ પણ અત્યંત લોકપ્રિય છે, પરંતુ જ્યારે સર્વરલેસ ટેક્નોલોજી અને ક્લાઉડ-નેટિવ માઇક્રોસર્વિસિસ સાથે કામ કરવામાં આવે છે, ત્યારે જાવા અને અન્ય JVM ભાષાઓનો ઉપયોગ ઓછો અને ઓછો થાય છે કારણ કે તે ઘણી બધી મેમરી સ્પેસ લે છે અને લોડ કરવામાં ખૂબ ધીમી છે, જેનાથી તે બનાવે છે. અલ્પજીવી કન્ટેનર સાથે વાપરવા માટે ખરાબ રીતે અનુકૂળ. સદભાગ્યે, આ પરિસ્થિતિ હવે ક્વાર્કસને કારણે બદલાવા લાગી છે.

સુપરફાસ્ટ સબએટોમિક જાવા નવા સ્તરે પહોંચી ગયું છે!

42 રિલીઝ, 8 મહિનાનું સામુદાયિક કાર્ય અને 177 અદ્ભુત વિકાસકર્તાઓ - આ બધાનું પરિણામ નવેમ્બર 2019 માં રિલીઝ થયું ક્વાર્કસ 1.0, એક રિલીઝ જે પ્રોજેક્ટના વિકાસમાં એક મહત્વપૂર્ણ સીમાચિહ્નરૂપ છે અને ઘણી બધી શાનદાર સુવિધાઓ અને ક્ષમતાઓ પ્રદાન કરે છે (તમે તેમના વિશે વધુ વાંચી શકો છો જાહેરાત).

આજે અમે તમને બતાવીશું કે કેવી રીતે ક્વાર્કસ આવશ્યક અને પ્રતિક્રિયાશીલ પ્રોગ્રામિંગ મોડલ્સને એક જ પ્રતિક્રિયાશીલ કોરમાં જોડે છે. અમે સંક્ષિપ્ત ઇતિહાસથી શરૂઆત કરીશું અને પછી ક્વાર્કસનો પ્રતિક્રિયાશીલ કોર ડ્યુઅલિઝમ શું છે અને કેવી રીતે તે વિશે વિગતવાર જઈશું. જાવા-વિકાસકર્તાઓ આ લાભોનો લાભ લઈ શકે છે.

સૂક્ષ્મ સેવાઓ, ઘટના આધારિત આર્કિટેક્ચર и સર્વર વિના-ફંક્શન્સ - આ બધું છે, જેમ તેઓ કહે છે, આજે ઉદય પર છે. તાજેતરમાં, ક્લાઉડ-સેન્ટ્રીક આર્કિટેક્ચરનું નિર્માણ ખૂબ સરળ અને વધુ સુલભ બન્યું છે, પરંતુ સમસ્યાઓ રહે છે - ખાસ કરીને જાવા વિકાસકર્તાઓ માટે. ઉદાહરણ તરીકે, સર્વરલેસ ફંક્શન્સ અને માઇક્રોસર્વિસિસના કિસ્સામાં, સ્ટાર્ટઅપનો સમય ઘટાડવા, મેમરી વપરાશ ઘટાડવા અને હજુ પણ તેમના વિકાસને વધુ અનુકૂળ અને આનંદપ્રદ બનાવવાની તાત્કાલિક જરૂર છે. જાવા એ તાજેતરના વર્ષોમાં ઘણા સુધારાઓ કર્યા છે, જેમ કે કન્ટેનર માટે સુધારેલ અર્ગનોમિક્સ કાર્યક્ષમતા વગેરે. જો કે, જાવાને કન્ટેનરમાં યોગ્ય રીતે કામ કરવું એ હજુ પણ પડકારજનક છે. તેથી અમે જાવાની કેટલીક સહજ જટિલતાઓને જોઈને શરૂઆત કરીશું, જે કન્ટેનર-ઓરિએન્ટેડ જાવા એપ્લિકેશન્સ વિકસાવતી વખતે ખાસ કરીને તીવ્ર હોય છે.

પ્રથમ, ચાલો ઇતિહાસ જોઈએ.

સ્ટ્રીમ્સ અને કન્ટેનર

સંસ્કરણ 8u131 થી શરૂ કરીને, જાવા એર્ગોનોમિક્સ કાર્યક્ષમતામાં સુધારાને કારણે કન્ટેનરને વધુ કે ઓછા સમર્થન આપવાનું શરૂ કર્યું. ખાસ કરીને, JVM હવે જાણે છે કે તે કેટલા પ્રોસેસર કોરો પર ચાલી રહ્યું છે અને તે મુજબ થ્રેડ પૂલ-સામાન્ય રીતે ફોર્ક/જોઇન પૂલ ગોઠવી શકે છે. અલબત્ત, આ સરસ છે, પરંતુ ચાલો કહીએ કે અમારી પાસે પરંપરાગત વેબ એપ્લિકેશન છે જે HTTP સર્વલેટ્સનો ઉપયોગ કરે છે અને ટોમકેટ, જેટી વગેરેમાં ચાલે છે. પરિણામે, આ એપ્લિકેશન દરેક વિનંતીને એક અલગ થ્રેડ આપશે અને I/O કામગીરીની રાહ જોતી વખતે તેને આ થ્રેડને અવરોધિત કરવાની મંજૂરી આપશે, ઉદાહરણ તરીકે, ડેટાબેઝ, ફાઇલો અથવા અન્ય સેવાઓને ઍક્સેસ કરતી વખતે. એટલે કે, આવી એપ્લિકેશનનું કદ ઉપલબ્ધ કોરોની સંખ્યા પર આધારિત નથી, પરંતુ એક સાથે વિનંતીઓની સંખ્યા પર આધારિત છે. વધુમાં, આનો અર્થ એ છે કે કોરોની સંખ્યા પર કુબરનેટ્સમાં ક્વોટા અથવા મર્યાદાઓ અહીં વધુ મદદરૂપ થશે નહીં, અને આ બાબત આખરે થ્રોટલિંગમાં સમાપ્ત થશે.

મેમરી થાક

થ્રેડો મેમરી છે. અને ઇન્ટ્રા-કન્ટેનર મેમરી મર્યાદાઓ કોઈ પણ રીતે રામબાણ નથી. ફક્ત એપ્લિકેશનો અને થ્રેડોની સંખ્યામાં વધારો કરવાનું શરૂ કરો, અને વહેલા કે પછી તમે સ્વિચિંગ ફ્રીક્વન્સીમાં ગંભીર વધારો અને પરિણામે, કાર્યક્ષમતામાં અધોગતિનો સામનો કરશો. ઉપરાંત, જો તમારી એપ્લિકેશન પરંપરાગત માઇક્રોસર્વિસ ફ્રેમવર્કનો ઉપયોગ કરે છે, અથવા ડેટાબેઝ સાથે કનેક્ટ કરે છે, અથવા કેશીંગનો ઉપયોગ કરે છે, અથવા અન્યથા મેમરીનો ઉપયોગ કરે છે, તો તમારે દેખીતી રીતે એક સાધનની જરૂર છે જે તમને JVM ની અંદર જોવાની પરવાનગી આપે છે અને તે કેવી રીતે મેમરીને માર્યા વિના તેનું સંચાલન કરે છે તે જોવાની મંજૂરી આપે છે. JVM પોતે (ઉદાહરણ તરીકે, XX:+UseCGroupMemoryLimitForHeap). અને તેમ છતાં, જાવા 9 થી, JVM એ cgroups સ્વીકારવાનું અને તે મુજબ અનુકૂલન કરવાનું શીખી લીધું છે, મેમરીને અનામત રાખવું અને તેનું સંચાલન કરવું એ એક જટિલ બાબત છે.

ક્વોટા અને મર્યાદા

Java 11 એ CPU ક્વોટા (જેમ કે PreferContainerQuotaForCPUCount) માટે સપોર્ટ રજૂ કર્યો. Kubernetes મર્યાદા અને ક્વોટા માટે પણ સપોર્ટ આપે છે. હા, આ બધું અર્થપૂર્ણ છે, પરંતુ જો એપ્લિકેશન ફરીથી ફાળવેલ ક્વોટા કરતાં વધી જાય, તો અમે ફરીથી કદ સાથે સમાપ્ત કરીએ છીએ - જેમ કે પરંપરાગત જાવા એપ્લિકેશનના કિસ્સામાં છે - કોરોની સંખ્યા દ્વારા અને દરેક માટે અલગ થ્રેડની ફાળવણી સાથે નિર્ધારિત વિનંતી, તો પછી આ બધામાં થોડો અર્થ નથી.
વધુમાં, જો તમે ક્વોટા અને મર્યાદાઓનો ઉપયોગ કરો છો અથવા Kubernetes અંતર્ગત પ્લેટફોર્મના સ્કેલ-આઉટ ફંક્શનનો ઉપયોગ કરો છો, તો સમસ્યા પણ પોતે હલ થતી નથી. અમે ફક્ત મૂળ સમસ્યાને ઉકેલવા માટે વધુ સંસાધનો ખર્ચીએ છીએ અથવા વધુ પડતો ખર્ચ કરીએ છીએ. અને જો તે સાર્વજનિક પબ્લિક ક્લાઉડમાં હાઇ-લોડ સિસ્ટમ છે, તો અમે લગભગ ચોક્કસપણે વધુ સંસાધનોનો ઉપયોગ કરીશું જે આપણને ખરેખર જરૂર છે.

અને આ બધાનું શું કરવું?

તેને સરળ રીતે કહીએ તો, અસુમેળ અને બિન-અવરોધિત I/O લાઇબ્રેરીઓ અને ફ્રેમવર્કનો ઉપયોગ કરો જેમ કે Netty, Vert.x અથવા અક્કા. તેઓ તેમની પ્રતિક્રિયાશીલ પ્રકૃતિને કારણે કન્ટેનરમાં કામ કરવા માટે વધુ યોગ્ય છે. I/O ને અવરોધિત ન કરવા બદલ આભાર, સમાન થ્રેડ એક સાથે બહુવિધ વિનંતીઓ પર પ્રક્રિયા કરી શકે છે. જ્યારે એક વિનંતિ I/O પરિણામોની રાહ જોઈ રહી છે, ત્યારે તે જે થ્રેડ પ્રોસેસિંગ કરે છે તેને રિલીઝ કરવામાં આવે છે અને બીજી વિનંતી દ્વારા કબજો લેવામાં આવે છે. અને જ્યારે I/O પરિણામો આખરે આવે છે, ત્યારે પ્રથમ વિનંતીની પ્રક્રિયા ચાલુ રહે છે. સમાન થ્રેડમાં વિનંતીઓની ઇન્ટરલીવ્ડ પ્રોસેસિંગ દ્વારા, તમે થ્રેડોની કુલ સંખ્યા ઘટાડી શકો છો અને વિનંતીઓની પ્રક્રિયા કરવા માટે સંસાધનનો વપરાશ ઘટાડી શકો છો.

નોન-બ્લોકિંગ I/O સાથે, કોરોની સંખ્યા મુખ્ય પરિમાણ બની જાય છે કારણ કે તે I/O થ્રેડોની સંખ્યા નક્કી કરે છે જે સમાંતર રીતે ચલાવી શકાય છે. જ્યારે યોગ્ય રીતે ઉપયોગ કરવામાં આવે, ત્યારે આ તમને કોરો વચ્ચેના ભારને અસરકારક રીતે વિતરિત કરવાની અને ઓછા સંસાધનો સાથે ઉચ્ચ વર્કલોડને હેન્ડલ કરવાની મંજૂરી આપે છે.

કેવી રીતે, તે બધું છે?

ના, બીજું કંઈક છે. પ્રતિક્રિયાશીલ પ્રોગ્રામિંગ સંસાધનોનો બહેતર ઉપયોગ કરવામાં મદદ કરે છે, પરંતુ તે કિંમતે પણ આવે છે. ખાસ કરીને, કોડને બિન-અવરોધિત કરવાના સિદ્ધાંતો અનુસાર ફરીથી લખવો પડશે અને I/O થ્રેડોને અવરોધિત કરવાનું ટાળવું પડશે. અને આ વિકાસ અને અમલનું એક સંપૂર્ણપણે અલગ મોડલ છે. અને જો કે અહીં ઘણી બધી ઉપયોગી લાઈબ્રેરીઓ છે, તે હજુ પણ સામાન્ય વિચારસરણીમાં આમૂલ પરિવર્તન છે.

પ્રથમ, તમારે કોડ કેવી રીતે લખવો તે શીખવાની જરૂર છે જે અસુમેળ રીતે ચાલે છે. એકવાર તમે નોન-બ્લોકિંગ I/O નો ઉપયોગ કરવાનું શરૂ કરો, તમારે સ્પષ્ટપણે સ્પષ્ટ કરવાની જરૂર છે કે જ્યારે વિનંતીનો પ્રતિસાદ પ્રાપ્ત થાય ત્યારે શું થવું જોઈએ. ફક્ત અવરોધિત કરવું અને રાહ જોવી એ હવે કામ કરશે નહીં. તેના બદલે, તમે કૉલબૅક્સ પસાર કરી શકો છો, પ્રતિક્રિયાશીલ પ્રોગ્રામિંગ અથવા ચાલુ રાખવાનો ઉપયોગ કરી શકો છો. પરંતુ આટલું જ નથી: નોન-બ્લોકિંગ I/O નો ઉપયોગ કરવા માટે, તમારે બિન-બ્લોકીંગ સર્વર્સ અને ક્લાયંટ બંનેની જરૂર છે, પ્રાધાન્ય સર્વત્ર. HTTP ના કિસ્સામાં, બધું સરળ છે, પરંતુ ડેટાબેસેસ, ફાઇલ સિસ્ટમ્સ અને ઘણું બધું પણ છે.

અને તેમ છતાં કુલ એન્ડ-ટુ-એન્ડ રીએક્ટિવિટી કાર્યક્ષમતાને મહત્તમ બનાવે છે, આવી પાળી વ્યવહારમાં પેટ માટે મુશ્કેલ બની શકે છે. તેથી, પ્રતિક્રિયાશીલ અને આવશ્યક કોડને જોડવાની ક્ષમતા આ માટે પૂર્વશરત બની જાય છે:

1. સોફ્ટવેર સિસ્ટમના સૌથી વધુ લોડ થયેલ વિસ્તારોમાં સંસાધનોનો અસરકારક રીતે ઉપયોગ કરો;
2. તેના બાકીના ભાગોમાં સરળ શૈલી કોડનો ઉપયોગ કરો.

ક્વાર્કસનો પરિચય

વાસ્તવમાં, આ ક્વાર્કસનો સાર છે - એક જ રનટાઈમ વાતાવરણમાં પ્રતિક્રિયાશીલ અને આવશ્યક મોડલ્સને જોડવા.

Quarkus Vert.x અને Netty પર આધારિત છે, જેમાં ડેવલપરને મદદ કરવા ટોચ પર પ્રતિક્રિયાશીલ ફ્રેમવર્ક અને એક્સ્ટેન્શન્સની શ્રેણી છે. ક્વાર્કસને માત્ર HTTP માઈક્રોસર્વિસિસ જ નહીં, પણ ઈવેન્ટ-આધારિત આર્કિટેક્ચર્સ બનાવવા માટે બનાવવામાં આવ્યું છે. તેની પ્રતિક્રિયાશીલ પ્રકૃતિને લીધે, તે મેસેજિંગ સિસ્ટમ્સ (Apache Kafka, AMQP, વગેરે) સાથે ખૂબ જ અસરકારક રીતે કામ કરે છે.

યુક્તિ એ છે કે આવશ્યક અને પ્રતિક્રિયાશીલ કોડ બંને માટે સમાન પ્રતિક્રિયાશીલ એન્જિનનો ઉપયોગ કેવી રીતે કરવો.

ક્વાર્કસ આ તેજસ્વી રીતે કરે છે. અનિવાર્ય અને પ્રતિક્રિયાશીલ વચ્ચેની પસંદગી સ્પષ્ટ છે - બંને માટે પ્રતિક્રિયાશીલ કર્નલનો ઉપયોગ કરો. તે ખરેખર જે મદદ કરે છે તે ઝડપી, બિન-અવરોધિત કોડ છે જે ઇવેન્ટ-લૂપ થ્રેડ ઉર્ફે IO થ્રેડમાંથી પસાર થતી લગભગ દરેક વસ્તુને હેન્ડલ કરે છે. પરંતુ જો તમારી પાસે ક્લાસિક REST અથવા ક્લાયન્ટ-સાઇડ એપ્લિકેશન્સ છે, તો ક્વાર્કસ પાસે એક આવશ્યક પ્રોગ્રામિંગ મોડલ તૈયાર છે. ઉદાહરણ તરીકે, ક્વાર્કસમાં HTTP સપોર્ટ નોન-બ્લોકિંગ અને રિએક્ટિવ એન્જિન (એક્લિપ્સ વર્ટ.એક્સ અને નેટી) ના ઉપયોગ પર આધારિત છે. તમારી એપ્લિકેશન દ્વારા પ્રાપ્ત તમામ HTTP વિનંતીઓ પ્રથમ ઇવેન્ટ લૂપ (IO થ્રેડ) દ્વારા પસાર કરવામાં આવે છે અને પછી વિનંતીઓનું સંચાલન કરતા કોડના ભાગ પર મોકલવામાં આવે છે. ગંતવ્યના આધારે, વિનંતી મેનેજમેન્ટ કોડને અલગ થ્રેડ (કહેવાતા વર્કર થ્રેડ, સર્વલેટ્સ અને જેક્સ-આરએસના કિસ્સામાં ઉપયોગમાં લેવાય છે) અથવા સ્રોત I/O થ્રેડ (પ્રતિક્રિયાશીલ માર્ગ) નો ઉપયોગ કરી શકાય છે.

મેસેજિંગ સિસ્ટમ કનેક્ટર્સ Vert.x એન્જિનની ટોચ પર ચાલતા બિન-અવરોધિત ક્લાયંટનો ઉપયોગ કરે છે. તેથી, તમે મેસેજિંગ મિડલવેર સિસ્ટમ્સમાંથી અસરકારક રીતે સંદેશાઓ મોકલી, પ્રાપ્ત અને પ્રક્રિયા કરી શકો છો.

સાઇટ પર Quarkus.io Quarkus સાથે પ્રારંભ કરવામાં તમને મદદ કરવા માટે અહીં કેટલાક સારા ટ્યુટોરિયલ્સ છે:

• પ્રતિક્રિયાશીલ માર્ગોનો ઉપયોગ
• પ્રતિક્રિયાશીલ SQL ક્લાયંટ
• રિએક્ટિવ મેસેજિંગ સાથે અપાચે કાફકાનો ઉપયોગ
• પ્રતિક્રિયાશીલ મેસેજિંગ સાથે AMQP નો ઉપયોગ કરવો
• Vertx API નો ઉપયોગ કરીને

અમે તમને માત્ર એક બ્રાઉઝરમાં રિએક્ટિવ પ્રોગ્રામિંગના વિવિધ પાસાઓ શીખવવા માટે ઓનલાઈન હેન્ડ્સ-ઓન ટ્યુટોરિયલ્સ પણ બનાવ્યાં છે, કોઈ IDE જરૂરી નથી અને કોઈ કમ્પ્યુટરની જરૂર નથી. તમે આ પાઠો શોધી શકો છો અહીં.

ઉપયોગી સંસાધનો

• ક્વાર્કસ અજમાવવાના 4 કારણો
• ક્વાર્કસ પ્રોજેક્ટ વેબસાઇટ - quarkus.io
• GitHub પર કવાર્કસ પ્રોજેક્ટ - github.com/quarkusio/quarkus
• ક્વાર્કસ પ્રોજેક્ટ ટ્વિટર - twitter.com/QuarkusIO
• ક્વાર્કસ પ્રોજેક્ટ ચેટ - quarkusio.zulipchat.com
• ક્વાર્કસ પ્રોજેક્ટ ફોરમ્સ - group.google.com/forum/#!forum/quarkus-dev

વિષયથી પરિચિત થવા માટે ક્વાર્કસ પર 10 વિડિઓ પાઠ

જેમ તેઓ વેબસાઇટ પર કહે છે Quarkus.io, ક્વાર્કસ - છે ક્યુબર્નેટિસ-ઓરિએન્ટેડ જાવા સ્ટેક, ગ્રેલવીએમ અને ઓપનજેડીકે હોટસ્પોટ માટે તૈયાર કરેલ અને શ્રેષ્ઠ જાવા લાઇબ્રેરીઓ અને ધોરણોમાંથી એસેમ્બલ.

વિષયને સમજવામાં તમારી મદદ કરવા માટે, અમે 10 વિડિયો ટ્યુટોરિયલ્સ પસંદ કર્યા છે જે ક્વાર્કસના વિવિધ પાસાઓ અને તેના ઉપયોગના ઉદાહરણોને આવરી લે છે:

1. ક્વાર્કસનો પરિચય: કુબરનેટ્સ માટે નેક્સ્ટ જનરેશન જાવા ફ્રેમવર્ક

થોમસ કવર્નસ્ટ્રોમ અને જેસન ગ્રીન દ્વારા
ક્વાર્કસ પ્રોજેક્ટનો ધ્યેય કુબરનેટ્સ અને સર્વરલેસ એન્વાયર્નમેન્ટ્સ માટે જાવા પ્લેટફોર્મ બનાવવાનો છે, અને એક જ રનટાઈમ એન્વાયર્નમેન્ટમાં રિએક્ટિવ અને ઇમ્પેરેટિવ પ્રોગ્રામિંગ મૉડલ્સને જોડવાનું છે જેથી કરીને ડિસ્ટ્રિબ્યુટેડ એપ્લિકેશન આર્કિટેક્ચરની વિશાળ શ્રેણી સાથે કામ કરતી વખતે ડેવલપર્સ લવચીક રીતે તેમના અભિગમમાં ફેરફાર કરી શકે. નીચેના પ્રારંભિક વ્યાખ્યાનમાં વધુ જાણો.

2. ક્વાર્કસ: સુપરફાસ્ટ સબટોમિક જાવા

દ્વારા: બર સટર
ડેવનેશન લાઈવનું આ વિડિયો ટ્યુટોરીયલ દર્શાવે છે કે કુબરનેટસ/ઓપનશિફ્ટ એન્વાયર્નમેન્ટમાં એન્ટરપ્રાઈઝ જાવા એપ્લીકેશન, API, માઈક્રોસર્વિસીસ અને સર્વરલેસ ફંક્શન્સને ઓપ્ટિમાઈઝ કરવા માટે કવાર્કસનો ઉપયોગ કેવી રીતે કરવો, તેને વધુ નાનો, ઝડપી અને વધુ સ્કેલેબલ બનાવે છે.

3. ક્વાર્કસ અને ગ્રાલવીએમ: હાઇબરનેટને સુપર સ્પીડમાં ઝડપી બનાવવું અને તેને સબએટોમિક કદમાં સંકોચવું

લેખક: સાન્ને ગ્રિનવેરો
પ્રસ્તુતિમાંથી તમે શીખી શકશો કે ક્વાર્કસ કેવી રીતે બન્યું, તે કેવી રીતે કાર્ય કરે છે અને તે તમને કેવી રીતે જટિલ લાઇબ્રેરીઓ બનાવવા દે છે, જેમ કે હાઇબરનેટ ORM, નેટીવ ગ્રાલવીએમ ઈમેજીસ સાથે સુસંગત.

4. સર્વરલેસ એપ્લીકેશન વિકસાવવાનું શીખો

લેખક: માર્ટિન લ્યુથર
નીચેનો વિડિયો બતાવે છે કે કેવી રીતે ક્વાર્કસનો ઉપયોગ કરીને એક સરળ જાવા એપ્લિકેશન બનાવવી અને તેને Knative પર સર્વરલેસ એપ્લિકેશન તરીકે કેવી રીતે જમાવવી.

5. ક્વાર્કસ: મજામાં કોડિંગ કરો

લેખક: એડસન યાનાગા
તમારો પ્રથમ ક્વાર્કસ પ્રોજેક્ટ બનાવવા માટેની વિડિયો માર્ગદર્શિકા, જે તમને સમજવાની મંજૂરી આપે છે કે ક્વાર્કસ શા માટે વિકાસકર્તાઓનું દિલ જીતી રહ્યું છે.

6. જાવા અને કન્ટેનર - તેમનું ભવિષ્ય એકસાથે શું હશે

માર્ક લિટલ દ્વારા પોસ્ટ કરવામાં આવ્યું
આ પ્રસ્તુતિ જાવાના ઇતિહાસનો પરિચય આપે છે અને સમજાવે છે કે શા માટે ક્વાર્કસ જાવાનું ભવિષ્ય છે.

7. ક્વાર્કસ: સુપરફાસ્ટ સબટોમિક જાવા

લેખક: દિમિત્રીસ એન્ડ્રીડિસ
ક્વાર્કસના ફાયદાઓની ઝાંખી કે જેને વિકાસકર્તાઓ તરફથી માન્યતા મળી છે: સરળતા, અતિ-ઉચ્ચ ઝડપ, શ્રેષ્ઠ પુસ્તકાલયો અને ધોરણો.

8. ક્વાર્કસ અને સબએટોમિક રોકેટ સિસ્ટમ્સ

લેખક: ક્લેમેન્ટ એસ્કોફિયર
GraalVM સાથે સંકલન દ્વારા, ક્વાર્કસ અતિ ઝડપી વિકાસ અનુભવ અને સબએટોમિક રનટાઇમ વાતાવરણ પૂરું પાડે છે. લેખક ક્વાર્કસની પ્રતિક્રિયાશીલ બાજુ વિશે વાત કરે છે અને પ્રતિક્રિયાશીલ અને સ્ટ્રીમિંગ એપ્લિકેશન્સ બનાવવા માટે તેનો ઉપયોગ કેવી રીતે કરવો.

9. એક્લીપ્સ માઇક્રોપ્રોફાઇલમાં ક્વાર્કસ અને ઝડપી એપ્લિકેશન વિકાસ

લેખક: જ્હોન ક્લિંગન
એક્લિપ્સ માઇક્રોપ્રોફાઇલ અને ક્વાર્કસને જોડીને, ડેવલપર્સ સંપૂર્ણ સુવિધાયુક્ત કન્ટેનરાઇઝ્ડ માઇક્રોપ્રોફાઇલ એપ્લિકેશન્સ બનાવી શકે છે જે દસ મિલીસેકન્ડ્સમાં લોન્ચ થાય છે. કુબરનેટ્સ પ્લેટફોર્મ પર જમાવટ માટે કન્ટેનરાઇઝ્ડ માઇક્રોપ્રોફાઇલ એપ્લિકેશનને કેવી રીતે કોડ કરવી તે વિડિઓ વિગતવાર છે.

10. જાવા, "ટર્બો" સંસ્કરણ

લેખક: માર્કસ બીએલ
લેખક બતાવે છે કે કવાર્કસનો ઉપયોગ સુપર-સ્મોલ, સુપર-ફાસ્ટ જાવા કન્ટેનર બનાવવા માટે કેવી રીતે કરવો જે વાસ્તવિક સફળતાને સક્ષમ કરે છે, ખાસ કરીને સર્વર વિનાના વાતાવરણમાં.

સોર્સ: www.habr.com