Zend Framework
LICENSE
This source file is subject to the new BSD license that is bundled with this package in the file LICENSE.txt. It is also available through the world-wide-web at this URL: http://framework.zend.com/license/new-bsd If you did not receive a copy of the license and are unable to obtain it through the world-wide-web, please send an email to<EMAIL_ADDRESS>so we can send you a copy immediately.
Represents a single Technorati KeyInfo query result object.
It provides information about your Technorati API Key daily usage.
__construct(
\DomElement $dom, string $apiKey
=
null
)
:
void
Constructs a new object from DOM Element.
Parses given Key element from $dom and sets API key string.
| Name | Type | Description |
|---|---|---|
| $dom | \DomElement | the ReST fragment for this object |
| $apiKey | string | the API Key string |
getApiQueries(
)
:
int
Returns the number of queries sent today.
| Type | Description |
|---|---|
| int | number of queries sent today |
getMaxQueries(
)
:
int
Returns Key's daily query limit.
| Type | Description |
|---|---|
| int | maximum number of available queries per day |
setApiKey(
string $apiKey
)
:
\Zend_Service_Technorati_KeyInfoResult
Sets API Key string.
| Name | Type | Description |
|---|---|---|
| $apiKey | string | the API Key |
| Type | Description |
|---|---|
| \Zend_Service_Technorati_KeyInfoResult | $this instance |


We want the civilians to have fun too so we have a select number of ADDON vehicles you can choose from, allowing you for many varieties of roleplays! If you have a reasonable suggestion for a new vehicle feel free to let us know! We are committed to your roleplays!
created with
Website Builder Software .


