క్వార్కస్ అత్యవసర మరియు రియాక్టివ్ ప్రోగ్రామింగ్‌ను ఎలా మిళితం చేస్తుంది

ఈ సంవత్సరం మేము కంటైనర్ థీమ్‌లను తీవ్రంగా అభివృద్ధి చేయడానికి ప్లాన్ చేస్తున్నాము, క్లౌడ్-నేటివ్ జావా и Kubernetes. ఈ అంశాల తార్కిక కొనసాగింపుగా ఇప్పటికే క్వార్కస్ ఫ్రేమ్‌వర్క్ గురించిన కథనం ఉంటుంది పరిగణించబడింది హబ్రేపై. నేటి కథనం "సబ్‌టామిక్ సూపర్‌ఫాస్ట్ జావా" రూపకల్పన గురించి తక్కువ మరియు క్వార్కస్ ఎంటర్‌ప్రైజ్‌కు అందించే వాగ్దానాల గురించి మరిన్ని.

జావా మరియు JVM ఇప్పటికీ బాగా ప్రాచుర్యం పొందాయి, అయితే సర్వర్‌లెస్ టెక్నాలజీలు మరియు క్లౌడ్-నేటివ్ మైక్రోసర్వీస్‌లతో పనిచేసేటప్పుడు, జావా మరియు ఇతర JVM భాషలు చాలా తక్కువగా ఉపయోగించబడతాయి, ఎందుకంటే అవి చాలా మెమరీ స్థలాన్ని తీసుకుంటాయి మరియు లోడ్ చేయడం చాలా నెమ్మదిగా ఉంటాయి, తద్వారా వాటిని తయారు చేస్తాయి. స్వల్పకాలిక కంటైనర్లతో ఉపయోగం కోసం సరిగా సరిపోదు. అదృష్టవశాత్తూ, క్వార్కస్ కారణంగా ఈ పరిస్థితి ఇప్పుడు మారడం ప్రారంభించింది.

సూపర్‌ఫాస్ట్ సబ్‌టామిక్ జావా కొత్త స్థాయికి చేరుకుంది!

42 విడుదలలు, 8 నెలల కమ్యూనిటీ వర్క్ మరియు 177 అద్భుతమైన డెవలపర్‌లు - వీటన్నింటికీ ఫలితం నవంబర్ 2019లో విడుదలైంది. క్వార్కస్ 1.0, ప్రాజెక్ట్ అభివృద్ధిలో ఒక ముఖ్యమైన మైలురాయిని గుర్తించే విడుదల మరియు చాలా అద్భుతమైన ఫీచర్‌లు మరియు సామర్థ్యాలను అందిస్తుంది (మీరు వాటి గురించి మరింత చదవగలరు ప్రకటన).

క్వార్కస్ అత్యవసర మరియు రియాక్టివ్ ప్రోగ్రామింగ్ మోడల్‌లను ఒకే రియాక్టివ్ కోర్‌గా ఎలా మిళితం చేస్తుందో ఈ రోజు మేము మీకు చూపుతాము. మేము సంక్షిప్త చరిత్రతో ప్రారంభిస్తాము మరియు క్వార్కస్ రియాక్టివ్ కోర్ ద్వంద్వవాదం అంటే ఏమిటి మరియు ఎలా అనే దాని గురించి వివరంగా తెలియజేస్తాము జావా-డెవలపర్లు ఈ ప్రయోజనాల ప్రయోజనాన్ని పొందవచ్చు.

