Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.forth > #11299 > unrolled thread

forth vs common lisp

Back to article view | Back to comp.lang.forth

Contents

  forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-04-14 17:05 -0700
    Re: forth vs common lisp BruceMcF <agila61@netscape.net> - 2012-04-14 17:10 -0700
      Re: forth vs common lisp Mark Wills <markrobertwills@yahoo.co.uk> - 2012-04-15 08:49 -0700
        Re: forth vs common lisp jacko <jackokring@gmail.com> - 2012-04-15 10:02 -0700
    Re: forth vs common lisp Fanzo <cristianof6@gmail.com> - 2012-04-15 17:47 +0200
      Re: forth vs common lisp BruceMcF <agila61@netscape.net> - 2012-04-15 11:20 -0700
        Re: forth vs common lisp "A. K." <akk@nospam.org> - 2012-04-15 22:22 +0200
          Re: forth vs common lisp BruceMcF <agila61@netscape.net> - 2012-04-15 13:29 -0700
            Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-04-24 09:33 -0700
      Re: forth vs common lisp lynx <rinkasu@kaze.void.null> - 2012-04-15 23:44 +0000
    Re: forth vs common lisp jacko <jackokring@gmail.com> - 2012-04-15 17:41 -0700
    Re: forth vs common lisp Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-04-18 09:49 -0700
      Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-18 19:34 +0100
        Re: forth vs common lisp Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-04-18 18:50 -0700
          Re: forth vs common lisp "Pascal J. Bourguignon" <pjb@informatimago.com> - 2012-04-19 04:08 +0200
            Re: forth vs common lisp Ron Aaron <rambamist@gmail.com> - 2012-04-19 06:25 +0300
              Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 19:55 +0100
                Re: forth vs common lisp Ron Aaron <rambamist@gmail.com> - 2012-04-19 21:39 +0300
                  Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 20:47 +0100
                    Re: forth vs common lisp Ron Aaron <rambamist@gmail.com> - 2012-04-19 22:37 +0300
                      Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 21:59 +0100
            Re: forth vs common lisp Roelf Toxopeus <rt4all@notthis.hetnet.nl> - 2012-04-19 09:28 +0200
            Re: forth vs common lisp Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-04-19 01:03 -0700
          Re: forth vs common lisp kodifik <kodifik@eurogaran.com> - 2012-04-19 02:05 -0700
            Re: forth vs common lisp Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-04-19 04:29 -0500
              Re: forth vs common lisp Tamas Papp <tkpapp@gmail.com> - 2012-04-19 10:15 +0000
                Re: forth vs common lisp Paul Rubin <no.email@nospam.invalid> - 2012-04-19 08:45 -0700
            Re: forth vs common lisp Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-04-19 14:15 -0700
              Re: forth vs common lisp Rugxulo <rugxulo@gmail.com> - 2012-04-19 16:06 -0700
                Re: forth vs common lisp "Pascal J. Bourguignon" <pjb@informatimago.com> - 2012-04-20 05:24 +0200
                  Re: forth vs common lisp lynx <rinkasu@kaze.void.null> - 2012-04-20 04:17 +0000
                    Re: forth vs common lisp Don Geddis <don@geddis.org> - 2012-04-20 08:34 -0700
                      Re: forth vs common lisp lynx <rinkasu@kaze.void.null> - 2012-04-20 16:54 +0000
                        Re: forth vs common lisp Kaz Kylheku <kaz@kylheku.com> - 2012-04-20 17:03 +0000
                        Re: forth vs common lisp Don Geddis <don@geddis.org> - 2012-04-20 16:57 -0700
                          Re: forth vs common lisp Tim Bradshaw <tfb@tfeb.org> - 2012-04-21 13:06 +0100
                  Re: forth vs common lisp Rugxulo <rugxulo@gmail.com> - 2012-04-20 13:20 -0700
                    Re: forth vs common lisp "Pascal J. Bourguignon" <pjb@informatimago.com> - 2012-04-20 23:14 +0200
                      Re: forth vs common lisp BruceMcF <agila61@netscape.net> - 2012-04-21 11:04 -0700
                        Re: forth vs common lisp Tim Bradshaw <tfb@tfeb.org> - 2012-04-21 22:12 +0100
                          Re: forth vs common lisp BruceMcF <agila61@netscape.net> - 2012-04-21 15:19 -0700
                            Re: forth vs common lisp Tim Bradshaw <tfb@tfeb.org> - 2012-04-22 01:01 +0100
                              Re: forth vs common lisp BruceMcF <agila61@netscape.net> - 2012-04-21 18:35 -0700
                                Re: forth vs common lisp Tim Bradshaw <tfb@tfeb.org> - 2012-04-22 03:13 +0100
                              Re: FreeDOS CL "Pascal J. Bourguignon" <pjb@informatimago.com> - 2012-04-22 10:58 +0200
                                Re: FreeDOS CL "Pascal J. Bourguignon" <pjb@informatimago.com> - 2012-04-22 11:01 +0200
                                  Re: FreeDOS CL quiet_lad <gavcomedy@gmail.com> - 2012-06-06 16:01 -0700
                            Re: forth vs common lisp jacko <jackokring@gmail.com> - 2012-04-22 06:18 -0700
                          Re: forth vs common lisp Kaz Kylheku <kaz@kylheku.com> - 2012-04-22 03:43 +0000
                    Re: forth vs common lisp Tim Bradshaw <tfb@tfeb.org> - 2012-04-21 13:02 +0100
                    Re: forth vs common lisp Kaz Kylheku <kaz@kylheku.com> - 2012-04-21 16:29 +0000
                Re: forth vs common lisp jacko <jackokring@gmail.com> - 2012-04-21 14:38 -0700
          Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 11:17 +0100
          Re: forth vs common lisp Rugxulo <rugxulo@gmail.com> - 2012-04-19 15:39 -0700
        Re: forth vs common lisp Paul Rubin <no.email@nospam.invalid> - 2012-04-18 22:17 -0700
          Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 10:11 +0100
            Re: forth vs common lisp Paul Rubin <no.email@nospam.invalid> - 2012-04-19 01:28 -0700
              Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 10:37 +0100
                Re: forth vs common lisp Ecki <ecki@intershop.de> - 2012-04-19 12:12 +0200
                Re: forth vs common lisp "Elizabeth D. Rather" <erather@forth.com> - 2012-04-19 09:35 -1000
                  Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 21:56 +0100
                    Re: forth vs common lisp "Elizabeth D. Rather" <erather@forth.com> - 2012-04-19 11:25 -1000
                      Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-20 00:00 +0100
            Re: forth vs common lisp John Passaniti <john.passaniti@gmail.com> - 2012-04-19 09:49 -0700
              Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 19:15 +0100
                Re: forth vs common lisp John Passaniti <john.passaniti@gmail.com> - 2012-04-19 12:01 -0700
                  Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-19 21:12 +0100
                    Re: forth vs common lisp John Passaniti <john.passaniti@gmail.com> - 2012-04-19 15:25 -0700
                      Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-20 00:59 +0100
                        Re: forth vs common lisp Paul Rubin <no.email@nospam.invalid> - 2012-04-19 18:49 -0700
                        Re: forth vs common lisp John Passaniti <john.passaniti@gmail.com> - 2012-04-20 07:14 -0700
                          Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-20 20:57 +0100
                            Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-20 21:21 +0100
                              Re: forth vs common lisp Nomen Nescio <nobody@dizum.com> - 2012-04-22 12:21 +0200
                                Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-22 12:27 +0100
                                  Re: forth vs common lisp Nomen Nescio <nobody@dizum.com> - 2012-04-22 14:59 +0200
                                    Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-22 15:25 +0100
                                    Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-06-03 15:09 -0700
                                      Re: forth vs common lisp Alex McDonald <blog@rivadpm.com> - 2012-06-03 18:21 -0700
                                        Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-06-03 18:58 -0700
                                        Re: forth vs common lisp and the abstraction claims of haskell and lisp quiet_lad <gavcomedy@gmail.com> - 2012-06-06 16:01 -0700
                                Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-22 15:38 +0100
                                Re: forth vs common lisp jacko <jackokring@gmail.com> - 2012-04-22 06:23 -0700
                            Re: forth vs common lisp John Passaniti <john.passaniti@gmail.com> - 2012-04-21 13:30 -0700
              Re: forth vs common lisp Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-04-21 18:12 -0700
        Re: forth vs common lisp Nomen Nescio <nobody@dizum.com> - 2012-04-20 11:55 +0200
          Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-20 12:14 +0100
            Re: forth vs common lisp Nomen Nescio <nobody@dizum.com> - 2012-04-20 16:56 +0200
              Re: forth vs common lisp Zbiggy <zbigniew2011REMOVE@gmail.REMOVE.com> - 2012-04-20 19:52 +0100
        Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-05-22 02:34 -0700
      Re: forth vs common lisp Rugxulo <rugxulo@gmail.com> - 2012-04-19 15:10 -0700
      Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-04-24 09:58 -0700
      Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-05-22 02:31 -0700
        Re: forth vs common lisp Ron Aaron <rambamist@gmail.com> - 2012-05-22 12:55 +0300
          Re: forth vs common lisp quiet_lad <gavcomedy@gmail.com> - 2012-05-28 15:19 -0700