3.1
standard
mandatory
Every
building
must be designed and
constructed
in such a way that
there will not be a threat to the
building
or the health of people in or
around the
building
due to the presence of harmful or dangerous
substances.
Limitation:
This standard does not apply to the removal of unsuitable material,
including turf, vegetable matter, wood, roots and topsoil on the
site
of a
period specified in regulation 6.
Environmental
Protection Act 1990
Land contamination is an unwanted legacy of Britain’s long industrial history.
Part IIA of the Environmental Protection Act 1990 (inserted by section 57 of
the Environment Act 1995) was introduced to enable the identification and
remediation of contaminated land from which contamination currently
represents an unacceptable risk. Risks associated with the land’s future use
will continue to be dealt with under the planning and building standards
system. Some functions of Part IIA, planning and building standards regimes
may, at times, overlap.
Public registers
Part IIA adopts a ‘suitable for use approach’ that requires the current risks to
be assessed and remediated as required, for a
site’s
existing use. The
primary regulatory role for this rests with the local authorities. Local
authorities and SEPA must establish public registers to record all prescribed
regulatory action taken under Part IIA. The register will contain particulars
relating to the remediation, as well as notifications of the identification, of
contaminated land. The registers will expand as new information is identified.
Section 78A(2) of the Act (as amended) provides a specific definition of
'contaminated land' for the purpose of the Act. Land that is not ‘contaminated
land’ as defined under the Act may still contain harmful or dangerous
substances and the following guidance should be useful to the local authority
in carrying out its other functions.
PAN 33
Land confirmed, or suspected of being contaminated is a material
consideration when local authorities determine planning applications. The
key role of the planning system is to ensure that all the ground included
within the planning application is suitable for the proposed future use.
Conditions may be added to any permission given to ensure the required
remediation takes place. Planning Advice Note (PAN) 33 ‘Development of
Contaminated Land’ explains further the role of planning and includes useful
cross-references to other relevant publications and regimes.
Harmful or dangerous
substances
Harmful or dangerous substances include deposits of faecal or animal matter
and any substance, or mixture of substances, which is, or could become,
corrosive, explosive, flammable, radioactive or toxic or which produces, or
could produce, any gas likely to have any such characteristic.
In the case of
conversions
, as specified in regulation 4, the
building
as
converted
shall meet the requirements of this standard in so far as is
reasonably practicable
, and in no case be worse than before the
conversion
(regulation 12, schedule 6).
3.1
—
3.1.0
domestic | environment | site preparation – harmful and dangerous substances | 2010
'ground immediately
adjoining'
Surface soil and vegetable matter can be detrimental to a
building’s
structure
commence, unsuitable material including turf, vegetable matter, wood, roots
and topsoil should be removed from the ground to be covered by the
least that which will prevent later growth that could damage the
building
. The
term ‘ground immediately adjoining’ is intended to cover ground that is
disturbed as a direct result of the
works
.
The solum (prepared area within the containing walls of a
building
) should be
treated to prevent vegetable growth and reduce the evaporation of moisture
from the ground to the inner surface of any part of a
dwelling
that it could
damage.
The solum should be brought to an even surface and any up filling should be
of hard, inert material. See guidance to standard 3.4 relating to
building
elements adjacent to the ground.
To prevent water collecting under the
building
, the solum should be not lower
than the highest level of the adjoining ground. However where this may not
be possible, such as on sloping ground, the solum should be laid to fall to an
outlet in the under
building
above the lowest level of the adjoining ground to
that is in contact with the ground, such as on sloping ground, should be
tanked see clause 3.4.7.
Made ground
Where the
site
contains fill or made ground, consideration should be given to
its compressibility and its collapse potential. Thought should be given to
foundation
design to prevent the damaging effect of differential settlement.
For the purposes of this Technical Handbook, clause 3.1.0 provides guidance
on what harmful or dangerous substances may consist of. Because of their
hazardous qualities, any ground below and immediately adjoining (see
clause 3.1.1) a
building
should have them removed or made safe. Guidance
on remedial action to deal with such substances is given in clause 3.1.5.
A preliminary desk-top study should be carried out to provide information on
the past and present uses of the proposed
building site
and surrounding area
that may give rise to contamination. Examples of land likely to contain
contaminants can include, but are not limited to:
•
asbestos works;
•
chemical works;
•
gas works, coal carbonisation plants and ancillary by-products works;
•
industries making or using wood preservatives;
•
landfill and other waste disposal sites;
•
metal mines, smelters, foundries, steel works and metal finishing works;
•
munitions production and testing sites;
•
nuclear installations;
•
oil storage and distribution sites;
•
paper and printing works;
•
railway land, especially the larger sidings and depots;
•
scrap yards;
3.1.0
—
3.1.3
domestic | environment | site preparation – harmful and dangerous substances | 2010
•
sewage works, sewage farms and sludge disposal sites;
•
tanneries; and
•
petrol filling stations.
During a walk-over of the area there may be signs of possible contaminants.
The preliminary investigation can assist in the design of the exploratory and
detailed ground investigation. A detailed ground investigation may be
necessary and should provide sufficient information for the risk assessment
and the design and specification of any remedial
work
.
Risk assessment should be specific to each
building site
and take into
account the presence of source, pathways and receptors at a particular
building site
. Generic assessment criteria may provide an indication of where
further consideration of risk to receptors is required. The selection of
assessment criteria should take into account the specific circumstances of
the
building site
and the receptors that may be exposed. Assessment criteria
should be authoritative and scientifically based. Should a risk be indicated
then further consideration would be warranted. This may involve collection
and assessment of further information. Useful tools for undertaking detailed
assessment of risk are available e.g. CONSIM and CLEA. Reference should
be made to SEPA and DEFRA web sites which contain details of published
and forthcoming guidance.
The Environment Agency manages an extensive research programme
related to land contamination. This programme is ongoing and a check
should be made to ensure that the most up-to-date guidance is used. The
following are just some of the publications that may be of interest:
•
assessment of risks to human health from land contamination, an
overview of the development of soil guideline values: CLR 7;
•
priority contaminants report: CLR 8;
•
contaminants in soils, collation of toxicological data and intake values for
humans: CLR 9;
•
contaminated land exposure assessment (CLEA) model, technical basis
and algorithms: CLR 10;
•
land contamination risk assessment tools: an evaluation of some of the
commonly used methods: Technical Report P260;
•
secondary model procedure for the development of appropriate soil
sampling strategies for land contamination - R&D Technical Report P5;
•
technical aspects of site investigation - R&D Technical report P5.
Where the desk study, records or local knowledge of previous use identifies
land that may contain, or give rise to, harmful or dangerous substances,
planning permission will normally be subject to conditions. These conditions
may be imposed to ensure that the development proposed for the land will
associated with the contaminants.
There may be occasions when land containing harmful or dangerous
substances has not been identified at the planning stage, and the presence
of contaminants is only suspected later. Some signs of the possible presence
of contaminants are given in the table below together with the possible
contaminant and the probable remedial action recommended.
3.1.3
—
3.1.5
domestic | environment | site preparation – harmful and dangerous substances | 2010
Possible contaminants and actions
Signs of possible
contamination
Possible contaminant
Probable remedial
action recommended
Vegetation (absence,
poor or unnatural
growth)
metals, metal compounds none
organic compounds, gases removal or treatment
Surface materials
(unusual colours and
contours may indicate)
metals, metal compounds none
oil and tarry wastes
removal, filling, sealing
or treatment
asbestos (loose)
removal, filling, sealing
or treatment
other fibres
none
organic compounds
including phenols
removal, filling or
treatment
potentially combustible
material including coal and
coke dust
removal, inert filling or
treatment
refuse and waste
removal or treatment
Fumes and odours
(may indicate organic
chemicals at very low
concentrations)
flammable, explosive, toxic
and asphyxiating gases
including methane and
carbon dioxide
corrosive liquids
removal, filling, sealing
or treatment
faecal, animal and
vegetable matter
(biologically active)
removal, filling or
treatment
Drums and containers
(whether full or empty)
various
removal with all
contaminated ground
The verifier may require the removal or treatment of any of the contaminants
in the table to clause 3.1.5, to be carried out by specialists.
If any signs of possible contaminants are present, the verifier should be told
at once. If the presence of any of the contaminants listed in the table to
clause 3.1.5 is confirmed, it is likely that some form of remedial action will be
required. For guidance, the normal course of remedial action is listed against
each contaminant. In all cases these courses of action assume that the
ground to be covered by the
building
will have at least 100 mm of in-situ
concrete cover. Expert advice may be required to provide an economical and
safe solution to the hazards encountered especially where contaminants are
present in large amounts or where there is imminent danger to health or
safety.
The Construction Industry Research and Information Association (CIRIA)
produces many useful guidance documents on the application of different risk
management techniques.
3.1.5
—
3.1.6
domestic | environment | site preparation – harmful and dangerous substances | 2010
There are a range of options for managing the risk of land that is
contaminated. This can include removal or treatment of the contaminant
source or breaking the pathway by which contaminants can present a risk to
receptors:
Removal
means that the contaminant itself and any contaminated ground to
be covered by the
building
should be taken out to a depth of 1 m (or less if the
verifier agrees) below the level of the lowest floor. The contaminant should
then be taken away to a place to be named by the local authority;
Filling
means that the ground to be covered by the
building
should be
determined on a
site
specific basis but is normally to a depth of 1 m (or less if
the verifier agrees) with a material which will not react adversely with any
contaminant remaining and may be used for making up levels. The type of
filling and the design of the ground floor should be considered together;
Inert filling
means that the filling is wholly non-combustible and not easily
changed by chemical reactions;
Sealing
means that an impermeable barrier is laid between the contaminant
and the
building
and sealed at the joints, around the edges and at the service
entries. Note that polyethylene may not be suitable if the contaminant is a
liquid such as a tarry waste or organic solvent;
Ground treatment
may provide a more cost effective and environmentally
sustainable solution. Treatment may be the only option where the presence of
structures or services prevents excavation. Treatment processes can be
biological, chemical or physical and be undertaken either in-situ
(contaminants are treated in the ground) or ex-situ (contaminated material is
excavated and then treated before being returned). The processes convert
the contaminant into a neutral form or render it harmless. There are also
solidification and stabilisation processes that can ‘fix’ contaminants in the soil
so as to reduce the harm, and thermal processes that alter the contaminant
by incineration or by volatilisation. The exact process to use will depend on
the contaminant present and the soil type. Expert advice should be sought.
The CIRIA and the EA websites also contain useful data sheets on remedial
treatment options.
The National House Building Council (NHBC), together with the Environment
Agency, has produced a guidance document ‘Guidance for the Safe
Development of Housing on Land Affected by Contamination’. The document
aims to promote the adoption of good practice in the identification,
investigation, assessment and remedial treatment of land affected by
contamination, so that the development of
housing
on such land can be
undertaken safely and with confidence that no unacceptable risks remain.
With the increasing re-development of former industrial land, attention is also
drawn to BS 10175: 2001; ‘Investigation of potentially contaminated sites,
Code of Practice’. The British Standard provides guidance on, and
recommendations for, the investigation of land that may be contaminated or
land with naturally enhanced concentrations of potentially harmful materials,
to determine or manage the ensuing risk. BS 5930: 1999, ‘Code of Practice
for Site Investigations’ is also relevant. This CoP deals with the investigation
of ground for the purpose of assessing their suitability for the
construction
of
3.1.6
—
3.1.8
domestic | environment | site preparation – harmful and dangerous substances | 2010
the
work
. It provides recommendations on certain constraints or problems
that can affect a
site
, such as geotechnical aspects and the legal aspects
including the need for licences or permits.
3.1.9 Risks to
construction
materials and services
Buildings,
and the materials they are
constructed
from, are classed as
receptors and therefore may be subject to damage if they come into contact
with contaminated land. A principal concern is that any attack or damage
from ground contaminants may affect the structural integrity or serviceability
of the
building
and present a health and safety threat.
Both natural and human generated ground conditions can be aggressive to
structures and services, in view of this the
construction
design should
take account of any ground contaminants that could affect or damage
buildings,
materials and services. In practice it may be more difficult to
assess and manage contamination risks when dealing with new
work
to
existing
buildings.
Site
analysis and hazard identification are necessary to allow assessment
of any contamination risks posed to the
construction.
The susceptibility of
construction
to aggressive contaminant attack generally depends on four
conditions:
•
presence of water;
•
contaminant concentrations;
•
contact between materials and contaminants;
•
material sensitivity.
The BRE publication BR 255:1994 'Performance of Building Materials in
Contaminated Land' provides detailed guidance on the vulnerability of
building
materials to the hazards arising from contamination.
The following table identifies some common aggressive substances, their
possible effects on
building
materials and possible mitigation options.
3.1.8
—
3.1.9
domestic | environment | site preparation – harmful and dangerous substances | 2010
SUBSTANCE AFFECTING MATERIALS
Material
Substance
Possible effect Mitigation Options
concrete,
mortar,
masonry
sulphates (acid
& water soluble
in soil)
pyrites
heavy metals
expansion,
disintegration
deterioration
• specify resistant
materials
chloride (acid &
water soluble in
soil)
reduced
strength
increased
permeability
reinforcement
corrosion
• provide protective
coatings, isolation or
sacrificial layers
excavate and
remove affected
material
inorganic and
organic acids
(depending on
type and
concentration)
expansion
degradation and
corrosion of
reinforcement
• excavate and
remove affected
material
magnesium
salts
disintegration
ammonium salts increased
porosity
• contain
contamination
structural steel,
metal pipes and
services
sulphate,
sulphur and
sulphide
corrosion
• design and
construct
site
drainage to reduce
or eliminate contact
between
contaminants and
building
structure or
services
inorganic and
organic acids
corrosion
plastics, rubbers alkalis,
ammonia,
chlorine,
hydrocarbons,
oils
swelling
deterioration
polythenes
benzene,
toluene, phenol
permeation
Notes:
1.
The potential for chemical attack often depends on the presence of
water as a substance carrier.
2.
Concrete, being an alkaline material is potentially vulnerable to
attack from acids.
3.1.9
—
3.1.9


