Migreerbare Applicaties

[Tyf]

Ik ben aan het proberen een systeem te ontwikkelen dat het moet mogelijk maken om applicaties te ontwikkelen die verplaats kunnen worden van apparaat naar apparaat, zonder verlies van de state van de applicatie.
Het moet dus mogelijk zijn om op pc A een applicatie in te laden via het framework, te werken ermee en deze applicatie dan weer door te zenden naar pc B. Pc b zal de ontvangen applicatie inladen en het mogelijk maken verder te werken van waar men gestopt was op pc A.
Dit moet op een zo algemeen mogelijke manier gebeuren, de applicatie die verzonden wordt kan vanalles zijn het framework weet dus niet op voorhand wat het zal krijgen en dient dit te ontdenken doormiddel van reflectie. Bij het doorzenden of bewaren is het de bedoeling dat alles weggeschreven wordt naar een binary stream doormiddel van serialization.

Ik heb al wat onderzoek gedaan naar Mobile Code, meer specifiek Mobile Agents (vooral deze lijken op wat ik wel ivm state bijhouden en verhuizen van pc naar pc), Strong/Weak Mobility maar hier gaat het altijd om een stukje programma die ingeladen wordt zonder interface. Ik wil echt een ganse applicatie doorzenden, inclusief UI. Ik ben dan ook gaan zoeken naar Migratable ui's, plastic gui's, ... probleem hier heel veel theoretische uitleg over hoe je een ui kan maken die van platfrom naar platform kan verplaatsen (desktop, web, gsm, ...) maar nergens hoe je er de logic zelf ook mee doorzend. Gui allen ben je niet zoveel mee.

Een ander probleem is dat bij bijna alle informatie met client server gewerkt wordt, maar mijn systeem wordt p2p. Eenmaal pc A de applicatie doorgezonden heeft zal hij er zich verder niks meer van aantrekken. Sommige zenden bijvoorbeeld een UI door die dan niet meer doet dan zaken op een server aanroepen bij drukken op een knop.


Ik ben nu in .net bezig dit te onderzoeken, maar loop dus constant vast. Hoop dat er mensen zijn die mij wat meer op weg kunnen helpen of al wat ervaring hebben in bepaalde onderdelen hiervan.

[RobIII]

>> SEA

Ik heb een beetje moeite, aan de hand van je TS, om me voor te stellen wat je nou precies wil. Je kunt je data toch gewoon opslaan in een bestand en die meekopiëren? En als je verbonden bent met een netwerk of zelfs internet zou je zelfs een centrale opslag van je data kunnen gebruiken. Ik zie niet waarom je daarvoor reflectie en andere omslachtige omstanden nodig zou hebben? En wat versta je dan onder p2p en waarom zou die niet overweg kunnen met een centrale opslag? Is je app wel altijd maar op 1 plaats tegelijk in gebruik?

Heb je misschien een wat concreter voorbeeld van wat je wil?

[ Voor 116% gewijzigd door RobIII op 09-02-2007 11:05 ]

[djluc]

Bedoel je eigenlijk de situatie van een terminal server sessie na te maken? Dus je logged in op client A, werkt in een applicatie. Vervolgens sluit je het venster, open je het op client B en kan je weer verder. Bedoel je het op die manier?

[Tyf]

Even use caseje maken:
Ik zit aan mijn pc een tekening te maken in een zeeeer simpel tekenprogrammaatje. Op een gegeven moment moet ik weg met de trein. Ik wil verder werken aan mijn tekening en stuur de ganse applicatie door naar mijn pda, waar ik kan verder werken aan mijn tekening. Eenmaal aangekomen op de bestemming wil ik mijn tekening weer op groot scherm zien en zend ik de applicatie door naar een andere pc.

Het moeilijke is dat de ontvangers de applicatie niet hebben. Het enigste dat ze nodig hebben is het framework zolang ze dit hebben kan ik gelijk welke applicatie doorzenden en erop werken. Dit moet zeer transparant gebeuren zonder installatie ofzo. Ik druk op pda zoek clients bv, ik vind mijn pc en zend de ganse applicatie door naar de pc waar ik dan verder mee kan werken.

