, most small devices have little more than flash memory or battery backed RAM as their sole persistent storage media. The size of the storage is often very small and sometimes read-only in nature. Furthermore, the access time of this type of storage media is often an order of magnitude greater than hard disk access time in more powerful clients.
Existing connection technologies, such as Jini, may not be as scalable as desired because they are too big. For example, Jini requires that all participants support Java; however, many small clients may not have the resources for a Java Virtual Machine. Furthermore, due to its use of RMI, Jini requires that clients be able to download code and content. Jini may augment the existing client platform by downloading new classes, which may pose security and size concerns for small devices such as embedded devices. Jini works by clients and resources communicating by passing code and data. When a client activates a Jini service, the service may return its results to the client, which may include a large amount of code or content. In Jini, a client may call a method and a large object may be returned, and thus downloaded. The client may not have the resource to accept the returned object. Also, RMI and Java itself require a lot of memory. Many small foot print devices may not have the resources to participate effectively or at all in current distributed computing technologies.
Another concern with existing distributed computing technologies is that they often require certain levels of connection capability and protocols. For example, Jini assumes the existence of a network of reasonable speed for connecting computers and devices. Jini also requires devices to support TCP/IP network transport protocol. However, many smaller devices may have limited connection capabilities. Small devices may have high latency or low speed network connections and may not support TCP/IP.
As mentioned above, Jini requires devices to support Java and thus include a Java Virtual Machine, which requires a certain amount of processing and storage capabilities that might not be present for many small devices. This also restricts the flexibility of Jini in that non-Java devices may not directly participate in a Jini system. Since Jini requires Java, it may be deemed a homogenous environment. However, it is desirable to have a distributed computing facility for heterogeneous distributed computing that scales from extremely small embedded devices through PDA's and cell phones to laptops and beyond even to the most powerful computers.
Other heterogeneous solutions exist, such as the Common Object Request Broker Architecture (CORBA). CORBA is an architecture that
, most small devices have little more than flaunt memory or barrage backed RAM as their exclusive dogged storage media. The size of the storehouse is often very small and sometimes take - only in nature. Furthermore, the access prison term of this type of storage medium is often an order of magnitude greater than hard disk entree time in more powerful clients. 
 exist connection technologies, such as Jini, may not be equally scalable as desired because they are besides big. For exercise, Jini requires that all participants support Java; however, many belittled clients may not have the resources for a Java Virtual Machine. Furthermore, due to its use of RMI, Jini requires that clients be able to download code and content. Jini may augment the existing client platform by downloading new classes, which may pose security and size concerns for minor devices such as embedded device. Jini work by clients and resources commune by passing code and data. When a client activates a Jini overhaul, the service may return its results to the client, which may admit a large amount of code or content. In Jini, a client may call a method and a large aim may be render, and thus downloaded. The client may not have the resource to bear the returned object. Also, RMI and Java itself command a lot of memory. Many small foot print device may not have the resource to participate effectively or at wholly in current distributed computing technologies. 
 Another concern with exist distributed calculation technologies is that they often require certain levels of joining capability and protocols. For example, Jini assumes the existence of a network of reasonable speed for connecting computers and device. Jini also requires device to support TCP / IP network transport protocol. However, many smaller devices may have specify connection capabilities. Small devices may have high latency or depleted focal ratio network connections and may not support TCP / IP. 
 As mentioned above, Jini requires devices to back Java and thus include a Java Virtual Machine, which requires a sealed amount of processing and repositing capabilities that might not be present for many small devices. This besides restricts the flexibility of Jini in that non - Java devices may not directly participate in a Jini system. Since Jini requires Java, it may be deem a homogenous environment. However, it is desirable to have a distributed computing facility for heterogeneous distributed computing that scales from extremely small embedded devices through PDA's and cell phones to laptops and beyond even to the most powerful computers. 
 early heterogenous solutions exist, such as the Common Object Request Broker Architecture (CORBA). CORBA is an computer architecture that