మైక్రోసర్వీసెస్, ఈవెంట్ నడిచే నిర్మాణాలు и serverless-ఫంక్షన్స్ - ఇవన్నీ, వారు చెప్పినట్లు, నేడు పెరుగుతున్నాయి. ఇటీవల, క్లౌడ్-సెంట్రిక్ ఆర్కిటెక్చర్‌ల సృష్టి చాలా సులభం మరియు మరింత అందుబాటులోకి వచ్చింది, అయితే సమస్యలు అలాగే ఉన్నాయి - ముఖ్యంగా జావా డెవలపర్‌లకు. ఉదాహరణకు, సర్వర్‌లెస్ ఫంక్షన్‌లు మరియు మైక్రోసర్వీస్‌ల విషయంలో, ప్రారంభ సమయాన్ని తగ్గించడం, మెమరీ వినియోగాన్ని తగ్గించడం మరియు వాటి అభివృద్ధిని మరింత సౌకర్యవంతంగా మరియు ఆనందించేలా చేయడం తక్షణ అవసరం. జావా ఇటీవలి సంవత్సరాలలో కంటైనర్‌ల కోసం మెరుగైన ఎర్గోనామిక్స్ కార్యాచరణ వంటి అనేక మెరుగుదలలను చేసింది. అయినప్పటికీ, కంటైనర్‌లో జావా సరిగ్గా పనిచేయడం ఇప్పటికీ సవాలుగా ఉంది. కాబట్టి మేము కంటైనర్-ఆధారిత జావా అప్లికేషన్‌లను అభివృద్ధి చేస్తున్నప్పుడు ముఖ్యంగా తీవ్రంగా ఉండే జావాలోని కొన్ని స్వాభావిక సంక్లిష్టతలను చూడటం ద్వారా ప్రారంభిస్తాము.

మొదట, చరిత్రను చూద్దాం.

ప్రవాహాలు మరియు కంటైనర్లు

వెర్షన్ 8u131తో ప్రారంభించి, ఎర్గోనామిక్స్ ఫంక్షనాలిటీలో మెరుగుదలల కారణంగా జావా ఎక్కువ లేదా తక్కువ మద్దతు కంటైనర్‌లను అందించడం ప్రారంభించింది. ప్రత్యేకించి, JVM ఇప్పుడు ఎన్ని ప్రాసెసర్ కోర్‌లపై రన్ అవుతుందో తెలుసు మరియు దాని ప్రకారం థ్రెడ్ పూల్‌లను-సాధారణంగా ఫోర్క్/జాయిన్ పూల్స్‌ను కాన్ఫిగర్ చేయగలదు. అయితే, ఇది చాలా బాగుంది, అయితే HTTP సర్వ్‌లెట్‌లను ఉపయోగించే మరియు టామ్‌క్యాట్, జెట్టీ మొదలైన వాటిలో రన్ అయ్యే సంప్రదాయ వెబ్ అప్లికేషన్ మా వద్ద ఉందని చెప్పండి. ఫలితంగా, ఈ అప్లికేషన్ ప్రతి అభ్యర్థనకు ప్రత్యేక థ్రెడ్‌ని ఇస్తుంది మరియు I/O ఆపరేషన్‌ల కోసం వేచి ఉన్నప్పుడు ఈ థ్రెడ్‌ను బ్లాక్ చేయడానికి అనుమతిస్తుంది, ఉదాహరణకు, డేటాబేస్, ఫైల్‌లు లేదా ఇతర సేవలను యాక్సెస్ చేస్తున్నప్పుడు. అంటే, అటువంటి అప్లికేషన్ యొక్క పరిమాణం అందుబాటులో ఉన్న కోర్ల సంఖ్యపై ఆధారపడి ఉండదు, కానీ ఏకకాల అభ్యర్థనల సంఖ్యపై ఆధారపడి ఉంటుంది. అదనంగా, కోర్ల సంఖ్యపై కుబెర్నెట్స్‌లో కోటాలు లేదా పరిమితులు ఇక్కడ పెద్దగా సహాయపడవు మరియు ఈ విషయం చివరికి థ్రోట్లింగ్‌లో ముగుస్తుంది.

మెమరీ అలసట

