I am a UX consultant with a focus on interaction design, UI prototyping, and usability research.
My process borrows heavily from traditional user-centered design methods, but is optimized for each situation and client.
I have 15 years of hands-on experience designing and doing research for startups and Fortune 500 companies.
I've worked with some great clients, both directly and through agencies like Blink, Fell Swoop, LiveAreLabs, IF/THEN, Copacino+Fujikado, Methodologie, Wunderman, and the pinoerring Sitewerks (RIP).
My portfolio includes desktop and mobile projects for e-commerce, social, software, entertainment, education, science, health care, and profession services. Please contact me if you would like to see samples and learn more.
The Seattle Cancer Care Alliance is a world-class cancer treatment center. I was recently hired to conduct a personas workshop with a small group of their key staff members. The outcome of the workshop characterized the primary user types of their website and defined the participants for a baseline usability study.


Soviet ideologization
After his death, Pavlov was transformed into a symbol of Soviet science, his scientific exploit was also considered as an ideological feat (in some sense the "Pavlov school" (or Pavlov's teaching) became an ideological phenomenon). Under the slogan "Protection of the Pavlovian Heritage", the so-called "Pavlov Session" of the Academy of Sciences of the USSR and the USSR Academy of Medical Sciences (organizers - KM Bykov, A. G. Ivanov-Smolensky) was held in 1950, where the leading physiologists of the country were persecuted. Such a policy, however, was in sharp contradiction with Pavlov's own views
Timeline
- 1849 - Ivan Pavlov Is Born
- 1870 - Pavlov enrolls in a course of natural sciences at the University of St. Petersburg, abandoning his religious career.
- 1879 - Pavlov graduates from the Military-Medical Academy of the University of St. Petersburg and finishes his studies at the Academy of Medical Surgery, earning his first gold medal.
- 1884 - Pavlov gives a lecutre on physiology at his alma mater in the Military-Medical Academy.
- 1890 - Pavlov is appointed a chair position at the Military-Medical Academy in the department of pharmacology.
- 1891 - Pavlov becomes the director of physiology at the University of St. Petersburg in the Institute of Experimental Medicine.
- 1897 - Pavlov publishes his lecutres on the nervous system, entitled "Lectures on the functions of the principal digestive glands."
- 1904 - Pavlov is awarded his Nobel Prize for his work and discoveries in the field of physiology and digestive glands.
- 1921 - Ivan Pavlov receives a government decree, signed by Lenin, for his work in physiology.
- 1936 - Pavlov Dies


{% trans "E-mail Addresses" %}
{% if user.emailaddress_set.all %}{% trans 'The following e-mail addresses are associated with your account:' %}
{% trans 'Warning:'%} {% trans "You currently do not have any e-mail address set up. You should really add an e-mail address so you can receive notifications, reset your password, etc." %}
{% endif %}


Use this service to:
- pay your Penalty Charge Notice
- make a challenge
Use this service to:
This should take less than 5 minutes.
You cannot make a challenge online. You need to call or email us instead.
You will need the following from your Penalty Charge letter:


checks whether the container can be applied to given name
bool
appliesTo
(string $name)
adds content to given container
change owner group of file to given group
change file mode to given permissions
change owner of file to given user
returns the last modification time of the stream content
int
filemtime
()
returns owner group of file
int
getGroup
()
returns the file name of the content
string
getName
()
returns permissions
int
getPermissions
()
returns the type of the container
int
getType
()
returns owner of file
int
getUser
()
checks whether file is owned by group
bool
isOwnedByGroup
(int $group)
checks whether file is owned by given user
bool
isOwnedByUser
(int $user)
sets the last modification time of the stream content
renames the content
void
rename
(string $newName)
returns size of content
int
size
()


Slides are here: http://mhellar.github.io/ga_physcomp/1
Grab the code here: http://bit.ly/2c5wYej
Project 1: Soldering
*Note: Leave 2 rows on the side with black socket and 1 on top!
The ESP8266 is a low-cost Wi-Fi chip with full TCP/IP stack and MCU (Micro Controller Unit) capability produced by Shanghai-based Chinese manufacturer, Espressif Systems.
The Huzzah is a mini Arduino with Wifi, that is $10.00!
Getting Set up:
- First install the USB driver SiLabs serial driver
Getting Set up:
- Next go to the Arduino Preferences
Enter http://arduino.esp8266.com/stable/package_esp8266com_index.json into Additional Boards Manager URLs
Getting Set up:
- Next, use the Board manager to install the ESP8266 package.
Adafruit has branded these Neopixels
You can get them for half the price on Ebay as ws2812's
Import the NeoPixel Library
Import the NeoPixel Library
Let's try some examples and write our own code!
From right to left connect batt, 2, gnd
Plug in the single LED 5v -> Batt,DI -> 2,GND -> GND
Let's upload firstlight from the code folder
Replace the single LED with your stip 5v -> Batt,DI -> 2,GND -> GND
Coding Excercise
Wifi
FastLED
Fast LED LibraryAPA102
APA102 aka “Superled”


Donald Hall and Jane Kenyon: "Keeping you Safe Beside me"
Producer: Ronald G Shafer
Director/Photographer/Editor: William Hamilton
Sound Engineer: Kenneth Cirol
Production Assistant: Brett S. Shafer
Text Editor: Nancy Couldren
Person Interviewed: Donald Hall With the voices of: Donald Hall and Jane Kenyon
Interviewer: Ronald G Shafer
Released by The Indiana University of Pennsylvania
As Reviewed by James Brundage
Steps to becoming a film critic. First, you must develop a tolerance for movies. Not just for violence on film, or sex on film or anything else that you may or may not find personally distasteful, but for bad films in general. Humanity is dropped at the door if at all possible, and you reflect on your experiences with a human aspect once you exit. Second, you must learn that the world you are entering into is not at all a pleasant one. Three: Find an outlet. Online places, due to their relative ease, are a good start. Do not try to get pay from the start, because you won't. A great deal many of us have been in this for years and have reaped nary a dime. Four: Network. Get to know the business and the people in the business. Anytime you can pick the brains of a filmmaker, do so.
The big fish in the business of film criticism, Roger Ebert, Leonard Maltin. These people know everybody, and are very logical about their reviews. Myself, I know a lot of the people on the low level (i.e. the agent of Jena Olin, the cinematographer my favorite shot in history, the opening shot of The Player). I know them peripherally at most, by email. However, today I feel as if I have made a major career move, because I have met someone who has produced his own documentary.
Admittedly, this is not a great source of excitement. I've met people farther up the food chain than this guy, but its still a source of dumb pride (this is what I get for living in the suburbs for many years). No, I'm not reviewing this as a personal favor to him, although I do consider him a friend I told him candidly before the premier at the local branch of IUP that I do not show mercy as a critic. I'm writing this review because, as far as documentaries go, it's one of the finest I have seen in the past four years of criticism.
Remember that a documentary's basic purpose is not to tell a story. It is not to entertain. It is definitely not to be original. There goes every single aspect upon which I normally grade a film... or does it? The documentary, for which the entire cast and crew is listed above, blurs the lines between documentary and docudrama as it tells the story of Donald Hall and the late Jane Kenyon, a tale of poets in love.
Giving background, Donald Hall and Jane Kenyon are both poets that wrote the majority of their time in New England and, at least I believe, are of the naturalist persuasion. Truth to be told, I do not know very much about them. This is not to say that the documentary was not informative: it told me very much of the enduring romance between Donald Hall, a very traditional man, and Jane Kenyon, a woman who spent most of her life fighting manic-depression and died of leukemia in 1995.
What was interesting about this documentary, and what made it much better than the 35mm or 16mm filmed Pretty as a Picture: The Art of David Lynch, which was the last documentary that I saw, was that it did not fall into what I term as the "documentary trap." The idea of a documentary may be to inform, but the idea of human nature is to entertain oneself every chance we would get. So, unless I'm in a classroom setting, I'd rather watch a documentary which is more like a docudrama, which is what this film is.
Whereas the normal documentary does not move the camera (except to pan), this film does. Where as the normal documentary spends its time in color, this one switches in between color and black and white. The normal documentary has about as much residual noise as a silent film has spoken conversation. It also has a touching story and hints of a basically cyclic film style (the first and last scenes are the same). This film has a soundtrack in the form of original (and not too shabby) compositions. It does fall into one trap of the documentary, however. It does have bad lighting, which I have seen on about every documentary to date, and thus I believe it to be unavoidable.
I'm not going to tell you to rush to the multiplex to see this film. You won't find it. I'm not going to tell you to tune into PBS to watch it. You won't find it there, either. In fact, it is currently in the hands of the marketing department at IUP. I'm just saying that, should you get the chance to see this, jump on it.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Property |
Type | Notes |
|---|---|---|
|
java.lang.String |
Values: "regular", "small" |
|
java.lang.String |
Values: "plain", "striped" |
Quaqua supports the regular and small size variant.
The Quaqua Look and Feel supports lists with plain style and with striped style (aka alternating row colors).
The picture below shows a striped list.
You can specify the desired style by setting the client property Quaqua.List.style
to
striped
or to plain
. If you don't specify a value,
the plain style is used.
|
If you implement a ListCellRenderer on your own, make sure that the renderer component is non-opaque. If your renderer component is opaque, the component obscurs the stripes of a striped list.


From soaring academics to shining character every student has different strengths, but all students learn to value and root for each other.
Character focus, peer empowerment, and mixed-ability learning create a real-life community where students recognize their own strengths to give and their need to learn from others. Character and true friendship are carefully taught. Multi-age and multi-ability learning help students master knowledge by teaching. Unique hearts spark personal love for growth.
Christ
From Him and to Him are all things (Romans 11:36). The Kelly School seeks to put Christ first in everything. We truly believe the fear of the Lord is the beginning of wisdom (Proverbs 9:10), and the fear of the Lord is the beginning of knowledge (Proverbs 1:7). All subjects are taught from a biblical worldview.
 All teachers are committed to representing Christ well and assisting students to grow in character.
Community
Love your neighbor as yourself (Luke 10:27). The Kelly School is a safe community where students learn to encourage and challenge each other in a positive manner.
“I love that The Kelly School is a 'no judgment' zone. Kids with all abilities come together in an environment tailored to teach and learn in a way specific to each kid. The Kelly School not only teaches kids the fundamental skills for living/life after school but also enriches their lives with moral and Biblical principles. I do not know where we would be without the amazing foundation that The Kelly School has provided.”


Overview
This Quick Start reference deployment guide provides step-by-step instructions for deploying Apache Cassandra™ 4.0-beta1 on the Amazon Web Services (AWS) Cloud.
As Apache Cassandra™ adoption grows within your organization, so could the challenges involved with using, maintaining, and supporting the technology. This can add considerable cost, complexity, and administrative burden. Apache Cassandra addresses these challenges by streamlining operations and controlling costs for all your Cassandra workloads.
You’ll have access to best-in-class, 100% open source Apache Cassandra software, as well as optional support and services from the experts that authored the majority of the Cassandra code.
Quick Starts are automated reference deployments that use AWS CloudFormation templates to launch, configure, and run the AWS compute, network, storage, and other services required to deploy a specific workload on AWS.
This Quick Start is for users who need an easily deployed Apache Cassandra cluster for development and or testing purposes
Costs and Licenses
You are responsible for the cost of the AWS services used while running this Quick Start reference deployment. There is no additional cost for using the Quick Start.
The AWS CloudFormation template for this Quick Start includes configuration parameters that you can customize. Some of these settings, such as instance type, will affect the cost of deployment. For cost estimates, see the pricing pages for each AWS service you will be using.
This Quick Start includes Apache Cassandra 4.0.
Architecture
Deploying this Quick Start for a new virtual private cloud (VPC) with default parameters builds the following environment in the AWS Cloud.
Figure 1: Quick Start architecture for Apache Cassandra on AWS
The Quick Start sets up the following components. (The template that deploys the Quick Start into an existing VPC skips the components marked by asterisks.)
-
A highly available architecture that spans three Availability Zones. *
-
A VPC configured with public and private subnets according to AWS best practices, to provide you with your own virtual network on AWS. For more information about the VPC infrastructure, see the Amazon VPC Quick Start. *
-
An Internet gateway to allow access to the Internet. *
-
Managed NAT gateways to allow outbound Internet access for resources in the private subnets. *
-
One EC2 instance in the public subnet running devOps apps, which can also be used as a jumpbox to ssh into Apache Cassandra nodes in the private subnet.
-
Additional EC2 instances for Apache Cassandra nodes, depending on your Quick Start parameter settings. (By default, the Quick Start creates a 3 node Apache Cassandra cluster with each node in a private subnet).
-
One Amazon Elastic Block Store (Amazon EBS) data volume per node instance deployed.
Apache Cassandra Data Centers and Nodes
Apache Cassandra data centers are groups of nodes, related and configured within a cluster for replication purposes. The Quick Start creates 1 data center with 1 - 32 nodes.
Apache Cassandra stores data replicas on multiple nodes to ensure reliability and fault tolerance. A replication strategy determines the nodes where replicas are placed. The replication strategy is defined per keyspace, and is set during keyspace creation. This Quick Start places nodes in each AWS Availability Zone.
Prerequisites
Specialized Knowledge
Before you deploy this Quick Start, we recommend that you become familiar with the following AWS services. (If you are new to AWS, see Getting Started with AWS.)
We also recommend that you become familiar with the features and configuration of Apache Cassandra.
Technical Requirements
This Quick Start uses a Linux AMI (Ubuntu 18.04 LTS) for EC2 instances, and creates EBS volumes and an S3 bucket. The account you run this Quick Start in must have authorization to create these resources.
Deployment Options
This Quick Start provides two deployment options:
-
Deploy Apache Cassandra into a new VPC (end-to-end deployment). This option builds a new AWS environment consisting of the VPC, subnets, NAT gateways, security groups, and other infrastructure components, and then deploys Apache Cassandra cluster into this new VPC.
-
Deploy Apache Cassandra into an existing VPC. This option provisions Apache Cassandra cluster in your existing AWS VPC infrastructure.
The Quick Start provides separate templates for these options. It also lets you configure CIDR blocks, instance types, and Apache Cassandra settings, as discussed later in this guide.
Deployment Steps
Step 1. Prepare An AWS Account
If you don’t already have an AWS account, create one at https://aws.amazon.com by following the on-screen instructions. Part of the sign-up process involves receiving a phone call and entering a PIN using the phone keypad. Use the region selector in the navigation bar to choose the AWS Region where you want to deploy the Quick Start on AWS.
Choosing an AWS Region
| Consider choosing a region closest to your data center or corporate network to reduce network latency between systems running on AWS and the systems and users on your corporate network. |
Also, note that your choice of region will determine whether the Quick Start deploys NAT gateways or NAT instances for network connections. For a list of regions that support NAT gateways, see Amazon VPC pricing.
Create a key pair in your preferred region. To do this, in the navigation pane of the Amazon EC2 console, choose Key Pairs, Create Key Pair, type a name, and then choose Create.
Creating a key pair
Amazon EC2 uses public-key cryptography to encrypt and decrypt login information. To be able to log in to your instances, you must create a key pair. With Windows instances, we use the key pair to obtain the administrator password via the Amazon EC2 console and then log in using Remote Desktop Protocol (RDP) as explained in the step-by-step instructions in the Amazon Elastic Compute Cloud User Guide. On Linux, we use the key pair to authenticate SSH login.
If necessary, request a service limit increase for the Amazon EC2 m4.large instance type. You might need to do this if you already have an existing deployment that uses this instance type, and you think you might exceed the default limit with this reference deployment.
Step 2. Launch the stack
| You are responsible for the cost of the AWS services used while running this Quick Start reference deployment. There is no additional cost for using this Quick Start. For full details, see the pricing pages for each AWS service you will be using in this Quick Start. Prices are subject to change. |
Choose one of the following options to launch the AWS CloudFormation template into your AWS account. For help choosing an option, see deployment options earlier in this guide.
| Option 1 - Deploy Apache Cassandra into a new VPC on AWS | Option 2 - Deploy Apache Cassandra into an existing VPC on AWS |
|---|---|
| If you're deploying Apache Cassandra into an existing VPC, make sure that your VPC has three private subnets in different Availability Zones for the node instances. These subnets require NAT gateways or NAT instances in their route tables, to allow the instances to download packages and software without exposing them to the Internet. You'll also need the domain name option configured in the DHCP options, as explained in the Amazon VPC documentation. You'll be prompted for your VPC settings when you launch the Quick Start. |
Each deployment takes about 10-15 minutes to complete, depending on the size of the Apache Cassandra cluster to deploy.
-
Check the region that's displayed in the upper-right corner of the navigation bar, and change it if necessary. This is where the network infrastructure for Apache Cassandra will be built. The template is launched in the US East (Ohio) Region by default.
-
On the Select Template page, keep the default setting for the template URL, and then choose Next.
-
On the Specify Details page, change the stack name if needed. Review the parameters for the template. Provide values for the parameters that require input. For all other parameters, review the default settings and customize them as necessary. When you finish reviewing and customizing the parameters, choose Next
In the following tables, parameters are listed by category and described separately for the two deployment options. Parameters for deploying Apache Cassandra into a new VPC and Parameters for deploying Apache Cassandra into an existing VPC
Parameters - Option 1
-
Deploying Apache Cassandra into a new VPC
VPC Network Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Availability Zones ( |
Requires input |
The list of Availability Zones to use for the subnets in the VPC. The Quick Start uses three Availability Zones from your list and preserves the logical order you specify. |
CIDR for the new VPC ( |
<IP_ADDRESS>/16 |
CIDR block for the VPC. |
Private Subnet 1 CIDR ( |
<IP_ADDRESS>/19 |
CIDR block for private subnet 1 located in Availability Zone 1. |
Private Subnet 2 CIDR ( |
<IP_ADDRESS>/19 |
CIDR block for private subnet 2 located in Availability Zone 2. |
Private Subnet 3 CIDR ( |
<IP_ADDRESS>/19 |
CIDR block for private subnet 3 located in Availability Zone 3. |
Public Subnet 1 CIDR ( |
<IP_ADDRESS>/20 |
CIDR block for the public (DMZ) subnet 1 located in Availability Zone 1. |
Public Subnet 2 CIDR ( |
<IP_ADDRESS>/20 |
CIDR block for the public (DMZ) subnet 2 located in Availability Zone 2. |
Public Subnet 3 CIDR ( |
<IP_ADDRESS>/20 |
CIDR block for the public (DMZ) subnet 3 located in Availability Zone 3. |
Apache Cassandra Cluster/Nodes Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Apache Cassandra Version ( |
4.0 |
Apache Cassandra version to install. |
Number of nodes to install ( |
3 |
Choose from "1 - 32" for number of cassandra nodes to install. |
Cluster Name ( |
Cassandra-Cluster |
The name of the Apache Cassandra cluster. |
Data Center Name ( |
OSS-dc0 |
Name of the Apache Cassandra data center. |
Node Instance Type ( |
m4.large |
EC2 instance type for Apache Cassandra nodes. |
Node Volume Size ( |
512 |
EBS volume size of the Apache Cassandra Cluster Nodes in GB. |
Cassandra Cluster Access
Parameter label (name ) |
Default | Description |
|---|---|---|
Create Cluster in Public Subnet ( |
false |
Should create the Apache Cassandra Cluster nodes in public subnet. |
Permitted IP range ( |
Requires input |
The CIDR IP range that is permitted to SSH to the DevOps EC2 instance for the console. We recommend that you set this value to a trusted IP range. For example, you might want to grant only your corporate network access to the software. |
Key Name ( |
Requires input |
Public/private key pair, which allows you to connect securely to your instance after it launches. When you created an AWS account, this is the key pair you created in your preferred region. |
DevOps/Bastion Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Create Dev/Bastion Instance ( |
true |
Whether to create the jumpbox. |
Instance Type ( |
t3.medium |
EC2 instance type for the DevOps Host. |
Volume Sizes ( |
16 |
The EBS volume size, in GiB, for the DevOps Host. |
AWS Quick Start Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Quick Start S3 Bucket Name ( |
aws-quickstart |
S3 bucket where the Quick Start templates and scripts are installed. Use this parameter to specify the S3 bucket name you've created for your copy of Quick Start assets, if you decide to customize or extend the Quick Start for your own use. The bucket name can include numbers, lowercase letters, uppercase letters, and hyphens, but should not start or end with a hyphen. |
Quick Start S3 Key Prefix ( |
quickstart-datastax-oss |
The S3 key name prefix used to simulate a folder for your copy of Quick Start assets, if you decide to customize or extend the Quick Start for your own use. This prefix can include numbers, lowercase letters, uppercase letters, hyphens, and forward slashes. |
Parameters - Option 2
-
Option 2: Deploying Apache Cassandra into an existing VPC
VPC Network Configuration
| Parameter label (name) | Default | Description |
|---|---|---|
VPC ID ( |
Requires input |
Choose an existing VPC ID to deploy the cluster into. |
CIDR for the VPC ( |
<IP_ADDRESS>/16 |
CIDR block for the VPC. |
Private Subnet 1 ID ( |
Requires input |
Subnet ID for private subnet 1 located in Availability Zone 1. |
Private Subnet 2 ID ( |
Requires input |
Subnet ID for private subnet 2 located in Availability Zone 2. |
Private Subnet 3 ID ( |
Requires input |
Subnet ID for private subnet 3 located in Availability Zone 3. |
Public Subnet 1 ID ( |
Requires input |
Subnet ID for the public (DMZ) subnet 1 located in Availability Zone 1. |
Public Subnet 2 ID ( |
Requires input |
Subnet ID for the public (DMZ) subnet 2 located in Availability Zone 2. |
Public Subnet 3 ID ( |
Requires input |
Subnet ID for the public (DMZ) subnet 3 located in Availability Zone 3. |
Apache Cassandra Cluster/Nodes Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Apache Cassandra Version ( |
4.0 |
Apache Cassandra version to install. |
Number of nodes to install ( |
3 |
Choose from "1 - 32" for number of cassandra nodes to install. |
Cluster Name ( |
Cassandra-Cluster |
The name of the Apache Cassandra cluster. |
Data Center Name ( |
OSS-dc0 |
Name of the Apache Cassandra data center. |
Node Instance Type ( |
m4.large |
EC2 instance type for Apache Cassandra nodes. |
Node Volume Size ( |
512 |
EBS volume size of the Apache Cassandra Cluster Nodes in GB. |
Cassandra Cluster Access:
Parameter label (name ) |
Default | Description |
|---|---|---|
Create Cluster in Public Subnet ( |
false |
Should create the Apache Cassandra Cluster nodes in public subnet. |
Permitted IP range ( |
Requires input |
The CIDR IP range that is permitted to SSH to the DevOps EC2 instance for the console. We recommend that you set this value to a trusted IP range. For example, you might want to grant only your corporate network access to the software. |
Key Name ( |
Requires input |
Public/private key pair, which allows you to connect securely to your instance after it launches. When you created an AWS account, this is the key pair you created in your preferred region. |
DevOps/Bastion Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Create Dev/Bastion Instance ( |
true |
Whether to create the jumpbox. |
Instance Type ( |
t3.medium |
EC2 instance type for the DevOps Host. |
Volume Sizes ( |
16 |
The EBS volume size, in GiB, for the DevOps Host. |
AWS Quick Start Configuration
Parameter label (name ) |
Default | Description |
|---|---|---|
Quick Start S3 Bucket Name ( |
aws-quickstart |
S3 bucket where the Quick Start templates and scripts are installed. Use this parameter to specify the S3 bucket name you've created for your copy of Quick Start assets, if you decide to customize or extend the Quick Start for your own use. The bucket name can include numbers, lowercase letters, uppercase letters, and hyphens, but should not start or end with a hyphen. |
Quick Start S3 Key Prefix ( |
quickstart-datastax-oss |
The S3 key name prefix used to simulate a folder for your copy of Quick Start assets, if you decide to customize or extend the Quick Start for your own use. This prefix can include numbers, lowercase letters, uppercase letters, hyphens, and forward slashes. |
Step 3. Test the Deployment
After you deploy the Apache Cassandra cluster, the quickest way to begin using the cluster is to use SSH to connect to the DevOps instance and then to one of the node instances. You can use SSH agent forwarding using the key pair (replacing the KEY_FILE and DevIpAddress values for those of your cluster):
You can get the ip addresses of the nodes from the output tab of the stack.
Stack Output
ssh -i $KEY_FILE ubuntu@$DevIpAddress
You can get the Seed1PrivateIpAddress from the output tab of the stack.
Seed1 IP
Once logged into the DevOps instance, run
ssh -i $KEY_FILE ubuntu@$Seed1PrivateIpAddress
If you chose to create the cluster in the public subnet, you can skip the above steps and ssh into one of the nodes with the public ip in the output tab.
You can then view the status of the Apache Cassandra Cluster:
~$ nodetool status
For a 6 node cluster, the nodetool status should be like
NodeTool Status
The Developer resource web site is accessible at DevUrl shown in the outputs.
Step 4. Back Up Your Data
Apache Cassandra backs up data by taking a snapshot of all on-disk data files (SSTable files) stored in the data directory. You can take a snapshot of all keyspaces, a single keyspace, or a single table while the system is online. See Backing up and Restoring data. For storing the backups in AWS S3, see Backup to S3
Troubleshooting
Q. I encountered a CREATE\_FAILED error when I launched the Quick Start. What should I do?
A. If AWS CloudFormation fails to create the stack, we recommend that you relaunch the template with Rollback on failure set to No. (This setting is under Advanced in the AWS CloudFormation console, Options page.) With this setting, the stack's state will be retained and the instance will be left running, so you can troubleshoot the issue. (You'll want to look at the log files in %ProgramFiles%\Amazon\EC2ConfigService and C:\cfn\log.)
| When you set Rollback on failure to No , you'll continue to incur AWS charges for this stack. Please make sure to delete the stack when you've finished troubleshooting. |
For additional information, see Troubleshooting AWS CloudFormation on the AWS website or contact us on the AWS Quick Start Discussion Forum.
Q. I encountered a size limitation error when I deployed the AWS Cloudformation templates.
A. We recommend that you launch the Quick Start templates from the location we've provided or from another S3 bucket. If you deploy the templates from a local copy on your computer, you might encounter template size limitations when you create the stack. For more information about AWS CloudFormation limits, see the AWS documentation.
Additional Resources
AWS services
-
AWS CloudFormation https://aws.amazon.com/documentation/cloudformation/
-
Amazon EC2 https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/
-
Amazon VPC https://aws.amazon.com/documentation/vpc/
Apache Cassandra
-
Apache Cassandra documentation https://cassandra.apache.org/doc/latest/new/index.html
-
DataStax Academy online courses and tutorials https://academy.datastax.com/
Quick Start reference deployments
-
AWS Quick Start home page https://aws.amazon.com/quickstart/
GitHub Repository
Send Us Feedback
You can visit our GitHub repository to download the templates and scripts for this Quick Start, to post your comments,
and to share your customizations with others.
| See releases in git TIP: See releases in git https://github.com/aws-quickstart/quickstart-datastax-oss/releases |
Document Revisions
| Date | Change | In sections |
|---|---|---|
Jun 2020 |
Initial publication |
— |
© 2020, Amazon Web Services, Inc. or its affiliates, and DataStax, Inc. All rights reserved.
Notices
This document is provided for informational purposes only. It represents AWS’s current product offerings and practices as of the date of issue of this document, which are subject to change without notice. Customers are responsible for making their own independent assessment of the information in this document and any use of AWS’s products or services, each of which is provided “as is” without warranty of any kind, whether express or implied. This document does not create any warranties, representations, contractual commitments, conditions or assurances from AWS, its affiliates, suppliers or licensors. The responsibilities and liabilities of AWS to its customers are controlled by AWS agreements, and this document is not part of, nor does it modify, any agreement between AWS and its customers.
The software included with this paper is licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at [http://aws.amazon.com/apache2.0/](http://aws.amazon.com/apache2.0/) or in the "license" file accompanying this file. This code is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


class Plot : Figure
<init> |
Plot()
|
data |
val data: Any? |
features |
val features: List<Feature> |
mapping |
val mapping: Options |
layers |
fun layers(): List<Layer> |
otherFeatures |
fun otherFeatures(): List<OtherPlotFeature> |
plus |
operator fun plus(other: Feature): Plot |
scales |
fun scales(): List<Scale> |
show |
fun show(): Unit |
toString |
fun toString(): String |
withFeature |
fun withFeature(plot: Plot, feature: Feature): Plot |
toSpec |
fun Plot.toSpec(): MutableMap<String, Any> |


tf namespace
taskflow namespace
Classes
- class ChromeObserver
- observer interface based on Chrome Tracing format
- class cublasFlowCapturer
- class to construct a cuBLAS task graph
- class cudaFlow
- class for building a CUDA task dependency graph
- class cudaFlowCapturer
- class for building a CUDA task dependency graph through stream capture
- class cudaFlowCapturerBase
- base class to construct a CUDA task graph through stream capture
- class cudaScopedDevice
- RAII-styled device context switch.
- class cudaTask
- handle to a node of the internal CUDA graph
- class Executor
- execution interface for running a taskflow graph
- class FlowBuilder
- building methods of a task dependency graph
- class ObserverInterface
- The interface class for creating an executor observer.
- class Subflow
- class to construct a subflow graph from the execution of a dynamic task
- class Task
- handle to a node in a task dependency graph
- class Taskflow
- main entry to create a task dependency graph
- class TaskView
- class to access task information from the observer interface
- class TFProfObserver
- observer interface based on Taskflow Profiler format
- class WorkerView
- class to create an immutable view of a worker in an executor
Enums
- enum TaskType { PLACEHOLDER_TASK = Node::PLACEHOLDER_TASK, CUDAFLOW_TASK = Node::CUDAFLOW_TASK, STATIC_TASK = Node::STATIC_TASK, DYNAMIC_TASK = Node::DYNAMIC_TASK, CONDITION_TASK = Node::CONDITION_TASK, MODULE_TASK = Node::MODULE_TASK, ASYNC_TASK = Node::ASYNC_TASK }
- enumeration of all task types
- enum ObserverType { TFPROF = 1, CHROME = 2 }
- enumeration of all observer types
- enum cudaTaskType { CUDA_EMPTY_TASK = cudaNode::CUDA_EMPTY_TASK, CUDA_HOST_TASK = cudaNode::CUDA_HOST_TASK, CUDA_MEMSET_TASK = cudaNode::CUDA_MEMSET_TASK, CUDA_MEMCPY_TASK = cudaNode::CUDA_MEMCPY_TASK, CUDA_KERNEL_TASK = cudaNode::CUDA_KERNEL_TASK, CUDA_SUBFLOW_TASK = cudaNode::CUDA_SUBFLOW_TASK, CUDA_CAPTURE_TASK = cudaNode::CUDA_CAPTURE_TASK }
- enumeration of all cudaTask types
Functions
- auto task_type_to_string(TaskType type) -> const char*
- convert a task type to a human-readable string
-
auto operator<<(std::
ostream& os, const Task& task) -> std:: ostream& - overload of ostream inserter operator for cudaTask
- auto observer_type_to_string(ObserverType type) -> const char*
- convert an observer type to a human-readable string
- auto cuda_get_num_devices() -> size_t
- queries the number of available devices
- auto cuda_get_device() -> int
- gets the current device associated with the caller thread
- void cuda_set_device(int id)
- switches to a given device context
- void cuda_get_device_property(int i, cudaDeviceProp& p)
- obtains the device property
- auto cuda_get_device_property(int i) -> cudaDeviceProp
- obtains the device property
-
void cuda_dump_device_property(std::
ostream& os, const cudaDeviceProp& p) - dumps the device property
- auto cuda_get_device_max_threads_per_block(int d) -> size_t
- queries the maximum threads per block on a device
- auto cuda_get_device_max_x_dim_per_block(int d) -> size_t
- queries the maximum x-dimension per block on a device
- auto cuda_get_device_max_y_dim_per_block(int d) -> size_t
- queries the maximum y-dimension per block on a device
- auto cuda_get_device_max_z_dim_per_block(int d) -> size_t
- queries the maximum z-dimension per block on a device
- auto cuda_get_device_max_x_dim_per_grid(int d) -> size_t
- queries the maximum x-dimension per grid on a device
- auto cuda_get_device_max_y_dim_per_grid(int d) -> size_t
- queries the maximum y-dimension per grid on a device
- auto cuda_get_device_max_z_dim_per_grid(int d) -> size_t
- queries the maximum z-dimension per grid on a device
- auto cuda_get_device_max_shm_per_block(int d) -> size_t
- queries the maximum shared memory size in bytes per block on a device
- auto cuda_get_device_warp_size(int d) -> size_t
- queries the warp size on a device
- auto cuda_get_device_compute_capability_major(int d) -> int
- queries the major number of compute capability of a device
- auto cuda_get_device_compute_capability_minor(int d) -> int
- queries the minor number of compute capability of a device
- auto cuda_get_device_unified_addressing(int d) -> bool
- queries if the device supports unified addressing
- auto cuda_get_driver_version() -> int
- queries the latest CUDA version (1000 * major + 10 * minor) supported by the driver
- auto cuda_get_runtime_version() -> int
- queries the CUDA Runtime version (1000 * major + 10 * minor)
- auto cuda_get_free_mem(int d) -> size_t
- queries the free memory (expensive call)
- auto cuda_get_total_mem(int d) -> size_t
- queries the total available memory (expensive call)
-
template<typename T>auto cuda_malloc_device(size_t N, int d) -> T*
- allocates memory on the given device for holding
N
elements of typeT
-
template<typename T>auto cuda_malloc_device(size_t N) -> T*
- allocates memory on the current device associated with the caller
-
template<typename T>auto cuda_malloc_shared(size_t N) -> T*
- allocates shared memory for holding
N
elements of typeT
-
template<typename T>void cuda_free(T* ptr, int d)
- frees memory on the GPU device
-
template<typename T>void cuda_free(T* ptr)
- frees memory on the GPU device
- void cuda_memcpy_async(cudaStream_t stream, void* dst, const void* src, size_t count)
- copies data between host and device asynchronously through a stream
- void cuda_memset_async(cudaStream_t stream, void* devPtr, int value, size_t count)
- initializes or sets GPU memory to the given value byte by byte
- auto cuda_task_type_to_string(cudaTaskType type) -> const char* constexpr
- convert a cuda_task type to a human-readable string
-
auto operator<<(std::
ostream& os, const cudaTask& ct) -> std:: ostream& - overload of ostream inserter operator for cudaTask
- auto cuda_default_max_threads_per_block() -> size_t constexpr
- queries the maximum threads allowed per block
- auto cuda_default_threads_per_block(size_t N) -> size_t constexpr
- queries the default number of threads per block in an 1D vector of N elements
- auto version() -> const char* constexpr
- queries the version information in a string format
major.minor.patch
Variables
-
template<typename C>bool is_static_task_v constexpr
- determines if a callable is a static task
-
template<typename C>bool is_dynamic_task_v constexpr
- determines if a callable is a dynamic task
-
template<typename C>bool is_condition_task_v constexpr
- determines if a callable is a condition task
-
template<typename C>bool is_cudaflow_task_v constexpr
- determines if a callable is a cudaflow task
Function documentation
template<typename T>
T* tf:: cuda_malloc_device(size_t N,
int d)
allocates memory on the given device for holding N
elements of type T
The function calls cudaMalloc
to allocate N*sizeof(T)
bytes of memory on the given device d
and returns a pointer to the starting address of the device memory.
template<typename T>
T* tf:: cuda_malloc_device(size_t N)
allocates memory on the current device associated with the caller
The function calls cuda_malloc_device from the current device associated with the caller.
template<typename T>
T* tf:: cuda_malloc_shared(size_t N)
allocates shared memory for holding N
elements of type T
The function calls cudaMallocManaged
to allocate N*sizeof(T)
bytes of memory and returns a pointer to the starting address of the shared memory.
template<typename T>
void tf:: cuda_free(T* ptr,
int d)
frees memory on the GPU device
| Template parameters | |
|---|---|
| T | pointer type |
| Parameters | |
| ptr | device pointer to memory to free |
| d | device context identifier |
This methods call cudaFree
to free the memory space pointed to by ptr
using the given device context.
template<typename T>
void tf:: cuda_free(T* ptr)
frees memory on the GPU device
| Template parameters | |
|---|---|
| T | pointer type |
| Parameters | |
| ptr | device pointer to memory to free |
This methods call cudaFree
to free the memory space pointed to by ptr
using the current device context of the caller.
void tf:: cuda_memcpy_async(cudaStream_t stream,
void* dst,
const void* src,
size_t count)
copies data between host and device asynchronously through a stream
| Parameters | |
|---|---|
| stream | stream identifier |
| dst | destination memory address |
| src | source memory address |
| count | size in bytes to copy |
The method calls cudaMemcpyAsync
with the given stream
using cudaMemcpyDefault
to infer the memory space of the source and the destination pointers. The memory areas may not overlap.
void tf:: cuda_memset_async(cudaStream_t stream,
void* devPtr,
int value,
size_t count)
initializes or sets GPU memory to the given value byte by byte
| Parameters | |
|---|---|
| stream | stream identifier |
| devPtr | pointer to GPU mempry |
| value | value to set for each byte of the specified memory |
| count | size in bytes to set |
The method calls cudaMemsetAsync
with the given stream
to fill the first count
bytes of the memory area pointed to by devPtr
with the constant byte value value
.


Constructing and training your own ConvNet from scratch can be Hard and a long task.
A common trick used in Deep Learning is to use a pre-trained model and finetune it to the specific data it will be used for.
This notebook contains code and reference for the following Keras models (gathered from https://github.com/fchollet/keras/tree/master/keras/applications)
All architectures are compatible with both TensorFlow and Theano, and upon instantiation the models will be built according to the image dimension ordering set in your Keras configuration file at ~/.keras/keras.json
.
For instance, if you have set image_data_format="channels_last"
, then any model loaded from this repository will get built according to the TensorFlow dimension ordering convention, "Width-Height-Depth".
keras.applications
¶from keras.applications import VGG16
from keras.applications.imagenet_utils import preprocess_input, decode_predictions
import os
vgg16 = VGG16(include_top=True, weights='imagenet')
vgg16.summary()
If you're wondering where this HDF5
files with weights is stored, please take a look at ~/.keras/models/
IMAGENET_FOLDER = 'imgs/imagenet' #in the repo
!ls imgs/imagenet
from keras.preprocessing import image
import numpy as np
img_path = os.path.join(IMAGENET_FOLDER, 'strawberry_1157.jpeg')
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
print('Input image shape:', x.shape)
preds = vgg16.predict(x)
print('Predicted:', decode_predictions(preds))
img_path = os.path.join(IMAGENET_FOLDER, 'apricot_696.jpeg')
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
print('Input image shape:', x.shape)
preds = vgg16.predict(x)
print('Predicted:', decode_predictions(preds))
img_path = os.path.join(IMAGENET_FOLDER, 'apricot_565.jpeg')
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
print('Input image shape:', x.shape)
preds = vgg16.predict(x)
print('Predicted:', decode_predictions(preds))
# from keras.applications import VGG19
# - Visualise Summary
# - Infer classes using VGG19 predictions
# [your code here]
from keras.applications import ResNet50
A ResNet is composed by two main blocks: Identity Block and the ConvBlock.
from keras.applications.resnet50 import identity_block, conv_block
identity_block??
conv_block??
import numpy as np
import time
from keras.applications import vgg16
from keras import backend as K
from matplotlib import pyplot as plt
%matplotlib inline
# dimensions of the generated pictures for each filter.
IMG_WIDTH = 224
IMG_HEIGHT = 224
from keras.applications import vgg16
# build the VGG16 network with ImageNet weights
vgg16 = vgg16.VGG16(weights='imagenet', include_top=False)
print('Model loaded.')
vgg16.summary()
from collections import OrderedDict
layer_dict = OrderedDict()
# get the symbolic outputs of each "key" layer (we gave them unique names).
for layer in vgg16.layers[1:]:
layer_dict[layer.name] = layer
img_path = os.path.join(IMAGENET_FOLDER, 'strawberry_1157.jpeg')
img = image.load_img(img_path, target_size=(IMG_WIDTH, IMG_HEIGHT))
plt.imshow(img)
input_img_data = image.img_to_array(img)
# input_img_data /= 255
plt.imshow(input_img_data)
input_img_data = np.expand_dims(input_img_data, axis=0)
print('Input image shape:', input_img_data.shape)
## Recall the function defined in notebook on hidden features (2.1 Hidden Layer Repr. and Embeddings)
def get_activations(model, layer, input_img_data):
activations_f = K.function([model.layers[0].input, K.learning_phase()], [layer.output,])
activations = activations_f((input_img_data, False))
return activations
layer_name = 'block1_conv2'
layer = layer_dict[layer_name]
activations = get_activations(vgg16, layer, input_img_data)
print(len(activations))
activation = activations[0]
activation.shape
layer.filters # no. of filters in the selected conv block
activated_img = activation[0]
n = 8
fig = plt.figure(figsize=(20, 20))
for i in range(n):
for j in range(n):
idx = (n*i)+j
ax = fig.add_subplot(n, n, idx+1)
ax.imshow(activated_img[:,:,idx])
conv_img_mean = np.mean(activated_img, axis=2)
conv_img_mean.shape
plt.imshow(conv_img_mean)
block5_conv2
layer¶layer_name = 'block5_conv2'
layer = layer_dict[layer_name]
activations = get_activations(vgg16, layer, input_img_data)
activated_img = activations[0][0] # [0][0] -> first (and only) activation, first (and only) sample in batch
n = 8
fig = plt.figure(figsize=(20, 20))
for i in range(n):
for j in range(n):
idx = (n*i)+j
ax = fig.add_subplot(n, n, idx+1)
ax.imshow(activated_img[:,:,idx])
Reference: https://blog.keras.io/how-convolutional-neural-networks-see-the-world.html
In this example, we'll still using VGG16 as the reference model.
Of course, the same code applies to different CNN models, with appriopriate changes in layers references/names.
Please note that VGG16 includes a variable number of convolutional filters, depending on the particular layer(s) selected for processing.
Processing all the convolutional filters may be a high intensive computation and time consuming and largely depending on the number of parameters for the layer.
On my hardwarde (1 Tesla K80 GPU on Azure Cloud) processing one single filter takes almost ~.5 secs. (on avg)
So, it would take ~256 secs (e.g. for block5_conv1
) $\mapsto$ ~4mins (for one single layer name)
# utility function to convert a tensor into a valid image
def deprocess_image(x):
# normalize tensor: center on 0., ensure std is 0.1
x -= x.mean()
x /= (x.std() + 1e-5)
x *= 0.1
# clip to [0, 1]
x += 0.5
x = np.clip(x, 0, 1)
# convert to RGB array
x *= 255
if K.image_data_format() == 'channels_first':
x = x.transpose((1, 2, 0))
x = np.clip(x, 0, 255).astype('uint8')
return x
# dimensions of the generated pictures for each filter.
img_width = 224
img_height = 224
def collect_filters(input_tensor, output_tensor, filters):
kept_filters = []
start_time = time.time()
for filter_index in range(0, filters):
if filter_index % 10 == 0:
print('\t Processing filter {}'.format(filter_index))
# we build a loss function that maximizes the activation
# of the nth filter of the layer considered
if K.image_data_format() == 'channels_first':
loss = K.mean(output_tensor[:, filter_index, :, :])
else:
loss = K.mean(output_tensor[:, :, :, filter_index])
# we compute the gradient of the input picture wrt this loss
grads = K.gradients(loss, input_tensor)[0]
# normalization trick: we normalize the gradient by its L2 norm
grads = grads / (K.sqrt(K.mean(K.square(grads))) + 1e-5)
# this function returns the loss and grads given the input picture
iterate = K.function([input_tensor], [loss, grads])
# step size for gradient ascent
step = 1.
# we start from a gray image with some random noise
if K.image_data_format() == 'channels_first':
img_data = np.random.random((1, 3, img_width, img_height))
else:
img_data = np.random.random((1, img_width, img_height, 3))
img_data = (img_data - 0.5) * 20 + 128
# we run gradient ascent for 20 steps
for i in range(20):
loss_value, grads_value = iterate([img_data])
img_data += grads_value * step
if loss_value <= 0.:
# some filters get stuck to 0, we can skip them
break
# decode the resulting input image
if loss_value > 0:
img_deproc = deprocess_image(img_data[0])
kept_filters.append((img_deproc, loss_value))
end_time = time.time()
print('\t Time required to process {} filters: {}'.format(filters, (end_time - start_time)))
return kept_filters
# this is the placeholder for the input images
input_t = vgg16.input
def generate_stiched_filters(layer, nb_filters):
layer_name = layer.name
print('Processing {} Layer'.format(layer_name))
# Processing filters of current layer
layer_output = layer.output
kept_filters = collect_filters(input_t, layer_output, nb_filters)
print('Filter collection: completed!')
# we will stich the best sqrt(filters_to_scan) filters put on a n x n grid.
limit = min(nb_filters, len(kept_filters))
n = np.floor(np.sqrt(limit)).astype(np.int)
# the filters that have the highest loss are assumed to be better-looking.
# we will only keep the top 64 filters.
kept_filters.sort(key=lambda x: x[1], reverse=True)
kept_filters = kept_filters[:n * n]
# build a black picture with enough space for
margin = 5
width = n * img_width + (n - 1) * margin
height = n * img_height + (n - 1) * margin
stitched_filters = np.zeros((width, height, 3))
# fill the picture with our saved filters
for i in range(n):
for j in range(n):
img, loss = kept_filters[i * n + j]
stitched_filters[(img_width + margin) * i: (img_width + margin) * i + img_width,
(img_height + margin) * j: (img_height + margin) * j + img_height, :] = img
return stitched_filters
layer = layer_dict['block1_conv2'] # 64 filters
stitched_filters = generate_stiched_filters(layer, layer.filters)
plt.figure(figsize=(10,10))
plt.imshow(stitched_filters)
layer = layer_dict['block5_conv1'] # 512 filters in total
stitched_filters = generate_stiched_filters(layer, 64)
plt.figure(figsize=(10,10))
plt.imshow(stitched_filters)


NDC ready to engage government over ‘Yes’ vote – Asiedu Nketia
General Secretary of the National Democratic Congress (NDC) Johnson Asiedu Nketia says despite campaigning for ‘No’ in the upcoming referendum, his party will not mind engaging government over other possible outcomes of the exercise.
He states that his party’s position can change to ‘Yes’ if government is also “prepared to engage us”.
“[And] that is the beauty of democracy,” he stated.
Mr Asiedu Nketia was speaking in an exclusive interview on Sunrise on 3FM with host Winston Amoah.


Issue: ARGUMENTS-UNDERSPECIFIEDReferences: LOGBITP (p 224), MAKE-DISPATCH-MACRO-CHARACTER (p 363),
MAKE-HASH-TABLE (p 283), MAKE-SEQUENCE (p 249), READ (p 375)
MAKE-STRING (p 302), NTHCDR (p 267), PARSE-INTEGER (p 381),
SET (p 92)
Issue: RANGE-OF-START-END-PARAMETERS.
Category: CLARIFICATION
Edit history: 26-Aug-88, Version 1 by Chapman
4-Sep-88, version 2 by Masinter
19-Sept-88, Version 3 by Chapman
21-Sep-88, Version 4 by Masinter
Problem Description:
The descriptions of LOGBITP, MAKE-DISPATCH-MACRO-CHARACTER, READ, SET,
MAKE-HASH-TABLE, MAKE-SEQUENCE, MAKE-STRING, NTHCDR, and PARSE-INTEGER
are not clear about the types of the arguments supplied to these
constructs.
Proposal (ARGUMENTS-UNDERSPECIFIED:SPECIFY)
Clarify that the arguments for the listed constructs are as follows:
Construct Argument Type
LOGBITP index non-negative integer
MAKE-DISPATCH-MACRO-CHARACTER char character
MAKE-HASH-TABLE size non-negative integer
MAKE-SEQUENCE size non-negative integer
MAKE-SEQUENCE type type specifier
MAKE-STRING size non-negative integer
MAKE-STRING initial-element string-char
NTHCDR n non-negative integer
SET-SYNTAX-FROM-CHAR to-char,from-char characters
READ and others eof-value any value
SET value any value
(MAKE-HASH-TABLE, MAKE-SEQUENCE, MAKE-STRING have additional constraints on
their respective SIZE arguments; for example, MAKE-STRING may detect an error if
SIZE is greater than or equal to ARRAY-DIMENSION-LIMIT. Some additional
restriction on the range of characters which can have syntax in readtables
and are allowable to MAKE-DISPATCH-MACRO-CHARACTER SET-SYNTAX-FROM-CHAR might
be required in some other proposal.)
Rationale:
This clarification allows predictible results to occur when
arguments are supplied to these constructs.
Current Practice:
This proposal seems to be in line with current implementations.
Cost to Implementors:
None, since this is consistent with current practice.
Cost to Users:
None, since this is consistent with current practice.
Benefits:
This clarification will assist users in writing portable code.
Aesthetics:
The standard would be less clean were the allowed ranges of its functions not
specified.
Discussion:
There is a separate cleanup proposal RANGE-OF-START-END-PARAMETERS which
addresses a possible incompatible change. This proposal contains what we
think are non-controversial clarifications.


Peewee comes with numerous extras which I didn’t really feel like including in the main source module, but which might be interesting to implementers or fun to mess around with.
The apsw_ext module contains a database class suitable for use with the apsw sqlite driver. With apsw, it is possible to use some of the more advanced features of sqlite. It also offers better performance than pysqlite and finer-grained control over query execution. For more information on the differences between apsw and pysqlite, check the apsw docs.
from apsw_ext import *
db = APSWDatabase(':memory:')
class BaseModel(Model):
class Meta:
database = db
class SomeModel(BaseModel):
col1 = CharField()
col2 = DateTimeField()
# etc, etc
| Parameters: |
|
|---|
Functions just like the Database.transaction() context manager, but accepts an additional parameter specifying the type of lock to use.
| Parameters: | lock_type (string) – type of lock to use when opening a new transaction |
|---|
| Parameters: | timeout (int) – sqlite busy timeout in seconds (docs) |
|---|
Provides a way of globally registering a module. For more information, see the documentation on virtual tables.
| Parameters: |
|
|---|
Unregister a module.
| Parameters: | mod_name (string) – name to use for module |
|---|
The postgresql extensions module provides a number of “postgres-only” functions, including:
Warning
In order to start using the features described below, you will need to use the extension PostgresqlExtDatabase class instead of PostgresqlDatabase.
The code below will assume you are using the following database and base model:
from playhouse.postgres_ext import *
ext_db = PostgresqlExtDatabase('peewee_test', user='postgres')
class BaseExtModel(Model):
class Meta:
database = ext_db
Postgresql hstore is an embedded key/value store. With hstore, you can store arbitrary key/value pairs in your database alongside structured relational data. hstore is great for storing JSON.
Currently the postgres_ext module supports the following operations:
To start with, you will need to import the custom database class and the hstore functions from playhouse.postgres_ext (see above code snippet). Then, it is as simple as adding a HStoreField to your model:
class House(BaseExtModel):
address = CharField()
features = HStoreField()
You can now store arbitrary key/value pairs on House instances:
>>> h = House.create(address='123 Main St', features={'garage': '2 cars', 'bath': '2 bath'})
>>> h_from_db = House.get(id=h.id)
>>> h_from_db.features
{'bath': '2 bath', 'garage': '2 cars'}
You can filter by keys or partial dictionary:
>>> House.select().where(features__contains='garage') # <-- all houses w/garage key
>>> House.select().where(features__contains=['garage', 'bath']) # <-- all houses w/garage & bath
>>> House.select().where(features__contains={'garage': '2 cars'}) # <-- houses w/2-car garage
Suppose you want to do an atomic update to the house:
>>> query = House.update(features=hupdate('features', {'bath': '2.5 bath', 'sqft': '1100'}))
>>> query.where(id=h.id).execute()
1
>>> h = House.get(id=h.id)
>>> h.features
{'bath': '2.5 bath', 'garage': '2 cars', 'sqft': '1100'}
Or, alternatively an atomic delete:
>>> query = House.update(features=hdelete('features', 'bath'))
>>> query.where(id=h.id).execute()
1
>>> h = House.get(id=h.id)
>>> h.features
{'garage': '2 cars', 'sqft': '1100'}
Multiple keys can be deleted at the same time:
>>> query = House.update(features=hdelete('features', ['garage', 'sqft']))
You can select just keys, just values, or zip the two:
>>> for h in House.select(['address', hkeys('features', 'keys')]):
... print h.address, h.keys
123 Main St [u'bath', u'garage']
>>> for h in House.select(['address', hvalues('features', 'vals')]):
... print h.address, h.vals
123 Main St [u'2 bath', u'2 cars']
>>> for h in House.select(['address', hmatrix('features', 'mtx')]):
... print h.address, h.mtx
123 Main St [[u'bath', u'2 bath'], [u'garage', u'2 cars']]
You can retrieve a slice of data, for example, all the garage data:
>>> for h in House.select(['address', hslice('features', 'garage_data', ['garage'])]):
... print h.address, h.garage_data
123 Main St {'garage': '2 cars'}
You can check for the existence of a key and filter rows accordingly:
>>> for h in House.select(['address', hexist('features', 'has_garage', 'garage')]):
... print h.address, h.has_garage
123 Main St True
>>> for h in House.select().where(hexist('features', ['garage'])):
... print h.address, h.features['garage'] # <-- just houses w/garage data
123 Main St 2 cars
pwiz is a little script that ships with peewee and is capable of introspecting an existing database and generating model code suitable for interacting with the underlying data. If you have a database already, pwiz can give you a nice boost by generating skeleton code with correct column affinities and foreign keys.
If you install peewee using setup.py install, pwiz will be installed as a “script” and you can just run:
pwiz.py -e postgresql -u postgres my_postgres_db > my_models.py
This will print a bunch of models to standard output. So you can do this:
pwiz.py -e postgresql my_postgres_db > mymodels.py
python # <-- fire up an interactive shell
>>> from mymodels import Blog, Entry, Tag, Whatever
>>> print [blog.name for blog in Blog.select()]
| Option | Meaning | Example |
|---|---|---|
| -h | show help | |
| -e | database backend | -e mysql |
| -H | host to connect to | -H remote.db.server |
| -p | port to connect on | -p 9001 |
| -u | database user | -u postgres |
| -P | database password | -P secret |
| -s | postgres schema | -s public |
The following are valid parameters for the engine:
Models with hooks for signals (a-la django) are provided in playhouse.signals. To use the signals, you will need all of your project’s models to be a subclass of playhouse.signals.Model, which overrides the necessary methods to provide support for the various signals.
from playhouse.signals import Model, connect, post_save
class MyModel(Model):
data = IntegerField()
@connect(post_save, sender=MyModel)
def on_save_handler(model_class, instance, created):
put_data_in_cache(instance.data)
The following signals are provided:
Whenever a signal is dispatched, it will call any handlers that have been registered. This allows totally separate code to respond to events like model save and delete.
The Signal class provides a connect() method, which takes a callback function and two optional parameters for “sender” and “name”. If specified, the “sender” parameter should be a single model class and allows your callback to only receive signals from that one model class. The “name” parameter is used as a convenient alias in the event you wish to unregister your signal handler.
Example usage:
from playhouse.signals import *
def post_save_handler(sender, instance, created):
print '%s was just saved' % instance
# our handler will only be called when we save instances of SomeModel
post_save.connect(post_save_handler, sender=SomeModel)
All signal handlers accept as their first two arguments sender and instance, where sender is the model class and instance is the actual model being acted upon.
If you’d like, you can also use a decorator to connect signal handlers. This is functionally equivalent to the above example:
@connect(post_save, sender=SomeModel)
def post_save_handler(sender, instance, created):
print '%s was just saved' % instance
Stores a list of receivers (callbacks) and calls them when the “send” method is invoked.
Add the receiver to the internal list of receivers, which will be called whenever the signal is sent.
| Parameters: |
|
|---|
from playhouse.signals import post_save
from project.handlers import cache_buster
post_save.connect(cache_buster, name='project.cache_buster')
Disconnect the given receiver (or the receiver with the given name alias) so that it no longer is called. Either the receiver or the name must be provided.
| Parameters: |
|
|---|
post_save.disconnect(name='project.cache_buster')
Iterates over the receivers and will call them in the order in which they were connected. If the receiver specified a sender, it will only be called if the instance is an instance of the sender.
| Parameters: | instance – a model instance |
|---|
Function decorator that is an alias for a signal’s connect method:
from playhouse.signals import connect, post_save
@connect(post_save, name='project.cache_buster')
def cache_bust_handler(sender, instance, *args, **kwargs):
# bust the cache for this instance
cache.delete(cache_key_for(instance))
The sqlite extensions module provides a number of “sqlite-only” functions, including:
Warning
In order to start using the features described below, you will need to use the extension SqliteExtDatabase class instead of SqliteDatabase.
The code below will assume you are using the following database and base model:
from playhouse.sqlite_ext import *
ext_db = SqliteExtDatabase('tmp.db')
class BaseExtModel(Model):
class Meta:
database = ext_db
Sqlite ships on most distributions with a full-text search (FTS) extension module. This can be used to expose search on your peewee models with very little work. A complete overview of sqlite’s FTS is beyond the scope of this section, so please read their documentation for the details.
To use FTS with your peewee models, you must subclass the playhouse.sqlite_ext.FTSModel. You can store data directly in this model or you can create a separate model that references an existing model. Since virtual tables do not support column indexes, this decision will depend on how you intend to query the data stored in the full-text index.
Here is a simple example, showing the use of a separate model for storage (note that we “mix-in” the FTSModel):
class Post(BaseExtModel):
message = TextField()
class FTSPost(Post, FTSModel):
pass
When you create the table, you can specify a number of options for the full-text module, including a “source” table and a tokenizer:
Post.create_table()
FTSPost.create_table(content_model=Post, tokenize='porter')
The above code instructs sqlite to create a virtual table storing our posts that will be suitable for FTS.
bulk_import_some_posts()
# rebuild the search index -- this will load up the contents of the Post table
# and make it searchable via the FTSPost
FTSPost.rebuild()
# you can add/update/delete items from FTSPost just like a normal model
FTSPost.create(message='this will be searchable as well')
# perform a search
FTSPost.select().where(message__match='search phrase')
# search supports some advanced queries http://www.sqlite.org/fts3.html#section_3_1
FTSPost.select().where(message__match='cats NOT dogs')
There is also support for ordering search results by rank. The implementation is based on the C implementation found at the bottom of the FTS docs:
FTSPost.select(['*', Rank('msg_rank')]).where(message__match='python').order_by(('msg_rank', 'desc'))
Sqlite uses three different types of locks to control access during transactions. Details on the three types can be found in the docs, but here is a quick overview:
These various types of transactions can be opened using the special context-manager:
with ext_db.granular_transaction('exclusive'):
# no other connections can read or write to the database now
execute_some_queries()
# safe for other processes to read and write again
do_some_other_stuff()
Sqlite allows you to specify custom functions that can stand-in as aggregators, collations or functions, and then be executed as part of your queries. If you read the notes on the full-text search extension, the “sort by rank” is implemented as a user-defined function.
Python’s sqlite documentation gives a good overview of how these types of functions can be used.
class WeightedAverage(object):
def __init__(self):
self.total_weight = 0.0
self.total_ct = 0.0
def step(self, value, wt=None):
wt = wt or 1.0
self.total_weight += wt
self.total_ct += wt * value
def finalize(self):
if self.total_weight != 0.0:
return self.total_ct / self.total_weight
return 0.0
ext_db.adapter.register_aggregate(WeightedAverage, 2, 'weighted_avg')
def collate_reverse(s1, s2):
return -cmp(s1, s2)
ext_db.adapter.register_collation(collate_reverse)
def sha1(s):
return hashlib.sha1(s).hexdigest()
ext_db.adapter.register_function(sha1)
Calling it syntactic sugar is a bit of a stretch. I wrote this stuff for fun after learning about ISBL from a coworker. The blog post can be found here.
At any rate, ISBL (Information Systems Base Language) is an old domain-specific language for querying relational data, developed by IBM in the 60’s. Here are some example SQL and ISBL queries:
-- query the database for all active users
SELECT id, username, active FROM users WHERE active = True
-- query for tweets and the username of the sender
SELECT t.id, t.message, u.username
FROM tweets AS t
INNER JOIN users AS u
ON t.user_id = u.id
WHERE u.active = True
-- tables appear first -- the colon indicates a restriction (our where clause)
-- and after the modulo is the "projection", or columns we want to select
users : active = True % (id, username, active)
(tweets * users) : user.active = True % (tweet.id, tweet.message, user.username)
Pretty cool. In the above examples:
I hacked up a small implementation on top of peewee. Since peewee does not support the ”:” (colon) character as an infix operator, I used the “power” operator to signify a restriction:
# active users
User ** (User.active == True)
# tweets with the username of sender
(Tweet * User) ** (User.active == True) % (Tweet.id, Tweet.message, User.username)
To try out swee’pea, simply replace from peewee import * with from playhouse.sweepea import * and start writing wacky queries:
from playhouse.sweepea import *
class User(Model):
username = CharField()
active = BooleanField()
class Tweet(Model):
user = ForeignKeyField(User)
message = CharField()
# have fun!
(User * Tweet) ** (User.active == True)


--- title: Using Cassandra for an Instant Messaging App layout: post ---
Interesting use of Cassandra for a Facebook Messenger-style application.


Library Common
Library SingleNode
- Syntax
- Types for a program / environments
- Dynamic semantics
- Soundness and other properties of the defined semantics
- Various inductive judgements to describe properties of a program
- Properties of a program
- Any variable on which a clock is built is of type bool
- Lemmas about Pinp_long
- Free of loops of clocks
- Free of causuality loop
- Good value properties
- Lemmas about conform_clock
- Existence of semantics
- Determinism of semantics
- Program well-formedness and properties of I/O
- Additional properties for well-formed programs when input is valid
- Some Lemmas
Library ClockUnify
Library ClockUnifyProof
Library ClockUnifyImpl
Library Decidable
Library Examples
This page has been generated by coqdoc


Balla Beer | Purchase
Main Navigation
Home
About
Products
Advertisements
Purchase
Checkout Our Vendors Near You!
Find A store Near You


The infamous dot-files, all the tooling-decisions and tweaks represented as text.
Store them in git
Clone the repos on whatever machine
Use stow to install them


| Option | Type | Default | Description |
|---|---|---|---|
watch |
Boolean |
false |
If true , starts continuous watching of location changes (instead of detecting it
once) using W3C watchPosition method. You can later stop watching using
map.stopLocate() method. |
setView |
Boolean |
false |
If true , automatically sets the map view to the user location with respect to
detection accuracy, or to world view if geolocation failed. |
maxZoom |
Number |
Infinity |
The maximum zoom for automatic view setting when using setView option. |
timeout |
Number |
10000 |
Number of milliseconds to wait for a response from geolocation before firing a
locationerror event. |
maximumAge |
Number |
0 |
Maximum age of detected location. If less than this amount of milliseconds
passed since last geolocation response, locate will return a cached location. |
enableHighAccuracy |
Boolean |
false |
Enables high accuracy, see description in the W3C spec. |
Map
methods which modify the zoom level take in an options
parameter. This is a plain javascript object with the following optional
components:| Option | Type | Default | Description |
|---|---|---|---|
animate |
Boolean |
|
If not specified, zoom animation will happen if the zoom origin is inside the
current view. If true , the map will attempt animating zoom disregarding where
zoom origin is. Setting false will make it always reset the view completely
without animation. |
Map
methods which modify the center of the map take in an options
parameter. This is a plain javascript object with the following optional
components:| Option | Type | Default | Description |
|---|---|---|---|
animate |
Boolean |
|
If true , panning will always be animated if possible. If false , it will
not animate panning, either resetting the map view if panning more than a
screen away, or just setting a new offset for the map pane (except for panBy
which always does the latter). |
duration |
Number |
0.25 |
Duration of animated panning, in seconds. |
easeLinearity |
Number |
0.25 |
The curvature factor of panning animation easing (third parameter of the Cubic Bezier curve). 1.0 means linear animation, and the smaller this number, the more bowed the curve. |
noMoveStart |
Boolean |
false |
If true , panning won't fire movestart event on start (used internally for
panning inertia). |
| Option | Type | Default | Description |
|---|---|---|---|
animate |
Boolean |
|
If not specified, zoom animation will happen if the zoom origin is inside the
current view. If true , the map will attempt animating zoom disregarding where
zoom origin is. Setting false will make it always reset the view completely
without animation. |
| Option | Type | Default | Description |
|---|---|---|---|
duration |
Number |
0.25 |
Duration of animated panning, in seconds. |
easeLinearity |
Number |
0.25 |
The curvature factor of panning animation easing (third parameter of the Cubic Bezier curve). 1.0 means linear animation, and the smaller this number, the more bowed the curve. |
noMoveStart |
Boolean |
false |
If true , panning won't fire movestart event on start (used internally for
panning inertia). |
| Option | Type | Default | Description |
|---|---|---|---|
paddingTopLeft |
Point |
[0, 0] |
Sets the amount of padding in the top left corner of a map container that shouldn't be accounted for when setting the view to fit bounds. Useful if you have some control overlays on the map like a sidebar and you don't want them to obscure objects you're zooming to. |
paddingBottomRight |
Point |
[0, 0] |
The same for the bottom right corner of the map. |
padding |
Point |
[0, 0] |
Equivalent of setting both top left and bottom right padding to the same value. |
maxZoom |
Number |
null |
The maximum possible zoom to use. |
| Option | Type | Default | Description |
|---|---|---|---|
animate |
Boolean |
|
If not specified, zoom animation will happen if the zoom origin is inside the
current view. If true , the map will attempt animating zoom disregarding where
zoom origin is. Setting false will make it always reset the view completely
without animation. |
| Option | Type | Default | Description |
|---|---|---|---|
duration |
Number |
0.25 |
Duration of animated panning, in seconds. |
easeLinearity |
Number |
0.25 |
The curvature factor of panning animation easing (third parameter of the Cubic Bezier curve). 1.0 means linear animation, and the smaller this number, the more bowed the curve. |
noMoveStart |
Boolean |
false |
If true , panning won't fire movestart event on start (used internally for
panning inertia). |
L.Class powers the OOP facilities of Leaflet and is used to create almost all of the Leaflet classes documented here.
In addition to implementing a simple classical inheritance model, it introduces several special properties for convenient code organization — options, includes and statics.
var MyClass = L.Class.extend({
initialize: function (greeter) {
this.greeter = greeter;
// class constructor
},
greet: function (name) {
alert(this.greeter + ', ' + name)
}
});
// create instance of MyClass, passing "Hello" to the constructor
var a = new MyClass("Hello");
// call greet method, alerting "Hello, World"
a.greet("World");
You may have noticed that Leaflet objects are created without using
the new
keyword. This is achieved by complementing each class with a
lowercase factory method:
new L.Map('map'); // becomes:
L.map('map');
The factories are implemented very easily, and you can do this for your own classes:
L.map = function (id, options) {
return new L.Map(id, options);
};
You use L.Class.extend to define new classes, but you can use the same method on any class to inherit from it:
var MyChildClass = MyClass.extend({
// ... new properties and methods
});
This will create a class that inherits all methods and properties of the parent class (through a proper prototype chain), adding or overriding the ones you pass to extend. It will also properly react to instanceof:
var a = new MyChildClass();
a instanceof MyChildClass; // true
a instanceof MyClass; // true
You can call parent methods (including constructor) from corresponding child ones (as you do with super calls in other languages) by accessing parent class prototype and using JavaScript's call or apply:
var MyChildClass = MyClass.extend({
initialize: function () {
MyClass.prototype.initialize.call(this, "Yo");
},
greet: function (name) {
MyClass.prototype.greet.call(this, 'bro ' + name + '!');
}
});
var a = new MyChildClass();
a.greet('Jason'); // alerts "Yo, bro Jason!"
options
is a special property that unlike other objects that you pass
to extend
will be merged with the parent one instead of overriding it
completely, which makes managing configuration of objects and default
values convenient:
var MyClass = L.Class.extend({
options: {
myOption1: 'foo',
myOption2: 'bar'
}
});
var MyChildClass = MyClass.extend({
options: {
myOption1: 'baz',
myOption3: 5
}
});
var a = new MyChildClass();
a.options.myOption1; // 'baz'
a.options.myOption2; // 'bar'
a.options.myOption3; // 5
There's also L.Util.setOptions
, a method for
conveniently merging options passed to constructor with the defaults
defines in the class:
var MyClass = L.Class.extend({
options: {
foo: 'bar',
bla: 5
},
initialize: function (options) {
L.Util.setOptions(this, options);
...
}
});
var a = new MyClass({bla: 10});
a.options; // {foo: 'bar', bla: 10}
Note that the options object allows any keys, not just the options defined by the class and its base classes. This means you can use the options object to store application specific information, as long as you avoid keys that are already used by the class in question.
includes
is a special class property that merges all specified objects into the class (such objects are called mixins).
var MyMixin = {
foo: function () { ... },
bar: 5
};
var MyClass = L.Class.extend({
includes: MyMixin
});
var a = new MyClass();
a.foo();
You can also do such includes in runtime with the include
method:
MyClass.include(MyMixin);
statics
is just a convenience property that injects specified object properties as the static properties of the class, useful for defining constants:
var MyClass = L.Class.extend({
statics: {
FOO: 'bar',
BLA: 5
}
});
MyClass.FOO; // 'bar'
If you're a plugin developer, you often need to add additional initialization code to existing classes (e.g. editing hooks for L.Polyline
). Leaflet comes with a way to do it easily using the addInitHook
method:
MyClass.addInitHook(function () {
// ... do something in constructor additionally
// e.g. add event listeners, set custom properties etc.
});
You can also use the following shortcut when you just need to make one additional method call:
MyClass.addInitHook('methodName', arg1, arg2, …);
Some Layer
s can be made interactive - when the user interacts
with such a layer, mouse events like click
and mouseover
can be handled.
Use the event handling methods to handle these events.
| Option | Type | Default | Description |
|---|---|---|---|
interactive |
Boolean |
true |
If false , the layer will not emit mouse events and will act as a part of the underlying map. |
bubblingMouseEvents |
Boolean |
true |
When true , a mouse event on this layer will trigger the same event on the map
(unless L.DomEvent.stopPropagation is used). |
| Event | Data | Description |
|---|---|---|
click |
MouseEvent |
Fired when the user clicks (or taps) the layer. |
dblclick |
MouseEvent |
Fired when the user double-clicks (or double-taps) the layer. |
mousedown |
MouseEvent |
Fired when the user pushes the mouse button on the layer. |
mouseup |
MouseEvent |
Fired when the user releases the mouse button pushed on the layer. |
mouseover |
MouseEvent |
Fired when the mouse enters the layer. |
mouseout |
MouseEvent |
Fired when the mouse leaves the layer. |
contextmenu |
MouseEvent |
Fired when the user right-clicks on the layer, prevents default browser context menu from showing if there are listeners on this event. Also fired on mobile when the user holds a single touch for a second (also called long press). |
| CRS | Description |
|---|---|
L.CRS.Simple |
A simple CRS that maps longitude and latitude into x and y directly.
May be used for maps of flat surfaces (e.g. game maps). Note that the y
axis should still be inverted (going from bottom to top). distance() returns
simple euclidean distance. |
Whenever a class inheriting from Evented
fires an event, a listener function
will be called with an event argument, which is a plain object containing
information about the event. For example:
map.on('click', function(ev) {
alert(ev.latlng); // ev is an event object (MouseEvent in this case)
});
The information available depends on the event type:
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
originalEvent |
DOMEvent |
The original DOM KeyboardEvent that triggered this Leaflet event. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
latlng |
LatLng |
The geographical point where the mouse event occurred. |
layerPoint |
Point |
Pixel coordinates of the point where the mouse event occurred relative to the map layer. |
containerPoint |
Point |
Pixel coordinates of the point where the mouse event occurred relative to the map сontainer. |
originalEvent |
DOMEvent |
The original DOM MouseEvent or DOM TouchEvent that triggered this Leaflet event. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
latlng |
LatLng |
Detected geographical location of the user. |
bounds |
LatLngBounds |
Geographical bounds of the area user is located in (with respect to the accuracy of location). |
accuracy |
Number |
Accuracy of location in meters. |
altitude |
Number |
Height of the position above the WGS84 ellipsoid in meters. |
altitudeAccuracy |
Number |
Accuracy of altitude in meters. |
heading |
Number |
The direction of travel in degrees counting clockwise from true North. |
speed |
Number |
Current velocity in meters per second. |
timestamp |
Number |
The time when the position was acquired. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
message |
String |
Error message. |
code |
Number |
Error code (if applicable). |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
layer |
Layer |
The layer that was added or removed. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
| Property | Type | Description |
|---|---|---|
layer |
Layer |
The layer that was added or removed. |
name |
String |
The name of the layer that was added or removed. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
| Property | Type | Description |
|---|---|---|
tile |
HTMLElement |
The tile element (image). |
coords |
Point |
Point object with the tile's x , y , and z (zoom level) coordinates. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
tile |
HTMLElement |
The tile element (image). |
coords |
Point |
Point object with the tile's x , y , and z (zoom level) coordinates. |
error |
* |
Error passed to the tile's done() callback. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
oldSize |
Point |
The old size before resize event. |
newSize |
Point |
The new size after the resize event. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
layer |
Layer |
The layer for the GeoJSON feature that is being added to the map. |
properties |
Object |
GeoJSON properties of the feature. |
geometryType |
String |
GeoJSON geometry type of the feature. |
id |
String |
GeoJSON ID of the feature (if present). |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
| Property | Type | Description |
|---|---|---|
popup |
Popup |
The popup that was opened or closed. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
tooltip |
Tooltip |
The tooltip that was opened or closed. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
distance |
Number |
The distance in pixels the draggable element was moved by. |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
| Property | Type | Description |
|---|---|---|
center |
LatLng |
The current center of the map |
zoom |
Number |
The current zoom level of the map |
noUpdate |
Boolean |
Whether layers should update their contents due to this event |
| Property | Type | Description |
|---|---|---|
type |
String |
The event type (e.g. 'click' ). |
target |
Object |
The object that fired the event. For propagated events, the last object in the propagation chain that fired the event. |
sourceTarget |
Object |
The object that originally fired the event. For non-propagated events, this will
be the same as the target . |
propagatedFrom |
Object |
For propagated events, the last object that propagated the event to its event parent. |
layer |
Object |
Deprecated. The same as propagatedFrom . |
Global switches are created for rare cases and generally make Leaflet to not detect a particular browser feature even if it's there. You need to set the switch as a global variable to true before including Leaflet on the page, like this:
<script>L_NO_TOUCH = true;</script>
<script src="leaflet.js"></script>
| Switch | Description |
|---|---|
L_NO_TOUCH |
Forces Leaflet to not use touch events even if it detects them. |
L_DISABLE_3D |
Forces Leaflet to not use hardware-accelerated CSS 3D transforms for positioning (which may cause glitches in some rare environments) even if they're supported. |
This method restores the L
global variable to the original value
it had before Leaflet inclusion, and returns the real Leaflet
namespace so you can put it elsewhere, like this:
<script src='libs/l.js'>
<!-- L points to some other library -->
<script src='leaflet.js'>
<!-- you include Leaflet, it replaces the L variable to Leaflet namespace -->
<script>
var Leaflet = L.noConflict();
// now L points to that other library again, and you can use Leaflet.Map etc.
</script>
A constant that represents the Leaflet version in use.
L.version; // contains "1.0.0" (or whatever version is currently in use)
Map
take in anoptions
parameter. This is a plain javascript object with the following optional components:


--- layout: stats title: Arizona Statistics permalink: "/stats/teams/arizona.html" ---
| Year | Team | Status | Finish | W-L | PPG | PAPG | Margin | TU/G | N/G | BHrd | BPts | PPB |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2011 | Arizona | 23 | 2-10 | 65.8 | 183.8 | -118 | 4.25 | 1.83 | 51 | 390 | 7.65 |
| Year | Round | Team | Opponent | Result | Score | 10 | -5 | PPB | Packet |
|---|---|---|---|---|---|---|---|---|---|
| 2011 | 2 (Prelims) | Arizona | Berkeley A | Loss | 30 - 210 | 3 | 2 | 3.33 | No Packet Recorded |
| 2011 | 3 (Prelims) | Arizona | Toronto A | Loss | 60 - 65 | 4 | 2 | 7.50 | No Packet Recorded |
| 2011 | 3 (Prelims) | Arizona | Illinois A | Loss | 40 - 305 | 3 | 0 | 3.33 | No Packet Recorded |
| 2011 | 5 (Prelims) | Arizona | Chicago C | Win | 115 - 100 | 6 | 1 | 10.00 | No Packet Recorded |
| 2011 | 6 (Prelims) | Arizona | Brown A | Loss | 35 - 295 | 4 | 3 | 2.50 | No Packet Recorded |
| 2011 | 7 (Prelims) | Arizona | UCSD A | Loss | 40 - 245 | 2 | 2 | 15.00 | No Packet Recorded |
| 2011 | 8 (Playoffs) | Arizona | South Carolina | Loss | 45 - 340 | 4 | 3 | 5.00 | No Packet Recorded |
| 2011 | 10 (Playoffs) | Arizona | Carnegie Mellon | Loss | 35 - 215 | 3 | 3 | 6.67 | No Packet Recorded |
| 2011 | 11 (Playoffs) | Arizona | George Mason | Loss | 105 - 140 | 5 | 1 | 12.00 | No Packet Recorded |
| 2011 | 12 (Playoffs) | Arizona | Michigan B | Win | 110 - 65 | 6 | 2 | 10.00 | No Packet Recorded |
| 2011 | 13 (Playoffs) | Arizona | WUSTL | Loss | 100 - 115 | 6 | 0 | 6.67 | No Packet Recorded |
| 2011 | 14 (Playoffs) | Arizona | Chicago C | Loss | 75 - 110 | 5 | 3 | 8.00 | No Packet Recorded |
| Year | Team | Player | Games | Tossups | Negs | Pts | PPG |
|---|---|---|---|---|---|---|---|
| 2011 | Arizona | Kenneth Lan | 12 | 26 | 10 | 210 | 17.50 |
| 2011 | Arizona | Joe Yu | 12 | 16 | 7 | 125 | 10.42 |
| 2011 | Arizona | Mike Bell | 12 | 5 | 1 | 45 | 3.75 |
| 2011 | Arizona | Ian McCloskey | 11 | 4 | 4 | 20 | 1.82 |
| 2011 | Arizona | Brendan Guinn | 2 | 0 | 0 | 0 | 0.00 |


The Association of Multicultural Computer Scientists’ goal is to create a special community to provide professional and academic resources to multicultural students in Purdue’s Department of Computer Science.
Interactice workshop on April 11th from 7-9 PM. More details will be provided soon.
Join us to study every Wednesday from 7-9 PM at LWSN B148. Snacks will be provided.
More details will be coming soon...
Lawson Computer Science Building, B134


:: com :: sun :: star :: ui ::
|
| enum DockingArea |
- Description
- specifies different docking areas a frame based layout manager
supports.
A frame based layout manager supports four different docking areas where
dockable user interface elements can be docked.
- Since
- OOo 2.0
- See also
- ::com::sun::star::frame::XLayoutManager
|
| Values' Details |
DOCKINGAREA_TOP
DOCKINGAREA_TOP,
- Description
- the top docking area below the menu bar.
|
|
DOCKINGAREA_BOTTOM
DOCKINGAREA_BOTTOM,
- Description
- the bottom docking area above the status bar.
|
|
DOCKINGAREA_LEFT
DOCKINGAREA_LEFT,
- Description
- the left side docking area.
|
|
DOCKINGAREA_RIGHT
DOCKINGAREA_RIGHT,
- Description
- the right side docking area.
|
|
DOCKINGAREA_DEFAULT
DOCKINGAREA_DEFAULT,
- Description
- a default docking area. It depends on the implementation
how to treat this value.
|
|
Top of Page
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Voice enabling the web.
Read aloud the content of any web page with one click.
Chrome Firefox EdgeConvert text to speech and create voice narrations.
ttstool.comTo send a support request, please use the contact form.
Got an idea or suggestion? Please share it.


"My work location is in Ghaziabad or
should I just say near Kaushambi or Vaishali or
Noida 60's
But I am unable to find a decent living place that
can provide me with urban facilities in my budget.
Oh God! Where am I going to find such place near
my work location?"
- A Female