Omdat ik ook soms op publiek toegankelijke pc's werk moet de applicatie na verzenden weer verdwijnen samen met alles wat er maar mee te maken heeft.

Er mag dus niet van uit gegaan worden dat er internet is of een of andere centrale server.

[djluc]

Hoe komt de applicatie dan op de PC als er geen internet is?

[Verwijderd]

djluc schreef op vrijdag 09 februari 2007 @ 11:28:
Hoe komt de applicatie dan op de PC als er geen internet is?

of modernere versie:

[Tyf]

idd het moet dus mogelijk zijn om eventueel via usb stick ofzo de applicatie door te sturen, indien er netwerk aanwezig is over het netwerk. In principe als je het kan wegschrijven naar een bestand ofzo, maakt de transportwijze niet echt meer uit.

[RobIII]

Tyf schreef op vrijdag 09 februari 2007 @ 11:46:
idd het moet dus mogelijk zijn om eventueel via usb stick ofzo de applicatie door te sturen, indien er netwerk aanwezig is over het netwerk. In principe als je het kan wegschrijven naar een bestand ofzo, maakt de transportwijze niet echt meer uit.

Wat is het probleem dan? Je app is een (aantal) bestand(en), data kun je opslaan als (een) bestand(en), settings etc. kunnen ook prima in (een) bestand(en). Kopieër het mapje met die bestanden op een stick of whatever, neem die mee naar de volgende "werkplek" en ga verder waar je gebleven bent.

Daarnaast snap ik nog steeds niet wat er dan p2p aan is

[ Voor 4% gewijzigd door RobIII op 09-02-2007 11:51 ]

[Tyf]

mja het gaat niet echt meer over settings, maar over de ganse toestand van je applicatie. Het is niet de bedoeling dat je alles gaat saven voor je verplaats. Bedoeling is dat het trouwens kan gebeuren met applicaties die hier niet voor voorzien zijn. Extreem gezegd photoshop ff doorzenden naar een andere pc en daar verder werken zonder dat deze geinstalleerd moet worden, settings gezet worden, ...
Bedoeling is dat het framework dus via reflection de applicatie ondekt en in gang zet. Misschien had ik gewoon moeten vragen hoe bewaar ik de state van een applicatie, thread informatie op zo een manier dat deze later weer ingeladen kan worden, onafhankelijk van welke applicatie ik draai. De applicatie zelf moet dus geen besef hebben dat deze gestopt, getransporteerd wordt en weer in gang gezet wordt.

P2P wel er is geen server, je zend van de ene client naar de andere. Peer to Peer

[ Voor 5% gewijzigd door Tyf op 09-02-2007 12:05 ]

[RobIII]

Tyf schreef op vrijdag 09 februari 2007 @ 12:04:
mja het gaat niet echt meer over settings, maar over de ganse toestand van je applicatie. Het is niet de bedoeling dat je alles gaat saven voor je verplaats. Bedoeling is dat het trouwens kan gebeuren met applicaties die hier niet voor voorzien zijn. Extreem gezegd photoshop ff doorzenden naar een andere pc en daar verder werken zonder dat deze geinstalleerd moet worden, settings gezet worden, ...

Ga dat maar rustig vergeten Dit gaat iig niet lukken op de manier die jij wil. Wat je zou kunnen doen is een Virtual PC draaien (VMWare, MS Virtual PC, etc) en die suspenden. Die image kun je dan overgooien naar een andere PC om zo verder te gaan; maar met apparatuur als een PDA e.d. gaat je dat niet lukken vrees ik
Daarnaast heb je het hier over een running state, iets wat ik uit je vorige posts helemaal niet opmaakte; dat is echter nogal een verschil