Another Virtualization technology??
## Hipster fad??
** Nope **
Note:
So you know, a lot has been said about docker
but why the hell are they reinventing the wheel with another virtualization
Is docker simply a product of bored techies that are reinventing the wheel??
do we need another one of these?
--
## No overhead
Note:
How many of you have worked with Vagrant and other virtualization tools for deployment?
The overhead of the harddrive and the CPU/etc overhead
You might be saying, oh great, so we get this new whole set of tools just to shave off some CPU cycles and eventually some bytes?
Not quite
Less isolation
--
## Container - the analogy
--
## Container - the analogy
--
# Solution
#### The real MV..Concept
--
Don't have to deal with:
* Configuring the development environment in the workstation
* Configuring the production environment in the server
* Configuring the continuous integration environment in the server
## One Container to rule them all
## How ??
Note:
The idea is that you don't have to configure your development environment, you don't configure


Octave:
+1 0 -1Drone:
D C B A OffReverb:
Concept:
Leif Ottosson
Programming:
Hans Lindetorp
Audio configuration made with WebAudioXML
If you have any questions or feedback about the app, please don't hesitate to contact us:
Leif Ottosson
Hans Lindetorp
Audio configuration made with WebAudioXML
If you have any questions or feedback about the app, please don't hesitate to contact us:


Path
Bhog – Sri Akhand Path Sahib
10:30 AM, 3rd April, 2015
at
Kothi Number 29, Phase 2, Mohali
Kirtan
Kirtan
12 noon to 1:00 PM, 3rd April, 2015
at
Gurudwara Sri Kalgidhar Sahib, Phase 4, Mohali
Sangeet
Geet Sangeet
7 PM to 10 PM, 3rd April, 2015
at
Sarao Group of Hotels
Site No.71-74, Opposite Silvi Park, Phase 10, Mohali
Wedding
Wedding
Reception of Barat - 9:30 AM, 5th April, 2015
Doli - 4 PM, 5th April, 2015
at
MJ Farms
Jhanjheri - Badala Road, Kharar, Mohali
RSVP
Kothi Number 29, Phase 2, Mohali
+91 -<PHONE_NUMBER>
Compliments from
Sukhwinder Singh, Jaswinder Kaur, Kulwant Singh, Kulwant Kaur, Santokh Kaur, JP Singh, Hardish Kaur, Ramandeep Singh, Jagdish Kaur, Tej, Gurminder Kaur, Aman Hanzra, Loveleen Sidhu, Vippy Roop Hanzra, Jasroop Randhawa, Neetu Gill, Jas Gill, Karambir Gill, Sage Gill, Jaibeer Singh, Rajbir Singh, Arnaz Singh, Tony Bal, Satvir Kang, Jassi Bal, Inderjit Chinna, JP Bal, Jasmine Bal, MP Bal, Neetu Bal, Harman Bal, Deep Bal a.k.a. Sound Shikari, Navdeep Bal, Navjot Bal, Harneet Hanzra and … Bikram Hanzra
Merci Beaucoup
Click here to download the invitation in PDF format.


Asking for mic...
Frequency bin count:
Analyser sample rate (Hz):
Maximum frequency (Hz):
Useable bin count:
Animation timestamp (ms):
Animation time delta (ms):
Camera position:
Frequency domain data:


UK's Corbyn: Will set up sustainable investment board including BoE governor
by Eren SengezerThe UK opposition Labour Party's leader Jeremy Corbyn on Monday said that, if elected, they will set up a "sustainable investment board including the Bank of England governor," and added that they will be launching their manifesto on Thursday.
"It's nonsense that I am anti-business," Corbyn argued. "Major British industries like steel will struggle under a trade deal with US President Trump."
These comments don't seem to be having an impact on the British pound's valuation. As of writing, the GBP/USD pair was up 0.42% on the day at 1.2955.


