

Pike Programming Language (2014) - zura
http://www.drdobbs.com/open-source/pike-programming-language/240168647

======
tomjakubowski
Pike is one of my favorite languages, but I've hardly used it. It's dear to me
to me for purely sentimental reasons. As the article briefly mentions, Pike is
the spiritual successor to LPC, a pretty unique language from the late
80s/early 90s used to extend LPMUDs and write areas, items, mobs, etc. I'd
dabbled in programming before, but LPC was the first language I used to write
real code shipped to production on a MUD called Aldebaran [1], with a user
base in the hundreds (felt huge at the time :-)), circa 2001.

I remember very quickly losing interest in playing Aldebaran when I saw how
the so-called "wizards" (programmers) could manipulate the world around them
with code [2]. I decided almost right away that I would play exactly enough to
fulfill the bare minimum requirements to apply to become a wizard and harass
the administrators until they let me have a trial run. A few weeks later, the
admins relented, and I haven't stopped coding since.

[1]: [http://aldebaran.mud.de/](http://aldebaran.mud.de/)

[2]: Looking back, Aldebaran to the wizard was an almost Emacs-like
interactive environment. You could create and manipulate items on the fly by
cloning a blueprint and, using a special wizard's staff, evaluate code
directly on that item without changing any files. And like Emacs, the text
editor it came with (an ed clone) was terrible :-)

~~~
klibertp
> used to extend LPMUDs

It would be probably better to say it was used to implement LPMUDs (still is,
BTW). Driver without a mudlib - written in LPC - was not very useful at all.

> special wizard's staff

A driver of the MUD I worked on had a special set of objects used for
introspection/reflection: you could inspect object state, set it's attributes
and evaluate arbitrary code "inside the object". These were invoked as normal
global commands IIRC. Now I wish we had it coded as a wizard's staff, too :)

> almost Emacs-like interactive environment

Also similar to image-based Smalltalk or Lisp. It's a pity that it wasn't used
to build a Smalltalk-like graphic environment, but in its text form this
environment was awesome, too.

> the text editor it came with (an ed clone) was terrible

OMG, please don't remind me of this. I had to learn ed, because on our MUD we
had no FTP access for some time and it was a tragic experience. I was only
able to live with it thanks to MUSHClient, which did a great job at handling
large amount of text and I mostly just copied the code to notepad and then
pasted it back after modification. But, on the flip side, I could never
understand why people don't like Vi - it's so much better than ed! ;)

------
mhd
For a very short while it looked like Pike could take a seat among the othe
"P" languages (Perl, Python, PHP), but that was _quite_ a while ago. And
mostly because it was bundled with the Roxen web server. IIRC its claim to
fame was easy headline font->image rendering…

fugaces labuntur anni, indeed.

------
arthursilva
Oh gosh, I remember checking out Pike a longgg time a go! Totally forgot about
it since them.

Checking it again today makes me realize how neat it is, the union types (now
in typescript as well) are awesome.

------
mkadlec
Reminds me of Javascript, but with better performance and without some of the
Javascript oddities.

~~~
klibertp
> Reminds me of Javascript

How exactly? Pike is no closer to JavaScript than to Python for example. Out
of languages I know I think only Boo looks a bit similar - Pike is it's own
thing, it's design is based on earlier LPC language, which IIRC existed years
before JavaScript, Python, Ruby and PHP.

BTW, LPC was fun to work with, too: prototype-based OO, mix of static and
dynamic typing similar to that of Dylan, shadowing (a bit like mixins, but not
quite) and inherent _liveness_ of the system (as proposed by Self and
Smalltalk, just using text UI instead of GUI) made it very exciting language
for the me back then: a fledgeling C++ programmer. IIRC it was byte-compiled,
too. LPC suffered because it was too closely tied to the idea of a MUD (there
were other commercial applications of it, though) and I think Pike tried to
fix this. But in the process Pike made the MUD-creators community less
interested in it, which drastically reduced its initial user base.