Page 5 of 5 — ← Prev page 1 2 3 4 [5]

#12742 — Re: forth vs common lisp and the abstraction claims of haskell and lisp

On Jun 3, 6:21 pm, Alex McDonald <b...@rivadpm.com> wrote:
> On Jun 3, 11:09 pm, quiet_lad <gavcom...@gmail.com> wrote:
>
> > On Apr 22, 5:59 am, Nomen Nescio <nob...@dizum.com> wrote:
>
> > > > Perhaps you should start by reading something easier, e.g. Wikipedia?
>
> > > That explains it. People who quote wikipedia need to rethink what "reliable
> > > sources" means!
>
> > amen to that, wikipedia is massively communist, and every democrats
> > fact checker, lol, slaughter all democrats
>
> Another post that demonstrates why people have justification in
> thinking you a fool.

Well I am an objectivist but am not very pro israel and I do think
polytheism is the way to go religion wise.  I admire Henry George who
said tax rent only and I am trying to integrate that with lazzie faire
ideas from objectivism.

[toc] | [prev] | [next] | [standalone]

#11529

In comp.lang.forth, Nomen Nescio wrote:

>>>     (reduce + 0 '(1 2 3 4))
>>
>>   expr [join { 1 2 3 4 } +]
>>
>> Oh, I forgot: even more "canonical" way would be:
>>
>>  namespace path ::tcl::mathop
>>  + 5 6 7 6 7 8
>
> Having to reference external libs is hardly canonical. Does anybody really
> write Tcl like that?

http://www.tcl.tk/man/tcl/TclCmd/expr.htm

#v+
[..]
 MATH FUNCTIONS

 When the expression parser encounters a mathematical function such as
 sin($x), it replaces it with a call to an ordinary Tcl function in the
 tcl::mathfunc namespace. The processing of an expression such as:

     expr {sin($x+$y)}

 is the same in every way as the processing of: 

     expr {[tcl::mathfunc::sin [expr {$x+$y}]]}

 which in turn is the same as the processing of: 

     tcl::mathfunc::sin [expr {$x+$y}]

 The executor will search for tcl::mathfunc::sin using the usual rules for
 resolving functions in namespaces. Either ::tcl::mathfunc::sin or
 [namespace current]::tcl::mathfunc::sin will satisfy the request, and
 others may as well (depending on the current namespace path setting).
[..]
#v-

Waiting for your statement, that TCL/Tk docs - which you most probably never
read - "aren't reliable enough".
-- 
Forth is a preserver of health (Hippocrates)

[toc] | [prev] | [next] | [standalone]

#11530

> And now you will tell us Tcl is really the same as APL since Tcl really has
> vector operations and the same syntax as APL.

LOL.... :D

Surely you mean J, as any fool could show APL different, due to the stickers on the keyboard.

[toc] | [prev] | [next] | [standalone]

#11503

On Apr 20, 3:57 pm, Zbiggy <zbigniew2011REM...@gmail.REMOVE.com>
wrote:
> Look at this then:
>
>   expr [join { 1 2 3 4 } +]
>
> Here you see 2 interesting things:
>
> 1. That TCL can be more Lisp-like, than you think.
> 2. That giving such trivial, simplistic example proves nothing.

You're wrong on both counts.  Your trivial, simplistic example proves
you don't understand Lisp and at this point, it seems like something
beyond mere willful ignorance.  You keep focusing entirely on syntax
without considering semantics and mechanism.  You seem to think that
if you can make a language *look* like another language, than it is
somehow comparable.  That's a trivial and superficial view.

Let's break down the TCL example you gave.  You created a string out
of the members of a list with the string "+" between them.  At this
point, you don't have anything that the system can evaluate, so you
have to pass it to eval which interprets it and returns the result.
So in your example, you took data from one form (a list), converted it
to another form (a string), evaluated the string, and got a result (a
number).  Wow, could you find a more inefficient way to do the same
thing?  How about instead using a language where programs and data
start as a list and stay as a list?  Might be a bit more efficient,
huh?!

> Oh, I forgot: even more "canonical" way would be:
>
> namespace path ::tcl::mathop
> + 5 6 7 6 7 8

Sure, but that is now even farther from Lisp because the arguments to
+ aren't a list, and you're further limited to just the set of
operations in tcl::mathop.  So using that same awesome technique,
apply it to an arbitrary function that accepts three arguments at a
time, with an arbitrary number of sets of such arguments.

> The problem is, that - you know - not everyone are using Lisps
> and TCLs just for addition of list elements. Some are trying
> to create little more complicated and useful things.

Yep, and that's where the biggest difference between TCL and Lisp
exists.  The examples you've given of TCL are a dead end.  Using
tcl::mathop to add a sequence of numbers is limited, and using expr/
join to wildly transform a list to a string to a value only works with
the standard math operators provided by TCL.  In the real world,
you'll probably want to use more complicated and arbitrary functions
and build programs up from that.  The simple examples I gave in Lisp
aren't much more than a sophisticated desk calculator, but as programs
get more complicated and interesting, you can build on those.  And you
can do that because the list structure is fundamental, and when the
entire language is based on that, it lets you do far more
sophisticated things.

I'm surprised you don't realize this.  You know that in Forth, the
consistency of using a stack as the fundamental mechanism to pass and
return values from words is what leads to a variety of useful
properties.  It allows you to have unnamed values flow in and out, and
this offers more than syntactic brevity; it provides a point of
consistency across both the built-in words of a language and the words
that the user extends the system with; it lets you freely construct
words that take and return arbitrary numbers of arguments.  The same
things are all equally true in Lisp, except that instead of a stack,
the list is the fundamental mechanism and everything--- both data and
programs-- are represented in them.

I'm bored.  Most people by now in the conversation would have put
aside their preconceptions and would have been driven by intellectual
curiosity to dive into Lisp to understand what makes the language
special.  You show no such curiosity.  Everything you write on the
subject is consistently superficial, either focusing on syntax or a
very weak understanding of what a list it.  TCL gives you something
called a "list" and so you boldly assume that a list in Lisp is the
same thing (and suffers from the same properties).  And now your
latest excuse to not spend an hour or two learning about what you're
so eager to comment on is that the examples here are trivial.  Yet
when you first started learning Forth, I'll bet you first used it as
an immediate calculator and your first programs were to do simple
mathematical transformations of data.  Man, that's some powerful
ignorance there, and while it would be fun to explore why you don't
want to learn, I'll let the people who know you struggle with that
attribute of your personality.

Just promise me this:  If at some point, circumstance compels you to
want to learn about Lisp and you'll probably dive into any of the Lisp
family of languages.  When you do that, please come back to this
thread and review what you wrote.  Thanks.

[toc] | [prev] | [next] | [standalone]

#11513

On Apr 19, 10:49 am, John Passaniti <john.passan...@gmail.com> wrote:
> When you progress as a programmer so that you no longer are bothered
> by syntax but instead are focusing on the meaning of the code, you'll
> be a better programmer.

Threads such as this one, answering Gavino's question about Lisp
versus Forth as the "most powerful language in the world," tend to
devolve into a lot of nonsense --- we get posts like the above by
Passaniti, who has never written a computer program in his life
( other than some Perl scripts).

So lets consider a concrete example:
https://groups.google.com/group/comp.lang.forth/browse_thread/thread/dd8e30fcc7589749

This puzzle-problem came from CodeJam. To qualify for CodeJam, a
person would have to write the program in under 8 minutes. That is
actually quite fast; I think that most competent programmers would
take around 1/2 hour. I took about 3 hours to write the program in
Forth though. This was with my novice package. Without the novice
package, I would expect a Forther to take about 3 days. This is a big
part of why Forth failed to be adopted in the work world --- because
it is a waste of time --- as I said earlier, the work world is all
about production.

I think that my program very successfully illustrates everything that
is bad about Forth --- primarily a lack of useful libraries. This is
why I said earlier that Forth was not a good language for desktop-
computer programming. My Straight Forth will only be for micro-
controller programming --- I will have a "sister language" (most
likely Racket) that will be used for desktop-computer programming jobs
that are related in some way to micro-controller programming (usually
processing data that goes to or comes from the micro-controller).

We are talking about desktop-computer programming in this thread
though. I would like to see the CodeJam program written in Lisp or
Factor or any other desktop-computer language for comparison purposes.
You should certainly be able to write a shorter and simpler program
than I wrote. Please time how long it takes you to write your program
and mention that too (if it takes you more than 1 hour, then don't
bother posting your code). With some actual code to compare, this
discussion will become a lot more meaningful --- hopefully the non-
programmers (John Passaniti, Elizabeth Rather, etc.) will stop posting
messages --- everybody who participates, please move over to that
thread (you can cross-post to comp.lang.lisp or whatever forum is
appropriate for the language that you use).

[toc] | [prev] | [next] | [standalone]

#11467

> Not writing anything in Lisp - but I'm using TCL, which has somewhat
> Lisp-like syntax

Tcl doesn't have a Lisp-like syntax. At all. Lisp uses prefix, Tcl uses
"normal" infix. Tcl isn't anything like Lisp. Probably the biggest proof is
I was productive with Tcl after an hour or two and after 3 decades of
thinking about learning Lisp and trying and giving up for various reasons I
still don't "get" Lisp. 

[toc] | [prev] | [next] | [standalone]

#11468

In comp.lang.forth, Nomen Nescio wrote:

>> Not writing anything in Lisp - but I'm using TCL, which has somewhat
>> Lisp-like syntax
>
> Tcl doesn't have a Lisp-like syntax. At all. Lisp uses prefix, Tcl uses
> "normal" infix.

In fact, TCL also uses prefix:

#v+
  % namespace path ::tcl::mathop
  % puts [+ 5 6]
  11
#v-

-- 
Forth is a preserver of health (Hippocrates)

[toc] | [prev] | [next] | [standalone]

#11473

Zbiggy said:

> In fact, TCL also uses prefix:
>
> #v+
>   % namespace path ::tcl::mathop
>   % puts [+ 5 6]
>   11
> #v-

Yet that is not the idiomatic way to write Tcl. expr is used to compute the
value of an expression, doesn't require mathop, and more to the point is
readable by normal Tcl programmers:

% puts [expr 5 + 6]
11
% 

If you posted your "way" to comp.lang.list they might appreciate it.

For extra credit since this is comp.lang.forth and everything is postfix,
let's see if you can write postfix in Tcl ;-) postfix is more useful than
either prefix or infix but then I prefer HP calculators and Forth.

[toc] | [prev] | [next] | [standalone]

#11481

In comp.lang.forth, Nomen Nescio wrote:

>> In fact, TCL also uses prefix:
>>
>> #v+
>>   % namespace path ::tcl::mathop
>>   % puts [+ 5 6]
>>   11
>> #v-
>
> Yet that is not the idiomatic way to write Tcl. expr is used to compute the
> value of an expression, doesn't require mathop, and more to the point is
> readable by normal Tcl programmers:
>
> % puts [expr 5 + 6]
> 11
> % 
>
> If you posted your "way" to comp.lang.list they might appreciate it.

It's not "my way", it is quite normal and obvious way - and (in)famous
[expr {}] is nothing more, than "convenience layer" for those
"infix-oriented", just like yourself.

If you're reading comp.lang.tcl, just ask them, is TCL prefix, or really
infix - if you still didn't notice, that TCL's syntax is:

  command parameter_1 parameter_2 ... parameter_n

It the above isn't prefix for you, then nothing is prefix for you.
-- 
Forth is a preserver of health (Hippocrates)

[toc] | [prev] | [next] | [standalone]

#12373

On Apr 18, 11:34 am, Zbiggy <zbigniew2011REM...@gmail.REMOVE.com>
wrote:
> In comp.lang.forth, Hugh Aguilar wrote:
>
> > I think that Lisp is a better language for desktop-computer
> > programming than Forth,
>
> ...because?
>
> Not writing anything in Lisp - but I'm using TCL, which has somewhat
> Lisp-like syntax. And although one doesn't need to use as many
> parentheses, as in case of Lisp - it's still a problem: to keep code
> readable, there is a must to use loads of transitory variables. Only to
> replace something like this:
>
>   set a [doIt1 [doIt2 [doIt3 $a1 $b1 $c1] [doIt4 $x1 $y1 $z1]] [doIt5 [doIt6 $a2 $b2 $c2] [doIt7 $x2 $y2 $z2]]]
>
> with:
>
>   set b [doIt3 $a1 $b1 $c1]
>   set c [doIt4 $x1 $y1 $z1]
>   set d [doIt6 $a2 $b2 $c2]
>   set e [doIt7 $x2 $y2 $z2]
>   set a [doIt1 [doIt2 $a $c] [doIt5 $d $e]]
>
> Using Lisp it can be even worse, it seems. Lisp seems to me (well, I may
> be wrong) a language for people more "purely theoretically" - and less
> technically - oriented. For them indeed it can be "most powerful LitW",
> since it better suits them.
>
> > but that Forth is better for micro-controller programming than Lisp.
>
> This goes without saying.
> --
> Forth is a preserver of health (Hippocrates)

I use tcl more n more in unix work.  Amazing lil language.

[toc] | [prev] | [next] | [standalone]

#11444

Hi,

On Apr 18, 11:49 am, Hugh Aguilar <hughaguila...@yahoo.com> wrote:
> On Apr 14, 6:05 pm, quiet_lad <gavcom...@gmail.com> wrote:
>
> > cl claims to be the most powerful programming language in the world!!!
> > can forth outdo it?www.paulgraham.com
>
> Any language that you write programs in is more powerful than any
> language that you don't write programs in.

In the very simplest stuff, yes, but a lot of the heavy abstractions
don't port very easily. It's truly difficult to write really really
portable and strictly conformant programs. I don't claim to be
anywhere near an expert, only very barely a lowly hacker, but not all
languages (libs, runtimes, OSes) are the same. It's a shame, too,
because it makes programs less useful when they don't transition well
(IMHO). I always get my hopes up and am almost always disappointed.

"Adapting old programs to fit new machines usually means adapting new
machines to behave like old ones." -- Alan Perlis

> Gavino, you could write a program in GW-BASIC and that would make GW-
> BASIC the most powerful language in the world --- as compared to not
> writing programs in Lisp, Forth, etc..

Keep in mind that the language syntax, strictly speaking, usually
doesn't do much without lots of libraries to interface to the OS and a
runtime. Sometimes this is easier on some OSes than others, and
obviously some language's pseudo-standard libraries are more robust
than others.

Jeff Vavasour wrote a simple Breakout (arcade) emulator in GW-BASIC.
And I know there's QBForth on forthfreak.net somewhere. And one guy's
(old) 186 emulator was written in FBC. But most of the trillions of
BASIC variants' code isn't very portable. The "standard"s for BASIC
are long gone and old (I think???). Doesn't mean nobody uses it, and
there are more popular and robust implementations, but it depends on
the end user, not the language, on how good / useful / powerful the
tool is.

Everyone seems to love Javascript even though most say it sucks, but
in the hands of Fabrice Bellard, you can have something really
interesting (JSLinux). It doesn't change the usefulness (or perceived
lack) in the language, just means the carpenter is more important than
the tools. Even the weakest OS (DOS?) can have powerful apps (Dillo w/
FLTK).

