Be careful. Factor is a gateway to lower level stack based languages.
I saw Zed Shaw do a presentation using factor and decided to spend a weekend playing with it. It was the start of a two year journey that ended with me writing forth for microcontrollers. That was time I should have studied but was somehow always sidelined by other things.
Hah, you could have done worse. The double-dose introduction to stack-based programming via HP calculators and Adobe PostScript in the 90s led me to spend on the order of 3000 hours developing Onyx (https://github.com/canonware/onyx), which started off as a PostScript clone minus graphics, and ended up a thing of its own.
On the bright side, I learned a tremendous amount about lexing, interpreters, exceptions, tail-call optimization, data structures, garbage collection, etc., which opened up lots of possibilities in later projects. With the benefit of hard experience I would never recommend using a stack-based language for a large project, but as a learning tool it has some nice qualities.
Fun stuff! I find that the more I find out about PL research and what I myself like in programming, the more I feel constrained in many languages.
I find that most of the bugs I write (which are many) are errors in dealing with mutable state. There is always one stupid little detail that leads to bad state. This has led me to dislike the programming language I write the most (probably python, despite really only wanting to write scheme) because it is mutation first. I was also sad to discover that I couldn't write self-recursive procedures in rust because they are never guaranteed to be actually recursive.
Did you get anything like that from your work with onyx? (And yes, I believe I have actually has a look at onyx about 10 years ago, back when trying to write poatscript).
I wouldn't hire you for a leadership role then, but it wouldn't stop me from hiring you. It is damn hard to find someone capable to delve deep into technology like that without hand-holding, and walk away with a working command of such obscure knowledge. People like that can be taught and trained to work on whatever project I am working on.
So with a gap working as a classical musician it might mean starting effectively as a (paid) intern, but it would still get your foot in the door.
I don't claim to be representative of all, or even most hiring managers though.
Imagine being able to say "I feel concatenative this afternoon" and easily find active interesting efforts to contribute to for a few hours, solo or pair or team. Dreams for the newborn github included support for let's-meetup-and-hack realtime dynamic community formation, but I've not yet seen the like.
I enjoyed Factor. Fixed stack-effect seemed a nice trade of flexibility for less oops.
I'd love to see someone start concatenative, but with a replace-the-world focus. So move quickly up-scale to single and multiple dispatch PICs, tabled WAM, clone V8 internals, link Z3, etc, etc. "If you're not able to implement other languages in bulk, and better than they are, you're still wedged". Sort of a LispMachine for an age where a much broader-than-cons foundation is possible/appropriate.
> I saw Zed Shaw do a presentation using factor and decided to spend a weekend playing with it.
I saw the same presentation back then and also spent a weekend with factor. It was a really valuable experience. The language was so different from anything I had previously used that I had to learn a new way of thinking. That was a great thing to go through.
Slava Pestov (the creator of factor) did a presentation on the language at Google back in the 2000s. A highlight from the talk was him explaining that there was a function 'boa' that you could call to construct an object 'by order of arguments'. He called it "a boa constructor." :)
This is almost 15 years ago, and I didn't have a reliable internet connection, so sadly no. There was two of us in a small computer group in Germany trying to figure things out, mostly.
In case anyone else was curious, Slava Pestov is now at Apple working on Swift. Top of his twitter[1] is a WWDC22 talk "Design protocol interfaces in Swift"[2] (but video seems 1x-only - I don't see a copy on yt - there's a transcript).
Ha! I implemented "concatenative" programming for Java as Binding [1] (or Unit) expressions, but had no idea. Seriously, never came across that term before this post.
The idea with binding expressions is the type of expression A and the type of expression B implement "reactions" with one another in order to form a binding expression when they are lexically adjacent.
65 mph
The type of `mph` defines a post reaction method with the type of `65` as an argument that results in type Rate. As I understand it this is concatenative, right?
Another example:
Money payment = 1.5M USD;
There are tons of these.
Concatenative programming in general feels like it should have a more prominent place in mainstream languages. Just my take.
you can then use simple algebra to solve unit conversion and many other common deductive reasoning questions ("how many miles per gallon...?"), relying on the units to guide you to the solution.
There's probably a name for this, and it is indeed built into the SI notation (km/h vs mph).
This is already implemented with manifold's unit expressions, but is made richer and more readable via concatenative features. For instance, '1.5 * USD' is not as readable as simply '1.5 USD'. However, unit expressions leverage operators for dimensional arithmetic:
Force f = 5 kg * 9.807 m/s/s; // result: 49.035 Newtons
Area space = (20ft + 2in) * (37ft + 7.5in); // result: 758 37/48 ft²
All unit expressions internally store amounts as SI units, which enables interunit expressions.
Length height = 6 ft + 4 cm; // mix SI and US units
out.println(height.to(ft)); // display any unit
You aren't limited to units. Generally, any concatenative sequence can be implemented. Like ranges:
IntegerRange range = 1 to 5;
Here the `to` identifier's type implements reactions to Number types to produce range types, which enables:
for (int i: 1 to 5) {
out.println(i);
}
See the manifold project's Unit and Science modules:
I wanted to reply like what is below but got cold feet. But thanks.
>>>> Why? tedious for me w/o a join. Or is there a feature lurking somewhere? At a different level stuff like this it strike me as “… nothing to see here move on .. “
I think most (? certainly many) readers like the links to past discussions. If it were just a list of past submissions, most of which didn't get comments, I'd agree with you.
I also try to drop the ones that got comments but the comments were off topic or otherwise useless.
I used to play around with Factor in 05-10ish. Had all of a semester of C and a few physics labs worth of Matlab under my belt so I never actually managed anything interesting in it but god damned if it hasn't ruined me for every other language.
Concatenate languages are fun, but damn if that isn't an annoying UI. It's gated with some kind of captcha, and it made me go through 40+ rounds, with every few selected images resizing and shifting the captcha.
Just took a look on desktop. I'm just inadvertently being sent to edit links with empty content when looking at some of the language features, and edits are recaptcha protected.
One of the text forms is totally stack based while the second is quite lispy. And, according to the official grammar, you can mix the two forms willy-nilly — aside from the function header which needs to be in the lisp form IIRC.
Damn, that indeed looks interesting. Could someone give here a Factor vs Forth tl;dr? Forth appears to be tailored for embedded systems, but the velociraptor is growing quick on me.
> Forth is untyped, not garbage collected, and close to the machine. For flow control, Forth code tends to use immediate words. Variables and arrays tend to be global, and programs aren't usually written in a functional manner. Factor is very different from this. It is dynamically typed, offering a high degree of reflection. Unreferenced objects are garbage collected with a generational garbage collector. Factor code is a little bit more distant from the machine, though the C FFI allows using words like malloc and mmap. For flow control, Factor generally uses quotations, allowing flexible higher order functions; parsing words are used mostly for definitions and data literals. Variables are dynamically or statically scoped (see below), and arrays are just objects which don't need to be treated specially.
There's no one forth. A huge number of forth users end up writing their own forth, with different semantics, because it can be easier that way.
Though you're right, forths are unusually commercial. Forth is old, and in some ways it stayed old. A lot of people that use it now have used it since the 80s, so they're quite used to paying for compilers.
There's also the fact that forths are used in very niche places, and the companies that use them are happy to pay up.
You'll find a very open community with really nice people though.
I saw Zed Shaw do a presentation using factor and decided to spend a weekend playing with it. It was the start of a two year journey that ended with me writing forth for microcontrollers. That was time I should have studied but was somehow always sidelined by other things.