[FoRK] Open source PowerShell clone available

[Simon Wistow]

On Tue, Apr 08, 2008 at 05:14:28PM -0400, Luis Villa said:
> I regularly thank $DEITY that I will never again see another 
> syntactically meaningful combination of @, $, and #. TMTOWTDI has its 
> place, but thankfully that place is not in my life. (Ruby and Python I 
> wouldn't mind seeing again in small, measured doses ;)

There's actually been a interesting (FCVO interesting, depending on who 
you are) discussion about this in parts of the Perl world. I weighed in 
with ...

So the use of sigils raises interesting questions. 

Python happily (apparently) does without Sigils. So do a lot of other 
languages like C. Except when it doesn't although whether * and & are 
sigils is a matter of debate.

Charles Simonyi 'invented' a way of retconning textual sigils into BCPL

    http://en.wikipedia.org/wiki/Hungarian_Notation

which provided a verbose but expressive way of having sigils. 

Microsoft later bastardised Hungarian Notation into the camelCaps 
abortion that is MFC. 

So clearly annotating a variable with a type is useful - the question is 
where along the spectrum you want to lie - full on verbosity or minimal 
decoration.

I happen to like the level Perl5 has struck although, to be fair, I have 
no idea if that's just because it's what I'm used to. I understand the 
confusion between refs and normal variables 

        @array
        $array[0]
        $array->[0]

but actually all those make perfect sense to me. I suppose the only way 
to simplify them would be to make all subroutines pass-by-reference and 
simplify down to 

        @array
        @array[0]

but, and again maybe this is just inertia, that doesn't make sense to me 
- the $ in $array[0] tells me I'm getting a single value back. Again 
maybe this is a distinction that gets blurred when all you have is pass 
by reference since $array[0] could pass back an array itself but we'll 
leave that for now.

As an aside I have real problems working with Python (and I've written 
some mildly large and complicated programs in it). This is not bash 
against Python but an anecdotal piece of evidence. I'm told that I have 
a very mild form of dyslexia (or similar) which manifests itself as a 
problem with pattern recognition. This normally isn't a problem but, 
when I'm tired, I can't read Python. Again, maybe it's a familiarity 
thing but I find that the lack of sigils and braces causes a problem 
trying to follow flow. As a corollary however I actually also have a 
problem reading strangely formatted English or text with no punctuation 
when I'm tired as well.

I'm sure that the Perl6 people will tell us that 99% of Perl6 will look 
like Perl5 and that this is just the corner cases, the golfing tools, 
the elements that will allow epxressive minimalism in the right place in 
the same way that we can do stuff like

    do_something foreach @item;

or 

	exit unless $stay_alive;

in Perl5.

Yet every example we see looks alien and unfamiliar - the edge cases 
seem to be the norm. Maybe it's just the Perl6 team stretching their 
wings but aren't the two major complaints about Perl that there are too 
many sigils and too many ways to do things - what's the advantage of 
adding more sigils and more ways to do things. Maybe we're mistaken 
and we've got the wrong idea but when *everyone* apart from the inner 
cabal (not to imply that P6 development is exclusive, it's anything but) 
is confused, even the party faithful then maybe there's some 
communication problems going on.

So, why does the new Perl6 syntax 

    for =$*IN -> $guess

fill me with The Fear[tm]?

Well, for a start (and this is a personal thing), no comforting brackets 
and braces to help punctuate the syntax. Does the for apply to the =$*IN 
or to both the $*IN and the $guess? I can work it out but it's not 
immediately clear. 

And is that = a sigil or an operator? Again, I can work out that it's 
actually any operator but it's not immediately obvious. To =$* looks 
like an emoticon for someone in a top hat and sunglasses giving me a 
kiss. But that's just me.

Playing the familiarity card again but 

	for =$*IN -> $guess

isn't obvious what'ts going on without any context. If that was 
presented to me cold I'd guess it meant a short hand for 

	while ($*IN != $guess) {
		...
		$*IN++;
	}

whereas 

	foreach my $guess ($*IN) {

	}

is far more 'intuitive'. I'd actually like to see something more like TT

	foreach my $guess in ($*IN) {

	}

or

	foreach in ($*IN) {

	}	

except that I can't quite get over the fact that $*IN to me looks like a 
single item

	foreach in ($*IN.lines) {

	}

or

	foreach in (@*IN) {

	}

would be better for me (the @ and $ magically switching the context of 
$*IN and the foreach forcing an implicit iterator for things that can 
support it) 

Simon