You have to really be motivated to bring an inferior language
implementation up to your level. It is almost like writing half of it
from scratch. You either make do with what you already have in order
to build more or you find a canned solution already. It just depends
on time, documentation, motivation, available hardware, etc. It's not
really easy to do.

I know this sounds kinda obvious and trite, I'm just saying ....

> Stop pestering everybody with these weird questions! What is the most
> powerful language in the world? Could Forth be used to guide a
> spaceship to Pluto? Do dogs smile? Who built the Giza pyramid complex?
> What is the sound of one hand clapping? What brilliance would result
> if Gavino were able to hold a thought in his head for more than 30
> seconds?

Heh, no offense to Gavino, but this was funny.    ;-)

[toc] | [prev] | [next] | [standalone]

#11574

On Apr 18, 9:49 am, Hugh Aguilar <hughaguila...@yahoo.com> wrote:
> On Apr 14, 6:05 pm, quiet_lad <gavcom...@gmail.com> wrote:
>
> > cl claims to be the most powerful programming language in the world!!!
> > can forth outdo it?www.paulgraham.com
>
> Any language that you write programs in is more powerful than any
> language that you don't write programs in.
>
> Gavino, you could write a program in GW-BASIC and that would make GW-
> BASIC the most powerful language in the world --- as compared to not
> writing programs in Lisp, Forth, etc..
>
> I think that Lisp is a better language for desktop-computer
> programming than Forth, but that Forth is better for micro-controller
> programming than Lisp. I don't know Lisp very well though, so I use
> Forth for desktop-computer programming. When I work as a computer
> programmer, I use whatever language my employer uses --- that is the
> "most powerful" language in the sense that it causes a paycheck to
> appear every Friday. Right now I work as a cab-driver, so I just
> program for fun --- any language that seems interesting and fun is the
> "most powerful" within that context --- this changes from day to day.
>
> Stop pestering everybody with these weird questions! What is the most
> powerful language in the world? Could Forth be used to guide a
> spaceship to Pluto? Do dogs smile? Who built the Giza pyramid complex?
> What is the sound of one hand clapping? What brilliance would result
> if Gavino were able to hold a thought in his head for more than 30
> seconds?