థ్రెడ్‌లు మెమరీ. మరియు ఇంట్రా-కంటైనర్ మెమరీ పరిమితులు ఏ విధంగానూ వినాశనం కాదు. అప్లికేషన్‌లు మరియు థ్రెడ్‌ల సంఖ్యను పెంచడం ప్రారంభించండి మరియు ముందుగానే లేదా తరువాత మీరు స్విచ్చింగ్ ఫ్రీక్వెన్సీలో క్లిష్టమైన పెరుగుదలను ఎదుర్కొంటారు మరియు ఫలితంగా పనితీరు క్షీణిస్తుంది. అలాగే, మీ అప్లికేషన్ సాంప్రదాయ మైక్రోసర్వీస్ ఫ్రేమ్‌వర్క్‌లను ఉపయోగిస్తుంటే, లేదా డేటాబేస్‌కు కనెక్ట్ చేసినట్లయితే, లేదా కాషింగ్‌ని ఉపయోగిస్తుంటే లేదా మెమరీని ఉపయోగించినట్లయితే, మీకు JVM లోపల చూసేందుకు మరియు మెమరీని చంపకుండా ఎలా నిర్వహిస్తుందో చూడటానికి మిమ్మల్ని అనుమతించే ఒక సాధనం అవసరం. JVM స్వయంగా (ఉదాహరణకు, XX:+UseCGroupMemoryLimitForHeap). అయినప్పటికీ, జావా 9 నుండి, JVM cgroupలను అంగీకరించడం మరియు తదనుగుణంగా స్వీకరించడం నేర్చుకుంది, మెమరీని రిజర్వ్ చేయడం మరియు నిర్వహించడం చాలా క్లిష్టమైన విషయంగా మిగిలిపోయింది.

కోటాలు మరియు పరిమితులు

Java 11 CPU కోటాలకు (PreferContainerQuotaForCPUCount వంటిది) మద్దతును పరిచయం చేసింది. కుబెర్నెటెస్ పరిమితులు మరియు కోటాలకు మద్దతును కూడా అందిస్తుంది. అవును, ఇదంతా అర్ధమే, కానీ అప్లికేషన్ మళ్లీ కేటాయించిన కోటాను మించి ఉంటే, మేము మళ్లీ పరిమాణంతో ముగుస్తాము - సాంప్రదాయ జావా అప్లికేషన్‌ల మాదిరిగానే - కోర్ల సంఖ్య మరియు ప్రతిదానికి ప్రత్యేక థ్రెడ్ కేటాయింపుతో నిర్ణయించబడుతుంది. అభ్యర్థించండి, అప్పుడు వీటన్నింటిలో కొంచెం అర్థం లేదు.
అదనంగా, మీరు కోటాలు మరియు పరిమితులు లేదా కుబెర్నెట్‌ల అంతర్లీన ప్లాట్‌ఫారమ్ యొక్క స్కేల్-అవుట్ ఫంక్షన్‌లను ఉపయోగిస్తే, సమస్య కూడా స్వయంగా పరిష్కరించబడదు. మేము అసలు సమస్యను పరిష్కరించడానికి ఎక్కువ వనరులను ఖర్చు చేస్తాము లేదా ఎక్కువ ఖర్చు చేస్తాము. మరియు ఇది పబ్లిక్ పబ్లిక్ క్లౌడ్‌లో అధిక-లోడ్ సిస్టమ్ అయితే, మేము ఖచ్చితంగా మనకు నిజంగా అవసరమైన దానికంటే ఎక్కువ వనరులను ఉపయోగిస్తాము.

మరి వీటన్నింటిని ఏం చేయాలి?

సరళంగా చెప్పాలంటే, అసమకాలిక మరియు నాన్-బ్లాకింగ్ 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 మైక్రోసర్వీస్‌లను మాత్రమే కాకుండా ఈవెంట్-డ్రైవెన్ ఆర్కిటెక్చర్‌లను రూపొందించడానికి రూపొందించబడింది. దాని రియాక్టివ్ స్వభావం కారణంగా, ఇది మెసేజింగ్ సిస్టమ్‌లతో (అపాచీ కాఫ్కా, AMQP, మొదలైనవి) చాలా ప్రభావవంతంగా పనిచేస్తుంది.

అత్యవసర మరియు రియాక్టివ్ కోడ్ రెండింటికీ ఒకే రియాక్టివ్ ఇంజిన్‌ను ఎలా ఉపయోగించాలి అనేది ఉపాయం.

