> since it won there's a module or three for anything.

I was just browsing the "Module tree reference" for Pike. There seems to be a crazy amount of modules for the language. Weirdly enough for web there's only CGI (and WebSockets for some reason), and the CGI module isn't really documented. Under protocols there seems to be everything I ever need.

Python won because of its C interface was easy, so it's got Numpy, Scipy, Pytorch, OpenCV bindings, etc. For these use cases, the speed of the interpreter is mostly irrelevant.

On the web dev front, Python was lucky to get easy bolted-on async I/O (via greenlets), so it was more performant than Ruby (which was really slow 10 years ago), and Django was less magical than RoR.

Once every 2 or so years it's posted and upvoted due to appearing interesting ("dynamic language with C syntax", and perhaps other characteristics/features). Not really receiving traction. That said the language is mature enough, still gets updates, and there're meet ups so can assume there're developers using it.

Turns out there is no Pike package for FreeBSD, no port, and the Pike git repository has a FreeBSD subdirectory last updated 22 years ago.

But ./configure && gmake && gmake install seemed to work, or at least it runs and nothing weird has happened so far.

I don't think it goes both ways in this case. I wasn't a fan of their inspiration from C, it doesn't mean I don't like C.

I'm fine with C. Keep the focus on Pike.

Looks like there’s a `mixed` type, variables of which can hold values of any type. But at least that’s something you can `grep` for.

A more subtle issue with type hints (as in TypeScript/Python, not sure if this applies to Pike) is that there are ways to work around the type system. You can get, for example, a variable of type `int` that actually holds a `list`:

https://news.ycombinator.com/item?id=43508152

I can turn off static type checking for a thing in C by using `void*`

Sounds like Julia, too.

Also you'd think having the type signature would help with performance, but in some cases it can cause the VM to enforce a runtime type check where it wouldn't have before, imposing worse performance.

> it's the MAC-10 of footguns

At least it might be shooting Nulls.

That's a bit anachronistic. Pike was released in 1994, the same year as Perl 5.0 and Python 1.0. Ruby did not exist yet!

Being an offshoot of an existing MUD language it was quite usable even a young language, comparably good performance and a compelling C embedding. History could very well have been different. The 90s was a really good decade for dynamic languages.

I mean let's be fair: back then MUD nerds were using LambdaMOO's "moo" language and LPmud's "LPC" before things like Python were mainstream or serious, Perl pre-5.0 was terrifying and limited, and Ruby wasn't even on the radar.

So when we went to go do "serious" work we kinda missed them.

Your options in 1991, 92, 93 were earlier perls, shell + awk/sed, or maybe tcl or a lisp/scheme if you were lucky.

The languages inside those MUDs actually were ahead of their time, and their programming model -- in the case of MOO [and its offshoots CoolMUD and ColdMUD] at least -- was more similar to advanced systems like Smalltalk or Self which were hot interesting topics at the time.

Being "confined" to being "game" languages made them not get taken seriously (unlike "JavaScript" which arrived with all sorts of weird warts but had Netscape's brand on it), so the LPC people tried to make it into a "serious" language in the form of Pike, and it's not half bad?

By the late 90s, obviously things had changed. If somebody in a successful "serious" company had adopted Pike/LPC it could easily have had an alternative history where they became commonly used instead of perl5 or php on the early web. (It took Python a decade to get serious headspace there.)

(Gratuitous plug for my LambdaMOO defibrilation: http://github.com/rdaum/moor)

I think it's important to point out that MUDs were probably the first complicated interactive synchronous "Internet applications", even though they were (primarily) textually driven and not "serious" (they were to us). So things like Pike (née-LPC) & moo were on the forefront here on how to author those kind of dynamic systems.

Early web sites, gopher, etc were just request/response mostly static content (sometimes with a dash of a database). They weren't synchronous or "live" in any real way. Things like IRC were synchronous but did not do programmable/dynamic content.

I cut my teeth on moo, and was bored & annoyed to tears writing cgi scripts in Python & Perl and the web didn't catch up to produce really interactive stuff until well over 10 years later ("web 2.0")

In 1994 there was very little competition in scripting and LPC/Pike/moo and the like cribbed ideas that are still not mainstream or became mainstream much later. It's the same year Python got to 1.0 and they didn't get real traction until 2005-2010 sometime.

At the time the alternatives were stuff like Tcl and Awk and Perl 5, which were relatively clunky, incompetent or slower. Perl won for web, though Pike had Roxen and could have, and if that had happened we would likely have gotten a more Smalltalk-like Internet than the PHP Internet we got.

Pike is fun, it will likely compile just fine on your odd computers if you have any and it has some characteristics that are uncommon like easy hot upgrades for long lived systems and modules as data.

You realize that you're on a site that is mainly for programmers, right? Programmers are often interested in languages, for the same reason that woodworkers are often interested in wood - even a kind of wood that they may never use.

I guess the other well-known syntax form at the time was the one in the Algol/Pascal/Ada/Modula-2 tradition with keywords (begin/end, if/endif, etc) for structuring blocks and that's what MOO cribbed from, while LPC (and later JavaScript, Java, etc.) did the braces thing.

At the time I liked braces a lot more but since then have come around to preferring the more Wirth-ish style. I think Julia has shown that a dynamic lisp-ish language can do this very elegantly.

Worst part of static compiled languages is the ugly syntax. Worst part of dynamic systems is they aren't machine-understandable. It's a direct tradeoff that results from formal language theory. Ruby isn't an answer to this, in fact it lies so far on the dynamic side of the fence that the one IDE targeted at it is more of an impediment than a help. There is no answer to the tradeoff, though there are a few current attempts, like Zest.

I personally don't need or want a computer to help me to understand the code I work on. It would be nice but not worth the need for a compile step. Pike looks like a compiled language, but doesn't even try to give you any of the advantages of machine understandability. It's purely cosmetic, why in the world would anyone want Python to look like C? If you want a dynamic language and don't want to deal with Ruby's... eccentricities, just use Python like everyone else.

https://github.com/jamii/zest

Ruby has static type system if I ever want to use it.