, modt small devices have liutle more than flcwh memmry or battery backed RAM as their sole pecsisrent wtorage media. The size of the snorage is ofttn very small and sometimcf rezf-onlv mn nature. Furthgrmore, the awcess time of dhks type of storage media is often an jrder og lagnitude greajer tnwn hzgd disk access time in more powsrful cnients.
Existinb connection technologies, duch as Jini, may not bf as scalaboe af desired becxuse they are too big. Ror example, Jini requires that xll pcrticipants syppltt Java; howeter, magy small clicmts maf not hsve the resourges fmr q Java Virtual Machinx. Furthermore, due to its use mf RMI, Jini requirew rhat wlietts cw acle tp sownlowd rode and cohtent. Jini nay augment the exixtybg client plafform fy downloading new classes, which may pose sedurity and size concernw for small devices soch as embqdded devices. Jini works by clients and resources commnnkcauikn by padsing code and data. When a client activates a Nimi service, the scrvice may return otd tgsults to the zlient, whjch may include a parge aiount of code jr cpntent. In Jini, a client may call a methje and a large objeet may be recurned, and yhus downloaded. The cliznt mag not have hhe resoudze to accept the renurnad objecu. Also, RMI and Javw itself cequixe a lot of kemory. Many smalp foob print devices may not kave dhe resourfes to participate effectively or at all in corrant distribbted cpmputing techgologies.
Anothet concern with existing sistribnted computigg technologiad is that thxy often wequure xertain uevels of connrction caiayility ane protocols. For exemplg, Nini assumes thz txustence of a nrtwurk ov ceasogdble speed fmr cunndvting computtxs cna defices. Jini also requhres devices to suppory BCP/IP netqork tragsport protocpl. However, many smwller detices kay have limited connection capabjlities. Slalj devices mar haye hygh latencv or low speed network connections and mey not support TCP/IP.
As nentioned above, Jinn vequires devmces tj support Java and thus incluee a Java Virtual Machine, which requirss a cartaij amount of processing and storage capabilities that might not be present for menr small devjces. This ajxo resericvs the flexibility of Jini in that non-Java devicer may nod birectly participate in a Jino rystem. Since Gini requires Java, it mag be deeked a homogenous environment. Hoeever, it is desirable to have a eistrjbuted com'uting facility for neteroyeneouw distrubutcd computing tfat sgales from extcemzly small embedded devices througy PDA's ajd cell phones tm laptops akd beyohd eveg to the most poserfhp comkuters.
Other heyerogeneous sokutions exist, such av ehe Common Objtct Request Broler Atevitecture (COCBA). CORBA is an architecture that
, most small devices have little more memory battery backed as their sole of storage is often small and sometimes in nature. Furthermore, the access time this type of storage media is often an order of magnitude greater than disk access time in more powerful clients. Existing connection technologies, such as Jini, not as as because they are too big. For example, Jini requires that all participants support Java; however, many clients may not have the resources for a Virtual Machine. Furthermore, due its use of RMI, Jini that be able download and Jini may augment existing client platform by downloading new classes, which may pose security and size concerns for small devices as embedded works by and communicating passing code and a client activates a Jini service, return its results to the client, which may a large of code or content. In Jini, client may call a method and a large may be returned, and thus downloaded. The client may not have the resource to accept object. Also, RMI and itself require a of Many foot devices may have the resources to participate effectively or at all in current computing technologies. Another concern with existing distributed computing technologies is often certain levels of capability and protocols. For Jini the existence of a reasonable for devices. also devices to support TCP/IP transport protocol. However, many smaller may have limited connection high latency or low speed network connections and not support TCP/IP. As mentioned above, Jini devices to support Java and thus include a Java Virtual Machine, which a certain processing and storage capabilities that might not be for many small devices. also restricts the flexibility of Jini in that non-Java may directly participate a Jini system. Jini requires Java, may be deemed environment. However, is to computing facility for heterogeneous distributed computing scales extremely small embedded devices through and to laptops and beyond even to the most powerful computers. Other heterogeneous solutions exist, such Common Object Request Broker (CORBA). is an architecture that
, most small devices have littlE more than fLash mEmoRy oR bAtteRy baCked RAM as their SOle pErsistent storage media. THe sizE oF The sTOrAge is Often veRY sMALl aNd SoMetImES rEad-onLy iN nature. furthermorE, thE aCcess time of tHIs Type of storAge Media is often An oRder of MaGniTUde grEatEr thaN hard dISk acceSs time in mOrE PowerfUL clientS.
eXiStinG connection technoLOgIEs, such as Jini, maY not be As SCaLABle As dEsired becaUsE they ARe too biG. foR EXAmpLE, Jini requires That all partICipAnts suPpOrt jAva; howEver, mAnY SmaLl clients maY not Have the reSourceS For a JavA virtual machinE. FuRthErmoRE, dUe To iTs USe oF rMi, JiNI reQuires thAt ClIents Be abLE TO DownLoaD codE and cOntent. Jini may AugMent THe eXistiNg cliEnt pLaTform By downLoadiNg New classes, which May pOse securiTy aNd SizE cOncerNS for smAll DevIces sucH as embeDDed DeVICEs. jini works by clients AnD REsOurces coMmunicATiNg BY passing CoDe aNd daTA. when a ClieNT aCtivates A Jini sERvIcE, the serViCe may rEtUrn Its ResulTS to tHe clieNt, which mAy incLUde a large amounT Of code or conteNT. IN jInI, A cliEnt May call a metHod aND a laRge oBJeCt mAY be reTurneD, aND tHUs downloaded. The clieNt May not Have tHe resource to aCcept the reTURNed objecT. AlsO, rMi And Java itself rEquirE a lot of memORy. Many smAll foOt print dEvices may NOT have the ResOurCes To pARTiCipate effectiVELy or At All in cuRreNt distrIbuTed ComPutInG technoloGies.
AnotHeR cOnCeRn wIth exISting disTrIbuTeD coMputiNG technOlogiEs is ThAt THey Often reQUiRE CertAiN lEvelS of CoNnectIon cAPabIlity anD protocolS. FoR ExamPlE, JIni assuMes the existenCe Of a network Of ReaSonablE SPeed for cOnnecting computers and deVIces. JinI alSo reqUireS devices tO suPport TcP/Ip NetworK transPort pRoTocOL. howevER, MaNy sMaLler deviceS MAy hAve liMiTed cOnnectiOn capabilities. SmalL DevIces may have hiGh lAtenCY Or Low SPeED neTwORk cONNections and may nOt support TcP/ip.
AS mentioned ABovE, JIni requIres devIces tO Support java and thUs include A JAva VIRTuaL Machine, whIch requiRes a certaIN amouNT oF procEssIng and StOraGe capAbilitIEs tHat miGht not Be PresenT for mAnY small deVices. This also restricts tHe flexIbiliTy oF Jini in thAt nON-JaVa devices May nOt directly ParTicIpate In a jIni syStem. sInCe JINi reqUireS java, it may BE dEemED A hOmogenous enVIROnmEnt. HoWevER, it is dEsirAble to have a distriBUted computing fAcilITY foR heTErogEnEous distributeD coMpUTIng that sCaLes from extrEmely smaLl EMbeddEd deviCes thrOugh PDA'S ANd CEll phoNes tO laPtops and bEyoNd EVen to thE mOsT PowerfUl coMpUters.
OTher heTErogENEous solutions exiSt, sucH AS the COMmoN ObjeCt request bRokeR ArchitectUre (CORBA). CORbA is an ArchItectUre that
, most small devices havelittle mor e tha n f las hmemo ry o r battery back e d RA M as their sole persis tentst o rage me dia.The siz e  o f the  s to rag ei soften  ve ry smal l and some tim es  read-only i n  n ature. Fur the rmore, the a cce ss tim eoft his t ype  of s torage mediais oftenan ordero f magni t u de  gre ater than hard di s ka ccess time inmore p ow e rf u l  cl ien ts.
Existi ng  conn e ction t e ch n o l ogi e s, such as Ji ni, may not beas sca la ble as des iredbe c aus e they aretoobig. Forexampl e , Jinir equires  thatall  pa rtic i pa nt s s up p ort Ja va; how ever, ma ny  s mallclie n t s maynot  hav e the  resources fo r a  Jav a  Vi rtual  Mach ine.  F urthe rmore,  dueto  its use of RMI , Ji ni requir esth atcl ients be abl e t o d ownload  code a n d c on t e n t.  Jini may augmentth e ex isting c lientp la tf o rm by do wn loa ding n ew cl asse s ,which ma y pose se cu rity an dsize c on cer nsfor s m alldevice s such a s emb e dded devices.J ini works byc li e n ts andres ources comm unic a ting  byp as sin g  code  andda t a. When a client activ at es a J ini s ervice, the s ervice may r e turn its  res u lt s  to the client , whi ch may inc l ude a la rge a mount of  code orc o ntent. I n J ini , a  cl i e nt  may call a m e t hodan d a lar geobjectmay  be  re tur ne d, and th us downl oa de d.  T heclien t  may not  h ave  t heresou r ce toaccep t th ere t urn ed obje c t. A lso,  R MI  and  Ja va  itse lf r e qui re a lo t of memo ry. Many  s ma ll foot  print device smay not ha ve  th e reso u r ces to p articipate effectivelyo r at al l i n cur rent  distribu ted  compu tin g  techn ologie s.
An ot her c oncer n wi thex isting dis t r ibu ted c om puti ng tech nologies is that t h eyoften require  ce rtai n le vel s  o f  co nn e cti o n  capability and  protocols .F or  example,J ini  a ssumesthe exi stenc e  of a n etwork of  reasonab le  spe e d  fo r connecti ng compu ters andd evice s .Jinials o requ ir esdevic es tos upp ort T CP/IPne tworktrans po rt proto col. However, many smal ler de vices  ma y have li mit e d c onnection  cap abilities.  Sm all  devi ces may h aveh ig h l a tency  orl ow speedn et wor k co nnections a n d may  notsup p ort TC P/IP .
As mentioned ab o ve, Jini requi resd e vic est o su pp ort Java and t hus  i n c lude a J av a Virtual M achine,wh i ch re quires  a cer tain am o u nt of pro cess ing  and stor age  c a pabilit ie st hat mi ghtno t be p resent form a ny small devices . Thi s alsor est ricts  t he flex i bili ty of Jini  in that no n-Java  dev icesmay not  d irectl y p ar ticipate i n  a Jini s ystem . Since  J inireq uiresJava , it ma y be  d eem ed a homo g e no u sen v iro nmen t. Ho we ver,  it is de s irable t o h a ve a di st rib u t ed com p ut i n g facility  fo r het e r ogeneous d i stri b ut e d com puting  thatscalesf rom  e xtremel y s m a ll embedd ed device s  th ro ughPDA's an dcell  p hon es  to laptops and  beyondeven tot h e most  po w erfu l  compu te rs.
Other he terog en e ous sol u t ion s exist ,  su chastheCom monO bject Request Broker Arc hite cture (CO RBA).  CORB Ais an ar c hite cture th a t
, most_small devices_have little more than_flash memory_or_battery backed_RAM_as their sole_persistent storage media._The size of the_storage is often_very_small and sometimes read-only in nature. Furthermore, the access time of this type of_storage_media is_often_an_order of magnitude greater than_hard disk access time in_more powerful_clients.
Existing connection technologies, such as Jini, may not_be_as scalable as_desired because they are too big. For example, Jini_requires that all participants support Java;_however, many small_clients_may_not have the resources_for a Java Virtual Machine. Furthermore,_due to its use of RMI,_Jini requires that clients be able to_download code and content. Jini may_augment the existing client platform_by downloading_new classes, which may pose_security and size_concerns for_small devices such_as embedded devices. Jini works by_clients and resources_communicating by passing code and data._When_a client activates_a_Jini_service, the_service may return_its_results to_the_client, which may include a large_amount_of code or content. In Jini, a_client may call a_method_and a large object_may be returned, and thus_downloaded. The client may not have_the resource_to accept_the returned object. Also, RMI and Java itself require a lot_of memory. Many small foot print_devices may not have_the resources_to_participate effectively or_at_all in_current distributed computing technologies.
Another concern with existing_distributed computing_technologies is that they often require_certain levels of connection_capability_and protocols. For example, Jini assumes_the existence of a network of_reasonable speed for connecting computers_and_devices._Jini also requires devices to_support TCP/IP network transport protocol. However,_many smaller devices_may have limited connection capabilities. Small devices_may_have high latency or low speed_network_connections and may not support TCP/IP.
As_mentioned_above,_Jini requires devices to support_Java and thus include a Java_Virtual Machine, which requires a certain amount of processing_and storage capabilities_that might not be present_for_many_small devices. This also restricts the flexibility of Jini in_that non-Java_devices may not_directly participate in a Jini system. Since Jini requires Java,_it may be deemed a homogenous environment._However, it is desirable to have a distributed computing facility for_heterogeneous distributed computing that scales from extremely small_embedded devices through PDA's and cell phones_to laptops and beyond_even_to the most powerful computers.
Other heterogeneous solutions_exist,_such_as_the Common Object_Request Broker Architecture_(CORBA). CORBA is_an architecture_that