[carapace]

Yes, it's feasible.

Wielded well (read "Starting Forth" and "Thinking Forth") the concatinative languages are very good for eliminating incidental complexity, so code approaches the Kolmogorov complexity of the problem or task it's for.

[codr7]

Feasible, but takes a lot of skills and hard work to break the problem down into small enough pieces.

It's a different way of writing software.

[carapace]

> takes a lot of skills and hard work to break the problem down

Same for every programming language.

The advantage that concatinative languages have over others is the closeness of their syntax to the semantics of the domain which makes them much easier to learn and use than other PLs (unless one has previously learned the other PLs first. Otherwise PLs like C and Java seem hopelessly baroque.)

[codr7]

I don't agree.

All languages fall on a spectrum, different priorities, strengths and weaknesses.

Forth is all about simplicity of implementation, it's the number one idea driving every decision. Which means a lot of other priorities, like higher level abstractions, are more difficult to achieve.

It does make a nice DSL sometimes, so does Lisp, to an even greater extent, while providing plenty of higher level abstractions.

[carapace]

> A simple solution has elegance. It is the result of exacting effort to understand the real problem and is recognized by its compelling sense of rightness. I stress this point because it contradicts the conventional view that power increases with complexity. Simplicity provides confidence, reliability, compactness, and speed.

~ Chuck Moore, from "Starting Forth" foreword.

https://www.forth.com/starting-forth/0-starting-forth/

> It can scarcely be denied that the supreme goal of all theory is to make the irreducible basic elements as simple and as few as possible without having to surrender the adequate representation of a single datum of experience.

~ Einstein

https://quoteinvestigator.com/2011/05/13/einstein-simple/

> a lot of other priorities, like higher level abstractions, are more difficult to achieve [in Forth]

I'm not a Forth person myself but if I were I would challenge you to name a higher level abstraction or other priority that was difficult to achieve in Forth, or perhaps, more topically, in Factor.

[codr7]

CLOS or Conditions from Common Lisp then, or LINQ from C#, or sum types.

And I don't mean something that looks sort of similar; I mean the same functionality, flexibility and level of convenience.

[carapace]

Like I said, I'm not a Forth person, but if there were any around to settle it I would bet you all those things have several implementations (I do know that many people have written OOP and OOP-like things in Forth.)

> I mean the same functionality, flexibility and level of convenience.

I feel like you're missing the point (although there's such a thing as ANSI Forth so you are in good company). In Forth re-implementing an exact model of some other system (like CLOS, which is, of course, very nice, I don't need to tell you) is a non-goal (you could do it but it would be kind of a stunt.)

The fundamental advantage of concatinative languages over pretty much all the other PLs and paradigms (except maybe Smalltalk and APL) is that they permit parsimony of code, what some have called "semantic compression", by refactoring better than other languages. One of the reasons Lisp is so powerful is that it's also pretty good for refactoring.

I could prove this using Category theory (and God willing someday I will), concatinative languages are closer to the metal (the "metal" in this case being, not the hardware, but the conceptual essence of programming and logic.)

Anyway, well met, and have a good week. :)