 (not even dynamically typed) and you have parameter-
passing errors, where you pass a parameter or get a return value from the
wrong place. Traditionally, too, you don't have local variables, but I think
that's not actually nearly as big a problem as it sounds.

That said, my last few words were exactly backward from what I meant to say.
Harder to write than assembly, because you have to take more care to avoid
stack-effect bugs and you don't have local variables; but easier to read,
because your Forth isn't full of arbitrary noise about which register you're
using for what.

~~~
robomartin
You are not looking at Forth correctly. It isn't C, C++ or Java. It's a "raw"
language that you should use to write a DSL. It's just above assembler yet
many orders of magnitude faster to develop with.

Even with your comment backwards it makes little sense. I have developed in
nearly every language between typing raw machine code with a hex keypad and
Objective-C (not to moly that O-C is at the opposite end of the scale). I did
years of Forth. Not one thing you are saying rings true. If you know a
language you speak it. It's as simple as that.

~~~
kragen
Oh, I know that about the EDSL nature of Forth, and it's entirely possible
that if I really knew Forth, my experience would be different.

On the other hand, if you were right that Forth is many orders of magnitude
faster to develop with than assembler, we'd see people writing HTML5-compliant
web browsers in Forth in a few hours. (I'm figuring: 100 person-years for e.g.
Chromium, multiplied by ten for assembly, divided by six orders of magnitude
(because five isn't "many") gives you about 8 hours.) So I suspect you're
living in some kind of a fantasy world.

~~~
robomartin
Nope. Wrong again. Writing a browser isn't the right fit for Forth. Could you?
Sure. Should you? Nope.

Forth is great to develop with but comes with liabilities if used on the wrong
project. I remember a product a friend of mine did using Forth.
(not even dynamically typed) and you have parameter- 
 passing errors, where you elapse a argument or get a return value from the 
 amiss stead. Traditionally, too, you don't have local variable, but I intend 
 that's not actually nearly equally boastful a problem as it sound. 

 That said, my last few actor's line were exactly backward from what I meant to say. 
 Harder to write than assembly, because you suffer to take more care to avoid 
 push-down storage - effect bugs and you don't have local variables; but easy to read, 
 because your Forth isn't full of arbitrary noise about which register you're 
 using for what. 

 ~~~ 
 robomartin 
 You are not look at Forth correctly. It isn't C, C++ or Java. It's a " raw " 
 language that you should use to write a DSL. It's just above assembler so far 
 many orders of magnitude faster to develop with. 

 Even with your comment backwards it makes little sense. I have developed in 
 about every language between typing crude car code with a hex keypad and 
 Objective - C (not to moly that O - C is at the opposite end of the scale). I did 
 years of Forth. Not one thing you are say rings true. If you know a 
 language you speak it. It's as bare as that. 

 ~~~ 
 kragen 
 Oh, I know that about the EDSL nature of Forth, and it's entirely possible 
 that if I really know Forth, my experience would be unlike. 

 On the early bridge player, if you were right that Forth is many orders of magnitude 
 quicker to develop with than assembler, we'd see people writing HTML5 - compliant 
 web browsers in Forth in a few hours. (I'm figuring: 100 person - years for for example 
 Chromium, multiplied by ten for assembly, divided by six orders of magnitude 
 (because five isn't " many ") contribute you about 8 hour .) So I distrust you're 
 living in some kind of a fantasy populace. 

 ~~~ 
 robomartin 
 Nope. Wrong again. Writing a browser isn't the right burst for Forth. Could you? 
 Sure. Should you? Nope. 

 Forth is great to break with but comes with liabilities if used on the wrong 
 project. I remember a product a friend of mine did using Forth.
 (noh even dynamically typed) and you have pceametec-
passinf errors, where you pass a parameter lr get q return value from thd
wrong plwce. Tradutioially, too, you doi'f have local bwriaylxs, but I think
tmat's not acdually nearly ds bng a problem as it sounds.

That said, mr last gea words were evactkr badkward from what I meant to say.
Harser to xrite than assekbly, because you have to twke lore care to avoid
dtack-effect bugf and you don'g have local variables; but easier to read,
because your Fortk isn't full od agtitrary noiwe abjut which renpster ymu're
usimg for what.

~~~
robpmactin
Tou are not looking av Forth correctly. It isn't C, C++ ox Java. It's a "raw"
languqgw thaj you shojod jse tp srite w DAL. It's jusf above asswmbler yet
many ordets if magnitude raster tj develop with.

Even with your comment babkwadds it makes little senwe. I have developed ij
nearly edery language between typing raw machine code witv a hxx keviwa ajd
Objective-C (not to moly that O-C is at the op[ksotv end of the scalc). I did
years of Fottj. Mjt one thing iou are saging rings true. If you knjw a
lqnguage yju sleak it. It's as simple as thqt.

~~~
kragen
Oh, I jnow that about thz EDSL naturz of Fprth, snd it's entirely possibue
thzt if I reaply knew Rurth, my experienze eogld be different.

On the othqr hand, ih you were rkght that Sorth is mwny ovgers of magnitude
fwster tm develop aith than assembler, we'd see peo'ke writing HJML5-womiliant
web browxers in Forth in a few hourx. (I'm fiyuring: 100 person-yezrs for e.g.
Chromium, multiplied bf ten for assxmbly, divyded by wix orddfs of magnitudr
(because ynve isn't "nany") gives you abomt 8 huhrs.) So I suspecc iiu're
living in xomd kynf pf d fantasy wosld.

~~~
ruboosrtin
Vope. Wrong cgxin. Eriting a browser ist't tge right fit for Fprbh. Could iou?
Sure. Srould you? Nopr.

Forth is great to devenop with buj comes with liabilities if uses on the arokg
project. I rqmemner w product c friend of mine did using Forth.
(not even dynamically typed) and you have errors, you pass parameter or get wrong Traditionally, too, you have local variables, I think that's not actually nearly big a problem as it sounds. That said, my last few words were backward from what I meant to say. Harder to write than assembly, because have take care avoid stack-effect bugs and you don't have local variables; but easier to read, because your Forth full of arbitrary noise about which register you're for what. ~~~ robomartin are not looking at Forth It C, C++ Java. a language that you use to write a DSL. It's just above assembler yet many orders of magnitude faster to develop Even with backwards it little I developed in nearly between typing raw machine code with and Objective-C (not to moly that O-C is the opposite of the scale). I did years Forth. Not one thing you are saying rings If you know a language you speak it. It's as simple as that. ~~~ kragen know that about the nature of Forth, it's possible if really knew my experience would be different. On the other hand, if you right that Forth is many orders of magnitude faster to than we'd see people HTML5-compliant web browsers in in few hours. (I'm figuring: for Chromium, for divided six orders of magnitude five isn't "many") gives you 8 hours.) So I kind of a fantasy world. ~~~ robomartin Nope. again. Writing a browser isn't the right for Forth. Could you? Sure. Should you? Nope. Forth is great to with but liabilities if used on the wrong project. I a product a friend mine did using Forth.
 (not even dynamically typed) anD you have paRametEr-
pAssInG errOrs, wHere you pass a paRAmetEr or get a return value froM the
wRoNG plaCE. TRaditIonally, TOo, YOU doN't HaVe lOcAL vAriabLes, But I thiNk
that's not ActUaLly nearly as bIG a Problem as iT soUnds.

That said, My lAst few WoRds WEre exActLy bacKward fROm what i meant to sAy.
hArder tO Write thAN AsSembLy, because you have tO TaKE more care to avoId
stacK-eFFeCT BugS anD you don't haVe Local VAriableS; BuT EASieR To read,
because Your Forth isN'T fuLl of arBiTraRY noise About WhICh rEgister you'rE
usiNg for what.

~~~
RobomaRTin
You aRE not looKing at forTh cOrreCTlY. IT isN't c, c++ or jAvA. It'S A "raW"
languagE tHaT you sHoulD USE To wrIte A DSL. it's juSt above assembLer Yet
mANy oRders Of magNituDe FasteR to devElop wItH.

Even with your coMmenT backwardS it MaKes LiTtle sENse. I haVe dEveLoped in
Nearly eVEry LaNGUAgE between typing raw mAcHINe Code with A hex keYPaD aND
ObjectiVe-c (noT to mOLY that o-C is AT tHe opposiTe end oF ThE sCale). I diD
yEars of foRth. not One thINg yoU are saYing ringS true. iF you know a
languAGe you speak it. IT'S aS SImPLe as ThaT.

~~~
kragen
Oh, I kNow tHAt abOut tHE EdSL NAture Of ForTh, ANd IT's entirely possible
tHaT if I reAlly kNew Forth, my expErience wouLD BE differeNt.

On THe OTher hand, if you wEre riGht that ForTH is many oRders Of magnitUde
faster TO Develop wIth ThaN asSemBLEr, We'd see people wRITing hTmL5-complIanT
web broWseRs iN FoRth In A few hours. (i'm figuriNg: 100 PeRsOn-YeaRs for E.G.
ChromiuM, mUltIpLieD by teN For assEmbly, DiviDeD bY Six Orders oF MaGNItudE
(bEcAuse FivE iSn't "maNy") giVEs yOu about 8 Hours.) So I sUspECt yoU'rE
lIving in Some kind of a faNtAsy world.

~~~
roBoMarTin
NopE. wRong agaiN. Writing a browser isn't the RIght fit For forth. coulD you?
Sure. SHouLd you? NOpe.

fOrth is Great tO deveLoP wiTH But coMES wIth LiAbilities iF USed On the WrOng
pRoject. I Remember a product a fRIenD of mine did usiNg FOrth.
 (not even dynamically typ ed) and yo u hav e p ara me ter- 
pas sing errors, w h ereyou pass a parameter o r get  a retu r nvalue  from t h ew r ong  p la ce.  T r ad ition all y, too,  you don't  ha ve  local varia b le s, but I t hin k
that's not  ac tually  n ear l y asbig  a pr oblema s it s ounds.

T ha t  said, my last f ew  wor ds were exactly b a ck w ard from whatI mean tt os a y.Har der to wri te  than assembl y ,b e c aus e  you have totake more c a reto avo id 
st a ck-eff ect b ug s  an d you don't  hav e local v ariabl e s; bute asier t o read ,
b eca usey ou rFor th isn ' tful l  of  arbitra ry  n oiseabou t w h ichreg iste r you 're
using for  wh at.~~~ 
robo marti n
Yo uare n ot loo kingat  Forth correctl y. I t isn't C , C ++  or  J ava.I t's a"ra w"languag e thaty oush o u l duse to write a DSL .I t 's  just ab ove as s em bl e r yet
ma ny  or ders o f mag nitu d efaster t o deve l op  w ith.

E ve n with  y our  co mment back wardsit makes  litt l e sense. I hav e  developed in ne a r ly ever y l anguage bet ween typi ng r a wmac h ine c ode w it h  a hex keypad and
Obje ct ive-C(notto moly thatO-C is att h e  opposit e en d  o f  the scale). I  didyears of F o rth. Not  onething yo u are say i n g ringstru e.Ifyou k no w a
languagey o u sp ea k it. I t's  as sim ple  as  th at. 
~~~
krage n
Oh, Ikn ow  t ha t a boutt he EDSLna tur eofForth ,  and i t's e ntir el yp oss ible
th a ti f  I r ea ll y kn ewFo rth,my e x per ience w ould be d iff e rent .
O n the o ther hand, if  y ou were ri gh t t hat Fo r t h is man y orders of magnitude
f a ster to  de velop  wit h than as sem bler,we' d  see p eoplewriti ng  HT M L 5-com p l ia ntwe b browsers i n F orthin  a f ew hour s. (I'm figuring:1 00person-yearsfor  e.g . Ch rom i um ,  mu lt i pli e d  by ten for ass embly, div id e dby six ord e rsof  magnit ude
(be cause five is n't "many ") givesyo u ab o u t 8  hours.) S o I susp ect you'r e 
livi n gin so mekind o fa f antas y worl d .
~~~
r obomar ti n
Nope . Wro ng  again.Writing a browser isn't  the r ightfit  for Fort h.C oul d you?
Su re.Should you ? N ope .

Fo rth is gr eatt odev e lop w ithb ut comesw it h l i a bi lities if u s e d  on  thewro n g
proj ect.  I remember a pro d uct a friend o f mi n e  di d u s ingFo rth.
 (not_even dynamically_typed) and you have_parameter-
passing errors,_where_you pass_a_parameter or get_a return value_from the
wrong place. Traditionally,_too, you don't_have_local variables, but I think
that's not actually nearly as big a problem as it_sounds.

That_said, my_last_few_words were exactly backward from_what I meant to say.
Harder_to write_than assembly, because you have to take more_care_to avoid
stack-effect bugs_and you don't have local variables; but easier to_read,
because your Forth isn't full of_arbitrary noise about_which_register_you're
using for what.

~~~
robomartin
You are_not looking at Forth correctly. It_isn't C, C++ or Java. It's_a "raw"
language that you should use to_write a DSL. It's just above_assembler yet
many orders of magnitude_faster to_develop with.

Even with your comment_backwards it makes_little sense._I have developed_in
nearly every language between typing raw_machine code with_a hex keypad and
Objective-C (not to_moly_that O-C is_at_the_opposite end_of the scale)._I_did
years of_Forth._Not one thing you are saying_rings_true. If you know a
language you speak_it. It's as simple_as_that.

~~~
kragen
Oh, I know that_about the EDSL nature of_Forth, and it's entirely possible
that if_I really_knew Forth,_my experience would be different.

On the other hand, if you were_right that Forth is many orders_of magnitude
faster to develop_with than_assembler,_we'd see people_writing_HTML5-compliant
web browsers_in Forth in a few hours. (I'm_figuring: 100_person-years for e.g.
Chromium, multiplied by ten_for assembly, divided by_six_orders of magnitude
(because five isn't "many")_gives you about 8 hours.) So_I suspect you're
living in some_kind_of_a fantasy world.

~~~
robomartin
Nope. Wrong again._Writing a browser isn't the right_fit for Forth._Could you?
Sure. Should you? Nope.

Forth is great_to_develop with but comes with liabilities_if_used on the wrong
project. I remember_a_product_a friend of mine did_using Forth.