develooper Front page | perl.perl6.users | Postings from August 2022

Re: BEGIN {} question

Thread Previous | Thread Next
ToddAndMargo via perl6-users
August 30, 2022 23:59
Re: BEGIN {} question
Message ID:
On 8/30/22 13:34, Richard Hainsworth wrote:
> Hi Todd,
> Long time no see.
> Re your 'keeper'. There is a reason why things are called the way they 
> are in Raku (aka Perl6). BEGIN is NOT a special subroutine.
> BEGIN is a phaser. And it introduces a block. Blocks are not subroutines 
> (subs). Even though blocks and subs (and methods and callables) are code 
> related things, a sub can take a signature, but a block cannot. You can 
> pass arguments to a block using pointy syntax, eg -> $x, %y {  ... }, 
> which is why it is possible to do things like 'for %some-hash.kv -> 
> $key, $value { .... }'. The 'for' takes a block, which can be pointy. 
> 'for' does not take a special subroutine.
> But a sub can have a parameter list, eg., 'sub (Int $b where *>= 10) { 
> say %b }; ' The 'where' bit means that the compiler will put in checks 
> that $b is always greater-equal to 10. So subs are far far more than 
> blocks.
> Also you cannot return from a block, but you can return from a sub.
> So, by putting in your keeper that BEGIN is a special subroutine, you 
> are ignoring a whole world of Raku goodness, as well as making it 
> difficult for yourself to understand other phasers.
> And talking of phasers, there are some really useful ones, like FIRST 
> and LAST, that are in loops. So if you want something to happen first 
> time in a loop, put it in FIRST { }.
> Also I see you are on the compile time whine again. When perl6 first 
> became available as 'pugs', it did take FOREVER. Then as more of perl6 
> became implemented as rakudo, startup times became slower.
> Things changed when modules were precompiled. I really do not understand 
> what you are talking about when you say you don't think precompile is 
> useful everywhere.
> For example, when I write something that is called from the command line 
> (for example in my raku-collection-raku-documentation distribution), I 
> have a one-liner raku program 'RakuDoc' that just says 'use 
> Collection::RakuDoc'.
> EVERYTHING else is in the module Collection::RakuDoc, all the MAIN 
> subroutines, and stuff. That then only gets compiled once. So, the first 
> time RakuDoc is called from the command line, there is a startup delay 
> because the whole module is compiled. Every other time RakuDoc is 
> called, its really so fast I don't notice a problem. Only the *one* line 
> is compiled each time the program is called. All the rest is in 
> precompiled form.
> Same with my Extractor program, which is in the raku-extraction module. 
> This is a GUI program that takes the rakudoc (aka POD6) files and 
> converts them into markdown. For example, I write the README's for my 
> github repos as README.rakudoc, then use Extractor to turn it into a 
> The result is far better because the rakudoc renderer I use 
> (from my pod-render distribution) automatically collects all the headers 
> and puts them into a Table of Contents. If you've tried to do a TOC in 
> markdown, you know what a hassle it is.
> But Extractor is a GTK::Simple program. And GTK::Simple takes forever to 
> precompile. But once done, I don't notice any startup time.
> And I change my software quite a lot, so every time I change something, 
> yes, startup is slow the first time, but not the next time. Surely, you 
> use a piece of software more than once.
> Compared to the OLD days,

Last week ?????  Chuckle.

> rakudo programs react like lightning. Design 
> your software properly, and you wont - as a human - notice much of a delay.
> I think the startup complaint (not the compile time for something) has 
> been effectively relegated to the days when rakudo was young. So whilst 
> in the past I truly sympathised with your rants about compile times, I 
> am now quite confused and I find sympathy hard to come by.
> Since you continue for ever to complain about 'compile' time issues,

"Stage parce" is specifically what I am whining about

> rather than startup times, I wonder whether the programs you write are 
> massive monolithic lines of code with thousands of lines, much like most 
> standard software when FORTRAN or COBOL were the high level languages, 
> or whether you design things to make each section more manageable.

$ raku -c --stagestats GetUpdates.pl6
Stage start : 0.000
Stage parse : 17.851
Stage syntaxcheck: Syntax OK

