stack based languages

Hello, i am interested in learning a stack oriented language, so i started learning Forth. (from http://www.amresearch.com/starting_forth/)
Some alternatives i heard of are cat and factor.

What is best to learn from those? And suggest a good tutorial

fuck off STACK FAG

Factor looks like the only one worth learning, since it actually has some relevant libraries.

It also has zero noteworthy tutorials.

>>1
>>3
STACK FAGS

>>3
Factor has very nice documentation and workspace too... i guess i'll go with factor.
Are stack oriented languages worth it though? Or am i wasting my time with rot swap dup swap over ?

>>5
STACK FAGGOT

>>2,4,6
STACK FAGGOT STILL IN THE CLOSET

: (fib) ( n next result -- result ) pick zero? [ 2nip ] [ rot 1- -rot over + swap (fib) ] if ;
: fib ( n -- result ) 1 0 (fib) ;

>>5
I don't think so, honestly.

You can do funky tricks with them, since they're pretty much Lisp minus the parens, but the readability leaves a lot to be desired.

>>2-9 STACK FAGGOTS BECAUSE YOU REPLIED TO THE THREAD
>>1, RUN! IT IS CONTAGIOUS!

>>9
you dont know lisp

>>8
That's almost as ugly as Perl. You want to calculate Fibonacci numbers, and you have to put up with the stack. The language model clearly gets in your way. You need to know Factor to understand these lines, yet I can't possibly think of a Fibonacci implementation that's not trivial in any other language:


(define (fib x)
        (if (< x 2)
            x
            (+ (fib (- x 1)) (fib (- x 2)))))

def fib(x):
    if x < 2: return x
    else:     return fib(x - 1) + fib(x - 2)

fib(x) = lambda x if x < 2 else fib(x - 1) + fib(x - 2)

unsinged int fib(unsigned int x) {
    return x < 2 ? x : fib(x - 1) + fib(x - 2)
}

I tried factor, but the hello-world hangs at 100% CPU. It's a piece of shit.

I tried factor and it crashed jedit

TO BAD FACTOR FUCKS SHIT AND STACKFAGS SHOUDL DIE!

>>12
fib(x) = lambda x if x < 2 else fib(x - 1) + fib(x - 2)
That was seriously fucked up, copypasted bits of the def one and failed it.

fib = lambda x: x if x < 2 else fib(x - 1) + fib(x - 2)

>>12,16
non-tail recursive fib = FAIL.
>>8 is tail recursive.

age because i want to see how ugly it will be if >>12 or >>16 do tail recursive fib in their shitty languages

>>18
(define (fib n)
  (define (iter i a b)
    (cond ((= i 0) a)
          ((= i 1) b)
          (else (iter (- i 1) b (+ a b)))))
  (iter n 0 1))

Stack fag is now a meme. I actually invented this meme one day, when someone was asking about ``How to learn forth.''

>>20
I was the first person on this board to use the insult "stack fag"

I've seen Expert Programmers debate Lisp vs. Forth. They are surprisingly equivalent in abstraction level. Lisp manipulates lists; Forth manipulates stacks. But Forth is closer to the hardware, and you'll have to worry about word sizes and the like more often in Forth than in Lisp. Conversely, there's a lot of work in embedded microcontrollers going on, and Forth fits in that small space better than Lisp (assuming you need on-board programming).

fib = 0:1:(zipWith (+) fib (tail fib))

>>23
Shit, nice

>>23
Stackfag

>>25
Fackstag

>>26
I see what you did there
That's how stack fags think, isn't it?

>>27
lllllllllaaaaaaaasdalkjsjdfjjjjjjjjjjjl;kjjjlkjjzxcvbvvvooiuuuwert;lkjadfsgggggggggggg,m.nf,.mnn.,mnnlkjsdfg;lkjxcoijupqwe;jasdfnlxcvnnnnnkjlvlkjljklkj;l;klk;lkjlkjmnnsadffffffffffffffopiuuu;pouiyhaerggi;;;;;uhvaiiiadvvvvvvvvvvvvvho;ijaaaaaaaaaaaaaaifevawhifehiufvpokkkkewqopiwqeoipwqeopiewqkjdcdddddddddddddhhhhhhhasdhlkfhsadbfjjsadbhkhbjkdfbhjkafsmnqqqqqqqqqqqqqmwmwqem,nqwe,nmeqw,nmqew,nmenm,qweijvvvvoisasdfoiuasdfjkwfeakjlhfejhklfehkjfeoiuuvdzoiuviouzdoipudoiuweeeeenkjjerttkjhlzx`cvoisaduasdfkjhawerrrrrrrrrrrrrasdfgsdfgfhrh

much nicer than >>8:
: (fib) ( result next n -- result ) 2dup zero? [ 3drop ] [ roll + swap 1- (fib) ] if ;
: fib ( n -- result ) 0 1 rot (fib) ;

[/code]: fib ( n -- result ) dup zero? [ 1 ] [ 1- dup fib 1- fib + ] if ;[/code]

much nicer than >>29

>>30
>>29 is much nicer than that shit because >>29 is tail recursive.
and because your bbcode segfaulted.

>>23
much nicer than stackshit

stackshit is just a fucking horrible unreadable shit

ATTN FACTOR GUY:

Write a Factor intro article following the style of this obsolete but fun Lua intro:
http://www.gamedev.net/reference/articles/article1932.asp

Then maybe more of us will join you.

FORTH:

: NEXT-FIBS OVER + SWAP ;
: FIB 0 1 0 2SWAP DO NEXT-FIBS LOOP DROP ;

I have to say I like Lua better though:

function fib(x)
  local a,b = 0,1
  for i = 1,x do
    a,b = b,a+b
  end
  return b
end

>>35
YOU ARE NOT FACTOR GUY.
Factor Guy always sages.

USING: math.matrices sequences.deep memoize ;
MEMO: fibs ( n -- seq )
 2 + { { 1 1 } { 1 0 } } <array>
 2 identity-matrix [ m. ] binary-reduce
 flatten reverse { 0 1 3 } swap nths ;
MEMO: fib ( n -- r ) dup 3 mod [ - fibs ] keep swap nth ;

>>35
local
not forth

>>38
Lua
lrn2read

>>1
Wow, I see this thread and I'm like, "Too bad I showed up to late to have any valuable input." Not so, apparently.

Factor is the correct choice here. It's the only concatentative language (besides Forth) that even has intentions of being a real boy, as far as I can tell. And it's actually doing a very good job of it. The downfall (at this time) is that there is very little introductory material. You can probably learn to write algorithms in it on your own. Writing a GUI program is going to require deciphering examples, which aren't badly written but are written in a language you don't know using libraries with no overview. At least the whole system and its libraries are documented. OTOH, I think a introductory material phase is coming when Factor hits 1.0, and from what I've seen of the people behind Factor, it's actually going to happen.

>>5
Are stack oriented languages worth it though? Or am i wasting my time with rot swap dup swap over ?
Yes, no, in that order.

I'm still a stack nub, but I've been Lisping for a while and concatenative languages are looking really good from here. Forth's a neat language, but lacks a lot of modern features. Thanks to being roughly Lisp-equivalent, you can actually write elegant programs despite this, but it's not necessarily something you want to do all the time. Factor, on the other hand, seems pretty much like an improved CL in every way.

I'll start with the second yes. Yes, you're wasting your time with shuffle words because using combinators whenever possible is best. Learn those well, and try to forget you know any shuffle words.

For the first yes, part of the reason concatenative languages are so cool is because combinators to encapsulate some of the most common patterns can be implemented, since words allow factoring at a finer granularity than functions (you can start a word "in the middle" of an expression whereas functions always need to operate through arguments.

Combinators are possible in Lisp:
[m](defun bi (function-1 function-2 &rest args)
  (values (apply function-1 args)
          (apply function-2 args)))

;; But in use, shit's clunky as hell.
(multiple-value-bind (a b)
  (bi (lambda (x) (* x 2))
      (lambda (x) (* x 3))
      2))[m]

Combinators are cool from both directions: they're both a way to avoid stackrobatics, and a reason to use a concatenative language in the first place — elegant expression of a fundamental type of logic.

The other part of the reason for the first yes is that concatenative languages, since they don't have variables [as the primary way of handling values], more clearly depict the flow of data, which is the interesting thing.

there is very little introductory material.
http://docs.factorcode.org/content/article-cookbook.html
http://docs.factorcode.org/content/article-first-program.html

>>41
Yes. Hopefully before long we'll have a proper book (i.e. something longer than 16 pages).

>>42
http://useless-factor.blogspot.com/2007/12/books-that-should-exist.html
Programming with Factor

Factor's included documentation is great, but it's not enough, by itself, to learn Factor. I, and probably most people who know Factor, learned through a combination of experimenting, reading blog posts and the mailing list, and talking on #concatenative. Many people will continue to learn Factor this way, but it still seems somehow insufficient. It should be possible to learn a programming language without participating in its community.

Of course, we can't write a book on Factor until we get to see what Factor will look like in version 1.0. But I'm confident that this book will be written, even if it goes unpublished in print, and I'm fairly sure that I'll have at least some part in it. Maybe it'll be a big group effort by the whole Factor community.

What I'm thinking is that we could have a book which teaches programming through Factor, to people who aren't yet programmers. I've talked a lot about this with Doug Coleman, and we agree that most programming books are bad; we should make a new book that does things very differently. But we can't agree or imagine just how...

>>43
Yes.

>>43
[quote]...most programming books are bad; we should make a new book that does things very differently. But we can't agree or imagine just how...[/quote]

translate SICP to FUUUUUctor

>>40
—
Oh my fucking god is that an em-dash what is wrong with you?

>>46
What's wrong with em-dashes? I use them all the time. I also use en-dashes where appropriate.

>>46
lrn2punctuation

Have you read your EoS today?

>>49
Did you mean: “Have you read your EoS to-day?”?

Adiós muchachos

The heavens increase your   registry There is   just completely useless   for any real   work in your   way You need   to decide on   an ABI and   parameter passing system   for your operating   system and write   to new stream   z decryption for.