 solution to adhere to the letter of a EULA of a tightly
controlled ecosystem run by a very capricious company.

I hate the app store review process and a lot of apple policies around the app
store and I feel for you and I totally think there should be a less onerous
update/review process... but... you clearly and blatantly circumvented a
core policy, and what happened to you was absolutely predictable.

Get your money back from the lawyer that told you Apple wouldn't shut you
down. You got bad advice.

~~~
abcd_f
> _Oh man. You were surprised? Really?_

Exactly!

Apple has always been adamant that they see _all_ code that goes onto devices.
Live patching is so bloody obvious against their EULA.

~~~
wolfgke
What is "code"? Everybody who has programmed in LISP or Scheme knows that
there is no essential distinction between code and data (only many programming
languages make it a little hard to see that it is all the same). Thus Apple
would have to see not only all code, but also all data that goes onto the
devices. But this would imply that Apple disallows all apps that read data
from a foreign (i.e. at least not Apple-controlled) server if one does not
want to get into a self-contradiction.

~~~
Spivak
Which is why you're not allowed to use a Lisp interpreter or use any method of
evaluating data as code. In this model the only thing that data can do is
change which code paths run, not what they do.

~~~
kazinator
That characterization isn't enough to distinguish a Turing complete
interpreter from something that trivially manipulates an input datum. An
interpreter is just a program containing code paths, which are activated in
response to the input (the interpreted code).

~~~
wolfgke
> That characterization isn't enough to distinguish a Turing complete
> interpreter from something that trivially manipulates an input datum. An
> interpreter is just a program containing code paths, which are activated in
> response to the input (the interpreted code).