Simple Pageby metfar Index |
A story of a little example |
The final task of the course Introduction: HTML & CSS For Beginners from Eduonix was to write a page incorporating some elemets such as:
Go back to the Index |
The 'creative' process |
|
I had my own agenda at this point. I wanted to try to:
|
The conclusion |
|
I started this page on my regular wordprocessor on which I usually work for the university tasks, the magnificent GhostWriter MarkDown Editor. It is simple to write on it but it is not an HTML Editor, but it can export to HTML. The advantage of it is that you can focus on writing and forget about the format (markDown is almost simple text). After that, I started to add some colour to the page (I left some links in the references). And I wanted that each section will have a button to return to the Index/MainMenu. So, I made a simple arrow to go back and I made some tests. I tried to insert text on it but if it was a word, it could be resized badly, and to add the text as a form, it was so large to copy it into the text. I thought about to add it in a blob format, but I love vectorial images (sorry about that).
The last step was to clean the source and to add the proper HTML format. This was a crude process of fighting againt Brackets but I think I was able to reach the goal. At the end, it helped me to find a lot of nesting problems and to navigate my source code closing sections to do it briskly. I think I could get used to using it for a couple of years. It's not so bad!
Thank you very much for this excelent course!!! P.S. Sorry about the colours I choose. I promise I'll try to use a pastel palette of colours from here on. |
References |
|


{% extends "base.html" %} {% block title %}The Open Source Report Card{% endblock %} {% block body %} {% macro nav_text() -%} Enter a GitHub username to see a dynamically generated progress report for their open source contributions {%- endmacro %} {% include "nav.html" with context %}
Every day, many thousands of open source contributions are made on GitHub by developers around the world. This data is publicly available through the API and—even more conveniently—on the GitHub Archive. This is generally a pretty fun dataset to play with but it is particularly exciting for hackers because we get to play with data that describes our own behavior! Last year, shortly after the full event stream was publicly released, the first annual GitHub data challenge produced some sick data visualizations and it's clear that people at GitHub have been thinking about how to Use The Data For Good™.
The one graph that is especially awesome in all sorts of surprising ways is the contributions heat map on every user's profile page. What sets this apart from the other visualizations that already exist on the site? It makes a general statement about one specific user. It lets a developer have a global view of their contributions, skills and habits. This ends up being extremely motivating because it lets the developer see their progress in real time. With this in mind, it seemed like a good idea to provide a more complete set of global statistics summarizing the hacker personality of any GitHub user.
So that's what I did.
The Open Source Report Card is an open source project developed on GitHub and licensed under the MIT License.
{% endblock %}


What is Flexbox and Its Purpose
More technical interview questions
What is FLEXBOX
Flexbox is a new layout mode in CSS3. The previous version of CSS defined four layout modes:
- block layout for laying out documents
- inline layout for laying out text
- table layout for laying 2D tabular data
- positioned layout for explicit positioning
CSS3 Layouts
CSS3 introduced two new layout methods as an alternative to abusing floats and tables:
- Grid layout divides space into columns & rows. Like table layouts, but better! The Grid layout spec is still being developed, and isn’t ready for use yet.
- Flexbox layout distributes space along a single column or row. Like float layouts, but better! The Flexbox spec is finished and enjoys excellent browser support today.
Spec Versions
There are three versions of the spec, but only one of them really matters:
-
The old 2009 spec — display: box — is no longer relevant.
-
The 2011 "tweener" spec — display: flexbox — was a draft spec, only implemented in IE10. You should avoid it if possible.
-
The final 2012 spec — display: flex — is the new hotness, with excellent browser support (see below).
Note: Each spec used a different keyword for the display property, which means if you’re reading an article about Flexbox, it’s easy to figure out which version of the spec they’re discussing. If you see anything other than display:flex, it’s an older article and can be ignored.
Flexbox Properties
There are too many properties to get into here, so I will refer you to the excellent CSS Tricks Flexbox Guide, which does a great job of introducing all the properties.
Don’t be overwhelmed. There are a lot of options, but Flexbox includes a set of intelligent defaults so you can create a powerful layout with very little code. Here’s an example:
.flex-container {
display: flex;
}
That one line of code does all the following:
- Treats .flex-container as a flex container.
- Treats all direct children of .flex-container as flex items.
- Flex items will be laid out in a horizontal line.
- Flex items will be laid out in source order.
- Flex items will be laid out starting from the left side of the flex container.
- Flex items will be sized based on their regular width properties.
- If there’s not enough space for all the flex items, they will be allowed to shrink horizontally until they all fit.
- If they need to shrink, each item will shrink equally.
- Flex items will all stretch vertically to match the height of the tallest flex item.
That’s quite a bit of logic for a single line of CSS! You can change any of those, but I wanted to give you a taste of how powerful Flexbox can be with no extra work.
Browser Support
As of August 2015, browser support is excellent! The current Flexbox spec is fully supported in all modern browsers, including mobile, IE11 and Edge.


Back to all votes
{{voting ? voting.title : 'Votes'}}
Sorry, there are no votes available for you at this time.
-
{{voting.title}}
{{voting.description}}
Details
{{voting.description}}
Voting is unavailable at the moment. You will receive an email as soon as the next round opens up.
Thanks for your vote!


