sm
a
s
Home
(current)
What is this
Contact
Editor
Editor mode
Key Name
Selected categories:
Selected relations:
Add to tree


Magic Trader Cema:
You may find a few things among these that you haven't seen elsewhere. If you have any question, please ask me. I'll answer your question.
Ask about the Cursed Bone
Ask about the Ectoplasm Liqueur
View the Exchange Item List


A
access of web pages. See web page access
algorithms. See computational approaches
anchor points. See entries for landmarks
artificial intelligence, 14–16
B
bookmarks, web, 22
usage, 48–49, 74–75, 98–99
buildings as landmarks, 24–26, 118
C
Chi, E. H. ,2, 113–114
cognitive landmarks. See semantic landmark characteristics
cognitive maps, 1, 9, 26. See also spatial cognition
landmarks and, 28–29, 110
computational approaches, 32–33, 43, 47, 118–119
content, text, in web pages. See semantic landmark characteristics
D
data. See statistical data
design, urban, 8–9
disorientation, hypertext, 20–21
E
environments, types of, 7
F
favorite sites. See bookmarks, web
G
Golledge, R. G., 1, 26, 28
graph theory, 12–13
graphical overview maps, 22
graphics, web. See visual landmark characteristics
guided tours, web, 22, 112
H
hierarchies, 22
Hirtle, S. C., 2, 35–37, 108, 119
home pages, 30–31, 36, 112
as landmarks, 30–31
hyperlinks. See links
hypertext, 18
node connectivity, 32–33, 42, 113
orientation, 20–21
hypertext navigation. See navigation, web
I
information architecture, 2
research implications, 111–112
Information Science, 5
J
knowledge, navigational, 6, 26
K
knowledge, navigational, 6, 26
L
landmarks, physical, 6, 37
characteristics, 24–26, 34
as navigational aids, 28–30, 110
types of, 35–36
landmarks, semantic web. See semantic landmark characteristics
landmarks, structural web. See structural landmark characteristics
landmarks, visual web. See visual landmark characteristics
landmarks, web, 30–33, 32, 110–111. See also web page elements
types of, 30
objective value
hypotheses, 40–41
computational approaches, 42–44
characteristics, 44–46
experiments, 48–50, 55–59, 91
analysis, 94–109
conclusions, 110–111
subjective value
hypotheses, 41
evaluation, 46–53
experiments, 80–91
analysis, 101–109
conclusions, 111
statistical analysis, 56–58
weighted analysis, 105–107, 118–119
learning, spatial knowledge, 26–27
links, 18–19, 42–44. See also structural landmark characteristics
statistical data, 104
Lynch, K., 8–9, 24–26
M
map-making, relational, 14–16
map recall. See recall in navigation
mental maps. See cognitve maps
methodology, 39–40, 48, 52, 112–116
algorithms, 43, 47, 118–119
standard deviation, 114–115
Mukherjea, S., 32–33, 42
N
navigation, physical, 5, 7, 27–28
animal, 11
landmarks and, 28–30, 119–120
learning, 26–27
neurological aspects, 10–13
recall, 39, 110
robot, 14–16
urban, 8–9, 29
virtual reality, 17
navigation, web, 2–3, 23–30, 110–111. See also web page access
aids, 22–23, 112
evaluation, 48–50, 75–80
paths, 48–49, 60–73, 75–80
navigational aids
landmarks as, 28–30
web, 22–23
navigational features, 5
networked space navigation. See space, networked
neural networks, 12–13
neuroscience, 10–13
nodes, 9, 13–14, 23, 30–33
connectivity, 32–33, 42, 113
O
objective landmark values. See landmarks, web, objective value
open-terrain navigation. See space, open-terrain
organizing concepts for landmarks, 28
orientation, hypertext, 20–21
P
Passini, R., 9, 29
page, web, See entries for web page
paths, web navigation, 48–49, 60–73, 75–80. See also starting points
recall of, 94
physical landmarks. See landmarks, physical
Pirolli, P. , 113–114
Pitkow, J., 113–114
points of reference. See entries for landmarks
Q
questionnaires, 46–47, 48–53
participants, 59–60, 81
questions, 51, 77–79, 81–88
R
Raubal, M. and Winter, S., 118–119
recall in navigation, 39, 110
of web pages. See web page recall
reference points. See entries for landmarks
relational map-making, 14–16
research implications, 111–112
research method, 39–40, 48, 52
robot navigation, 14–16
S
Sadalla, E. K., 3, 25, 27, 39
search engines, 22, 119–120
semantic landmark characteristics, 36
correlation with subjective landmarks, 103, 105–107
evaluation, 45–47, 86–88
recommendations, 113–114
Sorrows, M. E. and Hirtle, S. C., 2, 35–37, 108, 119
space, networked, 7, 13
space, open-terrain, 7, 16
spatial cognition, 2. See also cognitive maps
spatial representation of landmarks, 24–26
starting points, 48–49, 57, 68. See also paths, web navigation
statistical data, 75–77, 100
statistical data
navigation paths, 60–63, 65, 68, 71, 72, 85
objective landmark values, 56–58, 84, 102–107
subjective landmark values, 89, 90, 102–107
URL knowledge, 74, 86
structural landmark characteristics, 36. See also links evaluation, 42, 44, 46–47
correlation with subjective landmarks, 103, 105–107
recommendations, 113
URL length, 34, 42
subjective landmark values. See landmarks, web, subjective value
surveys of users. See questionnaires
T
text content in web pages. See semantic landmark characteristics
tours, web guided, 22
U
urban design, 8–9
URL knowledge, 49, 74–76, 85–86, 98–99
URL length, 34, 42
usability, 113
user interface navigational features, 5
V
virtual reality, 17
visual cues, 2
visual landmark characteristics, 35
evaluation, 44–47, 83–84
correlation with subjective landmarks, 104, 105–107
recommendations, 114–117
W
wayfinding.See navigation, physical
web site design, 2, 44–46, 103, 120
research implications, 111–112
web graphics. See visual landmark characteristics
web navigation. See navigation, web
web page access, 80. See also navigation, web
hypothesis, 40
measurability, 42–44
statistical data, 84–85, 98–99
conclusions, 109
web page elements, 20, 42–46, 105, 112, 114–116. See also landmarks, web
web page landmarks. See landmarks, web
web page recall, 80
hypothesis, 40, 53, 95
statistical data, 82–83, 96–97
evaluation, 93–97
conclusions, 109, 112
Winter, S. , 118–119
World Wide Web, 18, 20, 110-111
X
Y
Z


