Slashdot Mirror

Perl 6 != Perl 5++

Perl 5 is a interpreter which happens to grok Perl 5. It's the one and only implementation that implements all features (by definition). There is no other specification.

Perl 6 is not a interpreter or compiler. It's a specification and as such there will be many implementations. Do you know what the current "release" of C++ is? See...

Want to use Perl 6 today? Use Pugs.

I'm not sure why anybody is up in arms about a Perl6 release date. It takes a long time to get done. That's the way the world works. This isn't a platform with a fixed set of requirements, a predictable user base, and limited scalability requirements.

People have been arguing for who knows how long about syntax. At some point the argument has to end and someone has to implement that syntax. It's not an easy thing to bring either of these points to conclusion.

Parrot is register based, not stack based. Perl has been developed using Haskell, and eventually it will come to the point where perl can be compiled with itself. These are monumental tasks for volunteer workers pursuing some pretty hefty goals for the sake of pursuing them.

Pugs has been working for quite some time already, and its an easy transition for anybody already familiar with perl.

I can see criticizing the project because it's hard for a newbie to figure out how to help, or criticizing the syntax in favor of ruby/python/etc, or criticizing performance (although both Perl6 and Parrot perform very well IMO), but criticizing the time it has taken to build? Get off your high horse and go build your next big Web 2.0 script that can do anything as long as you have less than 100 daily visitors.

Perl 6's pugs engine has been capable of producing JavaScript as a back-end for some time, certainly since before this patent's date.

A lot of the support for Haskell *used* to be in Academia. But #haskell is full of people using it for every day real-world purposes it seems. I was especially impressed after talking to Cliff Beshers of Linspire who are doing all of their distro-specific coding such as the installer etc. in Haskell. I have now seen IRC bots in haskell, web servers and web application servers in haskell, and video games in haskell. Heck, the only existing implementation of Perl 6 is written in Haskell. It seems like it has escaped Academia and has been looking for a problem to solve for a few years now. And it looks like this multi-core business may well be it. Especially since haskell has a parallelizing compiler.

"Just email me and I'll give you commit rights, (almost) no questions asked."

You can start programming in Perl 6 today using Pugs.

If Larry Wall wants Perl to remain relevant despite the forward march of Python and Ruby, he needs to stop his exegesis prose wanking and churn out some working code.

Larry doesn't need to code anymore

> Something as simple as finding the balanced parentheses in the string: (a+b)/((c-d)+e) using a regular expression is difficult.

It's in fact impossible in true regular expressions since it requires you to maintain a stack.

> Yet there have been languages that have advanced string matching capabilities around since the 60's (start looking at Snobol -- which is still alive -- and some of it's descendants).