The Serial Port class writes to and reads from the one of the six UART On Chip Peripheral (OCP) devices integrated into the Beaglebone Black CPU (although only four of those devices are usable). In the Linux operating system there are two ways of accessing the UART OCP devices; the first, called TTY, is the
standard and approved Linux technique. TTY is a device driver and if the existence of a serial port is detected during boot time,
the device driver interface will be exposed as a file in the /dev
directory of the Beaglebone Black file system. The
serial ports will only be detected if that port is appropriately configured in the Device Tree.
The second type of access is called Memory Mapped access and this treats the Beaglebone Black's RAM memory as if it were a file. The UART is manipulated as if it were a bit at an offset in a virtual file. The BBBCSIO library does not, at this time, provide a class which utilizes Memory Mapped access to a serial port - the file system based TTY class named SerialPortFS is the only one available.
There are four usable serial ports on a Beaglebone Black. If these ports have been correctly configured in the Device Tree, the TTY device driver for that port will be accessible via a file in the /dev
directory. This file will have names in the format ttyO<Serial Port>
where <Serial Port>
is the number of the serial port. Thus the file /dev/ttyO0
is the interface for the TTY device driver on serial port 0. If you do not see the ttyO*
file in the /dev
directory this means that the serial device is not correctly configured in the Device Tree. By the way, these files are the sort of files you can open and read and write text from (like you can do with the SYSFS GPIO subsystem) in order to read and write data to the serial port. A command like ...
cat /dev/tty04... will continuously output all received data from the port. However reading and writing in this way is not too useful as you cannot easily set any of the serial port parameters (baudrate, parity etc.). In practice, the ttyO files best treated as true device files and if you want them to do anything you have to use an
ioctl()
call.
The pins (including the serial port pins) on the Beaglebone Black are 3.3Volt. You CANNOT connect them up to a 5V serial device without level shifting the voltage or you will burn out the BBB.
The serial port used in the examples below is ttyO4 - this must be configured in the Device Tree in order for it to be available for use. Typically this is done using a pre-prepared standard Device Tree Overlay. For more information on this see the Beaglebone Black and Device Tree Overlays Technical Note.
The armhf Linux running on the Beaglebone Black is not a real-time operating system. However, an OCP peripheral such as the serial port has its own internal clock and so, once the information is given to the port, it will be transmitted and received at the configured port speed with no interruptions. However, transfers made via multiple calls to the serial port can, and will, have variable gaps between transmissions as the process is pre-emptively swapped in and out by the kernel.
The code below illustrates how to use the SerialPortFS class to read and write from a serial device (serial port 4 in this case). See the comments in the code below for a simple method to use the UART1 to test out the connection mechanism.
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+= /// <summary> /// Demonstrates the use of a Serial ports. Reading and writing both /// binary data (in a byte array) and strings. /// /// The basic function is to open up the specified serial port /// and to set it to a baud rate of 115200, 1 stop, no parity etc. /// Then a single character and a CRLF combination will be transmitted. /// Once that is done, a loop is entered which counts (but does not read) /// received characters and transmits informational text regarding the /// number of pending bytes back out the serial port. /// /// When the user presses a key, the first four received bytes are read and /// output as hex values and then the remainder are read and output as a string. /// /// MEGA IMPORTANT NOTE: The pins (including the serial port pins) on the /// Beaglebone Black are 3.3Volt. You CANNOT connect them up to a 5V /// serial device without level shifting the voltage or you will burn out /// the BBB.  /// /// NOTE: /// Make sure you set up the serial ports. You can do this using device /// tree overlays in the uEnv.txt file. See the Beaglebone Black and Device /// Tree Overlays technical note for more information. /// http://www.ofitselfso.com/BeagleNotes/Beaglebone_Black_And_Device_Tree_Overlays.php /// You MUST make sure that the pins the UARTS use are not in use by other /// devices /// /// </summary> /// <param name="serialID">The serial portID</param> /// <history> /// 31 Aug 15 Cynic - Originally written /// </history> public void SerialPortFSTest(SerialPortEnum serialID) { // byte convByte; int bufLen = 4; byte[] txByteBuf = new byte[bufLen]; byte[] rxByteBuf = new byte[bufLen]; // open the port SerialPortFS serialPort = new SerialPortFS(serialID, SerialPortOpenModeEnum.OPEN_NONBLOCK); if (serialPort.PortIsOpen == false) { throw new Exception("ssHandle == null"); } // lets flush the queues - just to show we can serialPort.Flush(); // Dump the current settings Console.WriteLine(""); Console.WriteLine("Previous Settings on " + serialID.ToString()); Console.WriteLine("BaudRate=" + serialPort.BaudRate.ToString()); Console.WriteLine("BitLength=" + serialPort.BitLength.ToString()); Console.WriteLine("Parity=" + serialPort.Parity.ToString()); Console.WriteLine("StopBits=" + serialPort.StopBits.ToString()); // set some new settings serialPort.BaudRate = SerialPortBaudRateEnum.BAUDRATE_115200; serialPort.BitLength = SerialPortBitLengthEnum.BITLENGTH_8; serialPort.Parity = SerialPortParityEnum.PARITY_NONE; serialPort.StopBits = SerialPortStopBitsEnum.STOPBITS_ONE; // dump the current settings Console.WriteLine(""); Console.WriteLine("Current Settings on " + serialID.ToString()); Console.WriteLine("BaudRate=" + serialPort.BaudRate.ToString()); Console.WriteLine("BitLength=" + serialPort.BitLength.ToString()); Console.WriteLine("Parity=" + serialPort.Parity.ToString()); Console.WriteLine("StopBits=" + serialPort.StopBits.ToString()); // Write a character to the UART txByteBuf[0] = 0x58; // an 'X' txByteBuf[1] = 0x0a; // CR txByteBuf[2] = 0x0d; // LF serialPort.Write(txByteBuf, 3); Console.WriteLine(""); Console.WriteLine("If you now send some data to the port, then this program "); Console.WriteLine("will transmit text back indicating the number of bytes pending"); Console.WriteLine("Press any key when done..."); /* You can directly set the termios structure by doing * things like the code below. The various termios * bit flags and definitions are all located in the * SerialPortFS class */ // TermiosStruct xfer = serialPort.GetTermiosState(); // serialPort.DumpTermiosStruct(xfer); // set the two stop bits flag // xfer.c_cflag |= (SerialPortFS.CSTOPB); // serialPort.SetTermiosState(ref xfer); // xfer = serialPort.GetTermiosState(); // serialPort.DumpTermiosStruct(xfer); int numBytes = 0; while (Console.KeyAvailable == false) { Thread.Sleep(1000); // find out how much is waiting numBytes = serialPort.BytesInRxBuffer; // tell the other serial port how much we have serialPort.Write(numBytes.ToString()+" Bytes are pending.\r\n"); } // the user has now pressed a key on the console Console.WriteLine(""); Console.WriteLine("Now processing the received data.."); // find out how much is waiting numBytes = serialPort.BytesInRxBuffer; // read the data into our limited size rxByteBuf, note we specify the // rxByteBuf.Length so we do not over fill int numRead = serialPort.ReadByteArray(rxByteBuf, rxByteBuf.Length); // we have the data in the rxByteBuf - display it as hex values Console.Write("Received " + serialPort.BytesInRxBuffer.ToString() + " bytes, Displaying "+numRead.ToString() +" as hex values: "); for (int i = 0; i < numRead; i++) { Console.Write("0x" + rxByteBuf[i].ToString("X2") +" "); } Console.WriteLine(""); // there may be more data there than was in our read with ByteArray call. // As an example, we read and display the rest as a string Console.WriteLine("Now reading and displaying the remaining data as a string..."); Console.WriteLine("SerialData->"+ serialPort.ReadString(100) + "<-"); Console.WriteLine(""); // close the port serialPort.ClosePort(); serialPort.Dispose(); }In the above code, the
serialID
is passed in when the function was called. This value is a member of the
SerialPortEnum class
which lists all possible serial ports which
can be present on the Beaglebone Black. The above code is called via a line which looks like:
SerialPortFSTest(SerialPortEnum.UART_4);