క్వార్కస్ దీన్ని అద్భుతంగా చేస్తాడు. అత్యవసరం మరియు రియాక్టివ్ మధ్య ఎంపిక స్పష్టంగా ఉంటుంది - రెండింటికీ రియాక్టివ్ కెర్నల్‌ని ఉపయోగించండి. ఈవెంట్-లూప్ థ్రెడ్ లేదా IO థ్రెడ్ గుండా వెళ్ళే దాదాపు ప్రతిదానిని హ్యాండిల్ చేసే వేగవంతమైన, నాన్-బ్లాకింగ్ కోడ్‌తో ఇది నిజంగా సహాయపడుతుంది. కానీ మీరు క్లాసిక్ REST లేదా క్లయింట్-వైపు అప్లికేషన్‌లను కలిగి ఉంటే, Quarkus సిద్ధంగా ప్రోగ్రామింగ్ మోడల్‌ను కలిగి ఉంది. ఉదాహరణకు, క్వార్కస్‌లో HTTP మద్దతు నాన్-బ్లాకింగ్ మరియు రియాక్టివ్ ఇంజిన్ (Eclipse Vert.x మరియు Netty) వినియోగంపై ఆధారపడి ఉంటుంది. మీ అప్లికేషన్ ద్వారా స్వీకరించబడిన అన్ని HTTP అభ్యర్థనలు ముందుగా ఈవెంట్ లూప్ (IO థ్రెడ్) ద్వారా పంపబడతాయి మరియు అభ్యర్థనలను నిర్వహించే కోడ్‌లోని భాగానికి పంపబడతాయి. గమ్యాన్ని బట్టి, అభ్యర్థన నిర్వహణ కోడ్‌ను ప్రత్యేక థ్రెడ్‌లో పిలవవచ్చు (వర్కర్ థ్రెడ్ అని పిలవబడేది, సర్వ్‌లెట్‌లు మరియు Jax-RS విషయంలో ఉపయోగించబడుతుంది) లేదా సోర్స్ I/O థ్రెడ్ (రియాక్టివ్ రూట్)ని ఉపయోగించవచ్చు.

మెసేజింగ్ సిస్టమ్ కనెక్టర్‌లు Vert.x ఇంజిన్ పైన నడుస్తున్న నాన్-బ్లాకింగ్ క్లయింట్‌లను ఉపయోగిస్తాయి. అందువల్ల, మీరు మెసేజింగ్ మిడిల్‌వేర్ సిస్టమ్‌ల నుండి సందేశాలను సమర్థవంతంగా పంపవచ్చు, స్వీకరించవచ్చు మరియు ప్రాసెస్ చేయవచ్చు.

సైట్లో Quarkus.io క్వార్కస్‌తో ప్రారంభించడంలో మీకు సహాయపడే కొన్ని మంచి ట్యుటోరియల్‌లు ఇక్కడ ఉన్నాయి:

• రియాక్టివ్ మార్గాలను ఉపయోగించడం
• రియాక్టివ్ SQL క్లయింట్లు
• రియాక్టివ్ మెసేజింగ్‌తో అపాచీ కాఫ్కాను ఉపయోగించడం
• రియాక్టివ్ మెసేజింగ్‌తో AMQPని ఉపయోగించడం
• Vertx APIని ఉపయోగించడం

మేము బ్రౌజర్‌లో రియాక్టివ్ ప్రోగ్రామింగ్ యొక్క వివిధ అంశాలను మీకు బోధించడానికి ఆన్‌లైన్ హ్యాండ్-ఆన్ ట్యుటోరియల్‌లను కూడా సృష్టించాము, IDE అవసరం లేదు మరియు కంప్యూటర్ అవసరం లేదు. మీరు ఈ పాఠాలను కనుగొనవచ్చు ఇక్కడ.

ఉపయోగకరమైన వనరులు