Tyf schreef op vrijdag 09 februari 2007 @ 12:04:
Bedoeling is dat het framework dus via reflection de applicatie ondekt en in gang zet. Misschien had ik gewoon moeten vragen hoe bewaar ik de state van een applicatie, thread informatie op zo een manier dat deze later weer ingeladen kan worden, onafhankelijk van welke applicatie ik draai.

Ik zie niet wat dat met reflection te doen heeft; en de state van een applicatie "zo maar" even bewaren en ergens anders weer "in gebruik nemen" is niet iets wat je zo op een dooie zondag (figuurlijk gesproken) programmeert als het uberhaupt al generiek te maken is.

Tyf schreef op vrijdag 09 februari 2007 @ 12:04:
P2P wel er is geen server, je zend van de ene client naar de andere. Peer to Peer

Ik begreep de P2P zoals die gebruikt wordt in Napster, Bittorrent, Kazaa en dat soort zaken

[ Voor 4% gewijzigd door RobIII op 09-02-2007 13:19 ]

[Tyf]

Met photoshop wel extreem voorbeeld gegeven. Het zou om simpele .net programma's gaan.
In .net heb je al zeer veel informatie beschikbaar over je programma vermits deze runt in een vm. Je kan ook heel veel objecten serializeren met behoud van hun state en weer inlezen (reflection), zonder dat dit object zich speciaal moet gedragen of aangepast zijn.
Het grote probleem zit hem in de UI's daar deze niet serialiseerbaar zijn, ze opnieuw opbouwen is mogelijk maar dan zit ik met een UI met niks achter, geen logic en geen state.

[ Voor 27% gewijzigd door Tyf op 09-02-2007 13:44 ]

[djluc]

Wat is uiteindelijk het nut? Waarom is het noodzakelijk om de running state op te slaan? Als je al je bestanden en instellingen hebt kost het toch vrijwel geen moeite meer om binnen een minuut aan het werk te zijn? Welke extra informatie wil je opslaan?

Om bij het voorbeeldje van Photoshop te blijven: Je hebt sowieso de software nodig op de pc, deze moet je dus installeren. Enige wat je extra moet doen is je instellingen copieeren van je USB stick naar de pc. Dat is met een simpele batch automagisch te doen. Dan kan je toch meteen weer aan het werk?

Virtual PC's op je USB stick is in principe de meest simpele methode voor je probleem, maar je platformafhankelijkheid neemt dan wel toe.

[Tyf]

"Wat is uiteindelijk het nut? Waarom is het noodzakelijk om de running state op te slaan? Als je al je bestanden en instellingen hebt kost het toch vrijwel geen moeite meer om binnen een minuut aan het werk te zijn? Welke extra informatie wil je opslaan?"

Wel als je de bestanden en instellingen wilt gaan opslaan moet je applicatie dit ondersteunen. Het moet voorzien zijn dat je gaat verhuizen, je alles opslaat en weer verder gaat doen later. Ook stel dat je applicatie midden in een berekening zit dan moet deze ofwel het rekenen stopzetten en opnieuw verder doen later (of je applicatie moet weeral aangepast zijn dat hij tussentijdse berekeningen kan bewaren). Ik wil de berekening kunnen pauzeren en op een andere machine verder zetten.
Nu dit laatste is geen noodzaak, indien dit te moeilijk wordt laat ik het achterwege en moet er ofwel gewacht worden tot alles klaar is of moet er herbegonnen worden op de nieuwe pc.

Ik heb het over mobile code, installeren moet transparant gebeuren. Verzenden en werken (er wordt wel soort tijdelijke installatie gemaakt in de cache maar deze gebeurd volledig transparant voor de gebruiker).

Virual pc enzo zijn uit den boze. Het is een onderzoek en er moet voldoen worden aan de eisen, deze zijn een framework maken waarmee applicaties transparant van het ene apparaat (pc,pda,gsm) naar een andere kan verplaats worden zonder verlies van de running state.

[ Voor 10% gewijzigd door Tyf op 09-02-2007 13:57 ]

[Ramon]