Perl 5 does it over 300 times faster on the code I ported

> If the programs you write to be run from the command line are thousands 
> of lines long, then yes!! you will suffer!!! from long!!!! startup times 
> because the program is re-compiled EVERY time. However, if you redesign 
> the code, putting things into classes, roles, subroutines, and Raku-y 
> goody things, you can push stuff into modules, and reduce your calling 
> program to a single line.
> When you change your software, do you change every part of it every 
> time? Or do you change some client related interface part? Put the 
> interface part into one module, and the other more stable functionality 
> into other modules. Then when you change the interface part, you dont 
> change the other modules. They have already been compiled. So the first 
> time you start up your program, only the section you have changed gets 
> recompiled, not the entire monolith.
> By the way, I assume that you understand the Raku meaning of 'module', 
> as opposed to a 'distribution'. When I write a large piece of software, 
> I may have three or four different modules under the lib/ directory. The 
> top level program (I try to make it one line only), uses one module, 
> which then may use other modules, all of them in the same directory, 
> under the lib/ subdirectory. The distribution can then also contain 
> simple tests under t/ and development tests under xt/
> Regards,
> Richard

Hi Richard,

Long time no talk to you either.  Don't be a stranger.
(If you like, I can always "whine" about compile times
to get your attention, if you like.  Chuckle.)

Thank you.  That letter took a lot of work!

How does this sound?

      BEGIN is a special block of code called a "phaser"
      that runs at compile time.  It will see any code
      above it, such as variables and  imported modules,
      but not below it.

Speaking of muscle memory, I have not programmed in Modula2
for over 30 years, but I still catch myself wanting to put BEGIN and END 
on every procedure (M2's name for subs).

Can you show me an example of FIRST and LAST

To me module means the same thing as in Modula2.  It
is a pm6 file that I import with "use".  Geez, am I
calling that wrong too?  Once compiled, it gets  stuck
in the .precomp directory.  Most of the time that
workaround will work.  Write once; debug everywhere.
Wait.  That is Java.

Where .precomp does not work for me is my software
updates program.  This is a behemoth program (imports
six of my custom modules too) that goes out and checks
for software updates that I support at my customer
sites.  it is about 70 programs.

To do this open the web site with firefox.  Then I
use their developer's tools to examine the page's
source code.  I find the fragment I am looking
for and regex them to extract them.

In the process, I goof the regex/s "A LOT".  Not
to mention  having to chase down hidden character
that do not appear in Firefox's page source.
And download that are different on a web browser
than with curl.

I do have a function that allows me to only run that
one web site's extraction, so I do not have to go
through all 70 of them.

So, I have to recompile the code maybe up to 20 times
depending on the difficulty of the web site.  The
L-O-N-G delays drives me nuts.

    if $PageStatus ne 0  {
       $Status +|= %StatusHash<DOWNLOAD_FAIL>;
       PrintRedErr( "$SubName: failed to download <$WebSite>\n" );

    } else {
         # spurt "eraseme.html", $WebPage;
         #  <h2>Windows</h2>
         #  <p><a 
title='Microsoft Windows'>darktable-3.6.1-win64.exe</a></p>

       $ClickHere  = $WebPage;
       $ClickHere ~~ s/ .* '<h2>Windows</h2>' //;
       $ClickHere ~~ s/ .*? 'http' /http/;
       $ClickHere ~~ s/ '.exe' .* /.exe/;

       $NewRev  = $ClickHere;
       $NewRev ~~ s/ .* 'darktable-' //;
       $NewRev ~~ s/ '-win64.exe' .* //;

       if $Debug  { PrintBlue "$SubName: Click Here = <$ClickHere>\n 
           NewRev = <$NewRev>\n\n"; }

It is especially annoying when I get the .* in the
wrong position or I forget the ? on .*?.  The goof ups
are prodigious.  And not to mention the web site
changing all the time.

Was it you that told me how to use Q[] inside a
regex.  If it was, you are my hero!

So .precomp is not always practical.

Speaking of BEGIN, is this Raku's "parallel
processing" method?  Does Raku have a way to
spawn parallel processes and have them talk to
each other?


Thread Previous | Thread Next Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at | Group listing | About