• క్వార్కస్‌ని ప్రయత్నించడానికి 4 కారణాలు
• క్వార్కస్ ప్రాజెక్ట్ వెబ్‌సైట్ - quarkus.io
• GitHub పై క్వార్కస్ ప్రాజెక్ట్ – github.com/quarkusio/quarkus
• క్వార్కస్ ప్రాజెక్ట్ ట్విట్టర్ - twitter.com/QuarkusIO
• క్వార్కస్ ప్రాజెక్ట్ చాట్ - quarkusio.zulipchat.com
• క్వార్కస్ ప్రాజెక్ట్ ఫోరమ్స్ - group.google.com/forum/#!ఫోరమ్/క్వార్కస్-దేవ్

టాపిక్‌తో పరిచయం పొందడానికి క్వార్కస్‌పై 10 వీడియో పాఠాలు

వారు వెబ్‌సైట్‌లో చెప్పినట్లు Quarkus.io, క్వార్కస్ - ఉంది Kubernetes-ఆధారిత జావా స్టాక్, GraalVM మరియు OpenJDK హాట్‌స్పాట్ కోసం రూపొందించబడింది మరియు ఉత్తమ జావా లైబ్రరీలు మరియు ప్రమాణాల నుండి సమీకరించబడింది.

అంశాన్ని అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి, మేము క్వార్కస్ యొక్క వివిధ అంశాలను మరియు దాని ఉపయోగం యొక్క ఉదాహరణలను కవర్ చేసే 10 వీడియో ట్యుటోరియల్‌లను ఎంచుకున్నాము:

1. క్వార్కస్‌ని పరిచయం చేస్తోంది: కుబెర్నెటీస్ కోసం తదుపరి తరం జావా ఫ్రేమ్‌వర్క్

థామస్ క్వార్న్‌స్ట్రోమ్ మరియు జాసన్ గ్రీన్ ద్వారా
క్వార్కస్ ప్రాజెక్ట్ యొక్క లక్ష్యం కుబెర్నెట్స్ మరియు సర్వర్‌లెస్ ఎన్విరాన్‌మెంట్‌ల కోసం జావా ప్లాట్‌ఫారమ్‌ను సృష్టించడం మరియు రియాక్టివ్ మరియు ఇంపెరేటివ్ ప్రోగ్రామింగ్ మోడల్‌లను ఒకే రన్‌టైమ్ ఎన్విరాన్‌మెంట్‌లో కలపడం, తద్వారా డెవలపర్‌లు విస్తృత శ్రేణి పంపిణీ చేసిన అప్లికేషన్ ఆర్కిటెక్చర్‌లతో పనిచేసేటప్పుడు వారి విధానాన్ని సరళంగా మార్చుకోవచ్చు. దిగువ పరిచయ ఉపన్యాసంలో మరింత తెలుసుకోండి.

2. క్వార్కస్: సూపర్‌ఫాస్ట్ సబ్‌టామిక్ జావా

ద్వారా: బర్ సుటర్
DevNation Live నుండి వచ్చిన ఈ వీడియో ట్యుటోరియల్, Kubernetes/OpenShift వాతావరణంలో ఎంటర్‌ప్రైజ్ జావా అప్లికేషన్‌లు, APIలు, మైక్రోసర్వీస్‌లు మరియు సర్వర్‌లెస్ ఫంక్షన్‌లను ఆప్టిమైజ్ చేయడానికి క్వార్కస్‌ని ఎలా ఉపయోగించాలో వివరిస్తుంది, వాటిని చాలా చిన్నదిగా, వేగంగా మరియు మరింత స్కేలబుల్‌గా చేస్తుంది.

3. క్వార్కస్ మరియు GraalVM: హైబర్నేట్‌ను సూపర్ స్పీడ్‌లకు వేగవంతం చేయడం మరియు సబ్‌టామిక్ సైజులకు కుదించడం

రచయిత: సన్నె గ్రినోవెరో
ప్రెజెంటేషన్ నుండి మీరు Quarkus ఎలా ఏర్పడిందో, అది ఎలా పని చేస్తుందో మరియు హైబర్నేట్ ORM వంటి సంక్లిష్ట లైబ్రరీలను స్థానిక GraalVM చిత్రాలకు అనుకూలంగా చేయడానికి ఇది మిమ్మల్ని ఎలా అనుమతిస్తుంది.