Misschien snap ik het nog niet helemaal maar waarom doe je dit niet gewoon webbased? Tuurlijk P2P is het dan niet meer maar je kan toch wel een server inrichten waar alle berekeningen op worden gedaan die feedback geeft naar een client via http? Als je graag wil kunnen tekenen kan dat via flash en pda's kunnen ook een mooie interface laten zien. En je kan een webapplicatie ook wel zo inrichten dat hij gewoon doorgaat met werken als jij uitgelogd bent zodat je als je op een PDA weer inlogt dezelfde gegevens weer voor je ziet.

[chime]

Je zal dit niet voor elke applicatie kunnen doen.

De applicatie zal namenlijk "compatibel" moeten zijn met het framework: Het framework moet in staat zijn om de noodzakelijke gegevens op te halen om zo de running state te kunnen reconstrueren, deze gegevens dienen vervolgens in een bestandje geplaatst te worden (xml, txt, ...). Vervolgens moet je framework ook weer in staat zijn om de running state als het ware terug op te bouwen.

[Tyf]

"Misschien snap ik het nog niet helemaal maar waarom doe je dit niet gewoon webbased? Tuurlijk P2P is het dan niet meer maar je kan toch wel een server inrichten waar alle berekeningen op worden gedaan die feedback geeft naar een client via http? Als je graag wil kunnen tekenen kan dat via flash en pda's kunnen ook een mooie interface laten zien. En je kan een webapplicatie ook wel zo inrichten dat hij gewoon doorgaat met werken als jij uitgelogd bent zodat je als je op een PDA weer inlogt dezelfde gegevens weer voor je ziet."

Heel het punt is dat er geen centrale server is, als 2 clients elkaar tegen komen met het framework moeten deze applicaties onderling kunnen uitwisselen.

Chime: wel ik dacht wel al dat je applicatie in zekere mate compatibel moet zijn. Maar dit zou zo minimaal mogelijk moeten zijn. Het zou moeten zeer makkelijk zijn om een simpel programma zo aan te passen dat deze op het framework draait, zonder de halve applicatie opnieuw te moeten schrijven.
Heel simpel gezien wat ik in gedachten had was ik overloop alle elementen op de form van mijn applicatie. Maak hiervan een beschrijving en schrijf deze weg. Dan heb ik een volledige beschrijving van mijn form + huidige staat (bv welke tab actief staat, welke velden met wat ingevuld staan). Het probleem is dan weer, hoe krijg ik dan de logica te pakken van de applicatie en stuur ik die met de beschrijving mee.

Opgelet ik weet dat dit geen perfect oplossing is. Voorlopig heb je dus ook maar 1 form, het is een onderzoek, ik zoek de mogelijkheden en maak een klein testvoorbeeldje. Photoshop overzetten is dus nog niet nodig. Als ik al een simpel applicatie met 1 form kan overzetten met behoud van state en eventueel nog niet voltooide berekeningen zal ik al heel blij zijn.

[RobIII]

Tyf schreef op vrijdag 09 februari 2007 @ 13:54:
Ook stel dat je applicatie midden in een berekening zit dan moet deze ofwel het rekenen stopzetten en opnieuw verder doen later (of je applicatie moet weeral aangepast zijn dat hij tussentijdse berekeningen kan bewaren). Ik wil de berekening kunnen pauzeren en op een andere machine verder zetten.

Tyf schreef op vrijdag 09 februari 2007 @ 14:24:
Als ik al een simpel applicatie met 1 form kan overzetten met behoud van state en eventueel nog niet voltooide berekeningen zal ik al heel blij zijn.

Of je nou aan 't "rekenen" bent of "tekstverwerken" of "tekenen" of whatever; het "stilzetten" van een proces is daar heus niet anders om; voor een pc is "rekenen" hetzelfde als "tekenen". Dat het voor ons, mensen, gevoelsmatig makkelijker is een berekening te pauzeren dan een tekening is andere koek.