Elixir v1.3.4 Application behaviour
A module for working with applications and defining application callbacks.
In Elixir (actually, in Erlang/OTP), an application is a component implementing some specific functionality, that can be started and stopped as a unit, and which can be re-used in other systems.
Applications are defined with an application file named APP.app
where
APP
is the application name, usually in underscore_case
. The application
file must reside in the same ebin
directory as the compiled modules of the
application.
In Elixir, Mix is responsible for compiling your source code and
generating your application .app
file. Furthermore, Mix is also
responsible for configuring, starting and stopping your application
and its dependencies. For this reason, this documentation will focus
on the remaining aspects of your application: the application environment
and the application callback module.
You can learn more about Mix generation of .app
files by typing
mix help compile.app
.
Application environment
Once an application is started, OTP provides an application environment that can be used to configure the application.
Assuming you are inside a Mix project, you can edit the application
function in the mix.exs
file to the following:
def application do
[env: [hello: :world]]
end
In the application function, we can define the default environment values
for our application. By starting your application with iex -S mix
, you
can access the default value:
Application.get_env(:APP_NAME, :hello)
#=> :world
It is also possible to put and delete values from the application value, including new values that are not defined in the environment file (although this should be avoided).
Keep in mind that each application is responsible for its environment. Do not use the functions in this module for directly accessing or modifying the environment of other applications (as it may lead to inconsistent data in the application environment).
Application module callback
Often times, an application defines a supervision tree that must be started
and stopped when the application starts and stops. For such, we need to
define an application module callback. The first step is to define the
module callback in the application definition in the mix.exs
file:
def application do
[mod: {MyApp, []}]
end
Our application now requires the MyApp
module to provide an application
callback. This can be done by invoking use Application
in that module and
defining a start/2
callback, for example:
defmodule MyApp do
use Application
def start(_type, _args) do
MyApp.Supervisor.start_link()
end
end
start/2
typically returns {:ok, pid}
or {:ok, pid, state}
where
pid
identifies the supervision tree and state
is the application state.
args
is the second element of the tuple given to the :mod
option.
The type
argument passed to start/2
is usually :normal
unless in a
distributed setup where application takeovers and failovers are configured.
This particular aspect of applications is explained in more detail in the
OTP documentation:
A developer may also implement the stop/1
callback (automatically defined
by use Application
) which does any application cleanup. It receives the
application state and can return any value. Note that shutting down the
supervisor is automatically handled by the VM.
Summary
Functions
Gets the directory for app
Returns the given path inside app_dir/1
Deletes the key
from the given app
environment
Ensures the given app
and its applications are started
Ensures the given app
is started
Returns the value for key
in app
’s environment in a tuple
Returns the value for key
in app
’s environment
Formats the error reason returned by start/2
,
ensure_started/2
, stop/1
, load/1
and unload/1
,
returns a string
Returns all key-value pairs for app
Gets the application for the given module
Returns the value for key
in app
’s environment
Loads the given app
Returns a list with information about the applications which have been loaded
Puts the value
in key
for the given app
Returns the spec for app
Returns the value for key
in app
’s specification
Starts the given app
Returns a list with information about the applications which are currently running
Stops the given app
Unloads the given app
Types
Functions
Gets the directory for app.
This information is returned based on the code path. Here is an example:
File.mkdir_p!("foo/ebin")
Code.prepend_path("foo/ebin")
Application.app_dir(:foo)
#=> "foo"
Even though the directory is empty and there is no .app
file
it is considered the application directory based on the name
“foo/ebin”. The name may contain a dash -
which is considered
to be the app version and it is removed for the lookup purposes:
File.mkdir_p!("bar-123/ebin")
Code.prepend_path("bar-123/ebin")
Application.app_dir(:bar)
#=> "bar-123"
For more information on code paths, check the Code
module in
Elixir and also Erlang’s :code
module.
Returns the given path inside app_dir/1
.
Deletes the key
from the given app
environment.
See put_env/4
for a description of the options.
ensure_all_started(app, start_type) :: {:ok, [app]} | {:error, {app, term}}
Ensures the given app
and its applications are started.
Same as start/2
but also starts the applications listed under
:applications
in the .app
file in case they were not previously
started.
Ensures the given app
is started.
Same as start/2
but returns :ok
if the application was already
started. This is useful in scripts and in test setup, where test
applications need to be explicitly started:
:ok = Application.ensure_started(:my_test_dep)
Returns the value for key
in app
’s environment in a tuple.
If the configuration parameter does not exist, the function returns :error
.
Returns the value for key
in app
’s environment.
If the configuration parameter does not exist, raises ArgumentError
.
Formats the error reason returned by start/2
,
ensure_started/2
, stop/1
, load/1
and unload/1
,
returns a string.
Gets the application for the given module.
The application is located by analyzing the spec
of all loaded applications. Returns nil
if
the module is not listed in any application spec.
Returns the value for key
in app
’s environment.
If the configuration parameter does not exist, the function returns the
default
value.
Loads the given app
.
In order to be loaded, an .app
file must be in the load paths.
All :included_applications
will also be loaded.
Loading the application does not start it nor load its modules, but it does load its environment.
Returns a list with information about the applications which have been loaded.
Puts the value
in key
for the given app
.
Options
:timeout
- the timeout for the change (defaults to 5000ms):persistent
- persists the given value on application load and reloads
If put_env/4
is called before the application is loaded, the application
environment values specified in the .app
file will override the ones
previously set.
The persistent option can be set to true
when there is a need to guarantee
parameters set with this function will not be overridden by the ones defined
in the application resource file on load. This means persistent values will
stick after the application is loaded and also on application reload.
Returns the spec for app
.
The following keys are returned:
- :description
- :id
- :vsn
- :modules
- :maxP
- :maxT
- :registered
- :included_applications
- :applications
- :mod
- :start_phases
Note the environment is not returned as it can be accessed via
fetch_env/2
. Returns nil
if the application is not loaded.
Returns the value for key
in app
’s specification.
See spec/1
for the supported keys. If the given
specification parameter does not exist, this function
will raise. Returns nil
if the application is not loaded.
Starts the given app
.
If the app
is not loaded, the application will first be loaded using load/1
.
Any included application, defined in the :included_applications
key of the
.app
file will also be loaded, but they won’t be started.
Furthermore, all applications listed in the :applications
key must be explicitly
started before this application is. If not, {:error, {:not_started, app}}
is
returned, where app
is the name of the missing application.
In case you want to automatically load and start all of app
’s dependencies,
see ensure_all_started/2
.
The type
argument specifies the type of the application:
:permanent
- ifapp
terminates, all other applications and the entire node are also terminated.:transient
- ifapp
terminates with:normal
reason, it is reported but no other applications are terminated. If a transient application terminates abnormally, all other applications and the entire node are also terminated.:temporary
- ifapp
terminates, it is reported but no other applications are terminated (the default).
Note that it is always possible to stop an application explicitly by calling
stop/1
. Regardless of the type of the application, no other applications will
be affected.
Note also that the :transient
type is of little practical use, since when a
supervision tree terminates, the reason is set to :shutdown
, not :normal
.
Returns a list with information about the applications which are currently running.
Stops the given app
.
When stopped, the application is still loaded.
Unloads the given app
.
It will also unload all :included_applications
.
Note that the function does not purge the application modules.
Callbacks
start(start_type, start_args :: term) :: {:ok, pid} | {:ok, pid, state} | {:error, reason :: term}
Called when an application is started.
This function is called when an the application is started using
Application.start/2
(and functions on top of that, such as
Application.ensure_started/2
. This function should start the top-level
process of the application (which should be the top supervisor of the
application’s supervision tree if the application follows the OTP design
principles around supervision).
start_type
defines how the application is started:
:normal
- used if the startup is a normal startup or if the application is distributed and is started on the current node because of a failover from another mode and the application specification key:start_phases
is:undefined
.{:takeover, node}
- used if the application is distributed and is started on the current node because of a failover on the nodenode
.{:failover, node}
- used if the application is distributed and is started on the current node because of a failover on nodenode
, and the application specification key:start_phases
is not:undefined
.
start_args
are the arguments passed to the application in the :mod
specification key (e.g., mod: {MyApp, [:my_args]}
).
This function should either return {:ok, pid}
or {:ok, pid, state}
if
startup is successful. pid
should be the pid of the top supervisor. state
can be an arbitrary term, and if omitted will default to []
; if the
application is later stopped, state
is passed to the stop/1
callback (see
the documentation for the stop/2
callback for more information).
use Application
provides no default implementation for the start/2
callback.
Called when an application is stopped.
This function is called when an application has stopped, i.e., when its
supervision tree has been stopped. It should do the opposite of what the
start/2
callback did, and should perform any necessary cleanup. The return
value of this callback is ignored.
state
is the return value of the start/2
callback or the return value of
the prep_stop/1
function if the application module defines such a function.
use Application
defines a default implementation of this function which does
nothing and just returns :ok
.


{% extends '_base.html' %} {% block navform %}
{% endblock navform %} {% block content %}Signs may include a lump in the breast, a change in breast shape, dimpling of the skin, fluid coming from the nipple, a newly inverted nipple, or a red or scaly patch of skin.In those with distant spread of the disease, there may be bone pain, swollen lymph nodes, shortness of breath, or yellow skin.
Create account and get started


Japan's Sakurajima volcano erupts in miles-high plume of ash: Kyodo
TOKYO: Japan's Sakurajima volcano shot smoke and ash miles into the sky on Friday (Nov 8) in its biggest eruption in more than three years, Kyodo News reported.
The volcano, on the southernmost main island of Kyushu, spewed ash 5.5km high, the first time the ash cloud from an eruption has exceeded 5km since July 2016, Kyodo said, citing a local meteorological observatory.
The volcano has been highly active, erupting more than 100 times just this year, the report said, adding no damage has been reported so far.


--- layout: post title: "The Business of Ed-Tech: 2017 So Far" date: 2017-07-01 17:30:00 +0000 tags: image: https://s3.amazonaws.com/hackedu/2017-07-01-casino.jpg imagecredits: https://www.flickr.com/photos/aresauburnphotos/861541643 ---
This article is cross-posted to Hack Education
There have been several articles in the industry and investor press recently that describe the ed-tech market as “on the rebound,” with venture capitalists getting their “second wind” and finding ed-tech once again to be something worth throwing money at.
Yay.
And indeed, according to my calculations too, the amount of money invested in education technology companies is up from this time last year and up from this time in 2015 as well. (And 2015 was a record-setting year for ed-tech investment.)
For what it’s worth, investment analyst firm CB Insights predicts that funding this year will not exceed that 2015 level, but one of the reasons I like to track the data myself is that everyone’s numbers and everyone’s assessment of the industry seem to be different, depending in part on “what counts” as ed-tech.
So far this year, there have been 95 investments in ed-tech companies, totaling $1.8 billion. (And yes, I do include student loan companies here. If you’re an ed-tech analyst and you insist that private student loans are something you shouldn’t or needn’t monitor, you’re not paying attention to what’s going on.)
The average investment this year has been $21.2 million. (The median investment size: $4 million.)
Here’s a comparison of what funding looked like in Julys of previous years:
More than half of deals so far this year have been in what some call “early stage” companies – that is, companies raising seed or their first venture capital funding.
But the bulk of dollars have gone to “late stage” companies. Companies raising seed funding have raised $55 million so far this year. Companies raising C, D, and F rounds have raised over $1 billion.
Number of deals by country:
$1.4 billion in venture capital has gone to US companies so far this year. $280 million has gone to Chinese companies. $34 million has gone to Canadian companies. $25 million has gone to Indian companies.
Investors seem to really like “online education.” There have been 9 investments so far this year in companies that describe themselves that way – what a broad description, I realize – for a total of $320 million.
Tutoring companies also remain popular: 8 investments totaling $151 million.
There were 4 investments in coding bootcamps, totaling $37.6 million.
The type of startup receiving the most funding: student loan companies, which have raised $540 million so far this year.
Investments in companies serving the K–12 sector make up the majority of those funded so far this year. (But note: the kinds of companies that get coverage in the ed-tech and tech press – those that I’m likely to see and include in my research – are more likely to be those targeting K–12 and post-secondary education than those targeting the corporate learning market.)
The companies that have raised the most money so far this year:
These are the ed-tech “startups” that have raised the most venture capital. That is to say, these companies have not IPO’d or been acquired so even if they’re years old, they still sorta count as “startups.” (Clearly not all this funding happened this year):
Most of the investors who’ve participated in the 95 deals so far this year have only participated in one ed-tech deal. There are just 9 firms that have made three or more investments in 2017:
Do note the overlap in their investments – the “herd mentality” of venture capitalists.
There are only a couple of outcomes once a company has raised venture capital. I mean, it has to pay its investors back, of course. So either it gets acquired, merges with another company, goes public, or goes away.
There have been 40 acquisitions so far this year. This is down from 68 this time last year and down from 64 this time in 2015. Acquisitions, that is to say, are down significantly.
Companies that were actively acquiring startups in previous years – Blackboard, Pearson, and PowerSchool for example – have not bought any startups this year. (Frontline Education, which bought five startups last year, has acquired just one so far in 2017.)
Only one education company has gone public this year: Laureate Education, which raised $490 million with its initial public offering.
Stating that the amount of ed-tech investment is up so far this year doesn’t really tell us much about what the ed-tech industry really looks like.
No doubt, we should ask why it’s up – why are investors re-enthused about education companies (particularly when successful exits seem to be slumping)? What role do federal and state education politics play in ed-tech investment? (Private student loans. Coding bootcamps. Betsy DeVos. Donald Trump. For-profit universities. Voucher programs. Online charter schools. And so on…)
Find an error in my calculations? Feel free to file an issue on – or better yet, contribute to – the GitHub repository that powers this analysis.


Analytics Dashboard is an online reporting and business intelligence service that helps you easily analyze your business data, and create insightful reports for informed decision-making. It allows you to easily create and share powerful reports in minutes from MarkLogic database.
MarkLogic's full-text search engine makes it an ideal platform to power advanced search applications. MarkLogic’s full-text search includes faceting, real-time alerting, type-ahead suggestions, snippeting, language support, and much more.


PERLFAQ3
Section: Perl Programmers Reference Guide (1)Updated: 2009-08-15
Index Return to Main Contents
NAME
perlfaq3 - Programming ToolsDESCRIPTION
This section of the FAQ answers questions related to programmer tools and programming support.How do I do (anything)?
Have you looked at CPAN (see perlfaq2)? The chances are that someone has already written a module that can solve your problem. Have you read the appropriate manpages? Here's a brief index:
Basics perldata, perlvar, perlsyn, perlop, perlsub Execution perlrun, perldebug Functions perlfunc Objects perlref, perlmod, perlobj, perltie Data Structures perlref, perllol, perldsc Modules perlmod, perlmodlib, perlsub Regexes perlre, perlfunc, perlop, perllocale Moving to perl5 perltrap, perl Linking w/C perlxstut, perlxs, perlcall, perlguts, perlembed Various http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz (not a man-page but still useful, a collection of various essays on Perl techniques)
A crude table of contents for the Perl manpage set is found in perltoc.
How can I use Perl interactively?
The typical approach uses the Perl debugger, described in the perldebug(1) manpage, on an ``empty'' program, like this:
perl -de 42
Now just type in any legal Perl code, and it will be immediately evaluated. You can also examine the symbol table, get stack backtraces, check variable values, set breakpoints, and other operations typically found in symbolic debuggers.
Is there a Perl shell?
The psh (Perl sh) is currently at version 1.8. The Perl Shell is a shell that combines the interactive nature of a Unix shell with the power of Perl. The goal is a full featured shell that behaves as expected for normal shell activity and uses Perl syntax and functionality for control-flow statements and other things. You can get psh at http://sourceforge.net/projects/psh/ .Zoidberg is a similar project and provides a shell written in perl, configured in perl and operated in perl. It is intended as a login shell and development environment. It can be found at http://pardus-larus.student.utwente.nl/~pardus/projects/zoidberg/ or your local CPAN mirror.
The Shell.pm module (distributed with Perl) makes Perl try commands which aren't part of the Perl language as shell commands. perlsh from the source distribution is simplistic and uninteresting, but may still be what you want.
How do I find which modules are installed on my system?
From the command line, you can use the "cpan" command's "-l" switch:
$ cpan -l
You can also use "cpan"'s "-a" switch to create an autobundle file that "CPAN.pm" understands and cna use to re-install every module:
$ cpan -a
Inside a Perl program, you can use the ExtUtils::Installed module to show all installed distributions, although it can take awhile to do its magic. The standard library which comes with Perl just shows up as ``Perl'' (although you can get those with Module::CoreList).
use ExtUtils::Installed; my $inst = ExtUtils::Installed->new(); my @modules = $inst->modules();
If you want a list of all of the Perl module filenames, you can use File::Find::Rule.
use File::Find::Rule; my @files = File::Find::Rule-> extras({follow => 1})-> file()-> name( '*.pm' )-> in( @INC ) ;
If you do not have that module, you can do the same thing with File::Find which is part of the standard library.
use File::Find; my @files; find( { wanted => sub { push @files, $File::Find::fullname if -f $File::Find::fullname && /\.pm$/ }, follow => 1, follow_skip => 2, }, @INC ); print join "\n", @files;
If you simply need to quickly check to see if a module is available, you can check for its documentation. If you can read the documentation the module is most likely installed. If you cannot read the documentation, the module might not have any (in rare cases).
$ perldoc Module::Name
You can also try to include the module in a one-liner to see if perl finds it.
$ perl -MModule::Name -e1
How do I debug my Perl programs?
(contributed by brian d foy)Before you do anything else, you can help yourself by ensuring that you let Perl tell you about problem areas in your code.  You can find out more about these in strict and warnings.
#!/usr/bin/perl use strict; use warnings;
Beyond that, the simplest debugger is the "print" function. Use it to look at values as you run your program:
print STDERR "The value is [$value]\n";
The "Data::Dumper" module can pretty-print Perl data structures:
use Data::Dumper qw( Dumper ); print STDERR "The hash is " . Dumper( \%hash ) . "\n";
Perl comes with an interactive debugger, which you can start with the "-d" switch. It's fully explained in perldebug.
If you'd like a graphical user interface and you have Tk, you can use "ptkdb". It's on CPAN and available for free.
If you need something much more sophisticated and controllable, Leon Brocard's Devel::ebug (which you can call with the -D switch as -Debug) gives you the programmatic hooks into everything you need to write your own (without too much pain and suffering).
You can also use a commercial debugger such as Affrus (Mac OS X), Komodo from Activestate (Windows and Mac OS X), or EPIC (most platforms).
How do I profile my Perl programs?
(contributed by brian d foy, updated Fri Jul 25 12:22:26 PDT 2008)The "Devel" namespace has several modules which you can use to profile your Perl programs. The "Devel::DProf" module comes with Perl and you can invoke it with the "-d" switch:
perl -d:DProf program.pl
After running your program under "DProf", you'll get a tmon.out file with the profile data. To look at the data, you can turn it into a human-readable report with the "dprofpp" program that comes with "Devel::DProf".
dprofpp
You can also do the profiling and reporting in one step with the "-p" switch to <dprofpp>:
dprofpp -p program.pl
The "Devel::NYTProf" (New York Times Profiler) does both statement and subroutine profiling. It's available from CPAN and you also invoke it with the "-d" switch:
perl -d:NYTProf some_perl.pl
Like "DProf", it creates a database of the profile information that you can turn into reports. The "nytprofhtml" command turns the data into an HTML report similar to the "Devel::Cover" report:
nytprofhtml
CPAN has several other profilers that you can invoke in the same fashion. You might also be interested in using the "Benchmark" to measure and compare code snippets.
You can read more about profiling in Programming Perl, chapter 20, or Mastering Perl, chapter 5.
perldebguts documents creating a custom debugger if you need to create a special sort of profiler. brian d foy describes the process in The Perl Journal, ``Creating a Perl Debugger'', http://www.ddj.com/184404522 , and ``Profiling in Perl'' http://www.ddj.com/184404580 .
Perl.com has two interesting articles on profiling: ``Profiling Perl'', by Simon Cozens, http://www.perl.com/lpt/a/850 and ``Debugging and Profiling mod_perl Applications'', by Frank Wiles, http://www.perl.com/pub/a/2006/02/09/debug_mod_perl.html .
Randal L. Schwartz writes about profiling in ``Speeding up Your Perl Programs'' for Unix Review, http://www.stonehenge.com/merlyn/UnixReview/col49.html , and ``Profiling in Template Toolkit via Overriding'' for Linux Magazine, http://www.stonehenge.com/merlyn/LinuxMag/col75.html .
How do I cross-reference my Perl programs?
The B::Xref module can be used to generate cross-reference reports for Perl programs.
perl -MO=Xref[,OPTIONS] scriptname.plx
Is there a pretty-printer (formatter) for Perl?
Perltidy is a Perl script which indents and reformats Perl scripts to make them easier to read by trying to follow the rules of the perlstyle. If you write Perl scripts, or spend much time reading them, you will probably find it useful. It is available at http://perltidy.sourceforge.netOf course, if you simply follow the guidelines in perlstyle, you shouldn't need to reformat. The habit of formatting your code as you write it will help prevent bugs. Your editor can and should help you with this. The perl-mode or newer cperl-mode for emacs can provide remarkable amounts of help with most (but not all) code, and even less programmable editors can provide significant assistance. Tom Christiansen and many other VI users swear by the following settings in vi and its clones:
set ai sw=4 map! ^O {^M}^[O^T
Put that in your .exrc file (replacing the caret characters with control characters) and away you go. In insert mode, ^T is for indenting, ^D is for undenting, and ^O is for blockdenting---as it were. A more complete example, with comments, can be found at http://www.cpan.org/authors/id/TOMC/scripts/toms.exrc.gz
The a2ps http://www-inf.enst.fr/%7Edemaille/a2ps/black+white.ps.gz does lots of things related to generating nicely printed output of documents.
Is there a ctags for Perl?
(contributed by brian d foy)Ctags uses an index to quickly find things in source code, and many popular editors support ctags for several different languages, including Perl.
Exuberent ctags supports Perl: http://ctags.sourceforge.net/
You might also try pltags: http://www.mscha.com/pltags.zip
Is there an IDE or Windows Perl Editor?
Perl programs are just plain text, so any editor will do.If you're on Unix, you already have an IDE---Unix itself. The UNIX philosophy is the philosophy of several small tools that each do one thing and do it well. It's like a carpenter's toolbox.
If you want an IDE, check the following (in alphabetical order, not order of preference):
- Eclipse
-
http://e-p-i-c.sf.net/
The Eclipse Perl Integration Project integrates Perl editing/debugging with Eclipse.
- Enginsite
-
http://www.enginsite.com/
Perl Editor by EngInSite is a complete integrated development environment (IDE) for creating, testing, and debugging Perl scripts; the tool runs on Windows 9x/NT/2000/XP or later.
- Komodo
-
http://www.ActiveState.com/Products/Komodo/
ActiveState's cross-platform (as of October 2004, that's Windows, Linux, and Solaris), multi-language IDE has Perl support, including a regular expression debugger and remote debugging.
- Open Perl IDE
-
http://open-perl-ide.sourceforge.net/
Open Perl IDE is an integrated development environment for writing and debugging Perl scripts with ActiveState's ActivePerl distribution under Windows 95/98/NT/2000.
- OptiPerl
-
http://www.optiperl.com/
OptiPerl is a Windows IDE with simulated CGI environment, including debugger and syntax highlighting editor.
- Padre
-
http://padre.perlide.org/
Padre is cross-platform IDE for Perl written in Perl using the the wxWidgets to provide a native look and feel. It's open source under the Artistic License.
- PerlBuilder
-
http://www.solutionsoft.com/perl.htm
PerlBuilder is an integrated development environment for Windows that supports Perl development.
- visiPerl+
-
http://helpconsulting.net/visiperl/
From Help Consulting, for Windows.
- Visual Perl
-
http://www.activestate.com/Products/Visual_Perl/
Visual Perl is a Visual Studio.NET plug-in from ActiveState.
- Zeus
-
http://www.zeusedit.com/lookmain.html
Zeus for Window is another Win32 multi-language editor/IDE that comes with support for Perl:
For editors: if you're on Unix you probably have vi or a vi clone already, and possibly an emacs too, so you may not need to download anything. In any emacs the cperl-mode (M-x cperl-mode) gives you perhaps the best available Perl editing mode in any editor.
If you are using Windows, you can use any editor that lets you work with plain text, such as NotePad or WordPad. Word processors, such as Microsoft Word or WordPerfect, typically do not work since they insert all sorts of behind-the-scenes information, although some allow you to save files as ``Text Only''. You can also download text editors designed specifically for programming, such as Textpad ( http://www.textpad.com/ ) and UltraEdit ( http://www.ultraedit.com/ ), among others.
If you are using MacOS, the same concerns apply. MacPerl (for Classic environments) comes with a simple editor. Popular external editors are BBEdit ( http://www.bbedit.com/ ) or Alpha ( http://www.his.com/~jguyer/Alpha/Alpha8.html ). MacOS X users can use Unix editors as well.
- GNU Emacs
- http://www.gnu.org/software/emacs/windows/ntemacs.html
- MicroEMACS
- http://www.microemacs.de/
- XEmacs
- http://www.xemacs.org/Download/index.html
- Jed
- http://space.mit.edu/~davis/jed/
or a vi clone such as
- Elvis
- ftp://ftp.cs.pdx.edu/pub/elvis/ http://www.fh-wedel.de/elvis/
- Vile
- http://dickey.his.com/vile/vile.html
- Vim
- http://www.vim.org/
For vi lovers in general, Windows or elsewhere:
http://www.thomer.com/thomer/vi/vi.html
nvi ( http://www.bostic.com/vi/ , available from CPAN in src/misc/) is yet another vi clone, unfortunately not available for Windows, but in UNIX platforms you might be interested in trying it out, firstly because strictly speaking it is not a vi clone, it is the real vi, or the new incarnation of it, and secondly because you can embed Perl inside it to use Perl as the scripting language. nvi is not alone in this, though: at least also vim and vile offer an embedded Perl.
The following are Win32 multilanguage editor/IDEs that support Perl:
- Codewright
- http://www.borland.com/codewright/
- MultiEdit
- http://www.MultiEdit.com/
- SlickEdit
- http://www.slickedit.com/
- ConTEXT
- http://www.contexteditor.org/
There is also a toyedit Text widget based editor written in Perl that is distributed with the Tk module on CPAN. The ptkdb ( http://ptkdb.sourceforge.net/ ) is a Perl/tk based debugger that acts as a development environment of sorts. Perl Composer ( http://perlcomposer.sourceforge.net/ ) is an IDE for Perl/Tk GUI creation.
In addition to an editor/IDE you might be interested in a more powerful shell environment for Win32. Your options include
- Bash
- from the Cygwin package ( http://sources.redhat.com/cygwin/ )
- Ksh
- from the MKS Toolkit ( http://www.mkssoftware.com/ ), or the Bourne shell of the U/WIN environment ( http://www.research.att.com/sw/tools/uwin/ )
- Tcsh
- ftp://ftp.astron.com/pub/tcsh/ , see also http://www.primate.wisc.edu/software/csh-tcsh-book/
- Zsh
- http://www.zsh.org/
MKS and U/WIN are commercial (U/WIN is free for educational and research purposes), Cygwin is covered by the GNU General Public License (but that shouldn't matter for Perl use). The Cygwin, MKS, and U/WIN all contain (in addition to the shells) a comprehensive set of standard UNIX toolkit utilities.
If you're transferring text files between Unix and Windows using FTP be sure to transfer them in ASCII mode so the ends of lines are appropriately converted.
On Mac OS the MacPerl Application comes with a simple 32k text editor that behaves like a rudimentary IDE. In contrast to the MacPerl Application the MPW Perl tool can make use of the MPW Shell itself as an editor (with no 32k limit).
- Affrus
- is a full Perl development environment with full debugger support ( http://www.latenightsw.com ).
- Alpha
- is an editor, written and extensible in Tcl, that nonetheless has built in support for several popular markup and programming languages including Perl and HTML ( http://www.his.com/~jguyer/Alpha/Alpha8.html ).
- BBEdit and BBEdit Lite
- are text editors for Mac OS that have a Perl sensitivity mode ( http://web.barebones.com/ ).
Where can I get Perl macros for vi?
For a complete version of Tom Christiansen's vi configuration file, see http://www.cpan.org/authors/Tom_Christiansen/scripts/toms.exrc.gz , the standard benchmark file for vi emulators. The file runs best with nvi, the current version of vi out of Berkeley, which incidentally can be built with an embedded Perl interpreter---see http://www.cpan.org/src/misc/ .Where can I get perl-mode for emacs?
Since Emacs version 19 patchlevel 22 or so, there have been both a perl-mode.el and support for the Perl debugger built in. These should come with the standard Emacs 19 distribution.In the Perl source directory, you'll find a directory called ``emacs'', which contains a cperl-mode that color-codes keywords, provides context-sensitive help, and other nifty things.
Note that the perl-mode of emacs will have fits with "main'foo" (single quote), and mess up the indentation and highlighting. You are probably using "main::foo" in new Perl code anyway, so this shouldn't be an issue.
How can I use curses with Perl?
The Curses module from CPAN provides a dynamically loadable object module interface to a curses library. A small demo can be found at the directory http://www.cpan.org/authors/Tom_Christiansen/scripts/rep.gz ; this program repeats a command and updates the screen as needed, rendering rep ps axu similar to top.How can I write a GUI (X, Tk, Gtk, etc.) in Perl?
(contributed by Ben Morrow)There are a number of modules which let you write GUIs in Perl. Most GUI toolkits have a perl interface: an incomplete list follows.
- Tk
- This works under Unix and Windows, and the current version doesn't look half as bad under Windows as it used to. Some of the gui elements still don't 'feel' quite right, though. The interface is very natural and 'perlish', making it easy to use in small scripts that just need a simple gui. It hasn't been updated in a while.
- Wx
- This is a Perl binding for the cross-platform wxWidgets toolkit ( http://www.wxwidgets.org ). It works under Unix, Win32 and Mac OS X, using native widgets (Gtk under Unix). The interface follows the C++ interface closely, but the documentation is a little sparse for someone who doesn't know the library, mostly just referring you to the C++ documentation.
- Gtk and Gtk2
- These are Perl bindings for the Gtk toolkit ( http://www.gtk.org ). The interface changed significantly between versions 1 and 2 so they have separate Perl modules. It runs under Unix, Win32 and Mac OS X (currently it requires an X server on Mac OS, but a 'native' port is underway), and the widgets look the same on every plaform: i.e., they don't match the native widgets. As with Wx, the Perl bindings follow the C API closely, and the documentation requires you to read the C documentation to understand it.
- Win32::GUI
- This provides access to most of the Win32 GUI widgets from Perl. Obviously, it only runs under Win32, and uses native widgets. The Perl interface doesn't really follow the C interface: it's been made more Perlish, and the documentation is pretty good. More advanced stuff may require familiarity with the C Win32 APIs, or reference to MSDN.
- CamelBones
- CamelBones ( http://camelbones.sourceforge.net ) is a Perl interface to Mac OS X's Cocoa GUI toolkit, and as such can be used to produce native GUIs on Mac OS X. It's not on CPAN, as it requires frameworks that CPAN.pm doesn't know how to install, but installation is via the standard OSX package installer. The Perl API is, again, very close to the ObjC API it's wrapping, and the documentation just tells you how to translate from one to the other.
- Qt
- There is a Perl interface to TrollTech's Qt toolkit, but it does not appear to be maintained.
- Athena
- Sx is an interface to the Athena widget set which comes with X, but again it appears not to be much used nowadays.
How can I make my Perl program run faster?
The best way to do this is to come up with a better algorithm. This can often make a dramatic difference. Jon Bentley's book Programming Pearls (that's not a misspelling!) has some good tips on optimization, too. Advice on benchmarking boils down to: benchmark and profile to make sure you're optimizing the right part, look for better algorithms instead of microtuning your code, and when all else fails consider just buying faster hardware. You will probably want to read the answer to the earlier question ``How do I profile my Perl programs?'' if you haven't done so already.A different approach is to autoload seldom-used Perl code. See the AutoSplit and AutoLoader modules in the standard distribution for that. Or you could locate the bottleneck and think about writing just that part in C, the way we used to take bottlenecks in C code and write them in assembler. Similar to rewriting in C, modules that have critical sections can be written in C (for instance, the PDL module from CPAN).
If you're currently linking your perl executable to a shared libc.so, you can often gain a 10-25% performance benefit by rebuilding it to link with a static libc.a instead. This will make a bigger perl executable, but your Perl programs (and programmers) may thank you for it. See the INSTALL file in the source distribution for more information.
The undump program was an ancient attempt to speed up Perl program by storing the already-compiled form to disk. This is no longer a viable option, as it only worked on a few architectures, and wasn't a good solution anyway.
How can I make my Perl program take less memory?
When it comes to time-space tradeoffs, Perl nearly always prefers to throw memory at a problem. Scalars in Perl use more memory than strings in C, arrays take more than that, and hashes use even more. While there's still a lot to be done, recent releases have been addressing these issues. For example, as of 5.004, duplicate hash keys are shared amongst all hashes using them, so require no reallocation.In some cases, using substr() or vec() to simulate arrays can be highly beneficial. For example, an array of a thousand booleans will take at least 20,000 bytes of space, but it can be turned into one 125-byte bit vector---a considerable memory savings. The standard Tie::SubstrHash module can also help for certain types of data structure. If you're working with specialist data structures (matrices, for instance) modules that implement these in C may use less memory than equivalent Perl modules.
Another thing to try is learning whether your Perl was compiled with the system malloc or with Perl's builtin malloc. Whichever one it is, try using the other one and see whether this makes a difference. Information about malloc is in the INSTALL file in the source distribution. You can find out whether you are using perl's malloc by typing "perl -V:usemymalloc".
Of course, the best way to save memory is to not do anything to waste it in the first place. Good programming practices can go a long way toward this:
- *
-
Don't slurp!
Don't read an entire file into memory if you can process it line by line. Or more concretely, use a loop like this:
# # Good Idea # while (<FILE>) { # ... }
instead of this:
# # Bad Idea # @data = <FILE>; foreach (@data) { # ... }
When the files you're processing are small, it doesn't much matter which way you do it, but it makes a huge difference when they start getting larger.
- *
-
Use map and grep selectively
Remember that both map and grep expect a LIST argument, so doing this:
@wanted = grep {/pattern/} <FILE>;
will cause the entire file to be slurped. For large files, it's better to loop:
while (<FILE>) { push(@wanted, $_) if /pattern/; }
- *
-
Avoid unnecessary quotes and stringification
Don't quote large strings unless absolutely necessary:
my $copy = "$large_string";
makes 2 copies of $large_string (one for $copy and another for the quotes), whereas
my $copy = $large_string;
only makes one copy.
Ditto for stringifying large arrays:
{ local $, = "\n"; print @big_array; }
is much more memory-efficient than either
print join "\n", @big_array;
or
{ local $" = "\n"; print "@big_array"; }
- *
-
Pass by reference
Pass arrays and hashes by reference, not by value. For one thing, it's the only way to pass multiple lists or hashes (or both) in a single call/return. It also avoids creating a copy of all the contents. This requires some judgement, however, because any changes will be propagated back to the original data. If you really want to mangle (er, modify) a copy, you'll have to sacrifice the memory needed to make one.
- *
-
Tie large variables to disk.
For ``big'' data stores (i.e. ones that exceed available memory) consider using one of the DB modules to store it on disk instead of in RAM. This will incur a penalty in access time, but that's probably better than causing your hard disk to thrash due to massive swapping.
Is it safe to return a reference to local or lexical data?
Yes. Perl's garbage collection system takes care of this so everything works out right.
sub makeone { my @a = ( 1 .. 10 ); return \@a; } for ( 1 .. 10 ) { push @many, makeone(); } print $many[4][5], "\n"; print "@many\n";
How can I free an array or hash so my program shrinks?
(contributed by Michael Carman)You usually can't. Memory allocated to lexicals (i.e. my() variables) cannot be reclaimed or reused even if they go out of scope. It is reserved in case the variables come back into scope. Memory allocated to global variables can be reused (within your program) by using undef() and/or delete().
On most operating systems, memory allocated to a program can never be returned to the system. That's why long-running programs sometimes re- exec themselves. Some operating systems (notably, systems that use mmap(2) for allocating large chunks of memory) can reclaim memory that is no longer used, but on such systems, perl must be configured and compiled to use the OS's malloc, not perl's.
In general, memory allocation and de-allocation isn't something you can or should be worrying about much in Perl.
See also ``How can I make my Perl program take less memory?''
How can I make my CGI script more efficient?
Beyond the normal measures described to make general Perl programs faster or smaller, a CGI program has additional issues. It may be run several times per second. Given that each time it runs it will need to be re-compiled and will often allocate a megabyte or more of system memory, this can be a killer. Compiling into C isn't going to help you because the process start-up overhead is where the bottleneck is.There are two popular ways to avoid this overhead. One solution involves running the Apache HTTP server (available from http://www.apache.org/ ) with either of the mod_perl or mod_fastcgi plugin modules.
With mod_perl and the Apache::Registry module (distributed with mod_perl), httpd will run with an embedded Perl interpreter which pre-compiles your script and then executes it within the same address space without forking. The Apache extension also gives Perl access to the internal server API, so modules written in Perl can do just about anything a module written in C can. For more on mod_perl, see http://perl.apache.org/
With the FCGI module (from CPAN) and the mod_fastcgi module (available from http://www.fastcgi.com/ ) each of your Perl programs becomes a permanent CGI daemon process.
Both of these solutions can have far-reaching effects on your system and on the way you write your CGI programs, so investigate them with care.
See http://www.cpan.org/modules/by-category/15_World_Wide_Web_HTML_HTTP_CGI/ .
How can I hide the source for my Perl program?
Delete it. :-) Seriously, there are a number of (mostly unsatisfactory) solutions with varying levels of ``security''.First of all, however, you can't take away read permission, because the source code has to be readable in order to be compiled and interpreted. (That doesn't mean that a CGI script's source is readable by people on the web, though---only by people with access to the filesystem.) So you have to leave the permissions at the socially friendly 0755 level.
Some people regard this as a security problem. If your program does insecure things and relies on people not knowing how to exploit those insecurities, it is not secure. It is often possible for someone to determine the insecure things and exploit them without viewing the source. Security through obscurity, the name for hiding your bugs instead of fixing them, is little security indeed.
You can try using encryption via source filters (Starting from Perl 5.8 the Filter::Simple and Filter::Util::Call modules are included in the standard distribution), but any decent programmer will be able to decrypt it. You can try using the byte code compiler and interpreter described later in perlfaq3, but the curious might still be able to de-compile it. You can try using the native-code compiler described later, but crackers might be able to disassemble it. These pose varying degrees of difficulty to people wanting to get at your code, but none can definitively conceal it (true of every language, not just Perl).
It is very easy to recover the source of Perl programs. You simply feed the program to the perl interpreter and use the modules in the B:: hierarchy. The B::Deparse module should be able to defeat most attempts to hide source. Again, this is not unique to Perl.
If you're concerned about people profiting from your code, then the bottom line is that nothing but a restrictive license will give you legal security. License your software and pepper it with threatening statements like ``This is unpublished proprietary software of XYZ Corp. Your access to it does not give you permission to use it blah blah blah.'' We are not lawyers, of course, so you should see a lawyer if you want to be sure your license's wording will stand up in court.
How can I compile my Perl program into byte code or C?
(contributed by brian d foy)In general, you can't do this. There are some things that may work for your situation though. People usually ask this question because they want to distribute their works without giving away the source code, and most solutions trade disk space for convenience. You probably won't see much of a speed increase either, since most solutions simply bundle a Perl interpreter in the final product (but see ``How can I make my Perl program run faster?'').
The Perl Archive Toolkit ( http://par.perl.org/ ) is Perl's analog to Java's JAR. It's freely available and on CPAN ( http://search.cpan.org/dist/PAR/ ).
There are also some commercial products that may work for you, although you have to buy a license for them.
The Perl Dev Kit ( http://www.activestate.com/Products/Perl_Dev_Kit/ ) from ActiveState can ``Turn your Perl programs into ready-to-run executables for HP-UX, Linux, Solaris and Windows.''
Perl2Exe ( http://www.indigostar.com/perl2exe.htm ) is a command line program for converting perl scripts to executable files. It targets both Windows and unix platforms.
How can I get #!perl to work on [MS-DOS,NT,...]?
For OS/2 just use
extproc perl -S -your_switches
as the first line in "*.cmd" file ("-S" due to a bug in cmd.exe's ``extproc'' handling). For DOS one should first invent a corresponding batch file and codify it in "ALTERNATE_SHEBANG" (see the dosish.h file in the source distribution for more information).
The Win95/NT installation, when using the ActiveState port of Perl, will modify the Registry to associate the ".pl" extension with the perl interpreter. If you install another port, perhaps even building your own Win95/NT Perl from the standard sources by using a Windows port of gcc (e.g., with cygwin or mingw32), then you'll have to modify the Registry yourself. In addition to associating ".pl" with the interpreter, NT people can use: "SET PATHEXT=%PATHEXT%;.PL" to let them run the program "install-linux.pl" merely by typing "install-linux".
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/ .
IMPORTANT!: Whatever you do, PLEASE don't get frustrated, and just throw the perl interpreter into your cgi-bin directory, in order to get your programs working for a web server. This is an EXTREMELY big security risk. Take the time to figure out how to do it correctly.
Can I write useful Perl programs on the command line?
Yes. Read perlrun for more information. Some examples follow. (These assume standard Unix shell quoting rules.)
# sum first and last fields perl -lane 'print $F[0] + $F[-1]' * # identify text files perl -le 'for(@ARGV) {print if -f && -T _}' * # remove (most) comments from C program perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c # make file a month younger than today, defeating reaper daemons perl -e '$X=24*60*60; utime(time(),time() + 30 * $X,@ARGV)' * # find first unused uid perl -le '$i++ while getpwuid($i); print $i' # display reasonable manpath echo $PATH | perl -nl -072 -e ' s![^/+]*$!man!&&-d&&!$s{$_}++&&push@m,$_;END{print"@m"}'
OK, the last one was actually an Obfuscated Perl Contest entry. :-)
Why don't Perl one-liners work on my DOS/Mac/VMS system?
The problem is usually that the command interpreters on those systems have rather different ideas about quoting than the Unix shells under which the one-liners were created. On some systems, you may have to change single-quotes to double ones, which you must NOT do on Unix or Plan9 systems. You might also have to change a single % to a %%.For example:
# Unix (including Mac OS X) perl -e 'print "Hello world\n"' # DOS, etc. perl -e "print \"Hello world\n\"" # Mac Classic print "Hello world\n" (then Run "Myscript" or Shift-Command-R) # MPW perl -e 'print "Hello world\n"' # VMS perl -e "print ""Hello world\n"""
The problem is that none of these examples are reliable: they depend on the command interpreter. Under Unix, the first two often work. Under DOS, it's entirely possible that neither works. If 4DOS was the command shell, you'd probably have better luck like this:
perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
Under the Mac, 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 Mac's non-ASCII characters as control characters.
Using qq(), q(), and qx(), instead of ``double quotes'', 'single quotes', and `backticks`, may make one-liners easier to write.
There is no general solution to all of this. It is a mess.
[Some of this answer was contributed by Kenneth Albanowski.]
Where can I learn about CGI or Web programming in Perl?
For modules, get the CGI or LWP modules from CPAN. For textbooks, see the two especially dedicated to web stuff in the question on books. For problems and questions related to the web, like ``Why do I get 500 Errors'' or ``Why doesn't it run from the browser right when it runs fine on the command line'', see the troubleshooting guides and references in perlfaq9 or in the CGI MetaFAQ:
http://www.perl.org/CGI_MetaFAQ.html
Where can I learn about object-oriented Perl programming?
A good place to start is perltoot, and you can use perlobj, perlboot, perltoot, perltooc, and perlbot for reference.A good book on OO on Perl is the ``Object-Oriented Perl'' by Damian Conway from Manning Publications, or ``Intermediate Perl'' by Randal Schwartz, brian d foy, and Tom Phoenix from O'Reilly Media.
Where can I learn about linking C with Perl?
If you want to call C from Perl, start with perlxstut, moving on to perlxs, xsubpp, and perlguts. If you want to call Perl from C, then read perlembed, perlcall, and perlguts. Don't forget that you can learn a lot from looking at how the authors of existing extension modules wrote their code and solved their problems.You might not need all the power of XS. The Inline::C module lets you put C code directly in your Perl source. It handles all the magic to make it work. You still have to learn at least some of the perl API but you won't have to deal with the complexity of the XS support files.
I've read perlembed, perlguts, etc., but I can't embed perl in my C program; what am I doing wrong?
Download the ExtUtils::Embed kit from CPAN and run `make test'. If the tests pass, read the pods again and again and again. If they fail, see perlbug and send a bug report with the output of "make test TEST_VERBOSE=1" along with "perl -V".When I tried to run my script, I got this message. What does it mean?
A complete list of Perl's error messages and warnings with explanatory text can be found in perldiag. You can also use the splain program (distributed with Perl) to explain the error messages:
perl program 2>diag.out splain [-v] [-p] diag.out
or change your program to explain the messages for you:
use diagnostics;
or
use diagnostics -verbose;
What's MakeMaker?
(contributed by brian d foy)The "ExtUtils::MakeMaker" module, better known simply as ``MakeMaker'', turns a Perl script, typically called "Makefile.PL", into a Makefile. The unix tool "make" uses this file to manage dependencies and actions to process and install a Perl distribution.
REVISION
Revision: $Revision$Date: $Date$
See perlfaq for source control details and availability.
AUTHOR AND COPYRIGHT
Copyright (c) 1997-2009 Tom Christiansen, Nathan Torkington, and other authors as noted. All rights reserved.This documentation is free; you can redistribute it and/or modify it under the same terms as Perl itself.
Irrespective of its distribution, all code examples here are in the public domain. You are permitted and encouraged to use this code and any derivatives thereof in your own programs for fun or for profit as you see fit. A simple comment in the code giving credit to the FAQ would be courteous but is not required.
Index
- NAME
- DESCRIPTION
-
- How do I do (anything)?
- How can I use Perl interactively?
- Is there a Perl shell?
- How do I find which modules are installed on my system?
- How do I debug my Perl programs?
- How do I profile my Perl programs?
- How do I cross-reference my Perl programs?
- Is there a pretty-printer (formatter) for Perl?
- Is there a ctags for Perl?
- Is there an IDE or Windows Perl Editor?
- Where can I get Perl macros for vi?
- Where can I get perl-mode for emacs?
- How can I use curses with Perl?
- How can I write a GUI (X, Tk, Gtk, etc.) in Perl?
- How can I make my Perl program run faster?
- How can I make my Perl program take less memory?
- Is it safe to return a reference to local or lexical data?
- How can I free an array or hash so my program shrinks?
- How can I make my CGI script more efficient?
- How can I hide the source for my Perl program?
- How can I compile my Perl program into byte code or C?
- How can I get #!perl to work on [MS-DOS,NT,...]?
- Can I write useful Perl programs on the command line?
- Why don't Perl one-liners work on my DOS/Mac/VMS system?
- Where can I learn about CGI or Web programming in Perl?
- Where can I learn about object-oriented Perl programming?
- Where can I learn about linking C with Perl?
- I've read perlembed, perlguts, etc., but I can't embed perl in my C program; what am I doing wrong?
- When I tried to run my script, I got this message. What does it mean?
- What's MakeMaker?
- REVISION
- AUTHOR AND COPYRIGHT
This document was created by man2html, using the manual pages.
Time: 05:29:08 GMT, December 24, 2015


| S.No. | Student Name | Student Role No | Student Class | Action |
|---|---|---|---|---|
| {{i+1}} | {{student.studentName}} | {{student.studentRollNo}} | {{student.className}} |
|
| Photo | |
| Student Name | {{selectedStudentDetail.userName}} |
| Student RollNo | {{selectedStudentDetail.studentRollNo}} |
| Gender | {{selectedStudentDetail.gender}} |
| Class | {{selectedStudentDetail.className}} |
| School Name | {{selectedStudentDetail.schoolName}} |
| Father Name | {{selectedStudentDetail.fatherName}} |
| Father Username | {{selectedStudentDetail.fatherID}} |
| Father EmailID | {{selectedStudentDetail.fatherEmail}} |
| Father Mobile | {{selectedStudentDetail.fatherMobile}} |
| Mother Name | {{selectedStudentDetail.motherName}} |
| Mother Username | {{selectedStudentDetail.motherID}} |
| Mother EmailID | {{selectedStudentDetail.motherEmail}} |
| Mother Mobile | {{selectedStudentDetail.motherMobile}} |
Are you sure to delete this student?


Welcome!
Supporting text.
Call NowBacon ipsum dolor amet chuck sirloin doner pork chop tongue, short loin spare ribs pancetta beef ribs. Pancetta spare ribs turkey capicola bresaola beef ribs brisket corned beef meatball landjaeger hamburger shank meatloaf filet mignon. Chicken picanha shankle ribeye. Cow frankfurter meatloaf meatball tail t-bone alcatra kielbasa tenderloin ground round pig shoulder.
Showcase of our vehicles
short loin spare ribs pancetta beef ribs. Pancetta spare ribs turkey capicola bresaola beef ribs brisket corned beef meatball landjaeger hamburger shank meatloaf filet mignon. Chicken picanha shankle ribeye. Cow frankfurter meatloaf meatball tail t-bone alcatra kielbasa tenderloin ground round pig shoulder.
Call


{% extends "registration/base.html" %} {% load bootstrap4 %} {% load static %} {% block content %}
"The main objective for me is security, I do not want to have to answer to my neighbors."
~ Evans
Please Login to dive into our neighborhood!


Numbers 29:8
But ye shall offer a burnt offering unto the LORD for a sweet savor; one young bullock, one ram, and seven lambs of the first year; they shall be unto you without blemish:


My research explores how new media writing might attend to the ethical tuning of specific spaces and places in a networked posthuman ecology. I'm especially interested in multimodal communication, and specifically how we can use code to improve such experiences and make them more accessible.
Family and Home
I'm married to Dr. Cassie Quigley who works in Pitt's School of Education and we have two children together.
Entertainment
Riding bikes has always been an important part of my life. I guess this started with a movie I watched as a little kid, called Breaking Away. The main character felt trapped by his circumstances growing up in a small working class Indiana town, so he used the bicycle as a means of escape.
The main character took on an Italian persona, studied the language, sang arias, and used his bike to travel the countryside and improve himself physically. Apart from it's utilitarian value, the concept of the bicycle as a vehicle fascinated me - here was this relatively cheap form of transportation that could also serve as a tool for becoming.
I spent a lot of time riding my bike and dreaming. I also raced bikes all across America, and in Netherlands, Belgium, and France. When not writing papers, I still follow cycling online, reading blogs, and watching vlogs. It is my escape. It is this double life I live. That I am not willing to ever give up. There is just too much there.
Community
I gravitate towards other learners. My close friends have always been other people who like books and podcasts, who want to do cool things with their lives and make big days.
I think the real challenge has always seen to extend this learning, this passion for listening, engaging...to other people in our community. That’s our role as learners and educators. To include others in the process of becoming so that our work benefits others, just as others’ work has benefited our own.
School
I taught high school for 8 years which provided me with the most important education I’ve ever received. I worked with students in a number of different settings from international schools in Ireland and Cambodia, and in US inner-city schools and suburbs. In those 8 years I had much learning to do as a human being.
In the years since, I have sought through my teaching to continue that spirit of everyday learning; my students, colleagues, and our discourse have so much to teach me. I'm looking forward to our time together, and excited to see where this class will take us.


Christopher Biggins fears political correctness has driven Krankies out of panto
Christopher Biggins is worried that pantomime stars like the Krankies will abandon the festive plays due to ‘political correctness’.
Biggins is a staple of the pantomime scene, having played Widow Twankey in Aladdin and Buttons in Cinderella.
However, although he is returning to Aladdin this Christmas in Bromley, Biggins claims pantos are getting ‘ridiculous’.
The 70-year-old told The Daily Star: ‘The Krankies have stopped doing pantomime because it’s getting so ridiculous.
‘Panto is a British institution. It’s just a joke. It’s only tongue in cheek.’
The Porridge star also told the paper that he and other longtime panto stars have met up to discuss the future of pantomime, but is ‘determined’ not to give into political correctness.
While Biggins suggested that the Krankies – made up of husband and wife Janette and Ian Tough – were quitting panto due to worries they would be accused of transphobia, the couple actually retired from panto this year due to Janette’s health issues.
The 72-year-old, best known for playing Wee Jimmy Krankie, has osteoporosis and was concerned about the effect their ventriloquist dummy routine could have on her back.
Advertisement Advertisement
The Scottish star told The Sun: ‘It’s no good for my back being thrown around.
‘I know it was one part of our act that people really seemed to like but I’ll never play the dummy again. I can say it’s on doctor’s orders.
‘We’re both 72 now and feel the time is right to call it a day. But we’re not giving up the business — just pantos.’
The Krankies last appeared in Cinderella in Glasgow in 2018.
Metro.co.uk has contacted a rep for the Krankies for comment.
Got a showbiz story?
If you've got a story, video or pictures get in touch with the Metro.co.uk Entertainment team by emailing us<EMAIL_ADDRESS>calling 020 3615 2145 or by visiting our Submit Stuff page - we'd love to hear from you.


---
layout: default
title: "Monte carlo tree search gait planner for non-gaited legged system control"
---
{{ page.title }}
IEEE International Conference on Robotics and Automation (ICRA), 2022
Lorenzo Amatucci (1)(2) Joon-Ha Kim (1) Jemin Hwangbo (1) Hae-won Park (1)
(1) Korea Advanced Institute of Science and Technology(2) Istituto Italiano di Tecnologia
Abstract
In this work, a non-gaited framework for legged
system locomotion is presented. The approach decouples the
gait sequence optimization by considering the problem as
a decision-making process. The redefined contact sequence
problem is solved by utilizing a Monte Carlo Tree Search
(MCTS) algorithm that exploits optimization-based simulations
to evaluate the best search direction. The proposed scheme
has proven to have a good trade-off between exploration and
exploitation of the search space compared to the state-of-
the-art Mixed-Integer Quadratic Programming (MIQP). The
model predictive control (MPC) utilizes the gait generated by
the MCTS to optimize the ground reaction forces and future
footholds position. The simulation results, performed on a
quadruped robot, showed that the proposed framework could
generate known periodic gait and adapt the contact sequence
to the encountered conditions, including external forces and
terrain with unknown and variable properties. When tested on
robots with different layouts, the system has also shown its
reliability.
@INPROCEEDINGS{MCTSAmatucci2022,
author={Amatucci, Lorznzo and Kim, Joon-Ha and Hwangbo, Jemin and Park, Hae-Won},
booktitle={2022 International Conference on Robotics and Automation (ICRA)},
title={Monte Carlo Tree Search Gait Planner for Non-Gaited Legged System Control},
year={2022},
volume={},
number={},
pages={4701-4707},
doi={10.1109/ICRA46639.2022.9812421}
}


Navbar
Editing Magic#
555
Here you can modify the entity
ID
ID
Description
Updated At
...
Created At
...
Save


Claim your NHS Pension
Do you want an increased lump sum by giving up part of your 1995 pension?
If you have 1995 Section membership on or after 1 April 2008, you’re already entitled to a lump sum. You’re choosing to increase this lump sum.
How lump sums are calculated
For every £1 you give up from your pension, you’ll get £12 for your lump sum.
For example, if you give up £100 of your pension, you’d get £1200 of lump sum.


nips nips2003 nips2003-28 nips2003-28-reference knowledge-graph by maker-knowledge-mining
Source: pdf
Author: Michael J. Quinlan, Stephan K. Chalup, Richard H. Middleton
Abstract: This article addresses the issues of colour classiﬁcation and collision detection as they occur in the legged league robot soccer environment of RoboCup. We show how the method of one-class classiﬁcation with support vector machines (SVMs) can be applied to solve these tasks satisfactorily using the limited hardware capacity of the prescribed Sony AIBO quadruped robots. The experimental evaluation shows an improvement over our previous methods of ellipse ﬁtting for colour classiﬁcation and the statistical approach used for collision detection.
[1] B. E. Boser, I. M. Guyon, and V. N. Vapnik. A training algorithm for optimal margin classiﬁers. In D. Haussler, editor, Proceedings of the 5th Annual ACM Workshop on Computational Learning Theory, pages 144–152, Pittsburgh, PA, July 1992. ACM Press.
[2] C. Cortes and V. Vapnik. Support vector networks. Machine Learning, 20:273 – 297, 1995.
[3] V. Vapnik. The Nature of Statistical Learning Theory. Springer Verlag, New York, 1995.
[4] Bernhard Sch¨ lkopf and Alexander J. Smola. Learning with Kernels, Support Vector Machines, o Regularization, Optimization and Beyond. The MIT Press, 2002.
[5] B. Sch¨ lkopf, J. C. Platt, J. Shawe-Taylor, A. J. Smola, and R. C. Williamson. Estimating the o support of a high-dimensional distribution. Neural Computation, 13:1443–1471, 2001.
[6] RoboCup Legged League web site. http://www.openr.org/robocup/index.html.
[7] OPEN-R SDK. http://openr.aibo.com.
[8] Linda G. Shapiro and George C. Stockman. Computer Vision. Prentice Hall, 2001.
[9] J. Bunting, S. Chalup, M. Freeston, W. McMahan, R. Middleton, C. Murch, M. Quinlan, C. Seysener, and G. Shanks. Return of the NUbots! The 2003 NUbots Team Report, 2003. http://robots.newcastle.edu.au/publications/NUbotFinalReport2003.pdf.
[10] Michael J. Quinlan, Craig L. Murch, Richard H. Middleton, and Stephan K. Chalup. Traction monitoring for collision detection with legged robots. In RoboCup 2003 Symposium, 2003.
[11] Chih-Chung Chang and Chih-Jen Lin. LIBSVM: a library for support vector machines, 2001. Software available at http://www.csie.ntu.edu.tw/˜cjlin/libsvm.


Contact
Packages
Lessons
Group Lesson
Private Lesson
Semi-Private Lesson
About
Contact Us
Send us an E-mail for questions or reservations
Directions
Tamarindo, Costa Rica
+506.5554.8888
<EMAIL_ADDRESS>Contact us
First name:
Last name:
E-mail address:
Telephone:
Message:


| Rule Name |
Description |
| BooleanInstantiation |
Use Boolean.valueOf() for variable values or Boolean.TRUE and Boolean.FALSE for constant values instead of calling the Boolean() constructor directly or calling Boolean.valueOf(true) or Boolean.valueOf(false). |
| CatchError |
Catching Error is dangerous; it can catch exceptions such as ThreadDeath and OutOfMemoryError. |
| CatchException |
Catching Exception is often too broad or general. It should usually be restricted to framework or infrastructure code, rather than application code. |
| CatchNullPointerException |
Catching NullPointerException is never appropriate. It should be avoided in the first place with proper null checking, and it can mask underlying errors. |
| CatchRuntimeException |
Catching RuntimeException is often too broad or general. It should usually be restricted to framework or infrastructure code, rather than application code. |
| CatchThrowable |
Catching Throwable is dangerous; it can catch exceptions such as ThreadDeath and OutOfMemoryError. |
| DuplicateImport |
Duplicate import statements are unnecessary. |
| EmptyCatchBlock |
In most cases, exceptions should not be caught and ignored (swallowed). |
| EmptyElseBlock |
Empty else blocks are confusing and serve no purpose. |
| EmptyFinallyBlock |
Empty finally blocks are confusing and serve no purpose. |
| EmptyForStatement |
Empty for statements are confusing and serve no purpose. |
| EmptyIfStatement |
Empty if statements are confusing and serve no purpose. |
| EmptySwitchStatement |
Empty switch statements are confusing and serve no purpose. |
| EmptySynchronizedStatement |
Empty synchronized statements are confusing and serve no purpose. |
| EmptyTryBlock |
Empty try blocks are confusing and serve no purpose. |
| EmptyWhileStatement |
Empty while statements are confusing and serve no purpose. |
| EqualsAndHashCode |
If either the boolean equals(Object) or the int hashCode() methods are overridden within a class, then both must be overridden. |
| ImportFromSamePackage |
An import of a class that is within the same package is unnecessary. |
| ReturnFromFinallyBlock |
Returning from a finally block is confusing and can hide the original exception. |
| StringInstantiation |
Use a String literal (e.g., "...") instead of calling the corresponding String constructor (new String("..")) directly. |
| ThrowError |
Checks for throwing an instance of java.lang.Error. |
| ThrowException |
Checks for throwing an instance of java.lang.Exception. |
| ThrowExceptionFromFinallyBlock |
Throwing an exception from a finally block is confusing and can hide the original exception. |
| ThrowNullPointerException |
Checks for throwing an instance of java.lang.NullPointerException. |
| ThrowRuntimeException |
Checks for throwing an instance of java.lang.RuntimeException. |
| ThrowThrowable |
Checks for throwing an instance of java.lang.Throwable. |
| UnnecessaryGroovyImport |
A Groovy file does not need to include an import for classes from java.lang, java.util, java.io, java.net, groovy.lang and groovy.util, as well as the classes java.math.BigDecimal and java.math.BigInteger. |
| UnusedImport |
Imports for a class that is never referenced within the source file is unnecessary. |


Package org.drip.capital.entity
Class CapitalUnitEventContainer
java.lang.Object
org.drip.capital.entity.CapitalUnitEventContainer
public class CapitalUnitEventContainer
extends java.lang.Object
CapitalUnitEventContainer contains all the Stress Event Specifications across all of the Event Types that
belong inside of the a Capital Unit. The References are:
- Bank for International Supervision(2005): Stress Testing at Major Financial Institutions: Survey Results and Practice https://www.bis.org/publ/cgfs24.htm
- Glasserman, P. (2004): Monte Carlo Methods in Financial Engineering Springer
- Kupiec, P. H. (2000): Stress Tests and Risk Capital Risk 2 (4) 27-39
- Module = Portfolio Core Module
- Library = Capital Analytics
- Project = Basel Market Risk and Operational Capital
- Package = Economic Risk Capital Estimation Nodes
- Author:
- Lakshmi Krishnamurthy
-
Constructor Summary
Constructors Constructor Description CapitalUnitEventContainer()
Empty CapitalUnitEventContainer Constructor -
Method Summary
Modifier and Type Method Description boolean
addCorrelatedEvent(java.lang.String systemicEventName, java.lang.String correlatedEventName, PnLSeries correlatedEventPnLSeries)
Add Correlated Stress Event PnL Seriesboolean
addIdiosyncraticEvent(Event idiosyncraticEvent)
Add Idiosyncratic Eventboolean
addSystemicEvent(Event systemicEvent)
Add Systemic Eventboolean
containsCorrelatedEvent(java.lang.String systemicEventName, java.lang.String correlatedEventName)
Indicate if the Correlated Event is Availableboolean
containsIdiosyncraticEvent(java.lang.String idiosyncraticEventName)
Indicate if the Idiosyncratic Event is Availableboolean
containsSystemicEvent(java.lang.String systemicEventName)
Indicate if the Systemic Event is AvailablePnLSeries
correlatedEvent(java.lang.String systemicEventName, java.lang.String correlatedEventName)
Retrieve the Correlated Stress Event PnLEvent
idiosyncraticEvent(java.lang.String idiosyncraticEventName)
Retrieve the Idiosyncratic Event by NameIdiosyncraticEventContainer
idiosyncraticEventContainer()
Retrieve the Idiosyncratic Event ContainerEvent
systemicEvent(java.lang.String systemicEventName)
Retrieve the Systemic Event by NameSystemicEventContainer
systemicEventContainer()
Retrieve the Systemic Event ContainerMethods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Constructor Details
-
CapitalUnitEventContainer
public CapitalUnitEventContainer()Empty CapitalUnitEventContainer Constructor
-
-
Method Details
-
addSystemicEvent
Add Systemic Event- Parameters:
systemicEvent
- The Systemic Event- Returns:
- TRUE - The Systemic Event successfully added
-
containsSystemicEvent
public boolean containsSystemicEvent(java.lang.String systemicEventName)Indicate if the Systemic Event is Available- Parameters:
systemicEventName
- Systemic Event Name- Returns:
- TRUE - The Systemic Event is Available
-
systemicEvent
Retrieve the Systemic Event by Name- Parameters:
systemicEventName
- Systemic Event by Name- Returns:
- The Systemic Event
-
addIdiosyncraticEvent
Add Idiosyncratic Event- Parameters:
idiosyncraticEvent
- The Idiosyncratic Event- Returns:
- TRUE - The Idiosyncratic Event successfully added
-
containsIdiosyncraticEvent
public boolean containsIdiosyncraticEvent(java.lang.String idiosyncraticEventName)Indicate if the Idiosyncratic Event is Available- Parameters:
idiosyncraticEventName
- Idiosyncratic Event Name- Returns:
- TRUE - The Idiosyncratic Event is Available
-
idiosyncraticEvent
Retrieve the Idiosyncratic Event by Name- Parameters:
idiosyncraticEventName
- Idiosyncratic Event by Name- Returns:
- The Idiosyncratic Event
-
systemicEventContainer
Retrieve the Systemic Event Container- Returns:
- The Systemic Event Container
-
idiosyncraticEventContainer
Retrieve the Idiosyncratic Event Container- Returns:
- The Idiosyncratic Event Container
-


Build Pipelines
Continous Integration
Martin Reinhardt
Agenda
Basics
How to use Build Pipelines
Structuring Build Pipelines
Examples
Problems
Links
Basics about Continous Integration
- Using the IDE is not automating
- .. and is not automatically a repeatable build
- continous integration per build tool (ant,maven,gradle ...)
- testing is not only running Unit tests
- failures in tests lead to failed builds
- fix build after error occured, don't waste time ...
- reuse artificats
But how?
Using Build Pipelines
- Split long running tests up to several jobs
- get faster feedback and have smaller changes
- less to merge and/or to
- don't use every test in a build pipeline (performance, code coverage)
- it's all about speed!
- can be parametrized (different configurations, environments)
- can be used to trigger a new release candidate (continous delivery with promotion)
- can run in parallel (e.g. integration and webservice tests)
Seperation of the jobs
Basic model
- build
- deploy
- integration
- ui
But
- if build takes to long split it up (~5 minutes)
- don't overengineer single jobs
- better: parametrize build (SVN-branch, configuration, ...)
- use groups to manage user rights in jobs
Examples
- Static Build Pipeline
- don't overengineer single jobs
- better: parametrize build (SVN-branch, configuration, ...)
- use groups to manage user rights in jobs
- use of triggers
Problems
- Not so easy to configure:
CI-Team
- not the full change history visible
- failed single job in pipeline blocks the next job
- but: you can fix it
- or: customize the trigger
THE END
BY Martin Reinhardt
github


--- title: "Plant Collections" layout: "default" ---
Red Butte Garden is a museum of living plants. Plants are collected for their horticultural merit, use in research and conservation, and for their historical value. Each plant is given an accession number and carefully curated within the collections. To learn about our collections and displays, please click on the corresponding images below.
Red Butte Garden has several types of plant collections and each accession falls into one or more of the following categories:
Aside from our impressive collections, we also maintain a variety of ornamental displays. Displays are plants that are not included in our curated plant collections. We do not keep the same records on them. Rather, they are used to enhance our landscape plantings. Our most noteworthy displays include: Daffodils, Miniature Bulbs, and Succulents.
Red Butte Garden presents a stunning display each spring of over 500,000 bulbs (as of Dec 2018), 239,000 of which are daffodils. Daffodils were chosen as a prominent component due to their long lifespan, wide diversity of color, size and bloom type, and dislike by wildlife such as deer and squirrels.
The Red Butte Garden daffodil display started in 2003 in the Four Seasons Garden. The Four Seasons Garden, situated on a hill facing the Visitor Center, is the first thing that visitors see when they enter the Garden. This garden space, composed of large masses of plants best appreciated when viewed from a distance, lends itself well to a massive display of daffodils, with varieties chosen that, due to their size and color, stand out from a distance.
In 2013, Red Butte Garden was recognized as an official Daffodil Display Garden by the American Daffodil Society. Our display represents all 13 recognized divisions, which are based on floral parts and species derivation.
Read more about our Daffodil Display
Roses are among the most loved flowers in the world. There are about 150 distinct species, all found only in the northern hemisphere. Modern rose varieties began to appear in the late 18th century when repeat-blooming roses from China were introduced to Europe. Today, there are a wealth of roses available from which to choose, from hybrid teas and floribundas to shrub roses and groundcovers, from climbers and ramblers to miniatures. Old roses and species roses also add their beauty and charm to gardens.
At Red Butte Garden, the purpose of our Rose Collection is to display a wide variety of roses emphasizing a diversity of ornamental characteristics such as: flower color, form and fragrance; fall/winter interest, plant size, form and texture.
As our Collection grows, we strive to obtain species and cultivars of all rose classes that are winter-hardy and with an emphasis on disease resistant to showcase the variety of roses that thrive in Utah.
Native to southeastern Europe and eastern Asia, Lilacs belong to the genus Syringa. The name Syringa is derived from the ancient Greek word “syrinx,” which means “hollow stem,” referring to the straight, hollow young branches that were once used to make flutes. While in the wild there are only 12 species of Lilac, worldwide horticulturists have created over 2,000 named hybrids and cultivars, most of which arise from the Common Lilac, Syringa vulgaris. Lilacs belong to the same family as the olive, ash, forsythia, and jasmine.
Lilacs are trees or shrubs that range in size from 3 feet to 35 feet depending on the species or variety. Most varieties produce heart or spade-shaped leaves arranged in pairs along the stem, with a few species producing dissected leaves or leaves that encircle the stem.
Lilacs are located throughout Red Butte Garden, with the greatest diversity of the collection along the bottom of the Floral Walk, a few re-blooming varieties in the Water Conservation Garden, and some impressive tree lilacs in the Fragrance Garden meadow. The best time to view this beautiful and fragrant collection is from mid-April to mid-May.
Penstemon, commonly known as beardtongue, is one of the largest genus of flowering plants endemic to North America. Containing roughly 250 species, they are found naturally in every state except Hawaii, with the most species being found in the Western United States. With 100 species, Utah is home to the highest number of native Penstemon, including approximately 20 species that are rare or threatened. Their habitat ranges from alpine to hot desert conditions.
Penstemon species are known for their attractive, long lasting, tubular flowers that come in a variety of bright colors, from the less common white and yellow to the more common blue, purple, pink, and red. Beardtongues are able to sustain a high number of pollinators due to the large volume of nectar they contain. The diversity of flower shapes, colors, and arrangements reflect individual species specializations to attract specific pollinators, including bees, butterflies, and hummingbirds.
Like Utah, here at the Garden we have a diverse selection of Penstemon species including native species, rare taxa, hybrids, and cultivars. Our collection can be seen throughout the Garden, with the majority planted in the Water Conservation Garden and the Visitor Center Entrance Gardens.
At Red Butte Garden, the purpose of our Ornamental Grass Collection is to display a wide variety of non-invasive ornamental grasses and grass-like plants, emphasizing the diversity of taxa, size, form, color, and texture.
As we continue to expand and diversify our collection, we seek to increase the diversity of genera, species, varieties, and cultivars that demonstrate the variety or ornamental grasses available for the home landscape and how they perform in our region.
Conifers are woody plants that bear cones. They range in size from the tallest tree in the world (Sequoia sempervirens or Coast Redwood) to small dwarf varieties. Conifers are also among the oldest known trees, with Methuselah, a Bristlecone Pine from California, estimated to be around 5,000 years old. Most conifers are recognized by their needle-like foliage and are often described as evergreens, however, some varieties such as Larches and Bald Cypress, are deciduous, losing their leaves in the fall.
At Red Butte Garden, the purpose of our Conifer Collection is to display a wide variety of conifer and other gymnosperm taxa emphasizing the diversity of size, form, color, and texture and to showcase the assortment of conifers available for use in the home landscape.
As we continue to expand and diversify our collection, we seek to increase the diversity of Utah native species, water-wise species, unusual or rare forms, and miniature and dwarf varieties.
Red Butte Garden has been designated as a conifer reference garden by the American Conifer Society. We were selected because of an exceptional collection of coniferous taxa and a continuing commitment to their display and preservation. As of 2017, Red Butte Garden is home to 216 different conifer taxa.


Logs¶
Swift has quite verbose logging, and the generated logs can be used for cluster monitoring, utilization calculations, audit records, and more. As an overview, Swift’s logs are sent to syslog and organized by log level and syslog facility. All log lines related to the same request have the same transaction id. This page documents the log formats used in the system.
Note
By default, Swift will log full log lines. However, with the
log_max_line_length
setting and depending on your logging server
software, lines may be truncated or shortened. With log_max_line_length <
7
, the log line will be truncated. With log_max_line_length >= 7
, the
log line will be “shortened”: about half the max length followed by ” ... ”
followed by the other half the max length. Unless you use exceptionally
short values, you are unlikely to run across this with the following
documented log lines, but you may see it with debugging and error log
lines.
Proxy Logs¶
The proxy logs contain the record of all external API requests made to the proxy server. Swift’s proxy servers log requests using a custom format designed to provide robust information and simple processing. The log format is:
client_ip remote_addr datetime request_method request_path protocol
status_int referer user_agent auth_token bytes_recvd bytes_sent
client_etag transaction_id headers request_time source log_info
request_start_time request_end_time policy_index
| Log Field | Value |
| client_ip | Swift’s guess at the end-client IP, taken from various headers in the request. |
| remote_addr | The IP address of the other end of the TCP connection. |
| datetime | Timestamp of the request, in day/month/year/hour/minute/second format. |
| request_method | The HTTP verb in the request. |
| request_path | The path portion of the request. |
| protocol | The transport protocol used (currently one of http or https). |
| status_int | The response code for the request. |
| referer | The value of the HTTP Referer header. |
| user_agent | The value of the HTTP User-Agent header. |
| auth_token | The value of the auth token. This may be truncated or otherwise obscured. |
| bytes_recvd | The number of bytes read from the client for this request. |
| bytes_sent | The number of bytes sent to the client in the body of the response. This is how many bytes were yielded to the WSGI server. |
| client_etag | The etag header value given by the client. |
| transaction_id | The transaction id of the request. |
| headers | The headers given in the request. |
| request_time | The duration of the request. |
| source | The “source” of the request. This may be set for requests that are generated in order to fulfill client requests, e.g. bulk uploads. |
| log_info | Various info that may be useful for diagnostics, e.g. the value of any x-delete-at header. |
| request_start_time | High-resolution timestamp from the start of the request. |
| request_end_time | High-resolution timestamp from the end of the request. |
| policy_index | The value of the storage policy index. |
In one log line, all of the above fields are space-separated and url-encoded.
If any value is empty, it will be logged as a “-”. This allows for simple
parsing by splitting each line on whitespace. New values may be placed at the
end of the log line from time to time, but the order of the existing values
will not change. Swift log processing utilities should look for the first N
fields they require (e.g. in Python using something like
log_line.split()[:14]
to get up through the transaction id).
Swift Source¶
The source
value in the proxy logs is used to identify the originator of a
request in the system. For example, if the client initiates a bulk upload, the
proxy server may end up doing many requests. The initial bulk upload request
will be logged as normal, but all of the internal “child requests” will have a
source value indicating they came from the bulk functionality.
| Logged Source Value | Originator of the Request |
| FP | FormPost |
| SLO | Static Large Objects |
| SW | StaticWeb |
| TU | TempURL |
| BD | Bulk Operations (Delete and Archive Auto Extraction) (delete) |
| EA | Bulk Operations (Delete and Archive Auto Extraction) (extract) |
| CQ | Container Quotas |
| CS | Container Sync Middleware |
| TA | TempAuth |
| DLO | Dynamic Large Objects |
| LE | List Endpoints |
| KS | KeystoneAuth |
| RL | Rate Limiting |
| VW | Object Versioning |
| SSC | Server Side Copy |
Storage Node Logs¶
Swift’s account, container, and object server processes each log requests
that they receive, if they have been configured to do so with the
log_requests
config parameter (which defaults to true). The format for
these log lines is:
remote_addr - - [datetime] "request_method request_path" status_int
content_length "referer" "transaction_id" "user_agent" request_time
additional_info server_pid policy_index
| Log Field | Value |
| remote_addr | The IP address of the other end of the TCP connection. |
| datetime | Timestamp of the request, in “day/month/year:hour:minute:second +0000” format. |
| request_method | The HTTP verb in the request. |
| request_path | The path portion of the request. |
| status_int | The response code for the request. |
| content_length | The value of the Content-Length header in the response. |
| referer | The value of the HTTP Referer header. |
| transaction_id | The transaction id of the request. |
| user_agent | The value of the HTTP User-Agent header. Swift services
report a user-agent string of the service name followed by
the process ID, such as "proxy-server <pid of the
proxy>" or "object-updater <pid of the object
updater>" . |
| request_time | The duration of the request. |
| additional_info | Additional useful information. |
| server_pid | The process id of the server |
| policy_index | The value of the storage policy index. |


I am a passionate process driven web/backend developer 🚀 and also do competitive programming sometimes trying to solve problems using logic helps to keep brain cells active and alert 👨💻 .I am adaptive to new technology stacks and fast learner .Looking for opportunities as Software Developer working in full-stack development ,cloud computing and machine learning technologies
I love to read books and blogs 📘 during my free time and it ranges from tech 💻 to spirtuality 🕉.
My philosophy📗:-
कर्मण्येवाधिकारस्ते मा फलेषु कदाचन |
मा कर्मफलहेतुर्भूर्मा ते सङ्गोऽस्त्वकर्मणि


Textogram
Home
About Us
Contact Us
Welcome to Textogram!
You can format your text here as you wish...
Enter your text and format!!
(or)
Please upload only .txt files
Convert text into UPPER CASE
Convert text into lower case
Frequency of each Word
Character Count
Word Count
Number of lines in Text
Format


Soaring through the galaxies
Rollin' down to Dallas
McKay and his best friend
Thundercats on the move


Warling
Resort®
-Retreat for mind !!
Amidst the hustle and bustle of the silicon valley of India, If you feel that nothing is going right, you should perhaps head to Ramya Resort Bangalore - an oasis of absolute peace and tranquillity, tucked in lush greenery. The tall trees swaying in the gentle breeze, as if singing a welcome song for you; the chirping of the birds hiding in shrubs and behind the trees, will welcome you on your arrival at the resort.
If you are wondering how your day could be different from that of a mundane day, well we tell you how it exactly feels to be here. As the sun wakes up from a deep slumber, freshen up and try your hands at volley ball, badminton, basketball, football and a host of other outdoor and indoor games. Radiant Resort Bangalore also has a separate kids play area where children can have fun to the utmost.