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
README.md. 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, 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,
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.
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
On 30/08/2022 2:38 am, ToddAndMargo via perl6-users wrote:
On 8/28/22 15:58, ToddAndMargo via perl6-users wrote:
Hi All,
I am thinking of using
BEGIN {}
to fire up a splash screen (libnotify).
Question: is what happens between the brackets
isolated from the rest of the code? If I set
variable values or declare variables, are they
wiped out, etc.?
Many thanks,
-T
My keeper on BEGIN. That you for all the help
and tips!
Perl6: BEGIN {}
BEGIN is a special subroutine that runs at compile time.
It will see any code above it, such as variables and
imported modules, but not below it.
The idea is to run something at the start of compile before
the rest of compile completes. A splash screen for example.
Perl 6's compile can take a very long time and users may not
realize it started and restart it several times.
Note that a space is required between `BEGIN and the `{}`
BEGIN {
# Splash Screen
( my $ProgramName = $?FILE ) ~~ s|.*"/"||;
my Str $NotifyStr = "\nStarting $ProgramName\n";
my Str $Icon = "/home/linuxutil/Images/Info.png";
my Str $Title = "$ProgramName Splash Screen";
my Str $Timeout = "8"; # zenity = seconds
# Note: zenity seems to not detach when run without a shell
shell "zenity --info --title \"$Title\" --text \"$NotifyStr\"
--width=220 --timeout=$Timeout &";
}