Desalniettemin heb ik het idee dat je way over your head zit; je hebt geen benul wat er allemaal bij komt kijken om een running state op te slaan en die weer te resumen (en dan heb ik het niet over eigen software, maar software van derden). Je eigen software een running state laten opslaan is peanuts; kwestie van bepalen wat je wel/niet wil bewaren en een "suspend" knop maken (die in feite gewoon een save doet van het huidige "document" en wat zooi om weer te kunnen resumen). Wil je dit met software van derden gaan doen dan zul je toch al heel gauw naar virtuele machines moeten gaan kijken wil je dit uberhaupt (goed) werkend krijgen. De inhoud van een textbox op een willekeurig form is nog wel uit te lezen, maar de running-state (en trust me, dat is vele, véle malen meer dan jij ziet behalve de GUI) is echt wel een stuk moeilijker.

[Tyf]

Ja ben me wel bewust dat berekenen misschien foute woordkeuze is, een proces was idd beter gezegd.

Ik heb idd maar beperkt idee wat er bij kijken komt om een running state op te slaan en die weer te resumen, vandaag mijn vragen hier ook. Ik ben me er wel van bewust dat dit de gui niet alleen was, maar zocht een startpunt en dacht als ik al mijn gui zover krijg dat deze goed overgezet wordt is dat al een probleem minder.

Het is de bedoeling dat er met een virtual machine gewerkt wordt.

[RobIII]

Tyf schreef op vrijdag 09 februari 2007 @ 15:13:
Ik heb idd maar beperkt idee wat er bij kijken komt om een running state op te slaan en die weer te resumen, vandaag mijn vragen hier ook. Ik ben me er wel van bewust dat dit de gui niet alleen was, maar zocht een startpunt en dacht als ik al mijn gui zover krijg dat deze goed overgezet wordt is dat al een probleem minder.

De state van je GUI is nog wel je minste probleem

Tyf schreef op vrijdag 09 februari 2007 @ 15:13:
Het is de bedoeling dat er met een virtual machine gewerkt wordt.

En daarnet schreef je nog:

Tyf schreef op vrijdag 09 februari 2007 @ 13:54:
Virual pc enzo zijn uit den boze. Het is een onderzoek en er moet voldoen worden aan de eisen, deze zijn een framework maken waarmee applicaties transparant van het ene apparaat (pc,pda,gsm) naar een andere kan verplaats worden zonder verlies van de running state.

Je zult hoe dan ook, als je het fatsoenlijk werkend wil hebben, moeten gaan kijken naar virtualisatie. Of dat nou Virtual PC, VMWare of whatever is, of je eigen virtualisatie software schrijven (programmeer ze! ). Alle andere manieren die ik zo kan bedenken zijn gedoemd om te falen.

[ Voor 3% gewijzigd door RobIII op 09-02-2007 15:27 ]

[Coach4All]

Tyf schreef op vrijdag 09 februari 2007 @ 15:13:
.....

Het is de bedoeling dat er met een virtual machine gewerkt wordt.

Als ik het goed begrijp wil je dus een soort van VMWare Workstation op je PDA/PC/GSM, dat ook nog eens werkt op een manier als de software op een U3 stickje......

En je wilt dan "eenvoudig en snel" elke keer de software en de "vmdk" overblazen....

(Schitterend idee, maar of zoiets realiseerbaar is met minder dan tientallen manjaren werk... )

[Tyf]

ow was aan het denken aan java vm of .net vm
Nu van wat ik al gelezen heb en hoor lijkt de running state van 3th party software bijhouden en hervatten niet zo simpel ...
Zullen dan maar beginnen met eigen software aan te passen en voorzien dat ze kunnen pauzeren enzo.

"En je wilt dan "eenvoudig en snel" elke keer de software en de "vmdk" overblazen...."
eenvoudig voor de gebruiker, daarvoor niet voor de programmeur

en zoals eerder gezegd was even in de war met java vm was niet aan het denken aan VMware ofzo.

[djluc]

Je kan dit alleen doen in een gesloten omgeving (een virtuele PC bijvoorbeeld). Al is het alleen maar omdat de applicatie ook met het besturingssysteem communiceerd. Denk aan register settings, mappen, locaties enzovoorts.

