• Like
  • Save
Qore for the Perl Programmer
Upcoming SlideShare
Loading in...5
×
 

Qore for the Perl Programmer

on

  • 54 views

Slides for a talk on the Qore Language directed at the Houston Perl Mongers group back in 2011.

Slides for a talk on the Qore Language directed at the Houston Perl Mongers group back in 2011.

Statistics

Views

Total Views
54
Views on SlideShare
53
Embed Views
1

Actions

Likes
0
Downloads
0
Comments
0

1 Embed 1

http://www.slideee.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Qore for the Perl Programmer Qore for the Perl Programmer Presentation Transcript

    • The Qore Language ... for the Perl programmer B. Estrade http://houston.pm.org/ September 8th, 2011
    • What is Qore? According to Qore.org: "... ●thread-capable, ●embeddable, ●weakly-typed ●optionally strongly typed ●procedural ●object-oriented ..."
    • Qore's Influences According to http://en.wikipedia.org/wiki/Qore_Language: But, docs mention: ●Perl ●D ●Java ●C++
    • Some of Qore's Primary Design Goals ●natively multi-threaded, so scalable on SMP architectures ●embeddable ●native object serialization (JSON, XML) ●native database support (MySQL, Oracle, etc)
    • Never heard of Qore? Neither had I. ●used to do a lot of simulations of parallel things with Perl, serially ●wanted to use real threads to model threading, but "knew" Perl's threading options sucked ●So, I searched for a while and found Qore ●I liked it so much, I created a FreeBSD port for it - http://www.freshports.org/lang/qore/
    • What's to like about Qore? ●Familiarity ○it's eerily similar to Perl in many ways - data structures, operators, sigils, subroutines, TIMTOWTDI (usually), etc ●Allows Freeflow of thought ○The language syntax and semantics stay mostly out of the way of thought and expression, much like Perl ●It's meant to be threaded ●Imagine if Perl was designed from the beginning to support threads.
    • The Reality ●Qore is not nearly as expressive as Perl ●Not as "DWIM" as Perl ●Threading support could be at a higher level ●No real community (like none), so no C"Q"AN ●Still very cool and not a toy
    • Scripting's Role in the Many-Core Era ●scripting languages will be exposed as handicapped if they can't make native use of many-core ●most scripting languages are terrible at this ●I believe that interpreted offer the greatest opportunity for intuitive interfaces to many-core; as opposed to: ○ compiler/directive support (e.g., OpenMP) ○ low level threading libraries (e.g., PThreads, Portable Coroutine Library) ○ low level communication libraries (MPI) ● Don't get me wrong, I still <3 OpenMP & PCL :)
    • State of Threads Many-Core in Perl? ●It's not just about threads, it's about taking advantage of many-core environments in as many Perlish ways as possible. ● Some options: ○ Coro, AnyEvent ○ ExtUtils-nvcc, CUDA::Minimal, Perl OpenGL ○ PDL::Parallel::MPI, Parallel::MPI::Simple ○ ..? ● Wishful Options: ○ Parallel::OpenMP ○ Perl OpenCL ○ Inline::Qore ○ ..?
    • Where to get Qore? ●http://www.qore.org (latest, 0.8.2) ●MacPorts (0.8.2) ●lang/qore in FreeBSD Ports (mine, @0.8.0)
    • "Core" Qore, Under the Hood ●Bison ○parser generator (like Yacc) ●Flex ○lexical scanner, tokenizer ●pcre ○Perl compatible regular expression library ●libxml2 ●supported modules require other libaries
    • Qore has Optional Data Typing ●boolean ●string ●int (64 bit, signed) ●float (double) ●date ●binary blob (opaque) ●NULL - a state of undefinedness, like undef; ●NOTHING - no value, like the empty string, q{}; NULL != NOTHING; NULL really is something; NOTHING really is nothing.
    • The World says, Hello. #!qore %enable-all-warnings print("Hello!n"); #!perl use strict; use warnings; print("Hello!n");
    • Data Containers #!qore %enable-all-warnings # scalars my $x = 1; # arrays my $list=(1,2,'three',4.0,2001-01-15Z); # hashes my $hash=("a":1, "b":'two',"c":2.4); #!perl use strict; use warnings; # scalars my $x = 1; # arrays my @list=(1,2,'three',4.0,'2001-01-15Z'); # hashes my %hash = ("a"=>1, "b"=>two',"c"=>2.4);
    • Data Container Iteration #!qore %enable-all-warnings # scalars my $x = 0; printf("%sn",$x); # arrays my $list=(1,2,'three',4.0,2001-01-15Z); foreach my $i in ($list) { printf("%sn",$i); } # hashes my $hash=("a":1, "b":'two',"c":2.4); foreach my $k in (keys $hash) { printf("%s = %sn",$k,$hash.$k); } #!perl use strict; use warnings; # scalar my $x = 0; printf("%sn",$x); #arrays my @list=(1,2,'three',4.0,'2001-01-15Z'); foreach my $i (@list) { printf("%sn",$i); } # hashes my %hash = ("a"=>1, "b"=>'two',"c"=>2.4); foreach my $k (keys %hash) { printf("%s = %sn",$k,$hash{$k}); }
    • Complex Data Structures #!qore %enable-all-warnings # arrays of arrays my $list=((1,2,3), (4,5,6), (7,8,9)); # hash of arrays my $hash=('a':(1,2,3), 'b':(4,5,6), 'c':(7,8,9)); #!perl use strict; use warnings; # arrays of arrays my @list=([1,2,3], [4,5,6], [7,8,9]); # hash of arrays my %hash=('a'=>[1,2,3], 'b'=>[4,5,6], 'c'=>[7,8,9]);
    • Some Qore Array and Hash Operators Arrays: ●shift, unshift ●pop, push ●splice ●map, foldl, foldr ●elements (counts) Hashes ●keys (insert/creation order) ●delete (clear value) ●remove (remove from hash) ●elements ●find (query contents of hash on key and value)
    • Regular Expressions - whoa... #!qore %enable-all-warnings my $t = 'Branches'; # text my $s = 'abc'; # string my $p = 'a|z'; # pattern printf("%s %s: "'%s' =~ /%s/"n", ( $s =~ /a|z/ ) ? 'PASS' : 'FAIL' ,$t, $s, $p); $s = 'qrs'; printf("%s %s: "'%s' !~ /%s/"n", ( $s !~ /a|z/ ) ? 'PASS' : 'FAIL' ,$t, $s, $p); #!perl use strict; use warnings; my $t = 'Branches'; # text my $s = 'abc'; # string my $p = 'a|z'; # pattern printf("%s %s: "'%s' =~ /%s/"n", ( $s =~ /a|z/ ) ? 'PASS' : 'FAIL' ,$t, $s, $p); $s = 'qrs'; printf("%s %s: "'%s' !~ /%s/"n", ( $s !~ /a|z/ ) ? 'PASS' : 'FAIL' ,$t, $s, $p); ... code is valid in both Perl and Qore!
    • Subroutines & Closures #!qore %enable-all-warnings # defined sub sub say_hello (string $name) { printf("Hello, %s!n",$name); } # call sub say_hello("Frank"); # anonymous sub via closure my code $anonymous_sub = sub (string $name) { printf("Hello, %s!n",$name); }; $anonymous_sub("Frank"); #!perl use strict; use warnings; # defined sub sub say_hello { my $name = shift; printf("Hello, %s!n",$name); } # call sub say_hello("Frank"); # anonymous sub via closure my $anonymous_sub = sub { my $name = shift; printf("Hello, %s!n",$name); }; $anonymous_sub->("Frank");
    • Qore Subroutes & Closures ● General form is one of 2: [return_type] sub func_name([[type] variable,..]) { ... code block } OR sub func_name([[type] variable,..]) [returns return_type] { ... code block } ● Subroutines and closures also provide event handlers (inspired by D): ○ on_exit ○ on_success ○ on_exit sub myfunc() { on_exit do_x(); #subroutine called on exit, unconditionally ... code block; return ..something; }
    • Classes in Qore (w/o Perl counter example :( %require-our %enable-all-warnings class MyClass { # declare some private members private $.base1, $.x; constructor($a) { printf("Base1::constructor(%n)n", $a); $.a = $a; } destructor() { printf("Base1::destructor() (%n)n", $.a); } copy() { printf("Base1::copy() (%n)n", $.a); $.a = $.a + "-copy"; } hello() { printf("Base1 hello (%n, derived class %n)n", $.a, cast<Mid>($self).subclass()); } }
    • Qore Threading...finally ●invoked with background keyword ●%require-our to declare shares globals with "our" ○useful for implicit communication via shared memory ●use "my" to specify thread-local variables ●synchronization ○locks ○gates (recursive locks) ○conditional block ○mutex ●communication ○thread safe Queue class
    • The World says, Hello_r. #!qore %require-our %enable-all-warnings #shared, thread safe our $tcount = new Counter(); sub say_hello_r () { on_exit $tcount.dec(); my $tid = gettid(); printf("Hello! from Thread %sn",$tid); } for (my $i = 0; $i < 9; $i++) { $tcount.inc(); background say_hello_r(); } $tcount.waitForZero(); $qore ./hello_r.q Hello! from Thread 2 Hello! from Thread 3 Hello! from Thread 4 Hello! from Thread 7 Hello! from Thread 6 Hello! from Thread 10 Hello! from Thread 5 Hello! from Thread 9 Hello! from Thread 8 Hello! from Thread 11
    • ●higher level constructs, similar in spirit to OpenMP (fork/join), e.g.: ●better data environment control (private,shared,etc) ●process affinity control ●memory allocation/migration control (first touch, next touch) ●logical affine "locations" My Thread Support Wish List our $count = 0; background { critical { $count++; }; };
    • A lot more to Qore ●modules for database, XML, JSON ●interesting operators and idioms ●embeddable ●plenty of warts and room for improvement ○lacks syntactical sweetness of Perl ○higher level threading features ○needs more DWIM
    • Possible Future Talks, Discussions ●Perl's threading and asynchronous options (not me:) ●More on Qore's threading ●How to embed Qore (a design goal) ●Qore for web apps (design goal) ●Using Qore for threading in Perl - Inline::Qore, anyone? ●'Perqore' challenge, Polyglot programming with Perl & Qore ●Cray's Chapel Language - not as Perlish as Qore ●Lua - threading and coroutines ●Any D fans?
    • Qore Resources http://www.qore.org ●core language documention ●module documention ●C++ API Doxygen docs (for embedding & internals)