A R package that allows drawing of data from the UniProt API.
The goal of uniprotProteinView is to provide a means to show a graphical representation of the UniProt data as well as allow easy cross-comparison of features between different proteins for easy analysis of protein features.
There are two versions available, the primary version is an R-package, while the second one is a python port.
uniprotProteinView::drawProtein("Q04206")
uniprotProteinView::drawProtein( proteins = list(type = c("Q04206", "Q9D270"), colors = c("green", "green")), types = list(type = c("domain", "region of interest"), colors = c("red", "purple")), descriptionSearch = list(type = "phos", colors = "blue"), offSetFeatures = list(type = c("strand", "helix", "turn"), colors = c("green", "orange", "purple")) )


ENIAC
20 words and punchcards
Programmed by rewiring plugs
EDVAC
First stored-program computer
1,000 44-bit words
A memory "crisis"
500x500 grid of pixels gives 250Kb of memory
Modern shared memory layout
What do the following lists of numbers have in common?
The progression in access time (ns) and KBs of capacity, respectively


Continue
Alberta
British Columbia
Manitoba
New Brunswick
Newfoundland and Labrador
Nova Scotia
Ontario
Prince Edward Island
Quebec
Saskatchewan
Back


{% trans %} We're excited you've built an app using web technologies, and submitting it to the Firefox Marketplace is the best way for users to discover and enjoy it across their devices. First, you'll need to join the Marketplace Developer Program below. {% endtrans %}
{% trans %} To begin, please read and accept our Developer Agreement: {% endtrans %}


My Team
Engineer
engineer guy
ID: Person
Email: email.com
GitHub: github.com
Intern
Intern guy
ID:
Email: email.com
School: School for smart people
Manager
Boss Man
ID: The boss
Email: boss.com
Office Number: 1234


Archives the build artifacts (for example, distribution zip files or jar files)
so that they can be downloaded later.
Archived files will be accessible from the Jenkins webpage.
Normally, Jenkins keeps artifacts for a build as long as a build log itself is kept,
but if you don't need old artifacts and would rather save disk space, you can do so.
Note that the Maven job type automatically archives any produced Maven artifacts.
Any artifacts configured here will be archived on top of that.
Automatic artifact archiving can be disabled under the advanced Maven options.
The
Pipeline Snippet Generator generates this example
when all arguments are set to true (some arguments by default are true):
archiveArtifacts artifacts: '**/*.txt',
allowEmptyArchive: true,
fingerprint: true,
onlyIfSuccessful: true


Represents documents with dates and tasks. The document is ordered by date, which has a corresponding task.
More...
List of all members.
Public Member Functions |
|
void | AddLast () |
|
void | Modify (int rowNumber, DateTime date, string task) |
|
void | InsertTask (int i) |
|
void | InsertTask (int i, string task) |
|
void | Remove (int i) |
|
void | RemoveTask (int i) |
|
void | RemoveDate (int i) |
|
KeyValuePair< DateTime, string > | GotoFirst () |
|
KeyValuePair< DateTime, string > | Next () |
|
DateTime | GetDate (int i) |
|
string | GetTask (int i) |
|
int | GetStep (int i) |
| void | SetSteps (string strSteps) |
| | Sets all the steps,.
|
Public Attributes |
|
const string | TaskTag = "thema" |
Properties |
| DateTime | LastDate [get] |
| | Gets the last date in the list of dates.
|
|
bool | IsEnd [get] |
|
int | CountDates [get] |
|
int | CountTasks [get] |
|
int | NextStep [get] |
|
ReadOnlyCollection< DateTime > | Dates [get] |
|
ReadOnlyCollection< string > | Tasks [get] |
|
ReadOnlyCollection< int > | Steps [get, set] |
|
string | FileName [get, set] |
|
bool | HasName [get] |
|
DateTime | InitialDate [get, set] |
Detailed Description
Represents documents with dates and tasks. The document is ordered by date, which has a corresponding task.
Member Function Documentation
| void Bareplan.Core.Document.SetSteps |
( |
string |
strSteps | ) |
|
Sets all the steps,.
- Parameters:
-
| strSteps | The steps, as a space, comma, dash or semicolon separated values. |
Property Documentation
| DateTime Bareplan.Core.Document.LastDate |
|
get |
Gets the last date in the list of dates.
The documentation for this class was generated from the following file:
- C:/Users/baltasarq/Dropbox/prys/bareplan/Core/Document.cs