Een andere methode zou zijn als je de stappen op gaat slaan. Dat wil zeggen dat je gedurende een "run" alle input opneemt. Zodra je op een nieuw systeem zit ga je weer alles uitvoeren tot er een save actie komt.

[mjax]

Volgens mij is deze queste zo goed als onmogelijk te realiseren. Naast GUI en internal state, heb je ook te maken met externe resources. Hoe wil je de "state" daarvan suspenden en resumen? Om jouw Photoshop voorbeeld te gebruiken: stel ik ben een document aan het printen en ik suspend de applicatie en stuur 'm door naar m'n PDA (zo zou het toch moeten werken?). Wat moet die PDA dan met de print job doen?

Simpel voorbeeld natuurlijk.

[Confusion]

Tyf schreef op vrijdag 09 februari 2007 @ 13:54:
Wel als je de bestanden en instellingen wilt gaan opslaan moet je applicatie dit ondersteunen. Het moet voorzien zijn dat je gaat verhuizen, je alles opslaat en weer verder gaat doen later.

En nu moet je ondersteunen dat je je programma op een willekeurig moment stop, de state ergens opslaat, en het programma daarna weer vanuit die state laat starten. Het opslaan van bestanden en instellingen is niets anders dan het opslaan van het strikt noodzakelijke deel van de state. Meer opslaan weegt niet op tegen de moeilijkheden die dat met zich mee brengt.

Ook stel dat je applicatie midden in een berekening zit dan moet deze ofwel het rekenen stopzetten en opnieuw verder doen later (of je applicatie moet weeral aangepast zijn dat hij tussentijdse berekeningen kan bewaren). Ik wil de berekening kunnen pauzeren en op een andere machine verder zetten.

Waarom? Als je berekening zo belangrijk is dat langer duurt dan je computer aanstaat, dan heb je ofwel een dedicated machine nodig die daar permanent zijn ALU's op staat stuk te bijten (je kan toch niets anders met die machine doen), ofwel het is toch niet zo belangrijk. Daarnaast zijn berekeningen typisch het soort dingen waarvan je de toestand na iteratie n kan vastleggen, om de computer even later met iteratie n + 1 te laten starten.

Ik heb het over mobile code, installeren moet transparant gebeuren. Verzenden en werken (er wordt wel soort tijdelijke installatie gemaakt in de cache maar deze gebeurd volledig transparant voor de gebruiker).

Tjah, kijk eens naar Java Webstart, de auto-update mechanismen van diverse software en eventueel, inderdaad, naar Agents. Hier kan je een open source agent development kit downloaden, waar heel wat dot-com-Bubble euro's aan zijn opgegaan .

[roy-t]

=) Maar zijn die programma's die op dat 'framework' van jou gaan draaien thirdparty? of ga je ze ook zelf maken, als je ze zelf maakt is dit redelijk haalbaar lijkt me zo.

*ooh dit idee klinkt als een techshow project, waar je iets te zien krijgt dat je over 10jr allemaal in huis hebt!*

[Tyf]

Welja het is een onderzoek printjobs enzo zijn voorlopig niet van belang, maar je hebt gelijk resources zijn een groot probleem bij wat ik wil doen. En dan heb ik het niete alleen over printers die er niet meer zijn opeens

3th party programma's zullen dan ook niet werken, zal dan eisen dat de programma's die op het framework moeten draaien enkele functies ondersteunen, zoals het wegschrijven van hun current state.

Ooit misschiens eens op terugkomen binnen 10 jaar ;-)

Was overtuigd dat ,moest ik in java of .net, werken het nog doenbaar was (daarom niet simpel) vermits de vm echt wel een soort VMware achtig iets is, je software draait ook in een "gesloten" omgeving, geen rekening houdende met externe zaken zoals db, printers, etc.

Ik ga het dan ook iets minder groots aanpakken en werken met aangepaste software voor het framework.

[AquilaDus]

