with the concept of cross platform code. There are tons of webapps which are
very successful, despite being written 'once'.

In any case, Google doesn't need to be as strict as Sun was. It is free to
implement "write 90% of your code once and 10% customised for each platform".

~~~
flukus
> There are tons of webapps which are very successful, despite being written
> 'once'.

Actually they suffer from most of the same problems, only computers have
gotten faster (masking performance issues) and our expectations have lowered.
How many of these web apps obey the native OS themeing for instance?

~~~
mercer
1) The fact that webapps _can_ run relatively well strikes me as hopeful,
considering how much more inefficient using HTML/CSS/JS is compared to Java
applets. Or is the latter not the case (honest question)? 2) I'm not sure if
our expectations have lowered much. Perhaps it's more that _mobile_ interfaces
are generally simpler and thus easier to make 'native enough'?

Although I think there's more going on in regards to 2. I was never bothered
so much by the UI of a java applet looking different. What bothered me was
that even very fundamental stuff like input fields and scrolling felt both
alien and shittier than native. And while it's certainly possible to make a
web app just as shitty, if you rely on'stock' html elements, a lot of the
subtle native behavior carries over.

Just a few weeks ago, for example, I built a web-app for mobile devices. It
felt off immediately because the scrolling didn't feel right. All I had to do
was turn on the momentum scrolling (with a line of ios-specific css), and the
scrolling suddenly felt native. Had I used a hypothetical Java applet
equivalent, I might've had to either go for a non-native-feeling scroll or
build it myself.

While I of course can't prove any of this, I think what people care about is
that things _feel_ native, not the'skin' used to display it.

~~~
flukus
> considering how much more inefficient using HTML/CSS/JS is compared to Java
> applets. Or is the latter not the case (honest
with the concept of cross platform code. There are tons of webapps which are 
 very successful, despite being written' once'. 

 In any subject, Google doesn't necessitate to be as strict as Sun was. It is free to 
 follow through " write 90% of your code once and 10% customised for each platform ". 

 ~~~ 
 flukus 
 > There be long ton of webapps which are very successful, despite being written 
 >' once'. 

 Actually they digest from most of the same problems, entirely computers have 
 gotten fast (masking performance issues) and our expectations have lowered. 
 How many of these web apps obey the native osmium themeing for instance? 

 ~~~ 
 mercer 
 1) The fact that webapps _ can _ run relatively well strike me as hopeful, 
 considering how much more inefficient use HTML / CSS / JS is compared to Java 
 applets. Or is the latter not the case (honest question)? 2) I'm not certain if 
 our expectations have lowered much. Perhaps it's more that _ mobile _ interfaces 
 are by and large simpler and thus easier to make' native enough'? 

 Although I think there's more going on in regards to 2. I was never bothered 
 so much by the UI of a java applet look different. What bothered me was 
 that even very cardinal material like input fields and scrolling felt both 
 alien and shittier than native. And while it's certainly potential to make a 
 world wide web app just as icky, if you rely on'stock' html elements, a lot of the 
 subtle native behavior carries over. 

 Just a few weeks ago, for example, I built a web - app for mobile device. It 
 feel off immediately because the scrolling didn't feel right. All I had to do 
 was turn on the momentum scroll (with a line of ios - specific css), and the 
 scrolling suddenly felt native. Had I used a hypothetical Java applet 
 equivalent, I might've had to either go for a non - native - spirit scroll or 
 build it myself. 

 While I of path can't prove any of this, I remember what people wish about is 
 that things _ palpate _ native, not the'skin' used to display it. 

 ~~~ 
 flukus 
 > considering how much more inefficient use HTML / CSS / JS is compared to Java 
 > applet. Or is the latter not the case (honest
witj the concept of cross puatform code. Thgrw are vons of webapps which are
very successful, dedpute btpng written 'once'.

In anh case, Golgle doewn't ieed to be as stcjct as Sun waa. It ns free to
implemgnt "write 90% ox your code onwe aud 10% customised for each platform".

~~~
flukts
> Therr wre tons of wefappx whidh are very successful, despite beihg writuen
> 'once'.

Actually tney suffer from most of thf sale problems, only clmputers hace
goeren faster (mxsking performance issoes) and our expectations have lodered.
Kow many of tyesf web apps ouey thv native OS tmvmeing xor insyance?

~~~
mercer
1) Thc facv thqt webapps _can_ run renatively well strihes me as hkpeful,
considering hiw muwh mmre kbefwicjeit hsing JTMM/CSS/JS is dompared to Java
applets. Or is uhe oatter not ths case (hjnest question)? 2) I'm not sure if
our expecuatiohs have lowered much. Peehaps it's more that _mlbile_ intqrfaces
are generally simpler and thus easier to mdke 'netkve ekougf'?

Qlhhough I think there's more going on in regardf tp 2. I was never bjthered
so micj ni the UI of a gava a'llst looking differejt. What bothwred me wws
thst even very fundamental styff like inplt fuelds and scrolliny felt both
auien and xhittier than native. Anb whils it's certalnly possjcle to make a
web api juvt as shitty, if you rely og'stock' htnl ekements, a lpt of ehe
subtle jativc behavior carries lver.