import MapControlsCtrl from 'uoit-campus-map/src/controls/map-controls_controller.js'
MapControlsCtrl
The MapControlsCtrl
provides an interface between the map component
and the map control filter dropdowns.
It is not responsible for much actual map logic, but instead for
accepting user input and turning it into queries whose results
are assigned back to the controller. The MapCtrl
takes care of
turning the returned values into map-usable data, whereas this controller
simply makes it available.
The controller is made up of:
- constructor
- 3 methods for loading query results (location, category, collection)
- 3 methods for updating dropdown contents
- utility methods for setting active collection and showing all collections
Static Member Summary
| Static Public Members | ||
| public static get |
$inject: * |
Constructor Summary
| Public Constructor | ||
| public |
constructor($mapApi: Object, $tourApi: Object, $window: Object) Initialize controller dependencies. |
Member Summary
| Public Members | ||
| public |
categories: * |
|
| public |
Holds the user's selected categories (by ID). |
|
| public |
Holds the user's selected feature collections (by ID). |
|
| public |
collections: * |
|
| public |
features: * |
|
| public |
Holds the user's selected location (by ID). |
|
| public |
locations: * |
Method Summary
| Public Methods | ||
| public |
$onInit() Initialize the controls (show all map elements) |
|
| public |
getItemsInListByProp(items: Array, list: Array, prop: String): Array Filter an array for matches in another array by a property; return the matched items. |
|
| public |
Utility function for determining whether all items are selected (set 'select all' checkbox to checked if so). |
|
| public |
isIndeterminate(selected: String, items: String): Boolean Checks whether the number of selected items is more than zero but less than the total of available items (sets checkbox inputs to "indeterminate"). |
|
| public |
Load category list from server. |
|
| public |
Load collection list from server using the |
|
| public |
loadFeatures(filter: *): Promise Load feature list from server using the |
|
| public |
Load location list from server. |
|
| public |
removeItemFromList(item: *, list: Array) Find a specific array item and remove it from the array. |
|
| public |
setMapData(resources: Object) Sends current data to view for rendering in selection dropdowns. |
|
| public |
Utility function for or selecting or deselecting all items (set all item checkboxes to checked/unchecked). |
Static Public Members
public static get $inject: * source
Public Constructors
Public Members
public categories: * source
public collections: * source
public features: * source
public locations: * source
Public Methods
public getItemsInListByProp(items: Array, list: Array, prop: String): Array source
Filter an array for matches in another array by a property; return the matched items.
public isChecked(selected: String, items: String): Boolean source
Utility function for determining whether all items are selected (set 'select all' checkbox to checked if so).
public isIndeterminate(selected: String, items: String): Boolean source
Checks whether the number of selected items is more than zero but less than the total of available items (sets checkbox inputs to "indeterminate").
public loadCollections(): Promise source
Load collection list from server using the _id
of the currently
selected category and location (extracted directly from the
controller / this
) to filter by.
TODO:
- Update this doc to describe array of categories
public loadFeatures(filter: *): Promise source
Load feature list from server using the _id
s of the currently
selected categories to filter by.
Params:
| Name | Type | Attribute | Description |
| filter | * |
TODO:
- Update this doc to describe array of categories
public removeItemFromList(item: *, list: Array) source
Find a specific array item and remove it from the array.
Params:
| Name | Type | Attribute | Description |
| item | * | The item to remove |
|
| list | Array | The list to remove from |
public setMapData(resources: Object) source
Sends current data to view for rendering in selection dropdowns.
In order for the map to properly render the selected collection, the
options.collection
param passed to this method must at least look
like a valid FeatureCollection
(i.e. it can be a "true" collection,
or an object with a type
property of FeatureCollection
and a features
property containing an array of Feature
objects).
In the example, both scenarios are demonstrated – the location
and
category
properties are left out for brevity, but location
is
required in order for features to properly direct to tour scenes.
Example:
// "true" collection
const collection = this._CollectionResource.get('collectionId');
this.setMapData({ collection });
// "mock" collection
const features = this._FeatureResource.query();
this.setMapData({
collection: {
type: 'FeatureCollection',
features
}
});


| Interface | Description |
|---|---|
| IAnnotation |
The parent interface for all the annotations.
|
| IConfigurationAnnotation |
Encapsulate the @Configuration / @testng.configuration annotation
Created on Dec 20, 2005
|
| IDataProviderAnnotation |
Encapsulate the @DataProvider / @testng.data-provider annotation
Created on Dec 20, 2005
|
| IExpectedExceptionsAnnotation |
Encapsulate the @ExpectedExceptions / @testng.expected-exceptions annotation
Created on Dec 20, 2005
|
| IFactoryAnnotation |
Encapsulate the @Factory / @testng.factory annotation
Created on Dec 20, 2005
|
| IObjectFactoryAnnotation | |
| IParameterizable |
Parent interface for annotations that can receive parameters.
|
| IParametersAnnotation |
Encapsulate the @Parameters / @testng.parameters annotation
Created on Dec 20, 2005
|
| ITestAnnotation |
Encapsulate the @Test / @testng.test annotation.
|
| ITestOrConfiguration |
This interface captures methods common to @Test and @Configuration
Created on Dec 20, 2005
|
| Annotation Type | Description |
|---|---|
| AfterClass | |
| AfterGroups | |
| AfterMethod | |
| AfterSuite | |
| AfterTest | |
| BeforeClass | |
| BeforeGroups | |
| BeforeMethod | |
| BeforeSuite | |
| BeforeTest | |
| Configuration | Deprecated
Use @BeforeSuite, @AfterSuite, @BeforeTest, @AfterTest,
\@BeforeGroups, @AfterGroups, @BeforeClass, @AfterClass, @BeforeMethod,
\@AfterMethod
|
| DataProvider |
Mark a method as supplying data for a test method.
|
| ExpectedExceptions | Deprecated
Use @Test(expectedExceptions = "...")
|
| Factory |
Marks a method as a factory that returns objects that will be used by TestNG
as Test classes.
|
| Guice |
This annotation specifies what Guice modules should be used to instantiate
this test class.
|
| Listeners |
This annotation lets you define listeners directly on a test class
instead of doing so in your testng.xml.
|
| NoInjection |
Turn off TestNG injection for a parameter.
|
| ObjectFactory |
Marks a method as the object factory to use for creating all test instances.
|
| Optional |
Specifies that the current parameter is optional.
|
| Parameters |
Describes how to pass parameters to a @Test method.
|
| Test |
Mark a class or a method as part of the test.
|
| TestInstance |
If this annotation is used on a parameter of a data provider, that parameter is the instance
of the test method which is going to be fed by this data provider.
|


{% load i18n %} {% blocktrans with team_url=team.get_absolute_url trimmed %} {{ inviter }} has invited you to join team {{ team }}. You can accept or decline the invitation on the team page. {% endblocktrans %}


Use this controls to change the login state
You are currently not logged in
Current user: {{ currentUser }}


Wed Nov 28, 2007
I was trying to figure out how many people are reading my writing/editing and the numbers are pretty huge. First of all, I’ve been writing for the print edition of alive at a readership of about 500,000. Then every Tuesday articles I’ve edited for Metro Canada comes out countrywide at a readership of 700,000. And the tips of the day I write for Living Naturally are published on at least 7000 websites in the US and Canada, according to this Google search. Of course my name is only attached to the stuff I write in the magazine, but still, that’s a large audience to consider.
Sometimes I’m having an off day and rush through an article that 700,000 people are going to read. Then, when it comes out, I look at it and think “I can’t believe this drivel got published. I really should have spent more time on this…” Or “Ultimate Frisbee in December?  It’s a humbling experience.


Detect whether or not an object is a Typed Array.
Returns true when array is a Typed Array, and false when it is not.
true
false
MIT. See LICENSE.md for details.


