PERLRUN
Section: Perl Programmers Reference Guide (1)Updated: 2009-07-26
Index Return to Main Contents
NAME
perlrun - how to execute the Perl interpreterSYNOPSIS
perl [ -sTtuUWX ][ -hv ] [ -V[:configvar] ]
[ -cw ] [ -d[t][:debugger] ] [ -D[number/list] ]
[ -pna ] [ -Fpattern ] [ -l[octal] ] [ -0[octal/hexadecimal] ]
[ -Idir ] [ -m[-]module ] [ -M[-]'module...' ] [ -f ]
[ -C [number/list] ]
[ -P ]
[ -S ]
[ -x[dir] ]
[ -i[extension] ]
[ [-e|-E] 'command' ] [ -- ] [ programfile ] [ argument ]...
DESCRIPTION
The normal way to run a Perl program is by making it directly executable, or else by passing the name of the source file as an argument on the command line. (An interactive Perl environment is also possible---see perldebug for details on how to do that.) Upon startup, Perl looks for your program in one of the following places:- 1.
- Specified line by line via -e or -E switches on the command line.
- 2.
- Contained in the file specified by the first filename on the command line. (Note that systems supporting the #! notation invoke interpreters this way. See ``Location of Perl''.)
- 3.
- Passed in implicitly via standard input. This works only if there are no filename arguments---to pass arguments to a STDIN-read program you must explicitly specify a ``-'' for the program name.
With methods 2 and 3, Perl starts parsing the input file from the beginning, unless you've specified a -x switch, in which case it scans for the first line starting with #! and containing the word ``perl'', and starts there instead. This is useful for running a program embedded in a larger message. (In this case you would indicate the end of the program using the "__END__" token.)
The #! line is always examined for switches as the line is being parsed. Thus, if you're on a machine that allows only one argument with the #! line, or worse, doesn't even recognize the #! line, you still can get consistent switch behavior regardless of how Perl was invoked, even if -x was used to find the beginning of the program.
Because historically some operating systems silently chopped off kernel interpretation of the #! line after 32 characters, some switches may be passed in on the command line, and some may not; you could even get a ``-'' without its letter, if you're not careful. You probably want to make sure that all your switches fall either before or after that 32-character boundary. Most switches don't actually care if they're processed redundantly, but getting a ``-'' instead of a complete switch could cause Perl to try to execute standard input instead of your program. And a partial -I switch could also cause odd results.
Some switches do care if they are processed twice, for instance combinations of -l and -0. Either put all the switches after the 32-character boundary (if applicable), or replace the use of -0digits by "BEGIN{ $/ = "\0digits"; }".
Parsing of the #! switches starts wherever ``perl'' is mentioned in the line. The sequences ``-*'' and ``- '' are specifically ignored so that you could, if you were so inclined, say
#!/bin/sh #! -*-perl-*- eval 'exec perl -x -wS $0 ${1+"$@"}' if 0;
to let Perl see the -p switch.
A similar trick involves the env program, if you have it.
#!/usr/bin/env perl
The examples above use a relative path to the perl interpreter, getting whatever version is first in the user's path. If you want a specific version of Perl, say, perl5.005_57, you should place that directly in the #! line's path.
If the #! line does not contain the word ``perl'', the program named after the #! is executed instead of the Perl interpreter. This is slightly bizarre, but it helps people on machines that don't do #!, because they can tell a program that their SHELL is /usr/bin/perl, and Perl will then dispatch the program to the correct interpreter for them.
After locating your program, Perl compiles the entire program to an internal form. If there are any compilation errors, execution of the program is not attempted. (This is unlike the typical shell script, which might run part-way through before finding a syntax error.)
If the program is syntactically correct, it is executed. If the program runs off the end without hitting an exit() or die() operator, an implicit exit(0) is provided to indicate successful completion.
#! and quoting on non-Unix systems
Unix's #! technique can be simulated on other systems:- OS/2
-
Put
extproc perl -S -your_switches
as the first line in "*.cmd" file (-S due to a bug in cmd.exe's `extproc' handling).
- MS-DOS
- Create a batch file to run your program, and codify it in "ALTERNATE_SHEBANG" (see the dosish.h file in the source distribution for more information).
- Win95/NT
- The Win95/NT installation, when using the ActiveState installer for Perl, will modify the Registry to associate the .pl extension with the perl interpreter. If you install Perl by other means (including building from the sources), you may have to modify the Registry yourself. Note that this means you can no longer tell the difference between an executable Perl program and a Perl library file.
- Macintosh
- Under ``Classic'' MacOS, a perl program will have the appropriate Creator and Type, so that double-clicking them will invoke the MacPerl application. Under Mac OS X, clickable apps can be made from any "#!" script using Wil Sanchez' DropScript utility: http://www.wsanchez.net/software/ .
- VMS
-
Put
$ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' ! $ exit++ + ++$status != 0 and $exit = $status = undef;
at the top of your program, where -mysw are any command line switches you want to pass to Perl. You can now invoke the program directly, by saying "perl program", or as a DCL procedure, by saying @program (or implicitly via DCL$PATH by just using the name of the program).
This incantation is a bit much to remember, but Perl will display it for you if you say "perl "-V:startperl"".
Command-interpreters on non-Unix systems have rather different ideas on quoting than Unix shells. You'll need to learn the special characters in your command-interpreter ("*", "\" and """ are common) and how to protect whitespace and these characters to run one-liners (see -e below).
On some systems, you may have to change single-quotes to double ones, which you must not do on Unix or Plan 9 systems. You might also have to change a single % to a %%.
For example:
# Unix perl -e 'print "Hello world\n"' # MS-DOS, etc. perl -e "print \"Hello world\n\"" # Macintosh print "Hello world\n" (then Run "Myscript" or Shift-Command-R) # VMS perl -e "print ""Hello world\n"""
The problem is that none of this is reliable: it depends on the command and it is entirely possible neither works. If 4DOS were the command shell, this would probably work better:
perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
CMD.EXE in Windows NT slipped a lot of standard Unix functionality in when nobody was looking, but just try to find documentation for its quoting rules.
Under the Macintosh, it depends which environment you are using. The MacPerl shell, or MPW, is much like Unix shells in its support for several quoting variants, except that it makes free use of the Macintosh's non-ASCII characters as control characters.
There is no general solution to all of this. It's just a mess.
Location of Perl
It may seem obvious to say, but Perl is useful only when users can easily find it. When possible, it's good for both /usr/bin/perl and /usr/local/bin/perl to be symlinks to the actual binary. If that can't be done, system administrators are strongly encouraged to put (symlinks to) perl and its accompanying utilities into a directory typically found along a user's PATH, or in some other obvious and convenient place.In this documentation, "#!/usr/bin/perl" on the first line of the program will stand in for whatever method works on your system. You are advised to use a specific path if you care about a specific version.
#!/usr/local/bin/perl5.00554
or if you just want to be running at least version, place a statement like this at the top of your program:
use 5.005_54;
Command Switches
As with all standard commands, a single-character switch may be clustered with the following switch, if any.
#!/usr/bin/perl -spi.orig # same as -s -p -i.orig
Switches include:
- -0[octal/hexadecimal]
-
specifies the input record separator ($/) as an octal or
hexadecimal number. If there are no digits, the null character is the
separator. Other switches may precede or follow the digits. For
example, if you have a version of find which can print filenames
terminated by the null character, you can say this:
find . -name '*.orig' -print0 | perl -n0e unlink
The special value 00 will cause Perl to slurp files in paragraph mode. The value 0777 will cause Perl to slurp files whole because there is no legal byte with that value.
If you want to specify any Unicode character, use the hexadecimal format: "-0xHHH...", where the "H" are valid hexadecimal digits. (This means that you cannot use the "-x" with a directory name that consists of hexadecimal digits.)
- -a
-
turns on autosplit mode when used with a -n or -p. An implicit
split command to the @F array is done as the first thing inside the
implicit while loop produced by the -n or -p.
perl -ane 'print pop(@F), "\n";'
is equivalent to
while (<>) { @F = split(' '); print pop(@F), "\n"; }
An alternate delimiter may be specified using -F.
- -C [number/list]
-
The "-C" flag controls some of the Perl Unicode features.
As of 5.8.1, the "-C" can be followed either by a number or a list of option letters. The letters, their numeric values, and effects are as follows; listing the letters is equal to summing the numbers.
I 1 STDIN is assumed to be in UTF-8 O 2 STDOUT will be in UTF-8 E 4 STDERR will be in UTF-8 S 7 I + O + E i 8 UTF-8 is the default PerlIO layer for input streams o 16 UTF-8 is the default PerlIO layer for output streams D 24 i + o A 32 the @ARGV elements are expected to be strings encoded in UTF-8 L 64 normally the "IOEioA" are unconditional, the L makes them conditional on the locale environment variables (the LC_ALL, LC_TYPE, and LANG, in the order of decreasing precedence) -- if the variables indicate UTF-8, then the selected "IOEioA" are in effect a 256 Set ${^UTF8CACHE} to -1, to run the UTF-8 caching code in debugging mode.
For example, "-COE" and "-C6" will both turn on UTF-8-ness on both STDOUT and STDERR. Repeating letters is just redundant, not cumulative nor toggling.
The "io" options mean that any subsequent open() (or similar I/O operations) will have the ":utf8" PerlIO layer implicitly applied to them, in other words, UTF-8 is expected from any input stream, and UTF-8 is produced to any output stream. This is just the default, with explicit layers in open() and with binmode() one can manipulate streams as usual.
"-C" on its own (not followed by any number or option list), or the empty string "" for the "PERL_UNICODE" environment variable, has the same effect as "-CSDL". In other words, the standard I/O handles and the default "open()" layer are UTF-8-fied but only if the locale environment variables indicate a UTF-8 locale. This behaviour follows the implicit (and problematic) UTF-8 behaviour of Perl 5.8.0.
You can use "-C0" (or "0" for "PERL_UNICODE") to explicitly disable all the above Unicode features.
The read-only magic variable "${^UNICODE}" reflects the numeric value of this setting. This is variable is set during Perl startup and is thereafter read-only. If you want runtime effects, use the three-arg open() (see ``open'' in perlfunc), the two-arg binmode() (see ``binmode'' in perlfunc), and the "open" pragma (see open).
(In Perls earlier than 5.8.1 the "-C" switch was a Win32-only switch that enabled the use of Unicode-aware ``wide system call'' Win32 APIs. This feature was practically unused, however, and the command line switch was therefore ``recycled''.)
Note: Since perl 5.10.1, if the -C option is used on the #! line, it must be specified on the command line as well, since the standard streams are already set up at this point in the execution of the perl interpreter. You can also use binmode() to set the encoding of an I/O stream.
- -c
- causes Perl to check the syntax of the program and then exit without executing it. Actually, it will execute "BEGIN", "UNITCHECK", "CHECK", and "use" blocks, because these are considered as occurring outside the execution of your program. "INIT" and "END" blocks, however, will be skipped.
- -d
- -dt
- runs the program under the Perl debugger. See perldebug. If t is specified, it indicates to the debugger that threads will be used in the code being debugged.
- -d:foo[=bar,baz]
- -dt:foo[=bar,baz]
- runs the program under the control of a debugging, profiling, or tracing module installed as Devel::foo. E.g., -d:DProf executes the program using the Devel::DProf profiler. As with the -M flag, options may be passed to the Devel::foo package where they will be received and interpreted by the Devel::foo::import routine. The comma-separated list of options must follow a "=" character. If t is specified, it indicates to the debugger that threads will be used in the code being debugged. See perldebug.
- -Dletters
- -Dnumber
-
sets debugging flags. To watch how it executes your program, use
-Dtls. (This works only if debugging is compiled into your
Perl.) Another nice value is -Dx, which lists your compiled
syntax tree. And -Dr displays compiled regular expressions;
the format of the output is explained in perldebguts.
As an alternative, specify a number instead of list of letters (e.g., -D14 is equivalent to -Dtls):
1 p Tokenizing and parsing (with v, displays parse stack) 2 s Stack snapshots (with v, displays all stacks) 4 l Context (loop) stack processing 8 t Trace execution 16 o Method and overloading resolution 32 c String/numeric conversions 64 P Print profiling info, preprocessor command for -P, source file input state 128 m Memory and SV allocation 256 f Format processing 512 r Regular expression parsing and execution 1024 x Syntax tree dump 2048 u Tainting checks 4096 U Unofficial, User hacking (reserved for private, unreleased use) 8192 H Hash dump -- usurps values() 16384 X Scratchpad allocation 32768 D Cleaning up 65536 S Thread synchronization 131072 T Tokenising 262144 R Include reference counts of dumped variables (eg when using -Ds) 524288 J Do not s,t,P-debug (Jump over) opcodes within package DB 1048576 v Verbose: use in conjunction with other flags 2097152 C Copy On Write 4194304 A Consistency checks on internal structures 8388608 q quiet - currently only suppresses the "EXECUTING" message
All these flags require -DDEBUGGING when you compile the Perl executable (but see Devel::Peek, re which may change this). See the INSTALL file in the Perl source distribution for how to do this. This flag is automatically set if you include -g option when "Configure" asks you about optimizer/debugger flags.
If you're just trying to get a print out of each line of Perl code as it executes, the way that "sh -x" provides for shell scripts, you can't use Perl's -D switch. Instead do this
# If you have "env" utility env PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program # Bourne shell syntax $ PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program # csh syntax % (setenv PERLDB_OPTS "NonStop=1 AutoTrace=1 frame=2"; perl -dS program)
See perldebug for details and variations.
- -e commandline
- may be used to enter one line of program. If -e is given, Perl will not look for a filename in the argument list. Multiple -e commands may be given to build up a multi-line script. Make sure to use semicolons where you would in a normal program.
- -E commandline
- behaves just like -e, except that it implicitly enables all optional features (in the main compilation unit). See feature.
- -f
-
Disable executing $Config{sitelib}/sitecustomize.pl at startup.
Perl can be built so that it by default will try to execute $Config{sitelib}/sitecustomize.pl at startup (in a BEGIN block). This is a hook that allows the sysadmin to customize how perl behaves. It can for instance be used to add entries to the @INC array to make perl find modules in non-standard locations.
- -Fpattern
- specifies the pattern to split on if -a is also in effect. The pattern may be surrounded by "//", "", or '', otherwise it will be put in single quotes. You can't use literal whitespace in the pattern.
- -h
- prints a summary of the options.
- -i[extension]
-
specifies that files processed by the "<>" construct are to be
edited in-place. It does this by renaming the input file, opening the
output file by the original name, and selecting that output file as the
default for print() statements. The extension, if supplied, is used to
modify the name of the old file to make a backup copy, following these
rules:
If no extension is supplied, no backup is made and the current file is overwritten.
If the extension doesn't contain a "*", then it is appended to the end of the current filename as a suffix. If the extension does contain one or more "*" characters, then each "*" is replaced with the current filename. In Perl terms, you could think of this as:
($backup = $extension) =~ s/\*/$file_name/g;
This allows you to add a prefix to the backup file, instead of (or in addition to) a suffix:
$ perl -pi'orig_*' -e 's/bar/baz/' fileA # backup to 'orig_fileA'
Or even to place backup copies of the original files into another directory (provided the directory already exists):
$ perl -pi'old/*.orig' -e 's/bar/baz/' fileA # backup to 'old/fileA.orig'
These sets of one-liners are equivalent:
$ perl -pi -e 's/bar/baz/' fileA # overwrite current file $ perl -pi'*' -e 's/bar/baz/' fileA # overwrite current file $ perl -pi'.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig' $ perl -pi'*.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig'
From the shell, saying
$ perl -p -i.orig -e "s/foo/bar/; ... "
is the same as using the program:
#!/usr/bin/perl -pi.orig s/foo/bar/;
which is equivalent to
#!/usr/bin/perl $extension = '.orig'; LINE: while (<>) { if ($ARGV ne $oldargv) { if ($extension !~ /\*/) { $backup = $ARGV . $extension; } else { ($backup = $extension) =~ s/\*/$ARGV/g; } rename($ARGV, $backup); open(ARGVOUT, ">$ARGV"); select(ARGVOUT); $oldargv = $ARGV; } s/foo/bar/; } continue { print; # this prints to original filename } select(STDOUT);
except that the -i form doesn't need to compare $ARGV to $oldargv to know when the filename has changed. It does, however, use ARGVOUT for the selected filehandle. Note that STDOUT is restored as the default output filehandle after the loop.
As shown above, Perl creates the backup file whether or not any output is actually changed. So this is just a fancy way to copy files:
$ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3... or $ perl -p -i'.orig' -e 1 file1 file2 file3...
You can use "eof" without parentheses to locate the end of each input file, in case you want to append to each file, or reset line numbering (see example in ``eof'' in perlfunc).
If, for a given file, Perl is unable to create the backup file as specified in the extension then it will skip that file and continue on with the next one (if it exists).
For a discussion of issues surrounding file permissions and -i, see ``Why does Perl let me delete read-only files? Why does -i clobber protected files? Isn't this a bug in Perl?'' in perlfaq5.
You cannot use -i to create directories or to strip extensions from files.
Perl does not expand "~" in filenames, which is good, since some folks use it for their backup files:
$ perl -pi~ -e 's/foo/bar/' file1 file2 file3...
Note that because -i renames or deletes the original file before creating a new file of the same name, UNIX-style soft and hard links will not be preserved.
Finally, the -i switch does not impede execution when no files are given on the command line. In this case, no backup is made (the original file cannot, of course, be determined) and processing proceeds from STDIN to STDOUT as might be expected.
- -Idirectory
- Directories specified by -I are prepended to the search path for modules (@INC), and also tells the C preprocessor where to search for include files. The C preprocessor is invoked with -P; by default it searches /usr/include and /usr/lib/perl.
- -l[octnum]
-
enables automatic line-ending processing. It has two separate
effects. First, it automatically chomps $/ (the input record
separator) when used with -n or -p. Second, it assigns "$\"
(the output record separator) to have the value of octnum so
that any print statements will have that separator added back on.
If octnum is omitted, sets "$\" to the current value of
$/. For instance, to trim lines to 80 columns:
perl -lpe 'substr($_, 80) = ""'
Note that the assignment "$\ = $/" is done when the switch is processed, so the input record separator can be different than the output record separator if the -l switch is followed by a -0 switch:
gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
This sets "$\" to newline and then sets $/ to the null character.
- -m[-]module
- -M[-]module
- -M[-]'module ...'
- -[mM][-]module=arg[,arg]...
-
-mmodule executes "use" module "();" before executing your
program.
-Mmodule executes "use" module ";" before executing your program. You can use quotes to add extra code after the module name, e.g., '-Mmodule qw(foo bar)'.
If the first character after the -M or -m is a dash ("-") then the 'use' is replaced with 'no'.
A little builtin syntactic sugar means you can also say -mmodule=foo,bar or -Mmodule=foo,bar as a shortcut for '-Mmodule qw(foo bar)'. This avoids the need to use quotes when importing symbols. The actual code generated by -Mmodule=foo,bar is "use module split(/,/,q{foo,bar})". Note that the "=" form removes the distinction between -m and -M.
A consequence of this is that -MFoo=number never does a version check (unless "Foo::import()" itself is set up to do a version check, which could happen for example if Foo inherits from Exporter.)
- -n
-
causes Perl to assume the following loop around your program, which
makes it iterate over filename arguments somewhat like sed -n or
awk:
LINE: while (<>) { ... # your program goes here }
Note that the lines are not printed by default. See -p to have lines printed. If a file named by an argument cannot be opened for some reason, Perl warns you about it and moves on to the next file.
Also note that "<>" passes command line arguments to ``open'' in perlfunc, which doesn't necessarily interpret them as file names. See perlop for possible security implications.
Here is an efficient way to delete all files that haven't been modified for at least a week:
find . -mtime +7 -print | perl -nle unlink
This is faster than using the -exec switch of find because you don't have to start a process on every filename found. It does suffer from the bug of mishandling newlines in pathnames, which you can fix if you follow the example under -0.
"BEGIN" and "END" blocks may be used to capture control before or after the implicit program loop, just as in awk.
- -p
-
causes Perl to assume the following loop around your program, which
makes it iterate over filename arguments somewhat like sed:
LINE: while (<>) { ... # your program goes here } continue { print or die "-p destination: $!\n"; }
If a file named by an argument cannot be opened for some reason, Perl warns you about it, and moves on to the next file. Note that the lines are printed automatically. An error occurring during printing is treated as fatal. To suppress printing use the -n switch. A -p overrides a -n switch.
"BEGIN" and "END" blocks may be used to capture control before or after the implicit loop, just as in awk.
- -P
-
NOTE: Use of -P is strongly discouraged because of its inherent
problems, including poor portability. It is deprecated and will be
removed in a future version of Perl.
This option causes your program to be run through the C preprocessor before compilation by Perl. Because both comments and cpp directives begin with the # character, you should avoid starting comments with any words recognized by the C preprocessor such as "if", "else", or "define".
If you're considering using "-P", you might also want to look at the Filter::cpp module from CPAN.
The problems of -P include, but are not limited to:
-
- *
- The "#!" line is stripped, so any switches there don't apply.
- *
- A "-P" on a "#!" line doesn't work.
- *
- All lines that begin with (whitespace and) a "#" but do not look like cpp commands, are stripped, including anything inside Perl strings, regular expressions, and here-docs .
- *
-
In some platforms the C preprocessor knows too much: it knows about
the C++ -style until-end-of-line comments starting with "//".
This will cause problems with common Perl constructs like
s/foo//;
because after -P this will became illegal code
s/foo
The workaround is to use some other quoting separator than "/", like for example "!":
s!foo!!;
- *
- It requires not only a working C preprocessor but also a working sed. If not on UNIX, you are probably out of luck on this.
- *
- Script line numbers are not preserved.
- *
- The "-x" does not work with "-P".
-
- -s
-
enables rudimentary switch parsing for switches on the command
line after the program name but before any filename arguments (or before
an argument of --). Any switch found there is removed from @ARGV and sets the
corresponding variable in the Perl program. The following program
prints ``1'' if the program is invoked with a -xyz switch, and ``abc''
if it is invoked with -xyz=abc.
#!/usr/bin/perl -s if ($xyz) { print "$xyz\n" }
Do note that a switch like --help creates the variable ${-help}, which is not compliant with "strict refs". Also, when using this option on a script with warnings enabled you may get a lot of spurious ``used only once'' warnings.
- -S
-
makes Perl use the PATH environment variable to search for the
program (unless the name of the program contains directory separators).
On some platforms, this also makes Perl append suffixes to the filename while searching for it. For example, on Win32 platforms, the ``.bat'' and ``.cmd'' suffixes are appended if a lookup for the original name fails, and if the name does not already end in one of those suffixes. If your Perl was compiled with DEBUGGING turned on, using the -Dp switch to Perl shows how the search progresses.
Typically this is used to emulate #! startup on platforms that don't support #!. Its also convenient when debugging a script that uses #!, and is thus normally found by the shell's $PATH search mechanism.
This example works on many platforms that have a shell compatible with Bourne shell:
#!/usr/bin/perl eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}' if $running_under_some_shell;
The system ignores the first line and feeds the program to /bin/sh, which proceeds to try to execute the Perl program as a shell script. The shell executes the second line as a normal shell command, and thus starts up the Perl interpreter. On some systems $0 doesn't always contain the full pathname, so the -S tells Perl to search for the program if necessary. After Perl locates the program, it parses the lines and ignores them because the variable $running_under_some_shell is never true. If the program will be interpreted by csh, you will need to replace "${1+"$@"}" with $*, even though that doesn't understand embedded spaces (and such) in the argument list. To start up sh rather than csh, some systems may have to replace the #! line with a line containing just a colon, which will be politely ignored by Perl. Other systems can't control that, and need a totally devious construct that will work under any of csh, sh, or Perl, such as the following:
eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}' & eval 'exec /usr/bin/perl -wS $0 $argv:q' if $running_under_some_shell;
If the filename supplied contains directory separators (i.e., is an absolute or relative pathname), and if that file is not found, platforms that append file extensions will do so and try to look for the file with those extensions added, one by one.
On DOS-like platforms, if the program does not contain directory separators, it will first be searched for in the current directory before being searched for on the PATH. On Unix platforms, the program will be searched for strictly on the PATH.
- -t
-
Like -T, but taint checks will issue warnings rather than fatal
errors. These warnings can be controlled normally with "no warnings
qw(taint)".
NOTE: this is not a substitute for -T. This is meant only to be used as a temporary development aid while securing legacy code: for real production code and for new secure code written from scratch always use the real -T.
- -T
- forces ``taint'' checks to be turned on so you can test them. Ordinarily these checks are done only when running setuid or setgid. It's a good idea to turn them on explicitly for programs that run on behalf of someone else whom you might not necessarily trust, such as CGI programs or any internet servers you might write in Perl. See perlsec for details. For security reasons, this option must be seen by Perl quite early; usually this means it must appear early on the command line or in the #! line for systems which support that construct.
- -u
- This obsolete switch causes Perl to dump core after compiling your program. You can then in theory take this core dump and turn it into an executable file by using the undump program (not supplied). This speeds startup at the expense of some disk space (which you can minimize by stripping the executable). (Still, a ``hello world'' executable comes out to about 200K on my machine.) If you want to execute a portion of your program before dumping, use the dump() operator instead. Note: availability of undump is platform specific and may not be available for a specific port of Perl.
- -U
- allows Perl to do unsafe operations. Currently the only ``unsafe'' operations are attempting to unlink directories while running as superuser, and running setuid programs with fatal taint checks turned into warnings. Note that the -w switch (or the $^W variable) must be used along with this option to actually generate the taint-check warnings.
- -v
- prints the version and patchlevel of your perl executable.
- -V
- prints summary of the major perl configuration values and the current values of @INC.
- -V:configvar
-
Prints to STDOUT the value of the named configuration variable(s),
with multiples when your configvar argument looks like a regex (has
non-letters). For example:
$ perl -V:libc libc='/lib/libc-2.2.4.so'; $ perl -V:lib. libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc'; libc='/lib/libc-2.2.4.so'; $ perl -V:lib.* libpth='/usr/local/lib /lib /usr/lib'; libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc'; lib_ext='.a'; libc='/lib/libc-2.2.4.so'; libperl='libperl.a'; ....
Additionally, extra colons can be used to control formatting. A trailing colon suppresses the linefeed and terminator ';', allowing you to embed queries into shell commands. (mnemonic: PATH separator ':'.)
$ echo "compression-vars: " `perl -V:z.*: ` " are here !" compression-vars: zcat='' zip='zip' are here !
A leading colon removes the 'name=' part of the response, this allows you to map to the name you need. (mnemonic: empty label)
$ echo "goodvfork="`./perl -Ilib -V::usevfork` goodvfork=false;
Leading and trailing colons can be used together if you need positional parameter values without the names. Note that in the case below, the PERL_API params are returned in alphabetical order.
$ echo building_on `perl -V::osname: -V::PERL_API_.*:` now building_on 'linux' '5' '1' '9' now
- -w
-
prints warnings about dubious constructs, such as variable names
that are mentioned only once and scalar variables that are used
before being set, redefined subroutines, references to undefined
filehandles or filehandles opened read-only that you are attempting
to write on, values used as a number that don't look like numbers,
using an array as though it were a scalar, if your subroutines
recurse more than 100 deep, and innumerable other things.
This switch really just enables the internal $^W variable. You can disable or promote into fatal errors specific warnings using "__WARN__" hooks, as described in perlvar and ``warn'' in perlfunc. See also perldiag and perltrap. A new, fine-grained warning facility is also available if you want to manipulate entire classes of warnings; see warnings or perllexwarn.
- -W
- Enables all warnings regardless of "no warnings" or $^W. See perllexwarn.
- -X
- Disables all warnings regardless of "use warnings" or $^W. See perllexwarn.
- -x
- -xdirectory
-
tells Perl that the program is embedded in a larger chunk of unrelated
ASCII text, such as in a mail message. Leading garbage will be
discarded until the first line that starts with #! and contains the
string ``perl''. Any meaningful switches on that line will be applied.
All references to line numbers by the program (warnings, errors, ...) will treat the #! line as the first line. Thus a warning on the 2nd line of the program (which is on the 100th line in the file) will be reported as line 2, and not as line 100. This can be overridden by using the #line directive. (See ``Plain-Old-Comments-(Not!)'' in perlsyn)
If a directory name is specified, Perl will switch to that directory before running the program. The -x switch controls only the disposal of leading garbage. The program must be terminated with "__END__" if there is trailing garbage to be ignored (the program can process any or all of the trailing garbage via the DATA filehandle if desired).
The directory, if specified, must appear immediately following the -x with no intervening whitespace.
ENVIRONMENT
- HOME
- Used if chdir has no argument.
- LOGDIR
- Used if chdir has no argument and HOME is not set.
- PATH
- Used in executing subprocesses, and in finding the program if -S is used.
- PERL5LIB
-
A list of directories in which to look for Perl library
files before looking in the standard library and the current
directory. Any architecture-specific directories under the specified
locations are automatically included if they exist (this lookup
being done at interpreter startup time.)
If PERL5LIB is not defined, PERLLIB is used. Directories are separated (like in PATH) by a colon on unixish platforms and by a semicolon on Windows (the proper path separator being given by the command "perl -V:path_sep").
When running taint checks (either because the program was running setuid or setgid, or the -T or -t switch was specified), neither variable is used. The program should instead say:
use lib "/my/directory";
- PERL5OPT
- Command-line options (switches). Switches in this variable are taken as if they were on every Perl command line. Only the -[CDIMUdmtw] switches are allowed. When running taint checks (because the program was running setuid or setgid, or the -T switch was used), this variable is ignored. If PERL5OPT begins with -T, tainting will be enabled, and any subsequent options ignored.
- PERLIO
-
A space (or colon) separated list of PerlIO layers. If perl is built
to use PerlIO system for IO (the default) these layers effect perl's IO.
It is conventional to start layer names with a colon e.g. ":perlio" to emphasise their similarity to variable ``attributes''. But the code that parses layer specification strings (which is also used to decode the PERLIO environment variable) treats the colon as a separator.
An unset or empty PERLIO is equivalent to the default set of layers for your platform, for example ":unix:perlio" on UNIX-like systems and ":unix:crlf" on Windows and other DOS-like systems.
The list becomes the default for all perl's IO. Consequently only built-in layers can appear in this list, as external layers (such as :encoding()) need IO in order to load them!. See ``open pragma'' for how to add external encodings as defaults.
The layers that it makes sense to include in the PERLIO environment variable are briefly summarised below. For more details see PerlIO.
-
- :bytes
- A pseudolayer that turns off the ":utf8" flag for the layer below. Unlikely to be useful on its own in the global PERLIO environment variable. You perhaps were thinking of ":crlf:bytes" or ":perlio:bytes".
- :crlf
- A layer which does CRLF to ``\n'' translation distinguishing ``text'' and ``binary'' files in the manner of MS-DOS and similar operating systems. (It currently does not mimic MS-DOS as far as treating of Control-Z as being an end-of-file marker.)
- :mmap
- A layer which implements ``reading'' of files by using "mmap()" to make (whole) file appear in the process's address space, and then using that as PerlIO's ``buffer''.
- :perlio
- This is a re-implementation of ``stdio-like'' buffering written as a PerlIO ``layer''. As such it will call whatever layer is below it for its operations (typically ":unix").
- :pop
- An experimental pseudolayer that removes the topmost layer. Use with the same care as is reserved for nitroglycerin.
- :raw
-
A pseudolayer that manipulates other layers. Applying the ":raw"
layer is equivalent to calling "binmode($fh)". It makes the stream
pass each byte as-is without any translation. In particular CRLF
translation, and/or :utf8 intuited from locale are disabled.
Unlike in the earlier versions of Perl ":raw" is not just the inverse of ":crlf" - other layers which would affect the binary nature of the stream are also removed or disabled.
- :stdio
- This layer provides PerlIO interface by wrapping system's ANSI C ``stdio'' library calls. The layer provides both buffering and IO. Note that ":stdio" layer does not do CRLF translation even if that is platforms normal behaviour. You will need a ":crlf" layer above it to do that.
- :unix
- Low level layer which calls "read", "write" and "lseek" etc.
- :utf8
- A pseudolayer that turns on a flag on the layer below to tell perl that output should be in utf8 and that input should be regarded as already in valid utf8 form. It does not check for validity and as such should be handled with caution for input. Generally ":encoding(utf8)" is the best option when reading UTF-8 encoded data.
- :win32
- On Win32 platforms this experimental layer uses native ``handle'' IO rather than unix-like numeric file descriptor layer. Known to be buggy in this release.
-
On all platforms the default set of layers should give acceptable results.
For UNIX platforms that will equivalent of ``unix perlio'' or ``stdio''. Configure is setup to prefer ``stdio'' implementation if system's library provides for fast access to the buffer, otherwise it uses the ``unix perlio'' implementation.
On Win32 the default in this release is ``unix crlf''. Win32's ``stdio'' has a number of bugs/mis-features for perl IO which are somewhat C compiler vendor/version dependent. Using our own "crlf" layer as the buffer avoids those issues and makes things more uniform. The "crlf" layer provides CRLF to/from ``\n'' conversion as well as buffering.
This release uses "unix" as the bottom layer on Win32 and so still uses C compiler's numeric file descriptor routines. There is an experimental native "win32" layer which is expected to be enhanced and should eventually be the default under Win32.
The PERLIO environment variable is completely ignored when perl is run in taint mode.
-
- PERLIO_DEBUG
-
If set to the name of a file or device then certain operations of PerlIO
sub-system will be logged to that file (opened as append). Typical uses
are UNIX:
PERLIO_DEBUG=/dev/tty perl script ...
and Win32 approximate equivalent:
set PERLIO_DEBUG=CON perl script ...
This functionality is disabled for setuid scripts and for scripts run with -T.
- PERLLIB
-
A list of directories in which to look for Perl library
files before looking in the standard library and the current directory.
If PERL5LIB is defined, PERLLIB is not used.
The PERLLIB environment variable is completely ignored when perl is run in taint mode.
- PERL5DB
-
The command used to load the debugger code. The default is:
BEGIN { require 'perl5db.pl' }
The PERL5DB environment variable only used when perl is started with a bare -d switch.
- PERL5DB_THREADED
- If set to a true value, indicates to the debugger that the code being debugged uses threads.
- PERL5SHELL (specific to the Win32 port)
-
May be set to an alternative shell that perl must use internally for
executing ``backtick'' commands or system(). Default is "cmd.exe /x/d/c"
on WindowsNT and "command.com /c" on Windows95. The value is considered
to be space-separated. Precede any character that needs to be protected
(like a space or backslash) with a backslash.
Note that Perl doesn't use COMSPEC for this purpose because COMSPEC has a high degree of variability among users, leading to portability concerns. Besides, perl can use a shell that may not be fit for interactive use, and setting COMSPEC to such a shell may interfere with the proper functioning of other programs (which usually look in COMSPEC to find a shell fit for interactive use).
Before Perl 5.10.0 and 5.8.8, PERL5SHELL was not taint checked when running external commands. It is recommended that you explicitly set (or delete) $ENV{PERL5SHELL} when running in taint mode under Windows.
- PERL_ALLOW_NON_IFS_LSP (specific to the Win32 port)
- Set to 1 to allow the use of non-IFS compatible LSP's. Perl normally searches for an IFS-compatible LSP because this is required for its emulation of Windows sockets as real filehandles. However, this may cause problems if you have a firewall such as McAfee Guardian which requires all applications to use its LSP which is not IFS-compatible, because clearly Perl will normally avoid using such an LSP. Setting this environment variable to 1 means that Perl will simply use the first suitable LSP enumerated in the catalog, which keeps McAfee Guardian happy (and in that particular case Perl still works too because McAfee Guardian's LSP actually plays some other games which allow applications requiring IFS compatibility to work).
- PERL_DEBUG_MSTATS
- Relevant only if perl is compiled with the malloc included with the perl distribution (that is, if "perl -V:d_mymalloc" is 'define'). If set, this causes memory statistics to be dumped after execution. If set to an integer greater than one, also causes memory statistics to be dumped after compilation.
- PERL_DESTRUCT_LEVEL
- Relevant only if your perl executable was built with -DDEBUGGING, this controls the behavior of global destruction of objects and other references. See ``PERL_DESTRUCT_LEVEL'' in perlhack for more information.
- PERL_DL_NONLAZY
- Set to one to have perl resolve all undefined symbols when it loads a dynamic library. The default behaviour is to resolve symbols when they are used. Setting this variable is useful during testing of extensions as it ensures that you get an error on misspelled function names even if the test suite doesn't call it.
- PERL_ENCODING
- If using the "encoding" pragma without an explicit encoding name, the PERL_ENCODING environment variable is consulted for an encoding name.
- PERL_HASH_SEED
-
(Since Perl 5.8.1.) Used to randomise perl's internal hash function.
To emulate the pre-5.8.1 behaviour, set to an integer (zero means
exactly the same order as 5.8.0). ``Pre-5.8.1'' means, among other
things, that hash keys will always have the same ordering between
different runs of perl.
Most hashes return elements in the same order as Perl 5.8.0 by default. On a hash by hash basis, if pathological data is detected during a hash key insertion, then that hash will switch to an alternative random hash seed.
The default behaviour is to randomise unless the PERL_HASH_SEED is set. If perl has been compiled with "-DUSE_HASH_SEED_EXPLICIT", the default behaviour is not to randomise unless the PERL_HASH_SEED is set.
If PERL_HASH_SEED is unset or set to a non-numeric string, perl uses the pseudorandom seed supplied by the operating system and libraries.
Please note that the hash seed is sensitive information. Hashes are randomized to protect against local and remote attacks against Perl code. By manually setting a seed this protection may be partially or completely lost.
See ``Algorithmic Complexity Attacks'' in perlsec and ``PERL_HASH_SEED_DEBUG'' for more information.
- PERL_HASH_SEED_DEBUG
-
(Since Perl 5.8.1.) Set to one to display (to STDERR) the value of
the hash seed at the beginning of execution. This, combined with
``PERL_HASH_SEED'' is intended to aid in debugging nondeterministic
behavior caused by hash randomization.
Note that the hash seed is sensitive information: by knowing it one can craft a denial-of-service attack against Perl code, even remotely, see ``Algorithmic Complexity Attacks'' in perlsec for more information. Do not disclose the hash seed to people who don't need to know it. See also hash_seed() of Hash::Util.
- PERL_ROOT (specific to the VMS port)
- A translation concealed rooted logical name that contains perl and the logical device for the @INC path on VMS only. Other logical names that affect perl on VMS include PERLSHR, PERL_ENV_TABLES, and SYS$TIMEZONE_DIFFERENTIAL but are optional and discussed further in perlvms and in README.vms in the Perl source distribution.
- PERL_SIGNALS
- In Perls 5.8.1 and later. If set to "unsafe" the pre-Perl-5.8.0 signals behaviour (immediate but unsafe) is restored. If set to "safe" the safe (or deferred) signals are used. See ``Deferred Signals (Safe Signals)'' in perlipc.
- PERL_UNICODE
- Equivalent to the -C command-line switch. Note that this is not a boolean variable--- setting this to "1" is not the right way to ``enable Unicode'' (whatever that would mean). You can use "0" to ``disable Unicode'', though (or alternatively unset PERL_UNICODE in your shell before starting Perl). See the description of the "-C" switch for more information.
- SYS$LOGIN (specific to the VMS port)
- Used if chdir has no argument and HOME and LOGDIR are not set.
Perl also has environment variables that control how Perl handles data specific to particular natural languages. See perllocale.
Apart from these, Perl uses no other environment variables, except to make them available to the program being executed, and to child processes. However, programs running setuid would do well to execute the following lines before doing anything else, just to keep people honest:
$ENV{PATH} = '/bin:/usr/bin'; # or whatever you need $ENV{SHELL} = '/bin/sh' if exists $ENV{SHELL}; delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};
Index
This document was created by man2html, using the manual pages.
Time: 05:29:08 GMT, December 24, 2015


The Password Generator is currently under construction, we will be fixing a bug that sometimes resulted in users' generated password not meeting all of the criteria they requested. Sorry for the inconvenience. If you really want to access the file, you can go to our "Experimental Page" and test it out.


I listen to music every day. I listen on to go, when walking around, driving or when relaxing.
I find it very calming and it’s a nice way to pass time.
My favourite artists are The Chainsmokers. I listen to them every day and was lucky enough to see them in person once in Dublin at Summer in the City. My favourite song of theirs is Closer.
I also really like Drake and am going to see him soon in the 3Arena. Gods plan is the song he has released in my opinion.


Before Change
)
sm.associate_trial_component(TrialComponentName=trial_component_name, TrialName=trial_name)
time.sleep(15) // wait for search to get updated TODO [owen-t]: Replace with retry
analytics = ExperimentAnalytics(
experiment_name=experiment_name, sagemaker_session=sagemaker_session
After Change
def test_experiment_analytics_pagination(sagemaker_session):
with experiment(sagemaker_session) as experiment_name:
analytics = ExperimentAnalytics(
experiment_name=experiment_name, sagemaker_session=sagemaker_session
)
assert list(analytics.dataframe().columns) == ["TrialComponentName", "DisplayName", "hp1"]
assert (
len(analytics.dataframe()) > 10
) // TODO [owen-t] Replace with == 20 and put test in retry block
def test_experiment_analytics_search_by_nested_filter(sagemaker_session):
with experiment(sagemaker_session) as experiment_name:
search_exp = {
"Filters": [


Enter the name of the teams to which you want to assign this application.
- You must enter a team name if you have any user account role other than Security Lead. If you leave this field empty, the job will fail.
- Use a comma-separated list for multiple team names.
- The team name is case-sensitive and must exactly match the team name as entered in the Veracode Platform.
- If you assign the application to a non-existent team, the job will fail.


It takes 400 cocoa beans to make one pound of chocolate.
Chocolate comes from fruit tree; it's made from a seed.
Each cacao tree produces approximately 2,500 beans.
The average serving of milk chocolate has about the same amount of caffeine as a cup of decaf coffee.
Because cacao trees are so delicate, farmers lose, on average, 30 percent of their crop each year.
“Cacao” is how you say “cocoa” in Spanish.
It is poisonous for dogs and cats
A chocolate river existed for a short time back in 1971 for the movie Willy Wonka & The Chocolate Factory. I was made of 15,000 gallons of water, chocolate, and cream and spoiled failry quickly, leaving a terrible smell.
In Mayan times, the cocoa bean was used as currency.
White chocolate isn't considered real chocolate because it's made using cocoa butter instead of cocoa solids or cocoa liquor.
The chocolate chip cookie was an accident discovered by Ruth Wakefield in 1930. She ran out of baker's chocolate, so tried to put in broken pieces of Nestle chocolate expecting chocolate cookies. Instead, it created the famouse chocolate chip cookies that was then sold to Nestle for a lifetime supply of chocolate.


JOHNNY MNEMONIC A film review by Rob Furr Copyright 1995 Rob Furr
I've paid my dues when it comes to cyberpunk in the visual media. I've seen all the episodes of MAX HEADROOM, I've seen both versions of BLADE RUNNER, I even still have an episode of WHIZ KIDS on videotape somewhere.
And now, I've seen JOHNNY MNEMONIC.
Of course, I could have skipped that last one and missed nothing. Every scene in this movie (save one, and I'll get to that in a bit,) gave me a galloping case of the "Been there, done that"s. Which is *incredibly* depressing, as the original short story was exactly that: original. "Johnny Mnemonic" and the other stories that were collected in William Gibson's BURNING CHROME, were original, well-constructed, painfully clear and brilliantly vivid short stories.
Gibson's talent has been slowly fading since NEUROMANCER, it seems. COUNT ZERO was good, MONA LISA OVERDRIVE was all right, THE DIFFERENCE ENGINE was tolerable, VIRTUAL LIGHT was boring, and now he's got sole writing credit for this film, and it fits into that linear descent just fine, thank you very much.  Instead of the film noir-esque aura of the short story, where there *are* no good guys, Gibson ladled gallon after gallon of Hollywood Motivation into the plot--he's no longer just a courier with information that matters nothing to him, he's now The Sole Hope Of The World. He's no longer just in danger of getting diced by a monofilament thumb, he's now got a Tragic Flaw, by jiminy, and He'll Die Because Of His Own Mistakes.
Sigh.
This is not to say that I'm writing a rotten review because of how different JOHNNY MNEMONIC is from "Johnny Mnemonic"; that's just why I'm disappointed. I'm giving JOHNNY MNEMONIC a rotten review because, unfortunately, it's a rotten movie.
It's stunningly unoriginal in production design; remember what I said about having seen MAX HEADROOM? Well, if you've seen any given episode of MAX HEADROOM, you've seen what the designers of JOHNNY MNEMONIC were trying to do, and you've seen it done twenty times better than JOHNNY MNEMONIC did it, on an incredibly smaller budget.
It features some stunningly bad acting: Keanu Reeves is rotten ... totally, unreservedly, completely rotten. It's not his fault--the script is the primary culprit--but, as bad as his portrayal is, he gives the best performance of the cast. Ice-T *could* have given a decent performance--he's a better actor than Keanu is, in my humble opinion - but he's got about six lines and about four seconds of screen time, which makes it kind of hard to tell whether or not it was a decent go at the role.
It's got some hideously bad special effects. Oh, *one* scene is well done, but the rest was on a level with the effects done for STAR TREK V: THE FINAL FRONTIER.
It's got ... well, why go on? Bad acting, a bad script, unoriginal and badly executed design ... this movie is a turkey.
Almost.
One scene--*one* single, solitary scene is impressive, and it's almost enough for me to forgive most of the rest of the movie. Fortunately, the people who assembled the trailer also saw a good scene when they saw it, so most of it was included. The "What are you doing?" "Making a long-distance phone call." scene is probably the best virtual reality scene ever done on film or on TV. It's believable, well-done--Keanu performs well--and if I had my way, I'd pull that one single scene out of JOHNNY MNEMONIC and film an entirely different movie around it.
At any rate, I'm calling JOHNNY MNEMONIC a one-point-five star two-star movie. It didn't aim very high, and it missed what it was aiming at, but it had a redeeming feature or two. (On the Furr Scale, I rate movies by ambition and execution: rating EVIL DEAD II (a four-star one star movie, i.e., it didn't aim very high, but, boy, did it succeed) on the same scale as HEAVEN'S GATE (a one-star four star movie, i.e., it aimed very, very high, and failed utterly) is ludicrous. So I don't do it. A few examples; ROBOCOP is a three-star three star movie (aimed relatively high, did what it wanted to do,) THE RIGHT STUFF is a three-star four star movie (aimed very high, did pretty much what it wanted to do) and THE LAWNMOWER MAN was a two-star two star movie (didn't aim too high, and did what it was supposed to do, but not very well.))
-- Rob Furr's HTMLized .SIG is at http://www.groucho.com/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


|
| static double | deadband (double deadband, double value) |
| |
| static Boolean | equal (double a, double b) |
| |
| static Boolean | equal (double a, double b, double distance) |
| |
| static double | filter (double value, double lastvalue, double fail) |
| |
| static double | coerce (double min, double max, double value) |
| |
| static boolean | inBounds (double min, double max, double value) |
| |
Mathematical and Precision Utilities
| static double com.lasarobotics.library.util.MathUtil.coerce |
( |
double |
min, |
|
|
double |
max, |
|
|
double |
value |
|
) |
| |
|
static |
Forces a numerical value to be between a min and a max
- Parameters
-
| min | If less than min, returns min |
| max | If greater than max, returns max |
| value | Value to test |
- Returns
- Coerced value
| static double com.lasarobotics.library.util.MathUtil.deadband |
( |
double |
deadband, |
|
|
double |
value |
|
) |
| |
|
static |
Gives a "deadzone" where any value less than this would return zero.
- Parameters
-
| deadband | Maximum value that returns zero |
| value | Value to test |
- Returns
- Deadbanded value
| static Boolean com.lasarobotics.library.util.MathUtil.equal |
( |
double |
a, |
|
|
double |
b |
|
) |
| |
|
static |
Returns if two double values are equal to within epsilon.
- Parameters
-
| a | First value |
| b | Second value |
- Returns
- True if the values are equal, false otherwise
| static Boolean com.lasarobotics.library.util.MathUtil.equal |
( |
double |
a, |
|
|
double |
b, |
|
|
double |
distance |
|
) |
| |
|
static |
Returns if two double values are equal to within a distance.
- Parameters
-
| a | First value |
| b | Second value |
| distance | Maximum distance between a and b |
- Returns
- True if the values are equal ot within distance, false otherwise
| static double com.lasarobotics.library.util.MathUtil.filter |
( |
double |
value, |
|
|
double |
lastvalue, |
|
|
double |
fail |
|
) |
| |
|
static |
Ignores values equal to the fail value (normally zero).
- Parameters
-
| value | Current value |
| lastvalue | Previous value |
| fail | Filter this value, normally zero |
- Returns
- Filtered value
| static boolean com.lasarobotics.library.util.MathUtil.inBounds |
( |
double |
min, |
|
|
double |
max, |
|
|
double |
value |
|
) |
| |
|
static |
Tests if a number is between the bounds, inclusive.
- Parameters
-
| min | If less than min, returns false |
| max | If greater than max, returns false |
| value | Value to test |
- Returns
- Returns true if value is between (inclusive) min and max, false otherwise.
The documentation for this class was generated from the following file:
- ftc-library/src/main/java/com/lasarobotics/library/util/MathUtil.java


Parentheses, brackets, braces, quotes - what are they all used for?
In the JavaScript language parentheses, brackets, braces and quotes are used to do things such as store information, invoke functions and define data types.
- parentheses () are used for grouping and or containing expressions. This can be helpful when wanting to dictate how a sum is going to be calculated.
e.g. var a = (4 + 1) * 5
- Also used in functions for storing parameters. For instance, if you want to do a count of animals, but only those that are cats.
e.g. function countAnimals(cat)
- And when making 'if' statements, you would use the parentheses to contain the condition that you were looking to check against.
e.g. function countAnimals() { if ( animal = "cat" ) { return count; } }
- brackets [] are used to store data (i.e. arrays of information), which could be a simple list attached to one variable. Or it could be a list of data held within a property of an object.
e.g. var animals = [ "cat", dog", "mouse" ]
- Brackets are then also used for accessing data in the arrays, but inputting the index number of where that piece of information sits within the list.
e.g. console.log ( animals [1] );
returns "dog"
- Note: The index in an array starts at the number 0. Therefore, in the above example, "cat" is at position 0, "dog" is at position 1 and "mouse" is at position 2.
- braces {} are used to declare a piece of data as being an object. Within the braces, you then record all the properties of that object.
e.g. var ball = { shape: round, colour: red, size: big }
- Braces are also used to enclose blocks of code, such as a series of conditions within a formula or a for loop.
- single quotes '' and double quote " " are used when writing strings (e.g. a thing or a sentence, rather than a number or true/false). Both types of quotes are used for the same things and can be used as you wish, so long as the start and end of the string match (i.e. either ' ' OR " ").
- You can use a double quote within a string that has the start/end of a single quote, without exiting the string itself (and vice versa). This is useful when writing pieces of text that require the output to show "quotes".
- When declaring a variable which you know is going to be in the form of a string, but that you are yet to assign a value to, you can can assign " " to it and this will tell the variable to expect a string.
e.g. var animal = " ";


Extracts the condition of a
while
statement and places the negated condition to an
if
statement inside the while loop.


Guitars
I have 8 guitars in total, including 1 ukelele:
Click me for free vbucks
2 - Little Martin
1 - Full Sized Martin
1 - Fender Stratocaster
1 - Gibson Les Paul Sunburst
1 - Taylor (in Virginia)
1 - Epiphone Dot
1 - Ukelele
MAKE THIS MAN THE POTUS
These are my favorite movies
Battle Royale
Bee Movie
h
Obama
Care
Obama
Banos
Obama
Care
Obama
Banos
Obama
Care
Obama
Banos


2Win!
VIEWS
04
Monday 01/23/10:22am
http://2win.blah
Name of Playlist
05
VIEWS
04
Monday 01/23/10:22am
http://2win.blah
Name of Playlist
05
VIEWS
04
Monday 01/23/10:22am
http://2win.blah
Name of Playlist
05
VIEWS
04
Monday 01/23/10:22am
http://2win.blah
Name of Playlist
05


BBR wins contracts to build floating, rooftop solar panels
by Leila LaiMainboard-listed BBR Holdings on Monday announced that its wholly-owned subsidiary BBR Greentech has won two contracts to construct solar photovoltaic (PV) systems.
One contract is a tender by national water agency PUB to build two 1.5 megawatt-peak (MWp) floating solar PV systems on Bedok and Lower Seletar reservoirs. The systems will power Bedok Waterworks and the raw water pumping stations at the reservoirs, and together with an existing rooftop solar array at Bedok Waterworks will produce enough green energy to supply 30 per cent of the installations' total energy requirement.
Said Andrew Tan, CEO of BBR: "We are excited about winning the PUB tender as we had previously participated in a floating solar PV testbed project to study the feasibility of this technology on Tengeh Reservoir."
In the other contract, which is for the private sector, BBR will design, supply and install two solar PV systems on the rooftops of two industrial buildings in Marsiling and Benoi Sector.
BBR did not reveal the value of the contracts.
Stay updated with
BT newsletters
Terms & conditions Sign up
Construction works for both contracts are in progress and the systems are expected to be operational by Q2 2020. The contracts are not expected to have any material financial impact on the earnings of the group for the current financial year ending Dec 31.
BBR shares closed unchanged at S$0.16 before the announcement.


Frank de Jonge
Staff Engineer
I made EventSauce and Flysystem
EventSourcing is
not hard, but learning it is.
EventSourcing is a technique where decisions are made based on past events, resulting in newly recorded events that
are stored for later decisions and broadcast to interested parties so they can bla bla bla...
EventSourcing is a way to create software models using events.
$credit = 100;
$purchase = 80;
if ($credit >= $purchase) {
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = 60;
$purchase = 80;
if ($credit >= $purchase) {
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = fetch_credit();
echo "Credit is $credit\n";
$purchase = 80;
if ($credit >= $purchase) {
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = fetch_credit();
echo "Credit is $credit\n";
$purchase = amount_from_request();
if ($credit >= $purchase) {
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = fetch_credit(); // context
echo "Credit is $credit\n";
$purchase = amount_from_request();
if ($credit >= $purchase) {
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = fetch_credit();
echo "Credit is $credit\n";
$purchase = amount_from_request(); // input
if ($credit >= $purchase) {
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = fetch_credit();
echo "Credit is $credit\n";
$purchase = amount_from_request();
if ($credit >= $purchase) { // decision
$credit -= $purchase;
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
$credit = fetch_credit();
echo "Credit is $credit\n";
$purchase = amount_from_request();
if ($credit >= $purchase) {
$credit -= $purchase; // outcome
echo "Purchase of $purchase is OK!";
} else {
echo "Purchase of $purchase has failed.";
}
In a given context,
when handling input
a decision is made
which has an outcome.
class PersonalBudget {
public function __construct(private int $credit) {}
public function spend(int $amount): bool {
if ($amount > $this->credit) return false;
$this->credit -= $amount;
return true;
}
}
Event
a representation of a historical fact; something that happened
in the past.
Event
an immutable value-object
class PurchaseWasMade
{
private $amount;
public function __construct(int $amount) {
$this->amount = $amount;
}
public function amount(): int {
return $this->amount;
}
}
class PurchaseWasMade
{
// ...
public function toPayload(): array {
return ['amount' => $this->amount];
}
public static function fromPayload(array $payload) {
return new static($payload['amount']);
}
}
Aggregate Root
an interaction interface to your domain, limited by a consistency boundary
Aggregate Root
you steer a car by turning the steer, not by adjusting the wheels
class PersonalBudget
{
private $budget = 0;
public function __construct(AggregateRootId $id)
{
$this->id = $id;
}
}
class PersonalBudget
{
// ...
public function increaseBudget(int $amount)
{
// traditional CRUD
$this->budget += $amount;
}
}
class PersonalBudget
{
// ...
public function increaseBudget(int $amount)
{
// event sourced
$this->recordThat(new BudgetWasIncreased($amount));
}
}
class PersonalBudget
{
// ...
protected function recordThat(object $event)
{
$this->apply($event);
$this->recordedEvents[] = $event;
}
}
class PersonalBudget
{
// ...
protected function applyBudgetWasIncreased(
BudgetWasIncreased $event
) {
$this->budget += $event->amount();
}
}
class PersonalBudget
{
public function spend(int $amount)
{
if ($this->budget >= $amount) {
$this->budget -= $amount;
return true;
} else {
return false;
}
}
}
class PersonalBudget
{
public function spend(int $amount)
{
if ($this->budget >= $amount) {
$this->recordThat(new PurchaseWasMade($amount));
return true;
} else {
return false;
}
}
}
class PersonalBudget
{
public function spend(int $amount)
{
if ($this->budget >= $amount) {
$this->recordThat(new PurchaseWasMade($amount));
return true;
} else {
$this->recordThat(new BudgetWasInsufficient($amount));
return false;
}
}
}
$personalBudget->increaseBudget(50);
$personalBudget->increaseBudget(100);
$personalBudget->spend(75);
// Can I spend 10 now?
var_dump($personalBudget->spend(10));
$personalBudget->increaseBudget(50);
$personalBudget->increaseBudget(100);
$personalBudget->spend(75);
// Can I spend 100 now?
var_dump($personalBudget->spend(100));
new BudgetWasIncreased(50);
new BudgetWasIncreased(100);
new PurchaseWasMade(75);
// Can I spend 100 now?
new BudgetWasInsufficient(100);
class PersonalBudget
{
protected function recordThat(object $event)
{
$this->apply($event);
$this->recordedEvents[] = $event;
}
}
class PersonalBudget
{
protected function recordThat(object $event) { ... }
public function releaseEvents(): array
{
$releasedEvents = $this->recordedEvents;
$this->recordedEvents = [];
return $releasedEvents;
}
}
Aggregate Root Repository
is responsible for storing recorded events and reconstituting aggregates
interface AggregateRootRepository
{
public function persist(object $aggregateRoot);
public function retrieve(AggregateRootId id): object;
}
class AggregateRootRepository
{
public function persist(AggregateRoot $aggregate)
{
$events = $aggregate->releaseEvents();
$aggregateRootId = $aggregate->aggregateRootId();
}
}
class AggregateRootRepository
{
public function persist(AggregateRoot $aggregate)
{
$events = $aggregate->releaseEvents();
$aggregateRootId = $aggregate->aggregateRootId();
$headers = [Header::AGGREGATE_ROOT_ID => $aggregateRootId];
$messages = array_map(function (object $event) use ($headers) {
return new Message($event, $headers);
}, $events);
$this->messages->persist(...$messages);
$this->dispatcher->dispatch(...$messages);
}
}
class AggregateRootRepository
{
public function persist(AggregateRoot $aggregate)
{
$events = $aggregate->releaseEvents();
$aggregateRootId = $aggregate->aggregateRootId();
$headers = [Header::AGGREGATE_ROOT_ID => $aggregateRootId];
$messages = array_map(function (object $event) use ($headers) {
return new Message($event, $headers);
}, $events);
$this->messages->persist(...$messages);
$this->dispatcher->dispatch(...$messages);
}
}
class AggregateRootRepository
{
public function persist(AggregateRoot $aggregate)
{
$events = $aggregate->releaseEvents();
$aggregateRootId = $aggregate->aggregateRootId();
$headers = [Header::AGGREGATE_ROOT_ID => $aggregateRootId];
$messages = array_map(function (object $event) use ($headers) {
return new Message($event, $headers);
}, $events);
$this->messages->persist(...$messages);
$this->dispatcher->dispatch(...$messages);
}
}
class AggregateRootRepository
{
public function persist(AggregateRoot $aggregate)
{
$events = $aggregate->releaseEvents();
$aggregateRootId = $aggregate->aggregateRootId();
$headers = [Header::AGGREGATE_ROOT_ID => $aggregateRootId];
$messages = array_map(function (object $event) use ($headers) {
return new Message($event, $headers);
}, $events);
$this->messages->persist(...$messages);
$this->dispatcher->dispatch(...$messages);
}
}
interface MessageRepository
{
public function persist(Message ...$messages);
public function retrieveAll(AggregateRootId $id): Generator;
}
Can be MySQL, MongoDB, Redis, What-ever!
Store it somewhere
CREATE TABLE processing_payments (
id BIGINT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
aggregate_root_id VARCHAR(36) NOT NULL,
payload JSON NOT NULL,
INDEX aggregate_reconstitution (aggregate_root_id, id ASC)
);
Am I doing this right, @Willem?
Store it somewhere
SELECT payload
FROM processing_payments
WHERE aggregate_root_id = ":aggregate_root_id"
ORDER BY id ASC
Am I doing this right, @Willem?
Transport it somehow
interface MessageDispatcher
{
public function dispatch(Message ...$messages);
}
Can be RabbitMQ, Kafka, Sync, What-ever!
class SynchronousMessageDispatcher implements MessageDispatcher
{
public function __construct(private Consumer ...$consumers) {}
public function dispatch(Message ...$messages)
{
foreach ($messages as $message) {
foreach ($this->consumers as $consumer) {
$consumer->handle($message);
}
}
}
}
Synchronous
✅ No extra infrastructure
✅ Good enough (?)
❌ No retry mechanisms
❌ No horizontal scaling
❌ No easy rebuilds
Asynchronous
❌ Extra infrastructure
❌ More complex setup
✅ Retry mechanisms
✅ Horizontal scaling
✅ Rebuilds possible
In a given context,
when handling input
a decision is made
which has an outcome.
How about tests?
Given
A context When
Handling input Then
There is a outcome
Given
Existing events When
Handling input Then
New events!
/**
* @test
*/
public function it_allows_to_spend_within_the_budget()
{
$id = $this->aggregateRootId();
$this->given(
new BudgetWasIncreased(100)
)->when(
new MakePurchase($id, 40)
)->then(
new PurchaseWasMade(40)
);
}
/**
* @test
*/
public function it_disallows_to_spend_over_budget()
{
$id = $this->aggregateRootId();
$this->given(
new BudgetWasIncreased(100),
new PurchaseWasMade(80)
)->when(
new MakePurchase($id, 40)
)->then(
new BudgetWasInsufficient(40)
);
}
When to apply this:
Process modelling
Auditing requirements
Need to communicate change
Financial Transactions and Accounting
Additional benefits:
Insights on historical events
Super scalable
Aligns with event storming
It's super cool and looks great on your resume ;-P
Considerations:
Invest in DDD
Works well with CQRS
Works well with Hexagonal Architecture
With Event Sourcing
Simple tasks are more work.
Difficult tasks are possible.
Down-sides
Everything is recorded, and so are your failures.
Events outlive your model.
Events are flipping everywhere.
Fewer people know about it.
Reconstitution with many events can become a bottleneck, but there are solutions for that.
It puts software development upside-down and inside-out, which can be uncomfortable.


4th January 2015
Pair Programming at DBC
We have been pair programming now for over a month - at least twice a week - and giving & receiving formal feedback on each pair. Has it been good? yes. Has it been hard? yes, at times. Has it been useful? definitely.
I find that my nervousness is decreasing each time I pair- but there is always that feeling of "what if we don't get on?" "what if I can't keep up?" "what if they can't keep up?" ... I find that it almost always surprises me how much I can do in a pairing session and that is probably its biggest benefit for me at the moment. I have met some great people and have learnt to adapt to different styles of pairing. Sometimes when there is confusion it is so tempting to wish you were alone and could 'sort it out in private' and then come back - bullet proof. But as Brene Brown says that is a seductive way to take ourselves out of the game. So I am trying to remind myself to stay present, ask questions and talk through the difficult parts til we find the solution... so far seems to be working...
Feedback has been really helpful in helping me understand where to focus my efforts in subsequent pairing sesssions. In DBC feedback follows the guidelines of Actionable, Specific, and Kind. As a result the feedback has been focused on alot of positive feedback and specific constructive feedback which is great.


Preparation time
1-2 hours
Cooking time
over 2 hours
Serves
Serves 6-8
Dietary
Loaded with big pieces of fruit, Mary Berry's Christmas pudding recipe will win over the harshest critics.
Equipment and preparation: You will need a 1.4 litre/2½ pint pudding basin
Measure the sultanas, raisins, apricots and apple into a bowl with the orange juice. Add the measured brandy (rum or sherry), stir and leave to marinate for about one hour.
Put the measured butter, sugar and grated orange rind into a large bowl and cream together with a wooden spoon or a hand-held whisk until light and fluffy. Gradually beat in the eggs, adding a little of the measured flour if the mixture starts to curdle.
Sift together the flour and mixed spice, then fold into the creamed mixture with the breadcrumbs and the nuts. Add the soaked dried fruits with their soaking liquid and stir well.
Generously butter a 1.4 litre/2½ pint pudding basin. Cut a small disc of foil or baking parchment and press into the base of the basin.
Spoon into the prepared pudding basin and press the mixture down with the back of a spoon. Cover the pudding with a layer of baking parchment paper and foil, both pleated across the middle to allow for expansion. Tie securely with string and trim off excess paper and foil with scissors.
To steam, put the pudding in the top of a steamer filled with simmering water, cover with a lid and steam for eight hours, topping up the water as necessary.
To boil the pudding, put a metal jam jar lid, or metal pan lid, into the base of a large pan to act as a trivet. Place a long, doubled strip of foil in the pan, between the trivet and the pudding basin, ensuring the ends of the strip reach up and hang over the edges of the pan. This will help you to lift the heavy pudding basin out of the pan of hot water when it has finished cooking.
Lower the pudding onto the trivet and pour in enough boiling water to come half way up the side of the bowl. Cover with a lid, bring the water back to the boil, then simmer for about seven hours, until the pudding is a glorious deep brown colour, topping up the water as necessary.
For the brandy butter, place the butter into a mixing bowl and cream with a wooden spoon until light and fluffy – or for speed use an electric hand-held mixer. Beat in the sieved icing sugar until smooth, then add brandy, rum or cognac, to taste. Spoon into a serving dish, cover and set aside in the fridge.
When cooked through, remove the pudding from the pan and cool completely. Discard the paper and foil and replace with fresh. Store in a cool, dry place.
To serve, on Christmas Day, steam or boil the pudding for about two hours to reheat. Turn the pudding onto a serving plate. To flame, warm the brandy or rum in a small pan, pour it over the hot pudding and set light to it. Serve with brandy butter.
You need JavaScript to view this clip.
How to cream butter by hand


You need to enable JavaScript to run this app.
Log In
Username
Password
Forgotten Password
Log In
Terms and Conditions
Copy to come


Invalid Site!
Something went wrong with the web address you provided. Check your url and try again.
{% else %} {% if links %} {% else %}No pdf files found!
The website you provided had no valid pdfs within a 2-deep search. Perhaps try a different site?
{% endif %} {% endif %}


Advanced Javascript Course Notes
Explain "use strict";
What are the different types in in javascript?
-
Boolean
true or false -
Number
1,1.0 -
String
'a', "a" -
Null
null -
Undefined
undefined -
Object
{}, new Object()
What does the function typeof() do?
The function
typeof()
can be used to determine what type a value is.-
typeof(1)
the value is "number" -
typeof('a')
the value is "string" -
typeof(true)
the value is "boolean" -
typeof(undefined)
the value is "undefined" -
typeof(null)
the value is "object" -
typeof({})
the value is "object"
What does it mean that javascript is a dynamically typed language?
Javascript variables are determined dynamically at runtime as opposed to languages like java, which expects the variables to be defined ahead of time.
What is the difference between "udnefined" and "null"?
When a variable is
undefined
it has not yet been defined and is set to undefined by the javascript engine, whereas a variable can be assigned tonull
by the programmer to be manually set undefined.


Battle.net
Home
Game
Community
Media
Forums
Services
Log in
with your Battle.net account to post comments and personalize your site content.
StarCraft II
aAaNerchio
aAaNerchio
2350
Profile
Achievements
Match History
Rewards
Leagues & Ladders
Season 2
-
Snapshot
Highest Ranked in 1v1
Division:
Nexus Victor
Rank:
3
1v1
683 Games
528 Wins
Highest Ranked in 2v2
Division:
Corsair Upsilon
Rank:
12
2v2
41 Games
35 Wins
Not Yet Ranked
3v3
No Games Played
Not Yet Ranked
4v4
No Games Played
Career Stats
League Wins
1883
Games Played
2067
Custom Games
0
FFA
3
Co-Op vs AI
Casual Campaign Ace
Achievements
Liberty Campaign
1250
Exploration
370
Custom Game
0
Cooperative
0
Quick Match
430
Showcase
Showcase your best achievements here through the Battle.net client.
Log in
or
Create an Account
Account
Support
Knowledge Center
Browse our support articles
Ask a Question
Create a new support ticket
Your Support Tickets
View your active tickets (login required).
Explore
Battle.net Home
Connect. Play. Unite.
Account
Manage your Account
Support
Get Support and explore the knowledgebase.
Buy Games
Digital Games for Download
More
What is Battle.net?
What is Real ID?
Parental Controls
Account Security
Classic Games
Account Support
StarCraft II
Community Site
Forum Discussions
Character Profiles and more…
World of Warcraft
Community Site
Forum Discussions
Character Profiles and more…
Diablo III
Under Development, visit the Announcement Site
JavaScript must be enabled to use this site.


Module tasks
User library allowing to create and manage processes.
Functions
| getCurrentProcess () | Returns the current process object or nil if no process is active (only the case during boot) |
| sleep (secs) | Pause the current process for the specified number of seconds |
| getProcess (pid) | Get the process object corresponding to the given PID. |
| waitFor (proc) | Pause the current process until the given process has ended |
| kill (proc) | Kill the given process, calling the safe kill handler if present |
| unsafeKill (proc) | Kill the given process without accounting for the safe kill handler. |
| getProcessMetrics (pid) | Returns the process metrics from the given PID |
| getPIDs () | Returns the list of PIDs used by living processes |
| getProcesses () | Returns the list of all living process objects |
| newProcess (name, func) | Spawns and starts a new process |
Class process
| process.name | The name of the process |
| process.func | The coroutine function of the process |
| process.pid | The PID of the process. |
| process.status | The status of the process, can be one of "created", "running", "sleeping" or "wait_signal" |
| process:detach () | Detach the given process, that is make it an orphan process (with no parent) |
| process:kill () | Kill the given process |
Functions
- getCurrentProcess ()
-
Returns the current process object or nil if no process is active (only the case during boot)
Returns:
-
process object
- sleep (secs)
-
Pause the current process for the specified number of seconds
Parameters:
- secs Seconds to wait
See also:
- getProcess (pid)
-
Get the process object corresponding to the given PID.
Required permissions:
-
scheduler.list or process.edit
Parameters:
- pid PID of the process
Returns:
-
process object
- waitFor (proc)
-
Pause the current process until the given process has ended
Parameters:
- proc Process to wait for
See also:
- kill (proc)
-
Kill the given process, calling the safe kill handler if present
Parameters:
- proc process object
- unsafeKill (proc)
-
Kill the given process without accounting for the safe kill handler.
Parameters:
- proc process object
- getProcessMetrics (pid)
-
Returns the process metrics from the given PID
Parameters:
- pid pid of process
Returns:
-
process metrics
- getPIDs ()
-
Returns the list of PIDs used by living processes
Returns:
-
number[]
all PIDs
- getProcesses ()
-
Returns the list of all living process objects
Required permissions:
-
scheduler.list
Returns:
-
process[]
all process objects
- newProcess (name, func)
-
Spawns and starts a new process
Parameters:
- name The name of the process
- func The function to be called as process
Returns:
-
process
process object
Class process
A process object.
- process.name
- The name of the process
- process.func
- The coroutine function of the process
- process.pid
- The PID of the process. It's a reliable pointer to process that help know if a process is dead
- process.status
- The status of the process, can be one of "created", "running", "sleeping" or "wait_signal"
- process:detach ()
- Detach the given process, that is make it an orphan process (with no parent)
- process:kill ()
- Kill the given process


Interface AuthenticationToken
-
- All Superinterfaces:
Serializable
- All Known Subinterfaces:
HostAuthenticationToken
,RememberMeAuthenticationToken
- All Known Implementing Classes:
BearerToken
,CasToken
,UsernamePasswordToken
public interface AuthenticationToken extends Serializable
An AuthenticationToken is a consolidation of an account's principals and supporting credentials submitted by a user during an authentication attempt.
The token is submitted to an
Authenticator
via theauthenticate(token)
method. The Authenticator then executes the authentication/log-in process.Common implementations of an AuthenticationToken would have username/password pairs, X.509 Certificate, PGP key, or anything else you can think of. The token can be anything needed by an
Authenticator
to authenticate properly.Because applications represent user data and credentials in different ways, implementations of this interface are application-specific. You are free to acquire a user's principals and credentials however you wish (e.g. web form, Swing form, fingerprint identification, etc) and then submit them to the Shiro framework in the form of an implementation of this interface.
If your application's authentication process is username/password based (like most), instead of implementing this interface yourself, take a look at the
UsernamePasswordToken
class, as it is probably sufficient for your needs.RememberMe services are enabled for a token if they implement a sub-interface of this one, called
RememberMeAuthenticationToken
. Implement that interface if you need RememberMe services (the UsernamePasswordToken already implements this interface).If you are familiar with JAAS, an AuthenticationToken replaces the concept of a
Callback
, and defines meaningful behavior (Callback is just a marker interface, and of little use). We also think the name AuthenticationToken more accurately reflects its true purpose in a login framework, whereas Callback is less obvious.- Since:
- 0.1
- See Also:
RememberMeAuthenticationToken
,HostAuthenticationToken
,UsernamePasswordToken
-
-
Method Summary
All Methods Instance Methods Abstract Methods Modifier and Type Method Description Object
getCredentials()
Returns the credentials submitted by the user during the authentication process that verifies the submittedaccount identity
.Object
getPrincipal()
Returns the account identity submitted during the authentication process.
-
-
-
Method Detail
-
getPrincipal
Object getPrincipal()
Returns the account identity submitted during the authentication process.Most application authentications are username/password based and have this object represent a username. If this is the case for your application, take a look at the
UsernamePasswordToken
, as it is probably sufficient for your use.Ultimately, the object returned is application specific and can represent any account identity (user id, X.509 certificate, etc).
- Returns:
- the account identity submitted during the authentication process.
- See Also:
UsernamePasswordToken
-
getCredentials
Object getCredentials()
Returns the credentials submitted by the user during the authentication process that verifies the submittedaccount identity
.Most application authentications are username/password based and have this object represent a submitted password. If this is the case for your application, take a look at the
UsernamePasswordToken
, as it is probably sufficient for your use.Ultimately, the credentials Object returned is application specific and can represent any credential mechanism.
- Returns:
- the credential submitted by the user during the authentication process.
-
-


There are a number of predicates that are operating system dependent and are implemented in a Logic Server Extension, aosutil.lsx. Examples of environment-specific extended predicates are chdir/1 (change directory) and findfiles/3 (find file names in a directory structure). These are described under O.S. Predicates in the Prolog User's Guide.
The Amzi! IDE and the Amzi! command line tools are all Logic Server applications. If you want to use these predicates in the IDE, arun or your own stand-alone applications, you must either implement the extended predicates in your application or load aosutil.lsx with your application.
The full source code for osutils.cpp is included in directory src/lsx/osutils.
Copyright ©1987-2011 Amzi! inc. All Rights Reserved. Amzi! is a registered trademark and Logic Server is a trademark of Amzi! inc.


torchdata.samplers¶
This module implements samplers to be used in conjunction with torch.utils.data.DataLoader
instances.
Those can be used just like PyTorch’s torch.utils.data.Sampler
instances.
See PyTorch tutorial for more examples and information.
-
class
torchdata.samplers.
Distribution
(distribution: torch.distributions.distribution.Distribution, num_samples: int)[source]¶ Sample
num_samples
indices from distribution object.- Parameters
distribution (torch.distributions.distribution.Distribution) – Distribution-like object implementing
sample()
method.num_samples (int) – Number of samples to be yielded
-
class
torchdata.samplers.
RandomOverSampler
(labels)[source]¶ Sample elements randomly with underrepresented classes upsampled.
Length is equal to
max_samples_per_class * classes
.- Parameters
labels (torch.Tensor) – Tensor containing labels for respective samples.
-
class
torchdata.samplers.
RandomSubsetSampler
(indices, replacement=False, num_samples=None)[source]¶ Sample elements randomly from a given list of indices.
If without
replacement
, then sample from a shuffled dataset. If with replacement, then user can specifynum_samples
to draw.Similar to PyTorch’s
SubsetRandomSampler
, but this one allows you to specifyindices
which will be sampled in random order, notrange
subsampled.- Parameters
indices (typing.Iterable) – A sequence of indices
replacement (bool, optional) – Samples are drawn with replacement if
True
. Default:False
num_samples (int, optional) – Number of samples to draw, default=`len(dataset)`. This argument is supposed to be specified only when
replacement
isTrue
. Default:None


The Mirage defied the odds, celebrates its 30th birthday
22 Nov 2019, 11:26 by Dennis Rudner
The MIrage is shown on the Las Vegas Strip, Nov. 18, 2009. The Mirage, once considered the Strip's most luxurious hotel-casino, turns 30 years old on Nov. 22, 2019. (Jason Bean / Las Vegas Review-Journal)
With a published price tag of $630 million, of which $565 million was financed by risky junk bonds, the Mirage had to produce an unheard of $1 million dollars a day just to service the debt. The venture proved prophetic as the Mirage would exceed expectations and revolutionize the Las Vegas Strip. The Mirage, pictured on opening day, Nov. 22, 1989, ended a cautious decade and silenced fears that the spread of gambling establishments outside of Nevada would doom Las Vegas. (Wayne Kodey / Las Vegas Review-Journal)
Within 30 minutes of its opening to the general public an estimated 40,000 visitors entered the $630 million Mirage Hotel and Casino. The opening on Nov. 22, 1989 celebrated the first new major hotel-casino on the strip in over a decade. The 3,044-room Mirage boosted confidence in a future that would soon see the opening of The Mirage’s fellow mega-resorts Excalibur, Luxor, and the new MGM. (Jeff Scheid / Las Vegas Review-Journal)
The tropical-themed Mirage opened in November 1989 with the ultimate roadside attraction in a volcanic island that would erupt every 15 minutes. In addition to the waterfalls, giant aquariums, and white tigers found inside, architect Joel Bergman expanded the entertainment experience to the hotels exterior with a theatrical performance that would influence future spectacles at the Treasure Island and the Bellagio. (Wayne Kodey / Las Vegas Review-Journal)
With a published price tag of $630 million, of which $565 million was financed by risky junk bonds, the Mirage had to produce an unheard of $1 million dollars a day just to service the debt. The venture proved prophetic as the Mirage would exceed expectations and revolutionize the Las Vegas Strip. The Mirage, pictured on opening day, Nov. 22, 1989, ended a cautious decade and silenced fears that the spread of gambling establishments outside of Nevada would doom Las Vegas. (Wayne Kodey / Las Vegas Review-Journal)
Two orders of room service chicken wings arrive at room within 20 minutes of placing order on opening day at The Mirage. (Wayne Kodey / Las Vegas Review-Journal)
Dual people mover tracks bring visitors into The Mirage on November 22, 1989. (Wayne Kodey / Las Vegas Review-Journal)
The Mirage on opening night on Nov. 22, 1989. (Wayne Kodey / Las Vegas Review-Journal)
White tigers in repose on their throne in their own habitat at The Mirage. (Wayne Kodey / Las Vegas Review-Journal)
Gourmet restaurant at The Mirage. (Wayne Kodey / Las Vegas Review-Journal)
A visitor admires a stuffed tiger in the gift shop at The Mirage on Nov. 22, 1989. (Wayne Kodey / Las Vegas Review-Journal)
On a sunny Wednesday afternoon 30 years ago, The Mirage opened its doors, cementing the future of the Las Vegas Strip.
Thousands waited that morning for the newest resort on the Strip in more than 15 years to open. An estimated 750,000 people visited the property the first weekend.
Built at a cost of $620 million, analysts said the property needed $1 million in revenue a day to cover costs.
The Mirage helped boost the Las Vegas economy following a decade of being stagnant.
The Mirage exceeded analysts’ expectations and became a blueprint for other properties in the resort corridor.


--- layout: default permalink: none title: Four o four --- {% block content %}
The page you are looking for could not be found. Take a look at one of the pages below instead.


S'mores' Gallery 🐹
Be prepared for a LOAD of cuteness!
At her worst.
(She is very lazy! She's dead asleep here. Most likely very tired from all the eating she does)
At her best
Happy times in her food bowl!
She also looks a bit frightening when she yawns.
This is what happens when I leave her food where she can get to it. (Yes, her cheeks are filled with food).
Click to see a random picture of S'mores!


Layer Selection: Select first the base layer and then the attraction layer(s) from the Map Layer Selection tree on the right
Base Layers: OpenStreetMap and MapQuest are the two base layers offered for selection. The latter is set as default.
POIs: Select the attraction of your choice - Museums, Theatres, and/or Parks & Buildings from the Map Layer Selection tree
Info Popup: If you click a feature (corresponding to an attraction in the Map Layer Selection Tree), a popup appears indicating the name, address, and website of the attraction. Click on the (X) or any other attraction to make the current popup disappear.


This is your baseline app. Please edit this so it makes sense for future projects.
Seriously. It's way more radical than you might expect. There's some gnarly button action within, boss man.
Honestly, you may have to register or login to check it out. It's the only way to know if you're in with all the cool kids.
Please login. It'll make me feel like there was a point in making such an elaborate login page.


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import config.FrontendAppConfig @import uk.gov.hmrc.play.views.html.helpers.form @import views.html.helpers.{errorSummary, inputRadioGroupAddresses} @import models.takeovers.AddressChoice @import views.helpers.TitleHelper.title @(homeAddressForm: Form[AddressChoice], previousOwnerName: String, addressSeq: Seq[NewAddress])(implicit request: Request[_], messages: Messages, appConfig: FrontendAppConfig) @main_template(title = title(messages("page.takeovers.homeAddress.title", previousOwnerName), homeAddressForm)) { @Messages("common.button.back") @errorSummary( Messages("common.errorSummary.label"), homeAddressForm, dataJourney = Some("TakeOvers") ) @form(action = controllers.takeovers.routes.PreviousOwnersAddressController.submit()) {


--- layout: post title: The Curmudgeon Coder date: 2006-07-10 00:00:00 category: software-development ---
The Curmudgeon Coder: "The second problem with going higher and higher with abstractions is that, well, sometimes they leak. If your abstraction leaks and something breaks, will you be prepared to fix the problem? For example, Hibernate is an abstraction for mapping a database table row to an object. Is there anyone out there who has NOT pulled their hair out because of a leaky Hibernate abstraction? Its okay to admit it, really it is."


This document discusses how to create a Magic Lantern title using the Magic Lantern Studio SDK from Wizzer Works. The SDK is comprised of the Magic Lantern libraries and mastering tool chain.
Ideally, you should use the Magic Lantern Studio to create and modify a title. Refer to "Using the Magic Lantern Authoring Tools" for information on how to use the Magic Lantern authoring tools. However, you can create a title and add other actors to that title outside of the IDE.
There are some basic steps you take to create a title outside of The Studio. You have to
<to be supplied>
<to be supplied>
<to be supplied>
<to be supplied>


Some quick example text to build on the card title and make up the bulk of the card's content..
The command above should yield a folder on your Desktop titled "webproject". Change the name to anything you like and watch the folder pop up instantly on your Desktop.
Please fill out the form to register


"And Now for Something Completely Different . . . Again"
Signs of the Python Times
Why This Edition?
Major Changes in This Edition
Using the Examples and Demos
Conventions Used in This Book
Where to Look for Updates
Contacting O'Reilly
Acknowledgments