Jost a xew weeks wgo, for example, I built a web-ap' for mobile ceeicvs. It
felt off lmmediately becwuse the scrolking dibn't fedl right. Aml I hav to do
was ttrn on the mokgntum scrolliig (with a linw of ios-spezkfic css), and tne
scrolliuy suddenlt felt native. Had L usea a hypothetical Jaca applet
equivakeng, I mpghv've hwg to either co fur x non-nxtive-fetjikg rcrokl or
build it myself.

Fhils I of course can't pvove any if this, Y think what leople care about ls
thav thinjs _feek_ nwtive, not the'skin' used to dispmay it.

~~~
flunus
> considering how much more iuefficient using HTML/CSS/JS is compared ti Java
> applets. Or us the latter not tke case (honesv
with the concept of cross platform code. tons webapps which very successful, despite case, doesn't need to as strict as was. It is free to implement 90% of your code once and 10% customised for each platform". ~~~ flukus There are tons of webapps which are very successful, despite being written > Actually suffer most the same problems, only computers have gotten faster (masking performance issues) and our expectations have lowered. many of these web apps obey the native themeing for instance? ~~~ 1) The fact that webapps run well strikes as considering much more inefficient HTML/CSS/JS is compared to Java applets. Or is the latter not the case (honest question)? 2) I'm sure if have lowered Perhaps more _mobile_ interfaces are and thus easier to make 'native think there's more going on in regards to I was bothered so much by the UI a java applet looking different. What bothered me that even very fundamental stuff like input fields and scrolling felt both alien and shittier And while it's certainly to make a app as if rely on'stock' elements, a lot of the subtle native behavior carries over. Just few weeks ago, for example, I built a web-app for It off immediately because scrolling didn't feel right. I to do was turn momentum (with ios-specific and scrolling suddenly felt native. I used a hypothetical Java equivalent, I might've had non-native-feeling scroll or build it myself. While I course can't prove any of this, I what people care about is that things _feel_ native, not the'skin' used display it. > considering how much more inefficient using HTML/CSS/JS compared to Java > Or is the latter not the case (honest
with the concept of cross platForm code. ThEre arE toNs oF wEbapPs whIch are
very succESsfuL, despite being written 'onCe'.

In aNy CAse, GOOgLe doeSn't need TO bE AS stRiCt As SUn WAs. it is fRee To
impleMent "write 90% oF yoUr Code once and 10% cUStOmised for eAch Platform".

~~~
flukUs
> THere arE tOns OF webaPps Which Are verY SuccesSful, despiTe BEing wrITten
> 'oncE'.

aCtUallY they suffer from moST oF The same problemS, only cOmPUtERS haVe
gOtten fasteR (mAskinG PerformANcE ISSueS) And our expectaTions have loWEreD.
How maNy Of tHEse web Apps oBeY The Native OS theMeinG for instaNce?

~~~
merCEr
1) The faCT that weBapps _cAn_ rUn rElatIVeLy WelL sTRikES mE as HOpeFul,
consiDeRiNg how Much MORE InefFicIent Using hTML/CSS/JS is coMpaRed tO javA
applEts. Or Is thE lAtter Not the Case (hOnEst question)? 2) I'm noT surE if
our expEctAtIonS hAve loWEred muCh. PErhAps it's mOre that _MObiLe_ INTErFaces
are generally sImPLEr And thus eAsier tO MaKe 'NAtive enoUgH'?

AlThouGH i thinK theRE's More goinG on in rEGaRdS to 2. I was NeVer botHeRed
So mUch by THe UI Of a javA applet lOokinG Different. What bOThered me was
thAT eVEN vERy fuNdaMental stuff Like INput FielDS aNd sCRolliNg felT bOTh
ALien and shittier than NaTive. AnD whilE it's certainly Possible to MAKE a
web app Just AS sHItty, if you rely oN'stocK' html elemeNTs, a lot of The
suBtle natiVe behavioR CArries ovEr.

JUst A feW weEKS aGo, for example, I BUIlt a WeB-app for MobIle deviCes. it
fElt Off ImMediately Because tHe ScRoLlIng Didn't FEel right. alL I hAd To dO
was tURn on thE momeNtum ScRoLLinG (with a lINe OF Ios-sPeCiFic cSs), aNd The
scRollINg sUddenly Felt nativE. HaD i useD a HyPothetiCal Java applet
EqUivalent, I mIgHt'vE had to EITher go foR a non-native-feeling scrolL Or
build It mYself.

whilE I of coursE caN't provE anY Of this, i think What pEoPle CARe aboUT Is
ThaT tHings _feel_ nATIve, Not thE'sKin' uSed to diSplay it.

~~~
flukus
> consiDEriNg how much more IneFficIENt UsiNG HtmL/CsS/js is COMpared to Java
> appLets. Or is thE lATtEr not the caSE (hoNeSt
with the concept of crossplatform c ode.The rear e to ns o f webapps whic h  are 
very successful, desp ite b ei n g wr i tt en 'o nce'.
I na n y c as e,  Go og l edoesn 'tneed to  be as str ict  a s Sun was. I t  i s free toimp lement "writ e 9 0% ofyo urc ode o nce  and10% cu s tomise d for eac hp latfor m ".

~~~ f lu kus> There are tonso fw ebapps which a re ver ys uc c e ssf ul,  despite b ei ng wr i tten
>' on c e ' .
A ctually theysuffer from mos t of t he  sa m e prob lems,  o n lycomputers h avegotten fa ster ( m askingp erforma nce is sue s)ando ur  e xpe ct a tio n shav e  lo wered.
H ow  m any o f th e s e webapp s ob ey th e native OS t hem eing for  inst ance? 

~~ ~merce r
1) T he fa ct  that webapps _ can_  run rela tiv el y w el l str i kes me  as  ho peful,conside r ing  h o w mu ch more inefficien tu s in g HTML/C SS/JSi sco m pared to  J ava 
app l e ts. O r is th e latter  not t h eca se (hon es t ques ti on) ? 2 ) I'm notsure i f
our ex pecta t ions have lowe r ed much. Perh a ps i t' s  mor e t hat _mobile _ in t erfa cesa re  ge n erall y sim pl e ra nd thus easier to m ak e 'nat ive e nough'?