driving a cab when know programming? wtf

[toc] | [prev] | [next] | [standalone]

#12372

On Apr 18, 9:49 am, Hugh Aguilar <hughaguila...@yahoo.com> wrote:
> On Apr 14, 6:05 pm, quiet_lad <gavcom...@gmail.com> wrote:
>
> > cl claims to be the most powerful programming language in the world!!!
> > can forth outdo it?www.paulgraham.com
>
> Any language that you write programs in is more powerful than any
> language that you don't write programs in.
>
> Gavino, you could write a program in GW-BASIC and that would make GW-
> BASIC the most powerful language in the world --- as compared to not
> writing programs in Lisp, Forth, etc..
>
> I think that Lisp is a better language for desktop-computer
> programming than Forth, but that Forth is better for micro-controller
> programming than Lisp. I don't know Lisp very well though, so I use
> Forth for desktop-computer programming. When I work as a computer
> programmer, I use whatever language my employer uses --- that is the
> "most powerful" language in the sense that it causes a paycheck to
> appear every Friday. Right now I work as a cab-driver, so I just
> program for fun --- any language that seems interesting and fun is the
> "most powerful" within that context --- this changes from day to day.
>
> Stop pestering everybody with these weird questions! What is the most
> powerful language in the world? Could Forth be used to guide a
> spaceship to Pluto? Do dogs smile? Who built the Giza pyramid complex?
> What is the sound of one hand clapping? What brilliance would result
> if Gavino were able to hold a thought in his head for more than 30
> seconds?