Advanced matching is coming in Perl6 (which is runnable right now, http://www.pugscode.org./ Along with syntax noise that makes perl5 look like python in comparison... alas. I do love perl but as they say, the goggles, they do nothing. At any rate, care to let us know what some of Snobol's modern descendants are?

ChrisDolan,

I apologize for my unintentionally misleading statement. Parrot Does not have a XUL document. The intro to PUGS and HASKELL slides are XUL documents. They are both referenced from the PERL6 site. In my quest to find out more about PUGS and HASKELL I was thrown off course and had to learn about XUL first. There is no good purpose for that. A user should not be surprised by a new document format while on a quest for other information. And a fair question would be, where is the POD Perl 6 documentation? It is not on the site, nor is it on CPAN. I have not followed the project closely and as a casually interested user, the doc locations are not intutively obvious.

Thanks, E.

ChrisDolan,

I apologize for my unintentionally misleading statement. Parrot Does not have a XUL document. The intro to PUGS and HASKELL slides are XUL documents. They are both referenced from the PERL6 site. In my quest to find out more about PUGS and HASKELL I was thrown off course and had to learn about XUL first. There is no good purpose for that. A user should not be surprised by a new document format while on a quest for other information. And a fair question would be, where is the POD Perl 6 documentation? It is not on the site, nor is it on CPAN. I have not followed the project closely and as a casually interested user, the doc locations are not intutively obvious.

Thanks, E.

So what it's this: http://www.pugscode.org/.

What vapor? Sure, this isn't the real implementation, but it's certainly better than imagining that you're writing Perl 6 after reading a book on it. PUGS is finding implementation obstacles and speeding up the Parrot implementation of Perl 6. I don't think I'd use it for production work, either. People are already porting CPAN modules, too.

Ruby is a great language, and I do recommend having it and some familiarity with Rails under your belt, but stay away from the abomination that is PHP. *points to wretched soul* Look what happened to him...

Here http://www.pugscode.org/ is something on the PUGS project, which is making an implementation of Perl 6 in Haskell, conformant to the spec.

Apparently they are having a lot of fun.

If you don't mind working with an alpha version (in terms of features supported), you can try Pugs right now. It's pretty impressive and should be even better with the next release.

There's no official release date nor an official estimate, but when Pugs and Parrot meet in the middle (hopefully within the next couple of releases), things will start moving much more quickly. A feature-complete beta is probably not any closer than a year away, give or take the million things that can go wrong with any big open source project.

hmmmm... let's see:
an order of magnitude the performance of C++: this depends. If we're talking about regular expression-based parsing and general string manipulation, perl5 is already there. Hard math? 3- and 4-d matrix manipulations? not yet. Maybe perl7, who knows?
generic programming: perl5 has this, sort of. lots of stuff can be done in compile time. perl6 has generic types, I think even pugs have them already, but I don't recall exactly.
bazilion libraries? here, actually, this is one of the things the world (including c++) could learn from the perl community. really. including c and c++-written libraries that you can call from inside your perl programs.
I am still reading about this ITK thingie, so I won't comment, but looks good for starters.
Mind you, I work with C++ myself. But I don't think it's a perfect language (nor I am saying you said that), and I think each tool has its trade (but, seriously, I loathe Java).

While it's not production software by any means, you can begin testing and improving Pugs.

http://developers.slashdot.org/article.pl?sid=05/1 0/09/1831219

The release tarball will be available from CPAN shortly:

http://pugscode.org/dist/Perl6-Pugs-6.2.10.tar.gz
SIZE = 2394516
SHA1 = 3d8669fdccc3616c99cdde68659759b8b5782859

With two months of development, this release features more tightly integrated JavaScript and Perl5 code generator backends, a library interface to the Pugs system via support for the Haskell Cabal frameworks, as well as many new tests.

After the release, the push toward 6.28.0 will begin in earnest, with the newly specified container model and object model integrated back to the main runtime, fleshing out support for the remaining OO features.

Again, thanks to all the lambdacamels for building this new ship with me. :)

Enjoy!
/Autrijus/

Changes for 6.2.10 (r7520) - Oct 10, 2005

Feature Changes

Shared components

• Support for the Haskell Cabal framework, exposing Pugs as a library to other Haskell users, paving the way for use in IDEs, as well as future Inline::Pugs and Inline::GHC modules
• Adopted the code convention of expanding literal tab chars to spaces
• JavaScript backend can be invoked with pugs -B JS
• Perl 5 backend can be invoked with pugs -B Perl5
• Pugs will now compile version ranges in use/require statements
• Significant backend enhancements; see below
• $?PUGS_BACKEND can be used to tell which runtime is in use
• exec emulated partially on Win32

JavaScript backend