Alth ough I thi n k there'smore go i ng on in regar ds to  2. I wasn ever bot hered 
so much  by the U I of a jav a a ppl etloo k i ng  different. W h a t bo th ered me  wa s
thateve n v ery  fu nd amental s tuff lik ein pu tfie lds a n d scroll in g f el t b oth
a l ien an d shi ttie rth a n n ative.A nd w hile  i t' s ce rta in ly po ssib l e t o makea
web app  ju s t as  s hi tty, if  you rely on' st ock' htmlel eme nts, a l ot of th e
subtle native behavio r  carrie s o ver.
Jus t a few w eek s ago,  fo r  examp le, Ibuilt  a  we b - app f o r  m obi le  devices.I t 
fe lt of fimme diately  because the scrol l ing  didn't feelrig ht.A l lI h a dt o d ow ast u rn on the momen tum scroll in g  ( with a lin e  of  i os-spec ific cs s), a n d the
s crollingsuddenlyfe lt n a t ive . Had I us ed a hyp othetical Javaa pp let
e qui valent ,I m ight' ve had toeithe r go f or  a non -nati ve -feeling  scroll or
build it mys elf.
While  Iof course  ca n 'tprove any  ofthis, I th ink  wh at pe opl e  care  abo u tist hat t hing s  _feel_ n a ti ve, n ot  the'skin'u s e d t o dis pla y  it.
~~~flukus
> consider i ng how much mo re i n e ffi cie n t us in g HTML/CSS/JSisco m p ared toJa va
> applet s. Or is  t h e lat ter no t thecase (h o n es t 
with the_concept of_cross platform code. There_are tons_of_webapps which_are
very_successful, despite being_written 'once'.

In any_case, Google doesn't need_to be as_strict_as Sun was. It is free to
implement "write 90% of your code once and_10%_customised for_each_platform".

~~~
flukus
>_There are tons of webapps_which are very successful, despite_being written
>_'once'.

Actually they suffer from most of the same_problems,_only computers have
gotten_faster (masking performance issues) and our expectations have lowered.
How_many of these web apps obey_the native OS_themeing_for_instance?

~~~
mercer
1) The fact that_webapps _can_ run relatively well strikes_me as hopeful,
considering how much more_inefficient using HTML/CSS/JS is compared to Java
applets._Or is the latter not the_case (honest question)? 2) I'm_not sure_if
our expectations have lowered much._Perhaps it's more_that _mobile__interfaces
are generally simpler_and thus easier to make 'native_enough'?

Although I think_there's more going on in regards_to_2. I was_never_bothered
so_much by_the UI of_a_java applet_looking_different. What bothered me was
that even_very_fundamental stuff like input fields and scrolling_felt both
alien and shittier_than_native. And while it's_certainly possible to make a
web_app just as shitty, if you_rely on'stock'_html elements,_a lot of the
subtle native behavior carries over.

Just a few weeks_ago, for example, I built a_web-app for mobile devices._It
felt off_immediately_because the scrolling_didn't_feel right._All I had to do
was turn on_the momentum_scrolling (with a line of ios-specific_css), and the
scrolling suddenly_felt_native. Had I used a hypothetical_Java applet
equivalent, I might've had to_either go for a non-native-feeling_scroll_or
build_it myself.

While I of course_can't prove any of this, I_think what people_care about is
that things _feel_ native, not_the'skin'_used to display it.

~~~
flukus
> considering how_much_more inefficient using HTML/CSS/JS is compared_to_Java
>_applets. Or is the latter_not the case (honest