TS is niet toevallig bezig met een stage ergens in zuid-limburg? Ik heb namelijk een dergelijk onderzoek moeten doen voor een stageopdracht. Hierbij wilde men ook applicaties overdragen van een terminal (pc, pda of gsm) naar een andere.

Mijn conclusie was dat het wel te doen is, mits je bij de ontwikkeling van de mobile applicaties rekening houdt met deze requirement. Daarbij zul je ook nog eens tussenliggende laag moeten hebben op die terminals die er voor zorgt dat de draaiende applicaties worden geidentificeerd en worden overgezet als het nodig is.

Het kan dus, maar dan moet je wel alles van de grond af moeten opbouwen qua applicaties.

[LauPro]

Wat je beschrijft heeft KDE al een tijdje. Hiermee kan je de state van een applicatie herstellen als je deze opnieuw start. Bijvoorbeeld als je een e-mail aan het schrijven bent en je staat in een bepaalde folder dat na het afsluiten en het opnieuw starten van de applicatie (of uit-/inloggen) weer exact in de state terug komt waar die was. Dan krijg je dus zoiets:

C++:

int main(int argc, char **argv) {
    // ..
    KApplication app;
    ss *mainWin = 0;

    if (app.isRestored()) {
        RESTORE(ss);
    } else {
        // ..
        mainWin->show();
    }

    return app.exec();
}

Alleen in de praktijk ondersteunen vrij weinig programma's deze feature. Het is namelijk een pain in the ass om dit goed te krijgen. Alle factoren moeten worden meegenomen, geopende bestanden, posities van schermen, focus, states etc.

Tegenwoordig is het meer de trend om de application-state in het bestand dat opgeslagen wordt te zetten. Bijvoorbeeld bij Open Office waar de positie waar je het laatst was wordt bijgehouden in een tekstdocument. (Maar nog niet welke werkbalken je waar had bijv.)

[kamerplant]

Waarom zou dit voor 3th party software vrijwel onmogelijk zijn? Als ik mijn notebook (Mac OS X) dichtklap worden alle processen bevroren, zodra ik hem openklap gaat alles binnen 10 sec vrolijk weer door (ja, ook lopende berekeningen) tenzij bijvoorbeeld de wifi verbinding is weggevallen terwijl dit nodig was voor het proces. Waarin zit het verschil tussen dit en hetgeen wat de TS wilt?

Waarschijnlijk is het een domme vraag, ik ben geen programmeur, maar ik ben wel benieuwd.

[Ramon]

Datafeest schreef op woensdag 21 februari 2007 @ 23:15:
Waarom zou dit voor 3th party software vrijwel onmogelijk zijn? Als ik mijn notebook (Mac OS X) dichtklap worden alle processen bevroren, zodra ik hem openklap gaat alles binnen 10 sec vrolijk weer door (ja, ook lopende berekeningen) tenzij bijvoorbeeld de wifi verbinding is weggevallen terwijl dit nodig was voor het proces. Waarin zit het verschil tussen dit en hetgeen wat de TS wilt?

ik denk omdat je bent vergeten dat de TS zijn laptop wil dichtklappen en dan op zijn PDA de state van de applicaties op zijn laptop wil kunnen overnemen en verder wil kunnen werken?

[ Voor 6% gewijzigd door Ramon op 22-02-2007 00:02 ]

[Tyf]

Ben al wat verder geraakt nu. Heb het al een beetje generiek kunnen maken in de zin dat de applicatie zich geen save state method moet bevatten. Ik overloop via reflection alle members die er zijn en haal hun waardes op en schrijf deze weg (nog niet perfect, maar het is al een goed begin). Zo kan ik al van simpele applicaties hun state volledig bewaren in de zin van welke tabs actief staan, tekst in textboxen, size, kleuren, etc door de ganse applicatie door te geven naar een savestate method, ook is er een loadstate die op basis van een instantie van de applicatie en een path naar de bewaarde state van deze alles opnieuw kan inladen.

Threads zijn nog niet overdraagbaar denk dat dit ook zal blijven