you are sadly right, I suffer from paralysis of analysis, and fret
over lisp vs haskell vs smalltalk vs forth having the most power and
making me the most money... when I dont even study each one...I have
issues....I do enjoy when I write a program and it works though, that
is awesome!  I use mostly bash and tcl so far since they help so much
with unix management.... so much faulty software at work barf

[toc] | [prev] | [next] | [standalone]

#12375

On 05/22/2012 12:31 PM, quiet_lad wrote:

> you are sadly right, I suffer from paralysis of analysis, and fret
> over lisp vs haskell vs smalltalk vs forth having the most power and
> making me the most money... when I dont even study each one...

The language you use, is far more powerful (for you) than the one you
don't.  Use something and worry about "power" later.

[toc] | [prev] | [next] | [standalone]

#12534

On May 22, 2:55 am, Ron Aaron <rambam...@gmail.com> wrote:
> On 05/22/2012 12:31 PM, quiet_lad wrote:
>
> > you are sadly right, I suffer from paralysis of analysis, and fret
> > over lisp vs haskell vs smalltalk vs forth having the most power and
> > making me the most money... when I dont even study each one...
>
> The language you use, is far more powerful (for you) than the one you
> don't.  Use something and worry about "power" later.

fair enuf, for me tcl taking over from bash

[toc] | [prev] | [standalone]

Page 5 of 5 — ← Prev page 1 2 3 4 [5]

Back to top | Article view | comp.lang.forth

csiph-web