Slashdot Mirror

SwiftForth or Factor?

The kids is 9. Forth is maybe about 2-3 years older as a first language.

As an aside if one were going to go for a forth I'd say http://factorcode.org/ which is somewhat higher level.

Easy to factor that in, as long as you're sober enough to type Ctrl-H at the end of a word that is. If not, just follow the natural tendency of your head to nod down slightly, stack effect will be on the status line at the bottom of the window.

Look at Factor.

It has optimizing compiler (written in Factor) as a part of runtime and lets you have FORTH-like development interactivity with static optimizing compiler speeds.

Really needs more love.

Consider this test: imagine somebody created a programming language, not for actual use, but to prove a point. Would you consider learning that language?

Possibly, depending on what the point was. Joy for example, isn't entirely a 'real' language but has very interesting ideas behind it and is worth studying for that reason. If the ideas are interesting enough, eventually someone will translate them into a real language for doing actual work.

Both idea and implementation are important, and both need rigor and testability. The ideas have to come first, and necessarily won't be fully formed initially, but if the ideas can't ever actually be implemented, then they're probably incorrect - implementation is to philosophy as experiment is to science.

I think the 'bad' side of intellectualism, which people rightly dislike, is a tendency to merely promote ideas without ever considering if they are implementable in practice, or even to look down on implementation as a distraction from 'pure' ideology. Which would be like theorists in science looking down on experimentalists as misguided fools - 'we don't need to check against reality, we already know our ideas are correct. Just do it already, dammit!'

This stereotype of the ' ivory tower academic' promoting socially destructive ideas without checking if they are in fact correct (such as the right-wing bete noire, Marxism-Leninism - or the left-wing equivalent, 'Washington Consensus laissez-faire') is what think of when they say 'intellectual' with a sneer. A person who thinks, and teaches, but doesn't check their thinking and teaching against reality by consulting the lower, implementing, classes.

I'd like to think this stereotype is completely false - but, well, have you ever read a Lisp forum? In some cases, this attitude is alive and well even in computer science. Why are there so few working Lisp implementations? There's lots of discussion over the pure ideas, very little over the hard nuts-and-bolts of implementation, and often a sense that producing a working implementation fo a possibly-good-idea is somehow 'beneath' a 'real' computer scientist, because it's mere details which someone else lower down the pecking order should do.

Heck, I've seen that attitude right here in the phrase 'computer science has as much to do with computers as astronomy has with telescopes'.

If you like Forth, you should check out Factor, which is basically a modernized version of Forth (dynamically typed, no *very* low level filesystem junk that Forth has). I've recently started playing with it.

I can't see getting back to it now, either; lets face it, a huge bonus for any programming language choice is its popularity, so that others will maintain your code, so that you can get help and code fragments with a quick google.

You may want to check out Factor. Both the language and its libraries are actively being developed. It is concatenative like Forth, with a strong Lisp influence.

As I haven't seen anyone mention it, I will.

Factor is a fucking brilliant (yes, I mean that) stack-based language. It is, in many ways, a hyper-modern Forth. If you've never dealt with such a thing before, give it a look. It'll completely change how you think about programming.

Ruby has made some important OO design contributions

It has ?! Like what ?! What's in Ruby that wasn't in other languages ?!!

For patience's sake, this is the problem...All I see are ideas that were in other languages, thrown together in a learn-as-you-go experiment. People think continuations are cool? Then look at Scheme and look at Smalltalk. You can't compare years of development to that experiment. Ruby is rubbish. Compare it to any Smalltalk implementation. Download a Common Lisp IDE (LispWorks, Franz) and tell me how cool Ruby is...When people diss Java, remember to also diss HotSpot. Can your little language optimize code statistically like that? I thought not...

You want new stuff? Look at Factor, Joy, the Mozart/Oz system, or Slate.
Wanna compile at gcc performance? Try Scheme with the Bigloo implementation, or Objective Caml. Bechmarks for Ocaml here (and for SML with MLTon compiler here.- The bechmarks for Bigloo were reomved some time ago).

I'll just post the buzzwords for Factor:

Continuations, exception handling.
Powerful and logical meta-programming facilities. Introspection, code generation and extension of both syntax and semantics is very easy.
Higher-order programming allows code blocks to be treated as data and used as parameters.
Highly minimalist, very consistent design. No layers upon layers of indirection, no confusing corner-cases, no poorly-thought-out features.
Postfix syntax with an extensible parser; values are passed on the stack.
Higher-order programming allows code blocks to be treated as data and used as parameters.
A powerful and very generic collections library allows many algorithms to be expressed in terms of bulk operations without micro-management of elements, recursion, or loops.
A very consistent object model based on generic predicate dispatch.
Arithmetic operations that closely model mathematical concepts, rather than just being a thin abstraction over underlying machine arithmetic. All integer operations are done in arbitrary precision, and exact fractions are supported. Complex numbers and complex-valued elementary functions are integrated.
Damn, that Slava Pestov is one smart dude.

When you see those languages, you kinda get sad that Ruby is such an attention-grabber, but I can see clearly that this is just because of disinformation. With the exception of Joy and Slate (for now, I hope), all the others I cited have pretty workable environments.

And by the way, you don't write LISP anymore, it's Lisp.