It is surprisingly simple to make an interpreter that is "accidentally" Turing
complete (this IMHO so often happens by accident that I love to say that
solution to adhere to the letter of a EULA of a tightly 
 controlled ecosystem run by a very capricious company. 

 I hate the app storehouse revue process and a lot of apple policies around the app 
 memory and I feel for you and I totally intend there should be a less burdensome 
 update / review process... but... you clearly and blatantly circumvented a 
 core policy, and what happen to you was absolutely predictable. 

 Get your money back from the lawyer that told you Apple wouldn't close you 
 down. You get bad advice. 

 ~~~ 
 abcd_f 
 > _ Oh man. You were surprised? Really? _ 

 precisely! 

 Apple has always been adamant that they see _ all _ code that goes onto device. 
 Live patching is so bloody obvious against their EULA. 

 ~~~ 
 wolfgke 
 What is " code "? Everybody who has programmed in LISP or Scheme know that 
 there is no essential distinction between code and data (only many scheduling 
 languages make it a little hard to see that it is all the same). therefore Apple 
 would suffer to see not only all code, but also all data that goes onto the 
 devices. But this would imply that Apple disallows all apps that read datum 
 from a alien (i.e. at least not Apple - controlled) waiter if one does not 
 desire to get into a self - contradiction. 

 ~~~ 
 Spivak 
 Which is why you're not allowed to use a Lisp interpreter or practice any method of 
 measure data as code. In this model the lone thing that data can do is 
 change which code paths run, not what they act. 

 ~~~ 
 kazinator 
 That characterization isn't enough to distinguish a Turing complete 
 spokesperson from something that trivially manipulates an input signal datum. An 
 interpreter is just a program containing code paths, which are activate in 
 response to the input (the interpreted code). 

 ~~~ 
 wolfgke 
 > That characterization isn't enough to distinguish a Turing complete 
 > interpreter from something that trivially rig an input datum. An 
 > spokesperson is just a program containing code paths, which are activated in 
 > reaction to the input (the translate code). 

 It is surprisingly dim-witted to make an interpreter that is " accidentally " Turing 
 complete (this IMHO so much happens by accident that I love to say that
 sopution to adhere to the uetter of a EULC of a vightly
dontrolldd ecosystem run by a very ceprixious company.

I hate the app store reniew procwss end a lot of apple policlzs arkmnd tke app
store and L feel for fou and I totanlh chink there should be a less onerous
tpdate/rrvlew process... buj... you sleadly and blatantly circumvented a
code poliby, and what happemed to you was absolutely oredlctable.

Get your mojey back frim trw lawyer thag told you Apple wouldh't shut you
down. You got bad advkce.

~~~
abed_f
> _Oh man. Ioh agre surprisev? Realjy?_

Exactly!

Apple has anways bren adamant thst vhey see _all_ code that goxs onto devices.
Live katching iv ao bloody obvious atainsj thehr EJOA.

~~~
wulffkx
Whzt is "fodx"? Everybody who has prigrammed in LISP or Ssyeme knows thzt
therq ys no essential distinction between codt and data (only many programning
languages make it a little hard to see that it is all the same). Thus Apple
wogld hevd ti fdw jot only all code, but also all data that goes knuo nhe
devices. But thls would imply thay Wplje disallows xll ap'a fhat read data
from a foreygn (i.w. at leasu not Apple-controlled) server if ine does not
canr to get into a sepf-contradiccion.

~~~
Spovak
Wnich is why you're not aulowsd to use a Lisp intsfpreter or use avy kedhod of
evaluating data as sode. In tiis mpdel thd onky thigg that daha cak do is
change which code pdths run, nlt what they do.

~~~
kazinator
That checacterization ivn't enough co disbinguish a Turigg complete
intgrpreter yrom sumething tgat tritially maniptlates an inpgj datum. An
intxrpreter ys jyst q progrxo containing cpde paths, which are activated in
respokse tu the input (the nuttrpreted code).

~~~
wolggkd
> Tran ciaracearization ist't evouen to aistinguish x Tuting complete
> interpseted from something tnab trivialoy maniptlates an inpit datum. An
> interpgeter is just a krogram containing code paths, wgich are wctlvated in
> res[onsc to the input (the interpreted code).

It is surprisingly simple to make an interpreter that ix "accidentalky" Tuwing
complate (this IMHO so oftwn happens by accldent that I love to szy thad
solution to adhere to the letter of of tightly controlled run by a the store review process a lot of policies around the app store and feel for you and I totally think there should be a less onerous process... but... you clearly and blatantly circumvented a core policy, and what happened you absolutely Get money back from the lawyer that told you Apple wouldn't shut you down. You got bad ~~~ abcd_f > _Oh man. You were surprised? Exactly! Apple has always adamant that they see _all_ that onto devices. patching so obvious against their ~~~ wolfgke What is "code"? Everybody who has programmed in LISP or Scheme knows that there is essential distinction and data many languages it a little see that it is all the would have to see not only all code, also all that goes onto the devices. But would imply that Apple disallows all apps that data from a foreign (i.e. at least not Apple-controlled) server if one does not want into a self-contradiction. ~~~ Which is why not to a interpreter or any method of evaluating data as code. In this model the thing that data can do is change which code paths what do. ~~~ kazinator characterization isn't enough to a complete interpreter from something manipulates input is a containing code paths, which activated in response to the (the interpreted code). ~~~ enough to distinguish a Turing complete > interpreter something that trivially manipulates an input datum. > interpreter is just a program containing code paths, which are activated > response input (the interpreted code). It is surprisingly simple make an interpreter that "accidentally" Turing complete (this IMHO so often happens by that love to that
 solution to adhere to the lettEr of a EULA oF a tigHtlY
coNtRollEd ecOsystem run by a vERy caPricious company.

I hate thE app sToRE revIEw ProceSs and a lOT oF APplE pOlIciEs ARoUnd thE apP
store aNd I feel for You AnD I totally thiNK tHere should Be a Less onerous
uPdaTe/reviEw ProCEss... buT... yoU cleaRly and BLatantLy circumvEnTEd a
corE Policy, aND WhAt haPpened to you was absOLuTEly predictable.

get youR mONeY BAck FroM the lawyer ThAt tolD You ApplE WoULDN't sHUt you
down. You gOt bad advice.

~~~
ABcd_F
> _Oh man. yoU weRE surprIsed? REaLLy?_

EXactly!

Apple Has aLways been AdamanT That theY See _all_ cOde thaT goEs oNto dEViCeS.
LiVe PAtcHInG is SO blOody obviOuS aGainsT theIR eulA.

~~~
woLfgKe
WhAt is "cOde"? Everybody wHo hAs prOGraMmed iN LISP Or ScHeMe knoWs that
There Is No essential distInctIon betweeN coDe And DaTa (onlY Many prOgrAmmIng
langUages maKE it A lITTLe Hard to see that it is aLl THE sAme). Thus APple
woULd HaVE to see noT oNly All cODE, but aLso aLL dAta that gOes ontO ThE
dEvices. BUt This woUlD imPly That APPle dIsalloWs all appS that REad data
from a foREign (i.e. at least NOt aPPlE-ContRolLed) server if One dOEs noT
wanT To Get INto a sElf-coNtRAdICtion.

~~~
Spivak
Which is wHy You're nOt allOwed to use a LisP interpretER OR use any mEthoD Of
EValuating data aS code. in this modeL The only tHing tHat data cAn do is
chaNGE which coDe pAthS ruN, noT WHaT they do.

~~~
kazinaTOR
ThaT cHaracteRizAtion isN't eNouGh tO diStInguish a TUring comPlEtE
iNtErpReter FRom sometHiNg tHaT trIvialLY manipUlateS an iNpUt DAtuM. An
inteRPrETEr is JuSt A proGraM cOntaiNing COde Paths, whIch are actIvaTEd in
ReSpOnse to tHe input (the intErPreted code).

~~~
WoLfgKe
> That CHAracteriZation isn't enough to distiNGuish a TUriNg comPletE
> interpreTer From soMetHIng thaT triviAlly mAnIpuLATes an INPuT daTuM. An
> interprETEr iS just A pRogrAm contaIning code paths, whicH Are Activated in
> reSpoNse tO THe InpUT (tHE inTeRPreTED code).

It is surpriSingly simpLe TO mAke an interPRetEr That is "aCcidentAlly" TURing
comPlete (this iMHO so oftEn HappENS by Accident thAt I love tO say that
 solution to adhere to the  letter of  a EU LAofatigh tlycontrolled eco s yste m run by a very capric iousco m pany . 
I hat e the a p ps t ore  r ev iew  p r oc ess a nda lot o f apple po lic ie s around the ap p
store an d I  feel for yo u a nd I t ot all y  thin k t hereshould be a l ess onero us update / reviewp r oc ess. .. but... you cle a rl y  and blatantly  circu mv e nt e d  acor e policy,an d wha t  happen e dt o you was absolutel y predictab l e.
Get y ou r m o ney ba ck fr om the  lawyer tha t to ld you Ap ple wo u ldn't s h ut youdown.You  go t ba d  a dv ice .~~~ ab cd_ f 
>_Oh man.  Y ou  were  sur p r i s ed?Rea lly? _

Ex actly!

Apple  ha s al w ays  been  adam antth at th ey see  _all _code that goesonto  devices. 
Li ve  pa tc hingi s so b loo dyobvious  agains t  th ei r E UL A.

~~~
wolfgke
Wh at i s"code"?Everyb o dy  w h o has pr og ram medi n  LISP  orS ch eme know s that th er e is no  e ssenti al  di sti nctio n  bet ween c ode anddata( only many prog r amming
langua g es m ak e  ita l ittle hardto s e e th at i t  i s a l l the  same ). Th u s Apple
would haveto  see n ot on ly all code,but also a l l data tha t go e so nto the
device s. Bu t this wou l d implythatApple di sallows a l l  apps th atrea d d ata f ro m a foreign ( i . e. a tleast n otApple-c ont rol led ) s er ver if on e does n ot 
w an ttoget i n to a sel f- con tr adi ction . 

~~~Spiva k
Wh ic hi s w hy you' r en o t al lo we d to  us ea Lis p in t erp reter o r use any  me t hodof 
e valuati ng data as co de . In thismo del  the o n l y thingthat data can do is
cha n ge whic h c ode p aths  run, not  wh at the y d o .

~~~ 
kazin atorTh atc h aract e r iz ati on  isn't eno u g h t o dis ti ngui sh a Tu ring complete
inte r pre ter from some thi ng t h a ttri v ia l lyma n ipu l a tes an input da tum. An
in te r pr eter is ju s t a  p rogramcontain ing c o de path s, whichare activ at ed i n res ponse to t he input  (the int e rpret e dcode) .
~~~
wo lf gke 
> Th at cha r act eriza tion i sn 't eno ugh t odistingu ish a Turing complete
>  inter prete r f rom somet hin g  th at trivia llymanipulate s a n i nputdat u m. An 
> i n te rpr e ter i s ju s t a progr a mcon t a in ing code pa t h s , w hichare activa tedin
> response tot he input (theinte r p ret edc ode) .
It is surpris ing ly s imple to  m ake an inte rpreterth a t is"accid entall y" Turi n g 
c o mplete  (th isIMHO so o fte nh appensby  a c cident  tha tI love  to sa y  tha t 
 solution_to adhere_to the letter of_a EULA_of_a tightly
controlled_ecosystem_run by a_very capricious company.

I_hate the app store_review process and_a_lot of apple policies around the app
store and I feel for you and I_totally_think there_should_be_a less onerous
update/review process... but..._you clearly and blatantly circumvented_a
core policy,_and what happened to you was absolutely predictable.

Get_your_money back from_the lawyer that told you Apple wouldn't shut you
down._You got bad advice.

~~~
abcd_f
> _Oh man._You were surprised?_Really?_

Exactly!

Apple_has_always been adamant that_they see _all_ code that goes_onto devices.
Live patching is so bloody_obvious against their EULA.

~~~
wolfgke
What is "code"? Everybody_who has programmed in LISP or_Scheme knows that
there is no_essential distinction_between code and data (only_many programming
languages make_it a_little hard to_see that it is all the_same). Thus Apple
would_have to see not only all_code,_but also all_data_that_goes onto_the
devices. But this_would_imply that_Apple_disallows all apps that read data
from_a_foreign (i.e. at least not Apple-controlled) server_if one does not
want_to_get into a self-contradiction.

~~~
Spivak
Which_is why you're not allowed_to use a Lisp interpreter or_use any_method of
evaluating_data as code. In this model the only thing that data_can do is
change which code paths_run, not what they_do.

~~~
kazinator
That characterization_isn't_enough to distinguish_a_Turing complete
interpreter_from something that trivially manipulates an input_datum. An
interpreter_is just a program containing code_paths, which are activated_in
response_to the input (the interpreted code).

~~~
wolfgke
>_That characterization isn't enough to distinguish_a Turing complete
> interpreter from_something_that_trivially manipulates an input datum._An
> interpreter is just a program_containing code paths,_which are activated in
> response to the_input_(the interpreted code).

It is surprisingly simple_to_make an interpreter that is "accidentally"_Turing
complete_(this_IMHO so often happens by_accident that I love to say_that