• Passes 91% of the main test suite including TODO failures
• Integrated with MetaModel 1.0
• Faster code generation, taking advantage of -CPerl5 output.
• Switched to continuation passing style CPS to properly support return, ?CALLER_CONTINUATION, coroutines, and sleep
• Improved support for binding and autodereferentiation
• Initial support for multi subs
• Initial support for symbolic dereferentiation
• List construction no longer creates new containers
• Miscellaneous performance improvements
• Named-only arguments +$x and ++$x cant be passed positionally anymore
• Parts of the Prelude can be written in Perl 5 now to improve performance
• Perl 5-like regular expressions mostly working
• Proper UTF-8 handling
• Support for monkey-but $foo but {...}
• Support for $CALLER:: and $OUTER::
• Support for lazy {...} blocks for delayed evaluation
• Support for temp and let declarations
• Support for array and hash autovivification
• Support for array and hash slices
• Support for evaluating expressions in the PIL2JS shell :e <exp>
• Support for junctions
• Support for loading JSAN modules by using use jsan:Module.Name
• Support for lvalue subroutines foo = ...
• Support for slurpy hashes in subroutine signatures
• Support for the Proxy class not yet user-visible
• Support for the eqv operator
• Using for with only one element to loop over works now
• int works correctly on special values like Inf or NaN now
• substr returns a r/w proxy: substr$str, $pos, $len = $replacement

Perl 5 backend

• Passes 33% of the main test suite including TODO failure

In the Pugs project, the coders and testers are generally different people, when the tests being written first.

I'm fairly ignorant about the kernel development process, so I ask: could automated testing play a greater role in the quality assurance of the project?

That, uh, is the final plan for perl 6; to be written in perl 6.

It'll compile to parrot bytecode.

Of course, if you just want to mess with perl 6 before it's (completely) written in perl 6, hit Pugs.

If you find LISP interesting, Haskell might also be of interest.

Recent interest in Haskell has exploded because of the implementation of Pugs in GHC. Pugs is a compiler / interpreter prototype for Perl 6, which is also a functional language, borrowing many concepts from LISP and smalltalk (as well as just about every other popular research or practical programming language).

And much later, Pugs the Perl6 emulator, whose version number is supposed to approach 2*Pi (Pugs 6.2, Pugs 6.28, ...).

And much later, Pugs the Perl6 emulator, whose version number is supposed to approach 2*Pi (Pugs 6.2, Pugs 6.28, ...).

It's not actually the case that Haskell "forces" functional purity, at least not in the way the submitter seems to think. You can do things that are a LOT like non-pure functions, you just have to use Monads. You have the so-called "unsafe" functions, which perform side-effects in otherwise "pure" functions.

So you might ask, "If you're going to write code like that in Haskell, why not just use C++." The answer is because even when using Haskell in a non-idiomatic way, Haskell is still more beautiful :)

Monads are a means of threading "stateful" code in a very clean and predictable way through your programs. The parent's comment, "Very localized state (in one function) is easy enough, but anything more pervasive and you soon become more familiar with monads than you ever wanted to be," is sorta like saying, "You can write high-level code in C++, but you will soon become more familiar with objects than you ever wanted to be."

They are indeed a part of the language, and definitely a new concept, but monads aren't nearly as confusing as people seem to think, certainly not more confusing than objects, it's just a reputation issue that makes people think monads are confusing. Take it from a random-joe hacker like me. You don't need a PhD to perform IO in Haskell.

For instance, here's a basic implementation of 'cat' in Haskell:

import System.Environment(getArgs)

main = do
{a <- getArgs;
lines <- mapM readFile a;
putStr (concat lines);}

The code:

a <- b

getArgs just reads in the command-line arguments as a list, so 'a' represents a list of the filenames.

readFile takes a file name, reads the contents, and returns it as a list of lines.

mapM means 'perform this computation once for each item in this list'

putStr is obvious, concat just takes a list of lists and turns it into a single list.

There's a paper, Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell about how to do these kinds of "real-world" things in Haskell.

There's also a very cool version control system called darcs that's written in Haskell, and recently an implementation of Perl 6 called Pugs in Haskell.

peace,

isaac

Check out http://pugscode.org/

What is Pugs?

Pugs is an implementation of Perl 6, written in Haskell. It aims to implement the full Perl6 specification, as detailed in the Synopses. For more information, please see the overview.