4. సర్వర్‌లెస్ అప్లికేషన్‌లను అభివృద్ధి చేయడం నేర్చుకోండి

రచయిత: మార్టిన్ లూథర్
క్వార్కస్‌ని ఉపయోగించి సాధారణ జావా అప్లికేషన్‌ను ఎలా సృష్టించాలో మరియు దానిని నాటివ్‌లో సర్వర్‌లెస్ అప్లికేషన్‌గా ఎలా ఉపయోగించాలో క్రింది వీడియో చూపిస్తుంది.

5. క్వార్కస్: సరదాగా కోడింగ్ చేయండి

రచయిత: ఎడ్సన్ యనగా
మీ మొదటి క్వార్కస్ ప్రాజెక్ట్‌ను రూపొందించడానికి వీడియో గైడ్, క్వార్కస్ డెవలపర్‌ల హృదయాలను ఎందుకు గెలుచుకుంటుందో అర్థం చేసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.

6. జావా మరియు కంటైనర్లు - కలిసి వారి భవిష్యత్తు ఎలా ఉంటుంది

Mark Little పోస్ట్ చేసారు
ఈ ప్రదర్శన జావా చరిత్రను పరిచయం చేస్తుంది మరియు క్వార్కస్ జావా యొక్క భవిష్యత్తు ఎందుకు అని వివరిస్తుంది.

7. క్వార్కస్: సూపర్‌ఫాస్ట్ సబ్‌టామిక్ జావా

రచయిత: డిమిత్రిస్ ఆండ్రీడిస్
డెవలపర్‌ల నుండి గుర్తింపు పొందిన క్వార్కస్ ప్రయోజనాల యొక్క అవలోకనం: సరళత, అతి-అధిక వేగం, ఉత్తమ లైబ్రరీలు మరియు ప్రమాణాలు.

8. క్వార్కస్ మరియు సబ్‌టామిక్ రాకెట్ వ్యవస్థలు

రచయిత: క్లెమెంట్ ఎస్కోఫియర్
GraalVMతో అనుసంధానం ద్వారా, Quarkus ఒక అతి-వేగవంతమైన అభివృద్ధి అనుభవాన్ని మరియు సబ్‌టామిక్ రన్‌టైమ్ వాతావరణాన్ని అందిస్తుంది. Quarkus యొక్క రియాక్టివ్ సైడ్ గురించి మరియు రియాక్టివ్ మరియు స్ట్రీమింగ్ అప్లికేషన్‌లను రూపొందించడానికి దానిని ఎలా ఉపయోగించాలో రచయిత మాట్లాడుతున్నారు.

9. ఎక్లిప్స్ మైక్రోప్రొఫైల్‌లో క్వార్కస్ మరియు వేగవంతమైన అప్లికేషన్ అభివృద్ధి

రచయిత: జాన్ క్లింగన్
ఎక్లిప్స్ మైక్రోప్రొఫైల్ మరియు క్వార్కస్‌లను కలపడం ద్వారా, డెవలపర్‌లు పదుల మిల్లీసెకన్లలో ప్రారంభించే పూర్తి-ఫీచర్ కలిగిన కంటెయినరైజ్డ్ మైక్రోప్రొఫైల్ అప్లికేషన్‌లను సృష్టించవచ్చు. Kubernetes ప్లాట్‌ఫారమ్‌లో విస్తరణ కోసం కంటైనర్ చేయబడిన మైక్రోప్రొఫైల్ అప్లికేషన్‌ను ఎలా కోడ్ చేయాలో వీడియో వివరంగా తెలియజేస్తుంది.

10. జావా, "టర్బో" వెర్షన్

రచయిత: మార్కస్ బీల్
ప్రత్యేకించి సర్వర్‌లెస్ పరిసరాలలో నిజమైన పురోగతులను ఎనేబుల్ చేసే సూపర్-స్మాల్, సూపర్-ఫాస్ట్ జావా కంటైనర్‌లను రూపొందించడానికి క్వార్కస్‌ను ఎలా ఉపయోగించాలో రచయిత చూపారు.

మూలం: www.habr.com