AquilaDus, ik ben geen stage bezig, maar mijn thesis. De opdracht was een studie te maken over mijn startvraag. Het is wel in de limburg is het misschien mogelijk wat meer te vertellen wat je juist gedaan hebt op je stage toen je dit moest maken?

Ik heb dus papers gelezen waarin stond wat ik wou wel mogelijk was mits aanpassing van de vm in java. Maar ik wou het zo generiek mogelijk hebben en zonder aanpassing van de vm. Ben trouwens in .net bezig omdat dit toch iets meer mogelijkheden had dan java voor wat ik wou maken.

[ Voor 12% gewijzigd door Tyf op 26-02-2007 17:21 ]

[chris]

Dit is wel echt heel cool. De kunst is volgens mij om state-methods compleet te scheiden van methods die stateless zijn. Kijk anders ook eens naar Haskell, daar wordt dat heel goed gescheiden. Ik denk dat het daar prima mogelijk zou moeten zijn. Verder zou ik absoluut even googlen op "continuations", dat is ongeveer wat je wilt. Keep us posted!

[AquilaDus]

Tyf schreef op maandag 26 februari 2007 @ 17:19:
AquilaDus, ik ben geen stage bezig, maar mijn thesis. De opdracht was een studie te maken over mijn startvraag. Het is wel in de limburg is het misschien mogelijk wat meer te vertellen wat je juist gedaan hebt op je stage toen je dit moest maken?

Ik heb dus papers gelezen waarin stond wat ik wou wel mogelijk was mits aanpassing van de vm in java. Maar ik wou het zo generiek mogelijk hebben en zonder aanpassing van de vm. Ben trouwens in .net bezig omdat dit toch iets meer mogelijkheden had dan java voor wat ik wou maken.

Ik heb zelf toen vooral onderzoek gedaan naar hoe de overdracht in theorie moest gaan. Daarbij heb ik dan onderscheid gemaakt tussen:

1. items die lokaal aanwezig zijn op het apparaat (data die de application state bevat)
2. items in de buitenwereld (netwerk verbindingen e.d.)

Beide onderdelen brengen requirements met zich mee. Voor het eerste onderdeel gaat het dan inderdaad vooral om dat data state van de applicatie. Alle applicaties moeten dan inderdaad hierop worden ingericht en apart worden ontwikkeld. Hoe je deze state wil opslaan hangt dan inderdaad een beetje af van taal e.d. die je gebruikt. Ik heb zelf toen geen praktijk voorbeeld hiervoor uitgewerkt omdat dit niet mijn taak was.
Bij het tweede deel heb ik gekeken welke requirements er waren voor de buitenwereld waar de applicatie mee communiceert. In kort kwam dit neer op verbindingen waarvan endpoints kunnen worden veranderd (sommige high level protocollen ondersteunen dat, bv. SIP) en je moet instanties verwittigen (servers e.d.) die moeten weten waar jouw applicatie zich bevindt.

En de interne applicatie state is dan ook nog eens afhankelijk van data die binnenkomt via netwerkverbindingen. Ik heb toen vooral nog gekeken naar hoe al deze dingen in theorie moeten worden gecombineerd zodat de applicatie kan worden overgedragen zonder dat er foutieve dingen gebeuren met de state en er geen netwerkdata verloren gaat.

[igmar]

Het is eigenlijk niet te doen denk ik, mits je er een laag tussenzet. Applicaties kunnen op verschillende adressen geladen zijn, ze hebben files ed open, DLL's geladen, IP sockets open, etc, etc, etc.

Op Unix kun je het proces bevriezen, uivinden wat dat ding allemaal geladen heeft, en dat overzetten. Da's al reeel, maar er komt nogal wat bij kijken. Op Windows kun je ook de process state dumpen UMPD, maar de rest er omheen is er eigenlijk niet. Indien het bv dingen in een virtual machine draait is het al iets makkelijker, maar je zal dan de VM moeten aanpassen zodat de state ergens opgeslagen wordt, en ook weer ingelezen.

Niet echt simpel.