Complete the steps below in the Trinket to solve this problem with Python. It is recommended that you type each line instead of copying/pasting so you start to remember what you've done previously.
There may be multiple ways to get the correct answer. If you have a cool method, please fill out the feedback form for extra credit! See the footer or first page for the link.
# Import Libraries
, add:
import scipy.constants as sp
import math
# Variables
, add:
r_coil = #
. Replace #
with the radius of the coil.N_coil = #
. Replace #
with the number of turns in the coil.current = #
. Replace #
with the current.velocity = #
. Replace #
with the velocity.distance = #
. Replace #
with the distance from the wire to the center of the coil.time = #
. Replace #
with a small number. Example: time = 0.00000001
. Vary this variable and see how it changes your answers.# Calculations
, add the following to calculate the magnetic field due to the wire:
area_coil = sp.pi * (r_coil**2)
b_i = ((sp.mu_0/(4*sp.pi)) * 2 * current)/(distance)
b_f = ((sp.mu_0/(4*sp.pi)) * 2 * current)/(distance - velocity * time)
dBdt = (b_f - b_i)/time
vm_reading = dBdt * area_coil * N_coil
# Print
, print the answers! Add:
print("Part 1: The magnitude of dB/dt in the coil =", dBdt, "T/s")
print("Part 2: The magnitude of the volmeter reading =", vm_reading, "V")


Pending one time boot. Next boot will be performed with the specified one time boot settings. Subsequent boots will be performed with the default settings.
There are no power operations to display while power operation is in progress. When complete, any new power operations will be displayed here.


Performs logistic regression for binary longitudinal data, allowing for serial dependence among observations from a given individual and a random intercept term. Estimation is via maximization of the exact likelihood of a suitably defined model. Missing values and unbalanced data are allowed, with some restrictions.
| Version: | 1.1-5 |
| Depends: | R (≥ 2.10.0), methods, stats, graphics, utils |
| Published: | 2015-04-14 |
| Author: | M. Helena Gonçalves, M. Salomé Cabral and Adelchi Azzalini, apart from a set of Fortran-77 subroutines written by R. Piessens and E. de Doncker, belonging to the suite "Quadpack". |
| Maintainer: | M. Helena Gonçalves <mhgoncal at ualg.pt> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | yes |
| Citation: | bild citation info |
| Materials: | NEWS |
| CRAN checks: | bild results |
| Reference manual: | bild.pdf |
| Package source: | bild_1.1-5.tar.gz |
| Windows binaries: | r-devel: bild_1.1-5.zip, r-release: bild_1.1-5.zip, r-oldrel: bild_1.1-5.zip |
| OS X binaries: | r-release: bild_1.1-5.tgz, r-oldrel: bild_1.1-5.tgz |
| Old sources: | bild archive |
Please use the canonical form https://CRAN.R-project.org/package=bild to link to this page.


Starting with the Java SE 6 release, the Direct3D pipeline uses the Direct3D API for rendering. This pipeline is enabled in full-screen mode by default, if the drivers support the required features and the level of rendering quality.
It is possible to enable the Direct3D pipeline or to force its use, as described in the subsections below.
Consider enabling the Direct3D pipeline for your application if it makes heavy use of rendering operations such as alpha compositing, antialiasing, and transforms.
However, use caution when deciding to enable this pipeline in your application. For example, some built-in video chipsets (which are used in most notebooks) do not perform well using Direct3D, even if they satisfy the quality requirements for Java 2D pipelines.
The following are three cases to troubleshoot problems with Direct3D API.
Disable Direct3D pipeline:
Some older video boards/drivers combinations are known to cause issues (both rendering and performance) with the Direct3D pipeline. To disable the pipeline in such cases, with Java SE 5 and later releases, pass the parameter -Dsun.java2d.d3d=false
to the Java VM, or set the J2D_D3D
environment variable to false
.
Enable Direct3D pipeline:
With Java SE 5 and later releases, to enable the Direct3D pipeline in both windowed and full-screen mode, use the parameter -Dsun.java2d.d3d=true
, or set the J2D_D3D
environment variable to true
. Note: The pipeline is enabled only if the drivers support minimum required features.
Diagnose Direct3D pipeline rendering problems:
With the Java SE 8 release, some rendering issues (like missing pixels, garbled rendering) can be diagnosed by forcing different Direct3D rasterizers. Set the J2D_D3D_RASTERIZER
environment variable to one of the following: ref
, rgb
, hal
, or tnl
.
See Direct3D documentation for a description of these rasterizers. By default the best rasterizer is chosen based on its advertised capabilities. In particular, the ref
rasterizer forces the use of the reference Direct3D rasterizer from Microsoft. If a rendering problem is not reproducible with this rasterizer, then it is very likely to be a video driver bug.
The rgb
rasterizer is available only if the Direct3D SDK is installed. This SDK can be obtained from Microsoft Game Technologies Center.
For performance or quality problems with text rendering with the Direct3D pipeline, you can force the use of ARGB texture instead of the default Alpha texture for the Direct3D pipeline's glyph cache. To do this, set the J2D_D3D_NOALPHATEXTURE
environment variable to true
.


0 1 2 3 4 5 6 7 8 9
101 101
+ 1 AND + 11
= 110 = 1000
11 * 10 = 110
You can convert from decimal to binary
You can convert from binary to decimal
but....Python does it much better
>>> binary = bin(120)
>>> print(binary, type(binary))
0b1111000 < class 'str' >
>>> num = int('110011', base=2)
>>> print (num, type(num))
51 < class 'int' >
>>> x = 0x1A
>>> print(x)
26
>>> hexvalue = hex(31337)
>>> print(hexvalue, type(hexvalue))
0x815D < class 'str'>
>>> num = int('100', base=2)
>>> print(num)
4
>>> num = int('100', base=16)
>>> print(num)
256
| A | B | A AND B |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
| A | B | A OR B |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
| A | NOT A |
|---|---|
| True | False |
| False | True |
print(10 < 11 and 1 < 10) # print True
print(not(10 > 11)) # print True
print(10 > 20 or 1 > 10) # print False
if age > 18:
print('You are no longer in grade school')
elif age > 15:
print('You are in high school')
elif age > 10:
print('You are in middle school')
elif age > 5:
print('You are in elementary school')
else:
print('You are too young to do Python!')
Write a script to continuously ask the user to input a letter, then prints out a fruit you know starting with that letter. The script should ask the user up to 10 times. The letter is not case sentitive. Handle the error case where user enter something other than a letter. When the user enter stop, exit. A few examples fruit are: apple, banana, cherry.
What do we need to do?
Write a script to ask the user for a number between 1 and 10, and prints out the following pattern:
# If user input 4
*
**
***
****
What do we need to do?
Write a script to ask the user for two numbers between 1 and 10. Then, print out the following pattern:
# If user input 7 and 3
7 6 5 4 3
7 6 5 4
7 6 5
7 6
7
Break this down to smaller problems:
1. Ask for two numbers between 1 and 10, and determine where to start end where to end
2. Loop from start to end
3. Count, in reverse order, from end to start