Class: Aws::SageMaker::Types::UpdateImageVersionRequest
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb |
Overview
Constant Summary
Instance Attribute Summary
-
#alias ⇒ String
rw
The alias of the image version.
-
#aliases_to_add ⇒ Array<String>
rw
A list of aliases to add.
-
#aliases_to_delete ⇒ Array<String>
rw
A list of aliases to delete.
-
#horovod ⇒ Boolean
rw
Indicates Horovod compatibility.
-
#image_name ⇒ String
rw
The name of the image.
-
#job_type ⇒ String
rw
Indicates SageMaker job type compatibility.
-
#ml_framework ⇒ String
rw
The machine learning framework vended in the image version.
-
#processor ⇒ String
rw
Indicates CPU or GPU compatibility.
-
#programming_lang ⇒ String
rw
The supported programming language and its version.
-
#release_notes ⇒ String
rw
The maintainer description of the image version.
-
#vendor_guidance ⇒ String
rw
The availability of the image version specified by the maintainer.
-
#version ⇒ Integer
rw
The version of the image.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Aws::Structure#to_h. |
Instance Attribute Details
#alias ⇒ String
(rw)
The alias of the image version.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#aliases_to_add ⇒ Array
<String
> (rw)
A list of aliases to add.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#aliases_to_delete ⇒ Array
<String
> (rw)
A list of aliases to delete.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#horovod ⇒ Boolean
(rw)
Indicates Horovod compatibility.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#image_name ⇒ String
(rw)
The name of the image.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#job_type ⇒ String
(rw)
Indicates SageMaker job type compatibility.
TRAINING
: The image version is compatible with::Aws::SageMaker
training jobs.INFERENCE
: The image version is compatible with::Aws::SageMaker
inference jobs.NOTEBOOK_KERNEL
: The image version is compatible with::Aws::SageMaker
notebook kernels.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#ml_framework ⇒ String
(rw)
The machine learning framework vended in the image version.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#processor ⇒ String
(rw)
Indicates CPU or GPU compatibility.
CPU
: The image version is compatible with CPU.GPU
: The image version is compatible with GPU.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#programming_lang ⇒ String
(rw)
The supported programming language and its version.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#release_notes ⇒ String
(rw)
The maintainer description of the image version.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#vendor_guidance ⇒ String
(rw)
The availability of the image version specified by the maintainer.
NOT_PROVIDED
: The maintainers did not provide a status for image version stability.STABLE
: The image version is stable.TO_BE_ARCHIVED
: The image version is set to be archived. Custom image versions that are set to be archived are automatically archived after three months.ARCHIVED
: The image version is archived. Archived image versions are not searchable and are no longer actively supported.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end
#version ⇒ Integer
(rw)
The version of the image.
# File 'gems/aws-sdk-sagemaker/lib/aws-sdk-sagemaker/types.rb', line 40543
class UpdateImageVersionRequest < Struct.new( :image_name, :alias, :version, :aliases_to_add, :aliases_to_delete, :vendor_guidance, :job_type, :ml_framework, :programming_lang, :processor, :horovod, :release_notes) SENSITIVE = [] include Aws::Structure end


| BEP: | 3 |
|---|---|
| Title: | The BitTorrent Protocol Specification |
| Version: | 0e08ddf84d8d3bf101cdf897fc312f2774588c9e |
| Last-Modified: | Sat Feb 4 12:58:40 2017 +0100 |
| Author: | Bram Cohen<EMAIL_ADDRESS>|
| Status: | Final |
| Type: | Standard |
| Created: | 10-Jan-2008 |
| Post-History: | 24-Jun-2009 (arvid@bittorrent.com), clarified the encoding of strings in torrent files. 20-Oct-2012 (arvid@bittorrent.com), clarified that info-hash is the digest of en bencoding found in .torrent file. Introduced some references to new BEPs and cleaned up formatting. 11-Oct-2013 (arvid@bittorrent.com), correct the accepted and de-facto sizes for request messages 04-Feb-2017 (the8472.bep@infinite-source.de), further info-hash clarifications, added resources for new implementors |
BitTorrent is a protocol for distributing files. It identifies content by URL and is designed to integrate seamlessly with the web. Its advantage over plain HTTP is that when multiple downloads of the same file happen concurrently, the downloaders upload to each other, making it possible for the file source to support very large numbers of downloaders with only a modest increase in its load.
There are ideally many end users for a single file.
Metainfo files (also known as .torrent files) are bencoded dictionaries with the following keys:
All strings in a .torrent file that contains text must be UTF-8 encoded.
The name key maps to a UTF-8 encoded string which is the suggested name to save the file (or directory) as. It is purely advisory.
piece length maps to the number of bytes in each piece the file is split into. For the purposes of transfer, files are split into fixed-size pieces which are all the same length except for possibly the last one which may be truncated. piece length is almost always a power of two, most commonly 2 18 = 256 K (BitTorrent prior to version 3.2 uses 2 20 = 1 M as default).
pieces maps to a string whose length is a multiple of 20. It is to be subdivided into strings of length 20, each of which is the SHA1 hash of the piece at the corresponding index.
There is also a key length or a key files, but not both or neither. If length is present then the download represents a single file, otherwise it represents a set of files which go in a directory structure.
In the single file case, length maps to the length of the file in bytes.
For the purposes of the other keys, the multi-file case is treated as only having a single file by concatenating the files in the order they appear in the files list. The files list is the value files maps to, and is a list of dictionaries containing the following keys:
length - The length of the file, in bytes.
path - A list of UTF-8 encoded strings corresponding to subdirectory names, the last of which is the actual file name (a zero length list is an error case).
In the single file case, the name key is the name of a file, in the muliple file case, it's the name of a directory.
Tracker GET requests have the following keys:
The 20 byte sha1 hash of the bencoded form of the info value from the metainfo file. This value will almost certainly have to be escaped.
Note that this is a substring of the metainfo file. The info-hash must be the hash of the encoded form as found in the .torrent file, which is identical to bdecoding the metainfo file, extracting the info dictionary and encoding it if and only if the bdecoder fully validated the input (e.g. key ordering, absence of leading zeros). Conversely that means clients must either reject invalid metainfo files or extract the substring directly. They must not perform a decode-encode roundtrip on invalid data.
Tracker responses are bencoded dictionaries. If a tracker response has a key failure reason, then that maps to a human readable string which explains why the query failed, and no other keys are required. Otherwise, it must have two keys: interval, which maps to the number of seconds the downloader should wait between regular rerequests, and peers. peers maps to a list of dictionaries corresponding to peers, each of which contains the keys peer id, ip, and port, which map to the peer's self-selected ID, IP address or dns name as a string, and port number, respectively. Note that downloaders may rerequest on nonscheduled times if an event happens or they need more peers.
More commonly is that trackers return a compact representation of the peer list, see BEP 23.
If you want to make any extensions to metainfo files or tracker queries, please coordinate with Bram Cohen to make sure that all extensions are done compatibly.
It is common to announce over a UDP tracker protocol as well.
BitTorrent's peer protocol operates over TCP or uTP.
Peer connections are symmetrical. Messages sent in both directions look the same, and data can flow in either direction.
The peer protocol refers to pieces of the file by index as described in the metainfo file, starting at zero. When a peer finishes downloading a piece and checks that the hash matches, it announces that it has that piece to all of its peers.
Connections contain two bits of state on either end: choked or not, and interested or not. Choking is a notification that no data will be sent until unchoking happens. The reasoning and common techniques behind choking are explained later in this document.
Data transfer takes place whenever one side is interested and the other side is not choking. Interest state must be kept up to date at all times - whenever a downloader doesn't have something they currently would ask a peer for in unchoked, they must express lack of interest, despite being choked. Implementing this properly is tricky, but makes it possible for downloaders to know which peers will start downloading immediately if unchoked.
Connections start out choked and not interested.
When data is being transferred, downloaders should keep several piece requests queued up at once in order to get good TCP performance (this is called 'pipelining'.) On the other side, requests which can't be written out to the TCP buffer immediately should be queued up in memory rather than kept in an application-level network buffer, so they can all be thrown out when a choke happens.
The peer wire protocol consists of a handshake followed by a never-ending stream of length-prefixed messages. The handshake starts with character ninteen (decimal) followed by the string 'BitTorrent protocol'. The leading character is a length prefix, put there in the hope that other new protocols may do the same and thus be trivially distinguishable from each other.
All later integers sent in the protocol are encoded as four bytes big-endian.
After the fixed headers come eight reserved bytes, which are all zero in all current implementations. If you wish to extend the protocol using these bytes, please coordinate with Bram Cohen to make sure all extensions are done compatibly.
Next comes the 20 byte sha1 hash of the bencoded form of the info value from the metainfo file. (This is the same value which is announced as info_hash to the tracker, only here it's raw instead of quoted here). If both sides don't send the same value, they sever the connection. The one possible exception is if a downloader wants to do multiple downloads over a single port, they may wait for incoming connections to give a download hash first, and respond with the same one if it's in their list.
After the download hash comes the 20-byte peer id which is reported in tracker requests and contained in peer lists in tracker responses. If the receiving side's peer id doesn't match the one the initiating side expects, it severs the connection.
That's it for handshaking, next comes an alternating stream of length prefixes and messages. Messages of length zero are keepalives, and ignored. Keepalives are generally sent once every two minutes, but note that timeouts can be done much more quickly when data is expected.
All non-keepalive messages start with a single byte which gives their type.
The possible values are:
'choke', 'unchoke', 'interested', and 'not interested' have no payload.
'bitfield' is only ever sent as the first message. Its payload is a bitfield with each index that downloader has sent set to one and the rest set to zero. Downloaders which don't have anything yet may skip the 'bitfield' message. The first byte of the bitfield corresponds to indices 0 - 7 from high bit to low bit, respectively. The next one 8-15, etc. Spare bits at the end are set to zero.
The 'have' message's payload is a single number, the index which that downloader just completed and checked the hash of.
'request' messages contain an index, begin, and length. The last two are byte offsets. Length is generally a power of two unless it gets truncated by the end of the file. All current implementations use 2^14 (16 kiB), and close connections which request an amount greater than that.
'cancel' messages have the same payload as request messages. They are generally only sent towards the end of a download, during what's called 'endgame mode'. When a download is almost complete, there's a tendency for the last few pieces to all be downloaded off a single hosed modem line, taking a very long time. To make sure the last few pieces come in quickly, once requests for all pieces a given downloader doesn't have yet are currently pending, it sends requests for everything to everyone it's downloading from. To keep this from becoming horribly inefficient, it sends cancels to everyone else every time a piece arrives.
'piece' messages contain an index, begin, and piece. Note that they are correlated with request messages implicitly. It's possible for an unexpected piece to arrive if choke and unchoke messages are sent in quick succession and/or transfer is going very slowly.
Downloaders generally download pieces in random order, which does a reasonably good job of keeping them from having a strict subset or superset of the pieces of any of their peers.
Choking is done for several reasons. TCP congestion control behaves very poorly when sending over many connections at once. Also, choking lets each peer use a tit-for-tat-ish algorithm to ensure that they get a consistent download rate.
The choking algorithm described below is the currently deployed one. It is very important that all new algorithms work well both in a network consisting entirely of themselves and in a network consisting mostly of this one.
There are several criteria a good choking algorithm should meet. It should cap the number of simultaneous uploads for good TCP performance. It should avoid choking and unchoking quickly, known as 'fibrillation'. It should reciprocate to peers who let it download. Finally, it should try out unused connections once in a while to find out if they might be better than the currently used ones, known as optimistic unchoking.
The currently deployed choking algorithm avoids fibrillation by only changing who's choked once every ten seconds. It does reciprocation and number of uploads capping by unchoking the four peers which it has the best download rates from and are interested. Peers which have a better upload rate but aren't interested get unchoked and if they become interested the worst uploader gets choked. If a downloader has a complete file, it uses its upload rate rather than its download rate to decide who to unchoke.
For optimistic unchoking, at any one time there is a single peer which is unchoked regardless of its upload rate (if interested, it counts as one of the four allowed downloaders.) Which peer is optimistically unchoked rotates every 30 seconds. To give them a decent chance of getting a complete piece to upload, new connections are three times as likely to start as the current optimistic unchoke as anywhere else in the rotation.
This document has been placed in the public domain.


Make sure to use the latest version 2.7.6. A dangerous security issue has been found in previous versions!
A simple and easy to use plugin to create fullscreen scrolling websites (also known as single page websites or onepage sites).
It allows the creation of fullscreen scrolling websites, as well as adding some landscape sliders inside the sections of the site.
Customizations of the plugin and urgent changes are available upon request for some reasonable price. Contact me.
Would you like to have a website using fullpage.js functionality but you don't know how to use it? I can do it for you for a reasonable price. Contact me.
Suggestion are more than welcome, not only for feature requests but also for coding style improvements.
Let's make this a great plugin to make people's lives easier!
fullPage.js is fully functional on all modern browsers, as well as some old ones such as Internet Explorer 8, 9, Opera 12, etc.
It works with browsers with CSS3 support and with the ones which don't have it, making it ideal for old browsers compatibility.
It also provides touch support for mobile phones, tablets and touch screen computers.
Special thanks to Browserstack for supporting fullpage.js.
As you can see in the example files, you will need to include:
jquery.fullPage.js
(or its minified version jquery.fullPage.min.js
)The css file jquery.fullPage.css
Optionally, you can add the jQuery UI library in case you want to use other easing effects apart from the ones included in the jQuery library (linear
, swing
and easeInOutCubic
) or the one included by default in fullPage.js (easeInQuart
).
Optionally, you can install fullPage.js with bower or npm if you prefer:
Terminal:
// With bower
bower install fullpage.js
// With npm
npm install fullpage.js
###Including files:
<link rel="stylesheet" type="text/css" href="jquery.fullPage.css" />

###Optional use of CDN
If you prefer to use a CDN to load the needed files, fullPage.js is in CDNJS:
https://cdnjs.com/libraries/fullPage.js
###Required HTML structure
Each section will be defined with an element containing the section
class.
The active section by default will be the first section, which is taken as the home page.
Sections should be placed inside a wrapper (

in this case). The wrapper can not be the body
element.

Some section

Some section

Some section

Some section

If you want to define a different starting point rather than the first section or the first slide of a section, just add the class active
to the section and slide you want to load first.

Some section

In order to create a landscape slider within a section, each slide will be defined by default with an element containing the slide
class:

 Slide 1

 Slide 2

 Slide 3

 Slide 4

You can see a fully working example of the HTML structure in the demoPage.html
file.
###Initialization
All you need to do is call the plugin inside a $(document).ready
function:
$(document).ready(function() {
$('#fullpage').fullpage();
});
A more complex initialization with all options set could look like this:
$(document).ready(function() {
$('#fullpage').fullpage({
//Navigation
menu: '#menu',
lockAnchors: false,
anchors:['firstPage', 'secondPage'],
navigation: false,
navigationPosition: 'right',
navigationTooltips: ['firstSlide', 'secondSlide'],
showActiveTooltip: false,
slidesNavigation: true,
slidesNavPosition: 'bottom',
//Scrolling
css3: true,
scrollingSpeed: 700,
autoScrolling: true,
fitToSection: true,
fitToSectionDelay: 1000,
scrollBar: false,
easing: 'easeInOutCubic',
easingcss3: 'ease',
loopBottom: false,
loopTop: false,
loopHorizontal: true,
continuousVertical: false,
normalScrollElements: '#element1, .element2',
scrollOverflow: false,
touchSensitivity: 15,
normalScrollElementTouchThreshold: 5,
//Accessibility
keyboardScrolling: true,
animateAnchor: true,
recordHistory: true,
//Design
controlArrows: true,
verticalCentered: true,
resize : false,
sectionsColor : ['#ccc', '#fff'],
paddingTop: '3em',
paddingBottom: '10px',
fixedElements: '#header, .footer',
responsiveWidth: 0,
responsiveHeight: 0,
//Custom selectors
sectionSelector: '.section',
slideSelector: '.slide',
//events
onLeave: function(index, nextIndex, direction){},
afterLoad: function(anchorLink, index){},
afterRender: function(){},
afterResize: function(){},
afterSlideLoad: function(anchorLink, index, slideAnchor, slideIndex){},
onSlideLeave: function(anchorLink, index, slideIndex, direction, nextSlideIndex){}
});
});
If you are using fullPage.js with anchor links for the sections (using the anchors
option or the attribute data-anchor
in each section), then you will be able to use anchor links also to navigate directly to a certain slide inside a section.
This would be an example of a link with an anchor: http://alvarotrigo.com/fullPage/#secondPage/2 (which is the URL you will see once you access to that section/slide manually)
Notice the last part of the URL ends in #secondPage/2
.
Having the following initialization:
$(document).ready(function() {
$('#fullpage').fullpage({
anchors:['firstPage', 'secondPage', 'thirdPage']
});
});
The anchor at the end of the URL #secondPage/2
defines the section and slide of destination respectively. In the previous URL, the section of destination will be the one defined with the anchor secondPage
and the slide will be the 2nd slide, as we are using the index 2
for it. (the fist slide of a section has index 0, as technically it is a section).
We could have used a custom anchor for the slide instead of its index if we would have used the attribute data-anchor
on the HTML markup like so:

 Slide 1

 Slide 2

 Slide 3

 Slide 4

In this last case, the URL we would use would be #secondPage/slide3
, which is the equivalent to our previous #secondPage/2
.
Note that section anchors can also be defined in the same way, by using the data-anchor
attribute, if no anchors
array is provided.
Be careful! data-anchor
tags can not have the same value as any ID element on the site (or NAME element for IE).
It is possible to use sections or slides which don't take the whole viewport height resulting in smaller sections. This is ideal for footers.
It is important to realise that it doesn't make sense to have all of your sections using this feature. If there is more than one section in the initial load of the site, the plugin won't scroll at all to see the next one as it will be already in the viewport.
To create smaller sections just use the class fp-auto-height
in the section you want to apply it. It will then take the height defined by your section/slide content.

Whole viewport

Auto height

controlArrows
: (default true
) Determines whether to use control arrows for the slides to move right or left.
verticalCentered
: (default true
) Vertically centering of the content within sections. When set to true
, your content will be wrapped by the plugin. Consider using delegation or load your other scripts in the afterRender
callback.
resize
: (default false
) Whether you want to resize the text when the window is resized.
scrollingSpeed
: (default 700
) Speed in milliseconds for the scrolling transitions.
sectionsColor
:(default none
) Define the CSS background-color
property for each section:
Example:
$('#fullpage').fullpage({
sectionsColor: ['#f2f2f2', '#4BBFC3', '#7BAABE', 'whitesmoke', '#000'],
});
anchors
: (default []
) Defines the anchor links (#example) to be shown on the URL for each section. Anchors value should be unique. The position of the anchors in the array will define to which sections the anchor is applied. (second position for second section and so on). Using anchors forward and backward navigation will also be possible through the browser. This option also allows users to bookmark a specific section or slide. Be careful! anchors can not have the same value as any ID element on the site (or NAME element for IE).
Now anchors can be defined directly in the HTML structure by using the attribute data-anchor
as explained here.
lockAnchors
: (default false
). Determines whether anchors in the URL will have any effect at all in the plugin. You can still using anchors internally for your own functions and callbacks, but they won't have any effect in the scrolling of the site. Useful if you want to combine fullPage.js with other plugins using anchor in the URL.
Important It is helpful to understand that the values in the anchors
option array correlate directly to the element with the class of .section
by it's position in the markup.
easing
: (default easeInOutCubic
) Defines the transition effect to use for the vertical and horizontal scrolling.
It requires the file vendors/jquery.easings.min.js
or jQuery UI for using some of its transitions. Other libraries could be used instead.
easingcss3
: (default ease
) Defines the transition effect to use in case of using css3:true
. You can use the pre-defined ones (such as linear
, ease-out
...) or create your own ones using the cubic-bezier
function. You might want to use Matthew Lein CSS Easing Animation Tool for it.
loopTop
: (default false
) Defines whether scrolling up in the first section should scroll to the last one or not.
loopBottom
: (default false
) Defines whether scrolling down in the last section should scroll to the first one or not.
loopHorizontal
: (default true
) Defines whether horizontal sliders will loop after reaching the last or previous slide or not.
css3
: (default true
). Defines whether to use JavaScript or CSS3 transforms to scroll within sections and slides. Useful to speed up the movement in tablet and mobile devices with browsers supporting CSS3. If this option is set to true
and the browser doesn't support CSS3, a jQuery fallback will be used instead.
autoScrolling
: (default true
) Defines whether to use the "automatic" scrolling or the "normal" one. It also has affects the way the sections fit in the browser/device window in tablets and mobile phones.
fitToSection
: (default true
). Determines whether or not to fit sections to the viewport or not. When set to true
the current active section will always fill the whole viewport. Otherwise the user will be free to stop in the middle of a section (when )
fitToSectionDelay
: (default 1000). If fitToSection
is set to true, this delays
the fitting by the configured milliseconds.
scrollBar
: (default false
). Determines whether to use scrollbar for the site or not. In case of using scroll bar, the autoScrolling
functionality will still working as expected. The user will also be free to scroll the site with the scroll bar and fullPage.js will fit the section in the screen when scrolling finishes.
paddingTop
: (default 0
) Defines the top padding for each section with a numerical value and its measure (paddingTop: '10px', paddingTop: '10em'...) Useful in case of using a fixed header.
paddingBottom
: (default 0
) Defines the bottom padding for each section with a numerical value and its measure (paddingBottom: '10px', paddingBottom: '10em'...). Useful in case of using a fixed footer.
fixedElements
: (default null
) Defines which elements will be taken off the scrolling structure of the plugin which is necessary when using the css3
option to keep them fixed. It requires a string with the jQuery selectors for those elements. (For example: fixedElements: '#element1, .element2'
)
normalScrollElements
: (default null
) If you want to avoid the auto scroll when scrolling over some elements, this is the option you need to use. (useful for maps, scrolling divs etc.) It requires a string with the jQuery selectors for those elements. (For example: normalScrollElements: '#element1, .element2'
)
normalScrollElementTouchThreshold
: (default 5
) Defines the threshold for the number of hops up the html node tree Fullpage will test to see if normalScrollElements
is a match to allow scrolling functionality on divs on a touch device. (For example: normalScrollElementTouchThreshold: 3
)
keyboardScrolling
: (default true
) Defines if the content can be navigated using the keyboard
touchSensitivity
: (default 5
) Defines a percentage of the browsers window width/height, and how far a swipe must measure for navigating to the next section / slide
continuousVertical
: (default false
) Defines whether scrolling down in the last section should scroll down to the first one or not, and if scrolling up in the first section should scroll up to the last one or not. Not compatible with loopTop
or loopBottom
.
animateAnchor
: (default true
) Defines whether the load of the site when given an anchor (#) will scroll with animation to its destination or will directly load on the given section.
recordHistory
: (default true
) Defines whether to push the state of the site to the browser's history. When set to true
each section/slide of the site will act as a new page and the back and forward buttons of the browser will scroll the sections/slides to reach the previous or next state of the site. When set to false
, the URL will keep changing but will have no effect ont he browser's history. This option is automatically turned off when using autoScrolling:false
.
menu
: (default false
) A selector can be used to specify the menu to link with the sections. This way the scrolling of the sections will activate the corresponding element in the menu using the class active
.
This won't generate a menu but will just add the active
class to the element in the given menu with the corresponding anchor links.
In order to link the elements of the menu with the sections, an HTML 5 data-tag (data-menuanchor
) will be needed to use with the same anchor links as used within the sections. Example:

First section

Second section

Third section

Fourth section

$('#fullpage').fullpage({
anchors: ['firstPage', 'secondPage', 'thirdPage', 'fourthPage', 'lastPage'],
menu: '#myMenu'
});
Note: the menu element should be placed outside the fullpage wrapper in order to avoid problem when using css3:true
. Otherwise it will be appended to the body
by the plugin itself.
navigation
: (default false
) If set to true
, it will show a navigation bar made up of small circles.
navigationPosition
: (default none
) It can be set to left
or right
and defines which position the navigation bar will be shown (if using one).
navigationTooltips
: (default []) Defines the tooltips to show for the navigation circles in case they are being used. Example: navigationTooltips: ['firstSlide', 'secondSlide']
.
showActiveTooltip
: (default false
) Shows a persistent tooltip for the actively viewed section in the vertical navigation.
slidesNavigation
: (default false
) If set to true
it will show a navigation bar made up of small circles for each landscape slider on the site.
slidesNavPosition
: (default bottom
) Defines the position for the landscape navigation bar for sliders. Admits top
and bottom
as values. You may want to modify the CSS styles to determine the distance from the top or bottom as well as any other style such as color.
scrollOverflow
: (default false
) defines whether or not to create a scroll for the section in case its content is bigger than the height of it. When set to true
, your content will be wrapped by the plugin. Consider using delegation or load your other scripts in the afterRender
callback.
In case of setting it to true
, it requires the vendor plugin jquery.slimscroll.min
and it should be loaded before the fullPage.js plugin. For example:

sectionSelector
: (default .section
) Defines the jQuery selector used for the plugin sections. It might need to be changed sometimes to avoid problem with other plugins using the same selectors as fullpage.js..
slideSelector
: (default .slide
) Defines the jQuery selector used for the plugin slides. It might need to be changed sometimes to avoid problem with other plugins using the same selectors as fullpage.js.
responsiveWidth
: (default 0
) A normal scroll (autoScrolling:false
) will be used under the defined width in pixels. A class fp-responsive
is added to the body tag in case the user wants to use it for his own responsive CSS. For example, if set to 900, whenever the browser's width is less than 900 the plugin will scroll like a normal site.
responsiveHeight
: (default 0
) A normal scroll (autoScrolling:false
) will be used under the defined height in pixels. A class fp-responsive
is added to the body tag in case the user wants to use it for his own responsive CSS. For example, if set to 900, whenever the browser's height is less than 900 the plugin will scroll like a normal site.
You can see them in action here
Demo Scrolls one section up:
$.fn.fullpage.moveSectionUp();
Demo Scrolls one section down:
$.fn.fullpage.moveSectionDown();
Demo Scrolls the page to the given section and slide. The first slide, the visible one by default, will have index 0.
/*Scrolling to the section with the anchor link `firstSlide` and to the 2nd Slide */
$.fn.fullpage.moveTo('firstSlide', 2);
//Scrolling to the 3rd section in the site
$.fn.fullpage.moveTo(3, 0);
//Which is the same as
$.fn.fullpage.moveTo(3);
Demo
Exactly the same as moveTo
but in this case it performs the scroll without animation. A direct jump to the destination.
/*Scrolling to the section with the anchor link `firstSlide` and to the 2nd Slide */
$.fn.fullpage.silentMoveTo('firstSlide', 2);
Demo
Scrolls the horizontal slider of the current section to the next slide:
$.fn.fullpage.moveSlideRight();
Demo
Scrolls the horizontal slider of the current section to the previous slide:
$.fn.fullpage.moveSlideLeft();
Demo Sets the scrolling configuration in real time.
Defines the way the page scrolling behaves. If it is set to true
, it will use the "automatic" scrolling, otherwise, it will use the "manual" or "normal" scrolling of the site. Be careful when combining this option with scrollOverflow
set to true, as it might be difficult to scroll using the mouse wheel or the trackpad when the section is scrollable.
$.fn.fullpage.setAutoScrolling(false);
Demo
Sets the value for the option fitToSection
determining whether to fit the section in the screen or not.
$.fn.fullpage.setFitToSection(false);
Demo
Sets the value for the option lockAnchors
determining whether anchors will have any effect in the URL or not.
$.fn.fullpage.setLockAnchors(false);
Demo Adds or remove the possibility of scrolling through sections by using the mouse wheel/trackpad or touch gestures (which is active by default). Note this won't disable the keyboard scrolling. You
would need to use setKeyboardScrolling
for it.
directions
: (optional parameter) Admitted values: all
, up
, down
, left
, right
or a combination of them separated by commas like down, right
. It defines the direction for which the scrolling will be enabled or disabled.
//disabling scrolling
$.fn.fullpage.setAllowScrolling(false);
//disabling scrolling down
$.fn.fullpage.setAllowScrolling(false, 'down');
//disabling scrolling down and right
$.fn.fullpage.setAllowScrolling(false, 'down, right');
Demo Adds or remove the possibility of scrolling through sections by using the keyboard arrow keys (which is active by default).
directions
: (optional parameter) Admitted values: all
, up
, down
, left
, right
or a combination of them separated by commas like down, right
. It defines the direction for which the scrolling will be enabled or disabled.//disabling all keyboard scrolling
$.fn.fullpage.setKeyboardScrolling(false);
//disabling keyboard scrolling down
$.fn.fullpage.setKeyboardScrolling(false, 'down');
//disabling keyboard scrolling down and right
$.fn.fullpage.setKeyboardScrolling(false, 'down, right');
Demo Defines whether to record the history for each hash change in the URL.
$.fn.fullpage.setRecordHistory(false);
Demo Defines the scrolling speed in milliseconds.
$.fn.fullpage.setScrollingSpeed(700);
Demo Destroys the plugin events and optionally its HTML markup and styles.
Ideal to use when using AJAX to load content. ()
type
: can be empty or all
. If all
is passed, the HTML markup and styles used by fullpage.js will be removed. This way the original HTML markup, the one used before any plugin modification is made, will be maintained.//destroy any plugin event (scrolls, hashchange in the URL...)
$.fn.fullpage.destroy();
//destroy any plugin event and any plugin modification done over your original HTML markup.
$.fn.fullpage.destroy('all');
Updates the DOM structure to fit the new window size or its contents.
Ideal to use in combination with AJAX calls or external changes in the DOM structure of the site.
$.fn.fullpage.reBuild();
##Lazy Loading
Demo fullPage.js provides a way to lazy load images, videos and audio elements so they won't slow down the loading of your site or unnecessarily waste data transfer.
When using lazy loading, all these elements will only get loaded when entering in the viewport.
To enable lazy loading all you need to do is change your src
attribute to data-src
as shown below:

<video>
<source data-src="video.webm" type="video/webm" />
<source data-src="video.mp4" type="video/mp4" />
</video>
Demo You can see them in action here.
###afterLoad (anchorLink
, index
)
Callback fired once the sections have been loaded, after the scrolling has ended.
Parameters:
anchorLink
: anchorLink corresponding to the section.index
: index of the section. Starting from 1.In case of not having anchorLinks defined in the plugin the index
parameter would be the only one to use.
Example:
$('#fullpage').fullpage({
anchors: ['firstPage', 'secondPage', 'thirdPage', 'fourthPage', 'lastPage'],
afterLoad: function(anchorLink, index){
var loadedSection = $(this);
//using index
if(index == 3){
alert("Section 3 ended loading");
}
//using anchorLink
if(anchorLink == 'secondSlide'){
alert("Section 2 ended loading");
}
}
});
###onLeave (index
, nextIndex
, direction
)
This callback is fired once the user leaves a section, in the transition to the new section.
Returning false
will cancel the move before it takes place.
Parameters:
index
: index of the leaving section. Starting from 1.nextIndex
: index of the destination section. Starting from 1.direction
: it will take the values up
or down
depending on the scrolling direction.Example:
$('#fullpage').fullpage({
onLeave: function(index, nextIndex, direction){
var leavingSection = $(this);
//after leaving section 2
if(index == 2 && direction =='down'){
alert("Going to section 3!");
}
else if(index == 2 && direction == 'up'){
alert("Going to section 1!");
}
}
});
####Cancelling the scroll before it takes place
You can cancel the scroll by returning false
on the onLeave
callback:
$('#fullpage').fullpage({
onLeave: function(index, nextIndex, direction){
//it won't scroll if the destination is the 3rd section
if(nextIndex == 3){
return false;
}
}
});
###afterRender()
This callback is fired just after the structure of the page is generated. This is the callback you want to use to initialize other plugins or fire any code which requires the document to be ready (as this plugin modifies the DOM to create the resulting structure).
Example:
$('#fullpage').fullpage({
afterRender: function(){
var pluginContainer = $(this);
alert("The resulting DOM structure is ready");
}
});
###afterResize()
This callback is fired after resizing the browser's window. Just after the sections are resized.
Example:
$('#fullpage').fullpage({
afterResize: function(){
var pluginContainer = $(this);
alert("The sections have finished resizing");
}
});
###afterSlideLoad (anchorLink
, index
, slideAnchor
, slideIndex
)
Callback fired once the slide of a section have been loaded, after the scrolling has ended.
Parameters:
anchorLink
: anchorLink corresponding to the section.index
: index of the section. Starting from 1.slideAnchor
: anchor corresponding to the slide (in case there is)slideIndex
: index of the slide. Starting from 1. (the default slide doesn't count as slide, but as a section)In case of not having anchorLinks defined for the slide or slides the slideIndex
parameter would be the only one to use.
Example:
$('#fullpage').fullpage({
anchors: ['firstPage', 'secondPage', 'thirdPage', 'fourthPage', 'lastPage'],
afterSlideLoad: function( anchorLink, index, slideAnchor, slideIndex){
var loadedSlide = $(this);
//first slide of the second section
if(anchorLink == 'secondPage' && slideIndex == 1){
alert("First slide loaded");
}
//second slide of the second section (supposing #secondSlide is the
//anchor for the second slide
if(index == 2 && slideIndex == 'secondSlide'){
alert("Second slide loaded");
}
}
});
###onSlideLeave (anchorLink
, index
, slideIndex
, direction
, nextSlideIndex
)
This callback is fired once the user leaves an slide to go to another, in the transition to the new slide.
Returning false
will cancel the move before it takes place.
Parameters:
anchorLink
: anchorLink corresponding to the section.index
: index of the section. Starting from 1.slideIndex
: index of the slide. Starting from 0.
direction
: takes the values right
or left
depending on the scrolling direction.nextSlideIndex
: index of the destination slide. Starting from 0.
Example:
$('#fullpage').fullpage({
onSlideLeave: function( anchorLink, index, slideIndex, direction, nextSlideIndex){
var leavingSlide = $(this);
//leaving the first slide of the 2nd Section to the right
if(index == 2 && slideIndex == 0 && direction == 'right'){
alert("Leaving the fist slide!!");
}
//leaving the 3rd slide of the 2nd Section to the left
if(index == 2 && slideIndex == 2 && direction == 'left'){
alert("Going to slide 2! ");
}
}
});
####Cancelling a move before it takes place
You can cancel a move by returning false
on the onSlideLeave
callback. Same as with onLeave
.
#Build tasks
This gives the ability to compile the SCSS file to CSS as well compress and generate source-maps for the CSS and JS files.
##Installing dependencies
You must have node
amd npm
installed in order to run the compile and compress tasks.
Terminal:
// (Optional) Install Gulp module globally
npm install gulp -g
// Install fullpage's build dependencies
npm install
##Task commands
Terminal:
// Only compile the SCSS
gulp scss
// Only compress the CSS
gulp css
// Only compress the JS
gulp js
// Runs the css and js tasks (not the scss)
gulp
#Resources
easingcss3
value)If you want your page to be listed here. Please contact me with the URL.
You can find another list here.
Donations would be more than welcome :)
(The MIT License)
Copyright (c) 2013 Alvaro Trigo<EMAIL_ADDRESS>Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


MeltDown
Login
Signup
×
Login To Your Account
Valid. Please wait a moment.
Error. Please enter correct Username & password.
Login
Pop Movies


We are a small dessert place located in Bangalore which aims to provide you with delicious ice creams and sundaes. Our cafe was inaugurated On 25th January 2016 and has been going strong since. We believe that dessert is the highlight of every meal and therefore, aim to provide you the joy of ice cream delvered right to your door, with delivery cost being free for order above 300
In the unlikely event that the item order is unaivalable, or your delivery is unable to reach you within 4 hours, we will return the amount withdrawn from your account within 24 hours.
Once an order has been confirmed and a onfirmation message send, it can not be cancelled free of cost. In such a case, we reserve the right to charge you a cancellation fee of minimum Rs. 50 and a maximum of 50 per cent of the cost of the item.
Back


| Up | TOC | Index | |||||
| << 7 Included Tools | < 8.47 Graphics Constants | Up: 8 API Reference | 8.49 Graphics - Image Routines > | 9 Release Notes >> |
8.48 Graphics - Cross Platform
8.48.1 Routines
<IP_ADDRESS> position
<built-in> procedure position(integer row, integer column)
Parameters:
- row : an integer, the index of the row to position the cursor on.
- column : an integer, the index of the column to position the cursor on.
sets the cursor to where the next character will be output.
Comments:
Set the cursor to line row, column column, where the top left corner of the screen is line 1, column 1. The next character displayed on the screen will be printed at this location. position will report an error if the location is off the screen. The Windows console does not check for rows, as the physical height of the console may be vastly less than its logical height.
Example 1:
position(2,1) -- the cursor moves to the beginning of the second line from the top
See Also:
<IP_ADDRESS> get_position
include std/graphics.e namespace graphics public function get_position()
returns the current line and column position of the cursor.
Returns:
A sequence, {line, column}, the current position of the text mode cursor.
Comments:
The coordinate system for displaying text is different from the one for displaying pixels. Pixels are displayed such that the top-left is (x=0,y=0) and the first coordinate controls the horizontal, left-right location. In pixel-graphics modes you can display both text and pixels. get_position returns the current line and column for the text that you are displaying, not the pixels that you may be plotting. There is no corresponding routine for getting the current pixel position, because there is no such thing.
See Also:
<IP_ADDRESS> text_color
include std/graphics.e namespace graphics public procedure text_color(color c)
sets the foreground text color.
Parameters:
- c : the new text color. Add BLINKING to get blinking text in some modes.
Comments:
Text that you print after calling text_color will have the desired color.
When your program terminates, the last color that you selected and actually printed on the screen will remain in effect. Thus you may have to print something, maybe just '\n', in WHITE to restore white text, especially if you are at the bottom line of the screen, ready to scroll up.
Example 1:
text_color(BRIGHT_BLUE)
See Also:
<IP_ADDRESS> bk_color
include std/graphics.e namespace graphics public procedure bk_color(color c)
sets the background color to one of the sixteen standard colors.
Parameters:
- c : the new text color. Add BLINKING to get blinking text in some modes.
Comments:
To restore the original background color when your program finishes, ( often 0 - BLACK), you must call bk_color(0). If the cursor is at the bottom line of the screen, you may have to actually print something before terminating your program; printing '\n' may be enough.
Example 1:
bk_color(BLACK)
See Also:
<IP_ADDRESS> console_colors
include std/graphics.e namespace graphics public function console_colors(sequence colorset = {})
sets the codes for the colors used in text_color and bk_color.
Parameters:
- colorset : A sequence in one of two formats.
- Containing two sets of exactly sixteen color numbers in which the first set are foreground (text) colors and the other set are background colors.
- Containing a set of exactly sixteen color numbers. These are to be applied to both foreground and background.
Returns:
A sequence: This contains two sets of sixteen color values currently in use for foreground and background respectively.
Comments:
- If the colorset is omitted then this just returns the current values without changing anything.
- A color set contains sixteen values. You can access the color value for a specific color by using [X + 1] where 'X' is one of the Euphoria color constants such as RED or BLUE.
- This can be used to change the meaning of the standard color codes for some consoles that are not using standard values. For example, the Unix default color value for RED is 1 and BLUE is 4, but you might need this to swapped. See code Example 1. Another use might be to suppress highlighted (bold) colors. See code Example 2.
Example 1:
sequence cs cs = console_colors() -- Get the current FG and BG color values. cs[FGSET][RED + 1] = 4 -- set RED to 4 cs[FGSET][BLUE + 1] = 1 -- set BLUE to 1 cs[BGSET][RED + 1] = 4 -- set RED to 4 cs[BGSET][BLUE + 1] = 1 -- set BLUE to 1 console_colors(cs)
Example 2:
-- Prevent highlighted background colors sequence cs cs = console_colors() for i = GRAY + 1 to BRIGHT_WHITE + 1 do cs[BGSET][i] = cs[BGSET][i - 8] end for console_colors(cs)
See Also:
<IP_ADDRESS> wrap
include std/graphics.e namespace graphics public procedure wrap(object on = 1)
determines whether text will wrap when hitting the rightmost column.
Parameters:
- on : an object, 0 to truncate text, anything else to wrap.
Comments:
By default text will wrap.
Use wrap in text modes or pixel-graphics modes when you are displaying long lines of text.
Example 1:
puts(1, repeat('x', 100) & "\n\n") -- now have a line of 80 'x' followed a line of 20 more 'x' wrap(0) puts(1, repeat('x', 100) & "\n\n") -- creates just one line of 80 'x'
See Also:
<IP_ADDRESS> scroll
include std/graphics.e namespace graphics public procedure scroll(integer amount, console :positive_int top_line, console :positive_int bottom_line)
scrolls a region of text on the screen.
Parameters:
- amount : an integer, the number of lines by which to scroll. This is >0 to scroll up and <0 to scroll down.
- top_line : the 1-based number of the topmost line to scroll.
- bottom_line : the 1-based number of the bottom-most line to scroll.
Comments:
- New blank lines will appear at the vacated lines.
- You could perform the scrolling operation using a series of calls to puts, but scroll is much faster.
- The position of the cursor after scrolling is not defined.
Example 1:
.../euphoria/bin/ed.ex
See Also:
8.48.2 Graphics Modes
<IP_ADDRESS> graphics_mode
include std/graphics.e namespace graphics public function graphics_mode(object m = - 1)
attempts to set up a new graphics mode.
Parameters:
- x : an object, but it will be ignored.
Returns:
An integer, always returns zero.
Platform:
Windows
Comments:
- This has no effect on Unix platforms.
- On Windows it causes a console to be shown if one has not already been created.
See Also:


This page contains all of the options you can set as a subscriber. You are currently logged in as:
This page contains all of the options you can set as a subscriber. You are currently logged in as:
It'd be sad to see you go. But, if you hit the button below, you'll be unsubscribed.
If you're going because of something specific, please email the list administrator and say why.
This section allows you to change your options as a subscriber. There may be other options that you can set which are not provided here. If that's the case, email the list administratora>.


{% load otree %}
{{session.config.text1}}
In each cell, the amount to the left is the payoff for you and to the right for the other participant.
| The Other Participant | ||||
|---|---|---|---|---|
| {{player.other_player.strategy_1}} | {{player.other_player.strategy_2}} | {{player.other_player.strategy_3}} | ||
| You | {{ player.strategy_1 }} | {{ player.payoff_selfS1_otherS1 }}, {{ player.other_player.payoff_selfS1_otherS1 }} | {{ player.payoff_selfS1_otherS2 }}, {{ player.other_player.payoff_selfS2_otherS1 }} | {{ player.payoff_selfS1_otherS3 }}, {{ player.other_player.payoff_selfS3_otherS1 }} |
| {{ player.strategy_2 }} | {{ player.payoff_selfS2_otherS1 }}, {{ player.other_player.payoff_selfS1_otherS2 }} | {{ player.payoff_selfS2_otherS2 }}, {{ player.other_player.payoff_selfS2_otherS2 }} | {{ player.payoff_selfS2_otherS3 }}, {{ player.other_player.payoff_selfS3_otherS2 }} |


Lakshdeep Bajwa currently works as a teacher for an after school care enrichment program at Rock Creek Elementary School located in Rocklin, CA. Since 2012, he has implemented STEM into his cirriculum to enrich young children's lives by facilitating project-based learning. Some examples of work completed by elementary school age children include a fully functioning completely custom arcade cabinet from scratch.
At Child Development Centers and Continuing Development Incorporated, it is our mission to enrich children’s lives through quality, accredited child development programs and a commitment to developmentally appropriate practice. Our programs put children at the center of an interconnected circle of families, teachers and the community.
Washed dishes, attended to food preperation and storage along with appropriate cycling of fresh items to the front, took food orders, operated POS terminal
Supervison and care of before and after school elemenatary school age children at an on-campus recreation program, conflict resolution, parent interactions
GPA: 3.23
GPA: 3.44
Lakshdeep Bajwa currently works as a teacher for an after school care enrichment program at Rock Creek Elementary School located in Rocklin, CA. Since 2012, he has implemented STEM into his cirriculum to enrich young children's lives by facilitating project-based learning. Some examples of work completed by elementary school age children include a fully functioning completely custom arcade cabinet from scratch.
Lakshdeep Bajwa currently works as a teacher for an after school care enrichment program at Rock Creek Elementary School located in Rocklin, CA. Since 2012, he has implemented STEM into his cirriculum to enrich young children's lives by facilitating project-based learning. Some examples of work completed by elementary school age children include a fully functioning completely custom arcade cabinet from scratch.


This is the section where we get into the system calls that allow you to access the network functionality of a Unix box. When you call one of these functions, the kernel takes over and does all the work for you automagically.
 In that, the man pages are no use, as you've probably discovered. Well, to help with that dreadful situation, I've tried to lay out the system calls in the following sections in exactly (approximately) the same order that you'll need to call them in your programs.
That, coupled with a few pieces of sample code here and there, some milk and cookies (which I fear you will have to supply yourself), and some raw guts and courage, and you'll be beaming data around the Internet like the Son of Jon Postel!
I guess I can put it off no longer--I have to talk about the socket() system call. Here's the breakdown:
#include <sys/types.h> #include <sys/socket.h> int socket(int domain, int type, int protocol); |
But what are these arguments? First, domain should be set to "AF_INET", just like in the struct sockaddr_in (above.) Next, the type argument tells the kernel what kind of socket this is: SOCK_STREAM or SOCK_DGRAM. Finally, just set protocol to "0" to have socket() choose the correct protocol based on the type. (Notes: there are many more domains than I've listed. There are many more types than I've listed. See the socket() man page. Also, there's a "better" way to get the protocol. See the getprotobyname() man page.)
socket() simply returns to you a socket descriptor that you can use in later system calls, or -1 on error. The global variable errno is set to the error's value (see the perror() man page.)
In some documentation, you'll see mention of a mystical "PF_INET". This is a weird etherial beast that is rarely seen in nature, but I might as well clarify it a bit here. Once a long time ago, it was thought that maybe a address family (what the "AF" in "AF_INET" stands for) might support several protocols that were referenced by their protocol family (what the "PF" in "PF_INET" stands for). That didn't happen. Oh well. So the correct thing to do is to use AF_INET in your struct sockaddr_in and PF_INET in your call to socket(). But practically speaking, you can use AF_INET everywhere. And, since that's what W. Richard Stevens does in his book, that's what I'll do here.
Fine, fine, fine, but what good is this socket? The answer is that it's really no good by itself, and you need to read on and make more system calls for it to make any sense.
Once you have a socket, you might have to associate that socket with a port on your local machine. (This is commonly done if you're going to listen() for incoming connections on a specific port--MUDs do this when they tell you to "telnet to x.y.z port 6969".) The port number is used by the kernel to match an incoming packet to a certain process's socket descriptor. If you're going to only be doing a connect(), this may be unnecessary. Read it anyway, just for kicks.
Here is the synopsis for the bind() system call:
#include <sys/types.h> #include <sys/socket.h> int bind(int sockfd, struct sockaddr *my_addr, int addrlen); |
sockfd is the socket file descriptor returned by socket(). my_addr is a pointer to a struct sockaddr that contains information about your address, namely, port and IP address. addrlen can be set to sizeof(struct sockaddr).
Whew. That's a bit to absorb in one chunk. Let's have an example:
#include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define MYPORT 3490 main() { int sockfd; struct sockaddr_in my_addr; sockfd = socket(AF_INET, SOCK_STREAM, 0); // do some error checking! my_addr.sin_family = AF_INET; // host byte order my_addr.sin_port = htons(MYPORT); // short, network byte order my_addr.sin_addr.s_addr = inet_addr("<IP_ADDRESS>"); memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct // don't forget your error checking for bind(): bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)); . . . |
There are a few things to notice here: my_addr.sin_port is in Network Byte Order. So is my_addr.sin_addr.s_addr. Another thing to watch out for is that the header files might differ from system to system. To be sure, you should check your local man pages.
Lastly, on the topic of bind(), I should mention that some of the process of getting your own IP address and/or port can can be automated:
my_addr.sin_port = 0; // choose an unused port at random my_addr.sin_addr.s_addr = INADDR_ANY; // use my IP address |
See, by setting my_addr.sin_port to zero, you are telling bind() to choose the port for you. Likewise, by setting my_addr.sin_addr.s_addr to INADDR_ANY, you are telling it to automatically fill in the IP address of the machine the process is running on.
If you are into noticing little things, you might have seen that I didn't put INADDR_ANY into Network Byte Order! Naughty me. However, I have inside info: INADDR_ANY is really zero! Zero still has zero on bits even if you rearrange the bytes. However, purists will point out that there could be a parallel dimension where INADDR_ANY is, say, 12 and that my code won't work there. That's ok with me:
my_addr.sin_port = htons(0); // choose an unused port at random my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // use my IP address |
Now we're so portable you probably wouldn't believe it. I just wanted to point that out, since most of the code you come across won't bother running INADDR_ANY through htonl().
bind() also returns -1 on error and sets errno to the error's value.
Another thing to watch out for when calling bind(): don't go underboard with your port numbers. All ports below 1024 are RESERVED (unless you're the superuser)! You can have any port number above that, right up to 65535 (provided they aren't already being used by another program.)
Sometimes, you might notice, you try to rerun a server and bind() fails, claiming "Address already in use." What does that mean? Well, a bit a of socket that was connected is still hanging around in the kernel, and it's hogging the port. You can either wait for it to clear (a minute or so), or add code to your program allowing it to reuse the port, like this:
int yes=1; //char yes='1'; // Solaris people use this // lose the pesky "Address already in use" error message if (setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) { perror("setsockopt"); exit(1); } |
One small extra final note about bind(): there are times when you won't absolutely have to call it. If you are connect()ing to a remote machine and you don't care what your local port is (as is the case with telnet where you only care about the remote port), you can simply call connect(), it'll check to see if the socket is unbound, and will bind() it to an unused local port if necessary.
 Your user commands you (just like in the movie TRON) to get a socket file descriptor. You comply and call socket(). Next, the user tells you to connect to "<IP_ADDRESS>" on port "23" (the standard telnet port.) Yow! What do you do now?
Lucky for you, program, you're now perusing the section on connect()--how to connect to a remote host. So read furiously onward! No time to lose!
The connect() call is as follows:
#include <sys/types.h> #include <sys/socket.h> int connect(int sockfd, struct sockaddr *serv_addr, int addrlen); |
sockfd is our friendly neighborhood socket file descriptor, as returned by the socket() call, serv_addr is a struct sockaddr containing the destination port and IP address, and addrlen can be set to sizeof(struct sockaddr).
Isn't this starting to make more sense? Let's have an example:
#include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define DEST_IP "<IP_ADDRESS>" #define DEST_PORT 23 main() { int sockfd; struct sockaddr_in dest_addr; // will hold the destination addr sockfd = socket(AF_INET, SOCK_STREAM, 0); // do some error checking! dest_addr.sin_family = AF_INET; // host byte order dest_addr.sin_port = htons(DEST_PORT); // short, network byte order dest_addr.sin_addr.s_addr = inet_addr(DEST_IP); memset(&(dest_addr.sin_zero), '\0', 8); // zero the rest of the struct // don't forget to error check the connect()! connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr)); . . . |
Again, be sure to check the return value from connect()--it'll return -1 on error and set the variable errno.
Also, notice that we didn't call bind(). Basically, we don't care about our local port number; we only care where we're going (the remote port). The kernel will choose a local port for us, and the site we connect to will automatically get this information from us. No worries.
Ok, time for a change of pace. What if you don't want to connect to a remote host. Say, just for kicks, that you want to wait for incoming connections and handle them in some way. The process is two step: first you listen(), then you accept() (see below.)
The listen call is fairly simple, but requires a bit of explanation:
int listen(int sockfd, int backlog); |
sockfd is the usual socket file descriptor from the socket() system call. backlog is the number of connections allowed on the incoming queue. What does that mean? Well, incoming connections are going to wait in this queue until you accept() them (see below) and this is the limit on how many can queue up. Most systems silently limit this number to about 20; you can probably get away with setting it to 5 or 10.
Again, as per usual, listen() returns -1 and sets errno on error.
Well, as you can probably imagine, we need to call bind() before we call listen() or the kernel will have us listening on a random port. Bleah! So if you're going to be listening for incoming connections, the sequence of system calls you'll make is:
socket(); bind(); listen(); /* accept() goes here */ |
I'll just leave that in the place of sample code, since it's fairly self-explanatory. (The code in the accept() section, below, is more complete.) The really tricky part of this whole sha-bang is the call to accept().
Get ready--the accept() call is kinda weird! What's going to happen is this: someone far far away will try to connect() to your machine on a port that you are listen()ing on. Their connection will be queued up waiting to be accept()ed. You call accept() and you tell it to get the pending connection. It'll return to you a brand new socket file descriptor to use for this single connection! That's right, suddenly you have two socket file descriptors for the price of one! The original one is still listening on your port and the newly created one is finally ready to send() and recv(). We're there!
The call is as follows:
#include <sys/socket.h> int accept(int sockfd, void *addr, int *addrlen); |
sockfd is the listen()ing socket descriptor. Easy enough. addr will usually be a pointer to a local struct sockaddr_in. This is where the information about the incoming connection will go (and with it you can determine which host is calling you from which port). addrlen is a local integer variable that should be set to sizeof(struct sockaddr_in) before its address is passed to accept(). Accept will not put more than that many bytes into addr. If it puts fewer in, it'll change the value of addrlen to reflect that.
Guess what? accept() returns -1 and sets errno if an error occurs. Betcha didn't figure that.
Like before, this is a bunch to absorb in one chunk, so here's a sample code fragment for your perusal:
#include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define MYPORT 3490 // the port users will be connecting to #define BACKLOG 10 // how many pending connections queue will hold main() { int sockfd, new_fd; // listen on sock_fd, new connection on new_fd struct sockaddr_in my_addr; // my address information struct sockaddr_in their_addr; // connector's address information int sin_size; sockfd = socket(AF_INET, SOCK_STREAM, 0); // do some error checking! my_addr.sin_family = AF_INET; // host byte order my_addr.sin_port = htons(MYPORT); // short, network byte order my_addr.sin_addr.s_addr = INADDR_ANY; // auto-fill with my IP memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct // don't forget your error checking for these calls: bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)); listen(sockfd, BACKLOG); sin_size = sizeof(struct sockaddr_in); new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); . . . |
Again, note that we will use the socket descriptor new_fd for all send() and recv() calls. If you're only getting one single connection ever, you can close() the listening sockfd in order to prevent more incoming connections on the same port, if you so desire.
These two functions are for communicating over stream sockets or connected datagram sockets. If you want to use regular unconnected datagram sockets, you'll need to see the section on sendto() and recvfrom(), below.
The send() call:
int send(int sockfd, const void *msg, int len, int flags); |
sockfd is the socket descriptor you want to send data to (whether it's the one returned by socket() or the one you got with accept().) msg is a pointer to the data you want to send, and len is the length of that data in bytes. Just set flags to 0. (See the send() man page for more information concerning flags.)
Some sample code might be:
char *msg = "Beej was here!"; int len, bytes_sent; . . len = strlen(msg); bytes_sent = send(sockfd, msg, len, 0); . . . |
send() returns the number of bytes actually sent out--this might be less than the number you told it to send! See, sometimes you tell it to send a whole gob of data and it just can't handle it. It'll fire off as much of the data as it can, and trust you to send the rest later. Remember, if the value returned by send() doesn't match the value in len, it's up to you to send the rest of the string. The good news is this: if the packet is small (less than 1K or so) it will probably manage to send the whole thing all in one go. Again, -1 is returned on error, and errno is set to the error number.
The recv() call is similar in many respects:
int recv(int sockfd, void *buf, int len, unsigned int flags); |
sockfd is the socket descriptor to read from, buf is the buffer to read the information into, len is the maximum length of the buffer, and flags can again be set to 0. (See the recv() man page for flag information.)
recv() returns the number of bytes actually read into the buffer, or -1 on error (with errno set, accordingly.)
Wait! recv() can return 0. This can mean only one thing: the remote side has closed the connection on you! A return value of 0 is recv()'s way of letting you know this has occurred.
There, that was easy, wasn't it? You can now pass data back and forth on stream sockets! Whee!
"This is all fine and dandy," I hear you saying, "but where does this leave me with unconnected datagram sockets?" No problemo, amigo. We have just the thing.
Since datagram sockets aren't connected to a remote host, guess which piece of information we need to give before we send a packet? That's right! The destination address! Here's the scoop:
int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen); |
As you can see, this call is basically the same as the call to send() with the addition of two other pieces of information. to is a pointer to a struct sockaddr (which you'll probably have as a struct sockaddr_in and cast it at the last minute) which contains the destination IP address and port. tolen can simply be set to sizeof(struct sockaddr).
Just like with send(), sendto() returns the number of bytes actually sent (which, again, might be less than the number of bytes you told it to send!), or -1 on error.
Equally similar are recv() and recvfrom(). The synopsis of recvfrom() is:
int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen); |
Again, this is just like recv() with the addition of a couple fields. from is a pointer to a local struct sockaddr that will be filled with the IP address and port of the originating machine. fromlen is a pointer to a local int that should be initialized to sizeof(struct sockaddr). When the function returns, fromlen will contain the length of the address actually stored in from.
recvfrom() returns the number of bytes received, or -1 on error (with errno set accordingly.)
Remember, if you connect() a datagram socket, you can then simply use send() and recv() for all your transactions. The socket itself is still a datagram socket and the packets still use UDP, but the socket interface will automatically add the destination and source information for you.
Whew! You've been send()ing and recv()ing data all day long, and you've had it. You're ready to close the connection on your socket descriptor. This is easy. You can just use the regular Unix file descriptor close() function:
close(sockfd); |
This will prevent any more reads and writes to the socket. Anyone attempting to read or write the socket on the remote end will receive an error.
Just in case you want a little more control over how the socket closes, you can use the shutdown() function. It allows you to cut off communication in a certain direction, or both ways (just like close() does.) Synopsis:
int shutdown(int sockfd, int how); |
sockfd is the socket file descriptor you want to shutdown, and how is one of the following:
0 -- Further receives are disallowed
1 -- Further sends are disallowed
2 -- Further sends and receives are disallowed (like close())
shutdown() returns 0 on success, and -1 on error (with errno set accordingly.)
If you deign to use shutdown() on unconnected datagram sockets, it will simply make the socket unavailable for further send() and recv() calls (remember that you can use these if you connect() your datagram socket.)
It's important to note that shutdown() doesn't actually close the file descriptor--it just changes its usability. To free a socket descriptor, you need to use close().
Nothing to it.
This function is so easy.
It's so easy, I almost didn't give it it's own section. But here it is anyway.
The function getpeername() will tell you who is at the other end of a connected stream socket. The synopsis:
#include <sys/socket.h> int getpeername(int sockfd, struct sockaddr *addr, int *addrlen); |
sockfd is the descriptor of the connected stream socket, addr is a pointer to a struct sockaddr (or a struct sockaddr_in) that will hold the information about the other side of the connection, and addrlen is a pointer to an int, that should be initialized to sizeof(struct sockaddr).
The function returns -1 on error and sets errno accordingly.
Once you have their address, you can use inet_ntoa() or gethostbyaddr() to print or get more information. No, you can't get their login name. (Ok, ok. If the other computer is running an ident daemon, this is possible. This, however, is beyond the scope of this document. Check out RFC-1413 for more info.)
Even easier than getpeername() is the function gethostname(). It returns the name of the computer that your program is running on. The name can then be used by gethostbyname(), below, to determine the IP address of your local machine.
What could be more fun? I could think of a few things, but they don't pertain to socket programming. Anyway, here's the breakdown:
#include <unistd.h> int gethostname(char *hostname, size_t size); |
The arguments are simple: hostname is a pointer to an array of chars that will contain the hostname upon the function's return, and size is the length in bytes of the hostname array.
The function returns 0 on successful completion, and -1 on error, setting errno as usual.
In case you don't know what DNS is, it stands for "Domain Name Service". In a nutshell, you tell it what the human-readable address is for a site, and it'll give you the IP address (so you can use it with bind(), connect(), sendto(), or whatever you need it for.) This way, when someone enters:
$ telnet whitehouse.gov |
telnet can find out that it needs to connect() to "<IP_ADDRESS>".
But how does it work? You'll be using the function gethostbyname():
#include <netdb.h> struct hostent *gethostbyname(const char *name); |
As you see, it returns a pointer to a struct hostent, the layout of which is as follows:
struct hostent { char *h_name; char **h_aliases; int h_addrtype; int h_length; char **h_addr_list; }; #define h_addr h_addr_list[0] |
And here are the descriptions of the fields in the struct hostent:
h_name -- Official name of the host.
h_aliases -- A NULL-terminated array of alternate names for the host.
h_addrtype -- The type of address being returned; usually AF_INET.
h_length -- The length of the address in bytes.
h_addr_list -- A zero-terminated array of network addresses for the host. Host addresses are in Network Byte Order.
h_addr -- The first address in h_addr_list.
gethostbyname() returns a pointer to the filled struct hostent, or NULL on error. (But errno is not set--h_errno is set instead. See herror(), below.)
But how is it used? Sometimes (as we find from reading computer manuals), just spewing the information at the reader is not enough. This function is certainly easier to use than it looks.
/* ** getip.c -- a hostname lookup demo */ #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <netdb.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> int main(int argc, char *argv[]) { struct hostent *h; if (argc != 2) { // error check the command line fprintf(stderr,"usage: getip address\n"); exit(1); } if ((h=gethostbyname(argv[1])) == NULL) { // get the host info herror("gethostbyname"); exit(1); } printf("Host name : %s\n", h->h_name); printf("IP Address : %s\n", inet_ntoa(*((struct in_addr *)h->h_addr))); return 0; } |
With gethostbyname(), you can't use perror() to print error message (since errno is not used). Instead, call herror().
It's pretty straightforward. You simply pass the string that contains the machine name ("whitehouse.gov") to gethostbyname(), and then grab the information out of the returned struct hostent.
The only possible weirdness might be in the printing of the IP address, above. h->h_addr is a char*, but inet_ntoa() wants a struct in_addr passed to it. So I cast h->h_addr to a struct in_addr*, then dereference it to get at the data.


The course IDE automatically displays when you enroll in a course.
Follow these steps to navigate the course IDE:
- Read the instructions in the left panel.
- Update the main.py file with your answer.
- (Optional) Scroll down to the bottom of the instruction panel and click Show Hint to show a hint.
A hint displays at the bottom of the instruction panel.
- (Optional) Scroll down to the bottom of the instruction panel and click Solution to show the solution file.
A solution.py file displays.
- (Optional) Click Reset to reset the main.py file.
- Click Submit to check your answer.
The Chart panel displays your backtest results.
- If an error message displays, restart from step 2.
- Click Continue.


Dynamic Message Announcement
Quantity: 0
Subtotal: $0.00
The dynamically updated Quantity/Subtotal section is optimized for screen reader users:
- As options are checked or unchecked, the new Quantity and Subtotal information is announced for screen reader users.


Pat's World Famous Salmon cookies
Store Name
Max number of customers
Minimum number of customers
Average Cookie per customer


These notes describe how to use the new graphical interface. For details of how to proceed with a fit, and of the models included with Fish, please refer to manual for Fish version 2.
Uncompress the zip file in the location in which you wish to keep Fish.
Run fish.exe
(in Windows) or fish
(Linux) to start Fish. The main Fish window and a plot window should appear after a few seconds.
If you start Fish from a console window, you can add the parameter -console
. This runs Fish with terminal output visible, which may be useful for debugging purposes. For example:
fish -console
The first time you use Fish, you will see a window that asks you to specify a working directory and a model file. These are equivalent to the values previously stored in fishpref.txt
. You can either accept the default values, or you may choose a directory and model file you have used with earlier versions of Fish. Your choice will be saved so that you will not see this window each time you start Fish. The settings can be changed at a later date from Fish's Preferences menu.
The main window contains three tabs. These tabs represent the different steps that are necessary to start a fit, which you will be familiar with from earlier versions.
This tab allows you to load data files and choose which data sets to work with. Use the Add file button to add new data files to this list. If the file contains more than one dataset, they will all be listed.
If you "hover" the mouse over the Label column of the table, you will see a "tool tip" containing details of the dataset.
Select the checkboxes next to the datasets you wish to use in the fit. The number of sets you need will depend on the model you are going to use. For example, if you use the "General microemulsion" model supplied with Fish, you need to choose three sets. The set numbers used by the model are shown in the second column – you can double click these to edit and reassign them.
By default, the range of datapoints used is as specified in the datafile. You can sent a different range by right clicking on an active dataset and choosing "Set range".
This tab contains the list of currently loaded models. Select the one you wish to use during the fit. Again, hovering over the names of the models will show a tool tip with more details of the model.
You can add additional model files to the list using the button at the bottom. Any models in the file will be added to the bottom of the list. If you edit a model (using a text editor, for example), right click the model in the model tab and choose "Refresh model file". This will re-read all the models contained in the same model file. To use the new version of the model, re-select it in the model list.
This tab shows the familiar Fish fitting table. To enable a parameter for fitting (i.e. n=ON
in the old Fish) ensure that its checkbox is selected.
Click the large Run button at the bottom of the tab to run a cycle of the fit. The plot window will update immediately to show the progress of the fit. You can return to any previous cycle in the fit using the field in the bottom left corner. You can continue the fit from an earlier cycle if wish, or else use the "fast forward" button to return to the latest cycle.
The parameter values can be edited by double clicking them. Any changes will be reflected immediately in the plotting window.
A goodness of fit parameter (equal to XDWE/SSR), lambda, and the variance are shown below the fitting table.
This window allows you to view and set numerical constants (Nn), and also change controls flags (Kn). If you change any values, you must click Apply or OK for them to take effect.
You can open a new plot window by choosing "Plot > New window" from the main Fish menu bar. You can have as many active plotting windows as you wish.
In each plot window, you can switch between linear and log axes using the Axis menu. The Series menu allows you to choose which data are shown on each plot. You can add series, remove them, or edit existing series. There is no limit to the number of series on a single plot. You could choose to show all the datasets on one plot, separated vertically if you wish; or you can use a separate plot window for each set. You could have two windows to show data on linear and logarithmic axes simultaneously. Spend some time using the "Edit series" dialog and decide which view works best for you.
The Plot menu contains options to save or print the current plot. It also allows you to set plot properties such as adding a title or changing axis labels or colours.
The Window menu allows you to choose a table of parameters or model description to display alongside the plot so that they can be included in any printouts. You can also choose to display the current date and time at the top of the plot, and toggle display of the legend. You can save these settings as the defaults for future new windows.
Useful hint: when you choose New window, the plot window contains plots for the highest currently selected dataset. Therefore, if you choose New window after selecting the second set but before the third, the window will be ready to plot set 2 without you having to edit the series.
Right clicking the plot window displays a popup menu that allows you to zoom in on the plot or re-scale the axes.
The file menu allows you to save the current fit either as a .q
data file, or as parameters in model file format.
If you choose "Save as", a new file is created with your chosen name. If you overwrite an existing file, the previous contents of the file will be erased. If you subsequently choose "Save", the new data will be appended to the current file. Data is also added to the log file.
Please send any feedback on the beta version of Fish to<EMAIL_ADDRESS>Please report any bugs that you find in the program, and also any aspects of the program that do not work as your intuition said they should.
Some advanced features are currently unavailable in this version of Fish. Please let me know which features you would like to see implemented next!


Near the beginning of "At First Sight" there's a scene guaranteed to make almost every female viewer very, very jealous of Mira Sorvino, who plays Amy Benic, a worn-out yet still somewhat glamorous New York architect who's come to a mountain spa for a bit of rest. And what better treatment to start with than a full-body massage from the magic fingers of Virgil Adams, who is played by -- breathe deeply, ladies -- Val Kilmer? Minutes after he touches her, Amy is so relaxed, she bursts into tears. "Oh no," Virgil apologizes. "Did I go too deep?". Like Virgil, the slickly produced "At First Sight" tends to shy away from depth as well. Sad, since there's certainly the potential for a fascinating picture here as Virgil, blind since early childhood, is persuaded by Amy to participate in an experimental surgery program that may restore his vision. The movie's most intriguing stretch begins immediately after the operation, as Virgil struggles to reintrepret his world visually, instead of through his other senses. But after paying lip service to the challenges of adjusting to being able to see again, the Steve Levitt screenplay backpedals into the safer ground of conventional romance, as long-suffering Amy does her best to be patient while Virgil rants about how "seeing sucks." Though derived from a true story chronicled by Dr. Oliver Sacks in his 1996 book "An Anthropologist On Mars," "Sight" always seems closer to soap opera than case study. All the usual suspects are brought in, including Virgil's overprotective scold of a sister (Kelly McGillis), the hand-wringing research scientist (Bruce Davidson) and Amy's cynical ex-husband (Steven Weber), who's certain she'll come back to him on the rebound. The most enjoyable of these walking cliches, a smart-mouthed therapist played by Nathan Lane, ends up getting short shrift after a promising build-up. As for Kilmer and Sorvino, suffice to say the sparks don't exactly fly between them. Speaking in a slowed-down, slightly thick voice, Kilmer gives a performance that seems technically accurate but strangely chilly, while the generally bubbly Sorvino seems to be trying to channel the spirit of Justine Bateman here; she's all goofy looks, curled lips and "ohmigod" flutteriness. Though the movie is not particularly insightful as either a medical drama or a love story, director Irwin Winkler knows how to make a pretty picture, and "Sight" even works in a couple of creative touches, such as a distorted, disorienting double-exposure technique used to express Virgil's first visions of the people around him. The soundtrack, featuring two scintillating new songs from jazz pianist Diana Krall and a host of standards, is also highly agreeable, even though the sluggish plot it accompanies could inspire most viewers to close their eyes for a long winter's nap. James Sanford
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


address: 75 9th Ave, New York, NY 10011
cost: Free Entry
address: 20 Hudson Yards, New York, NY 10001
cost: Free
address: New York, NY 10018
cost: Free
address: 334 Furman St, Brooklyn, NY 11201
cost: Free
address: 350 5th Ave, New York, NY 10118
cost: Prices Vary
address: 45 Rockefeller Plaza, New York, NY 10111
cost: Free
address:New York, NY
cost: Free
address: 820 Washington St New York, NY 10014
cost: Free
address: Governors Island, New York, NY 11231
cost: Free


are you...
Looking to Teach Looking to Code Representing a School
or, send us an email at {{site.email}}


GoTo index
Search for Covid Cases in UK by Month:
Choose Month :
all
Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
Sep
Oct
Nov
Dec
Choose Date :
Monthly Data
Daily Average
Search


SchemalessBehavior class
Located in /behaviors/schemaless.php (line 34)
ModelBehavior | --SchemalessBehavior
beforeSave method
Set the schema to allow saving whatever has been passed
setup method
Don't currently have any settings at all - disabled
Documentation generated on Tue, 26 Jul 2011 01:09:01 +0900 by phpDocumentor 1.4.3


Team TASEWA's Expense Tracker
Dashboard
Welcome, Percy!
Log Out
Current Income: $1000
Current Balance: $100
Current Expense: $900
User Profile
Income List
Expense List
View Graph


Paastor now supports simple MongoDB deployments. With a few clicks, you can have MongoDB running on any of your servers.
From the Server Manager, hit the MongoDB checkbox for one of your servers and fill out the required fields. Take note of any security information you set - it will not be saved by Paastor. In a few moments, it will be installed and you will be ready to connect.
Often people use MongoDB in a trusted environment and do not allow it to receive remote connections.
If you opt for remote access, be aware of how to connect, and that it may be slightly different than connecting to local or cloud based MongoDB services. This is because local and cloud systems shield you from some of the normal MongoDB administration, and create granular permissions at the database level.
Paastor creates an admin user which you can use to connect to any database, and create new users for those databases.
However, you must specify that you are connecting as an admin user. This is because MongoDB stores database permissions inside each database.
You must tell MongoDB that your authSource
is admin
.
var mongoose = require('mongoose');
var mongoUri = "mongodb://username:password@<IP_ADDRESS>:27017/somedatabase?authSource=admin";
mongoose.connect(mongoUri);
var mongoose = require('mongoose');
var mongoUri = "mongodb://username:password@<IP_ADDRESS>:27017/somedatabase";
var options = {
auth: { authSource: 'admin' }
};
mongoose.connect(mongoUri, options);
New databases are created immediately when you connect to them. There is no need to create one.


primary[R]
Object
Create a new set of connection pools.
The pool manager will by default use the original seed list passed to the connection objects, accessible via connection.seeds. In addition, the user may pass an additional list of seeds nodes discovered in real time. The union of these lists will be used when attempting to connect, with the newly-discovered nodes being used first.
# File lib/mongo/util/pool_manager.rb, line 17 def initialize(client, seeds=[]) @client = client @seeds = seeds @previously_connected = false end
We’re healthy if all members are pingable and if the view of the replica set returned by isMaster is equivalent to our view. If any of these isn’t the case, set @refresh_required to true, and return.
# File lib/mongo/util/pool_manager.rb, line 43 def check_connection_health begin seed = get_valid_seed_node rescue ConnectionFailure @refresh_required = true return end config = seed.config if config @refresh_required = true seed.close return end if config['hosts'].length != @members.length @refresh_required = true seed.close return end config['hosts'].each do |host| member = @members.detect do |m| m.address == host end if member && validate_existing_member(member) next else @refresh_required = true seed.close return false end end seed.close end
# File lib/mongo/util/pool_manager.rb, line 90 def close(opts={}) begin pools.each { |pool| pool.close(opts) } rescue ConnectionFailure end end
# File lib/mongo/util/pool_manager.rb, line 86 def closed? pools.all? { |pool| pool.closed? } end
# File lib/mongo/util/pool_manager.rb, line 27 def connect close if @previously_connected initialize_data members = connect_to_members initialize_pools(members) cache_discovered_seeds(members) @members = members @previously_connected = true end
# File lib/mongo/util/pool_manager.rb, line 23 def inspect "<Mongo::PoolManager:0x#{self.object_id.to_s(16)} @seeds=#{@seeds}>" end
# File lib/mongo/util/pool_manager.rb, line 121 def pools [@primary_pool, <EMAIL_ADDRESS>end
# File lib/mongo/util/pool_manager.rb, line 97 def read read_pool.host_port end
# File lib/mongo/util/pool_manager.rb, line 101 def<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>pinned = thread_local[:pinned_pools][self.object_id] if pinned && pinned.matches_mode(mode) && pinned.matches_tag_sets(tags) && pinned.up? pool = pinned else pool = select_pool(mode, tags, acceptable_latency) end unless pool raise ConnectionFailure, "No replica set member available for query " + "with read preference matching mode #{mode} and tags matching #{tags}." end pool end
Generated with the Darkfish Rdoc Generator 2.


This package adds collective parallel read and write capability to the R package ncdf4 version 1.8. Typical use is as a parallel NetCDF4 file reader in SPMD style programming. Each R process reads and writes its own data in a synchronized collective mode, resulting in faster parallel performance. Performance improvement is conditional on a parallel file system.
| Version: | 0.1-4 |
| Depends: | R (≥ 3.0.0) |
| Enhances: | pbdMPI |
| Published: | 2014-06-22 |
| Author: | Pragneshkumar Patel [aut, cre], George Ostrouchov [aut], Wei-Chen Chen [aut], Drew Schmidt [aut], David Pierce [aut] |
| Maintainer: | Pragneshkumar Patel <pragnesh at utk.edu> |
| BugReports: | http://group.r-pbd.org/ |
| License: | GPL (≥ 3) |
| Copyright: | Most files are originally designed by David Pierce under GPL (>= 3). |
| URL: | http://r-pbd.org/ |
| NeedsCompilation: | yes |
| SystemRequirements: | OpenMPI (>= 1.5.4) on Solaris, Linux and Mac. (Parallel) HDF5 and (Parallel) NetCDF4 (4.1 or later) libraries. No MPI library required on Windows. |
| Citation: | pbdNCDF4 citation info |
| Materials: | README ChangeLog INSTALL |
| In views: | HighPerformanceComputing, SpatioTemporal |
| CRAN checks: | pbdNCDF4 results |
| Reference manual: | pbdNCDF4.pdf |
| Vignettes: |
pbdNCDF4-guide |
| Package source: | pbdNCDF4_0.1-4.tar.gz |
| Windows binaries: | r-devel: pbdNCDF4_0.1-4.zip, r-release: pbdNCDF4_0.1-4.zip, r-oldrel: pbdNCDF4_0.1-4.zip |
| OS X binaries: | r-release: pbdNCDF4_0.1-4.tgz, r-oldrel: pbdNCDF4_0.1-4.tgz |
| Old sources: | pbdNCDF4 archive |
| Reverse enhances: | pbdDEMO |
Please use the canonical form https://CRAN.R-project.org/package=pbdNCDF4 to link to this page.


For the background of the comic strip I decided to use pictures of the pub I work in. These are the unedited images I will use to create the comic.
For the characters in the comic strip I decided to get a few of the regulars to pose and reenact the scene from the film. Here are the unedited images.


[name]
This class is used internally to convert from [page:Geometry] to [page:BufferGeometry].
Constructor
[name]()
This creates a new [name].
Properties
[property:Integer id]
Unique number for this [name] instance.
[property:String name]
Optional name. Default is the empty string.
[property:Array type]
String 'DirectGeometry'.
[property:Array indices]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array vertices]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array normals]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array colors]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array uvs]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array uvs2]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array groups]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array morphTargets]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array skinWeights]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Array skinIndices]
Initialiased as an empty array, this is populated by [page:.fromGeometry]().
[property:Box3 boundingBox]
Bounding box for the bufferGeometry, which can be calculated with
[page:.computeBoundingBox](). Default is *null*.
[property:Sphere boundingSphere]
Bounding sphere for the bufferGeometry, which can be calculated with
[page:.computeBoundingSphere](). Default is *null*.
[property:Boolean verticesNeedUpdate]
Default is false.
[property:Boolean normalsNeedUpdate]
Default is false.
[property:Boolean colorsNeedUpdate]
Default is false.
[property:Boolean uvsNeedUpdate]
Default is false.
[property:Boolean groupsNeedUpdate]
Default is false.
Methods
[page:EventDispatcher EventDispatcher] methods are available on this class.
[property:null computeBoundingBox]( )
See [page:Geometry.computeBoundingBox].
[property:null computeBoundingSphere]( )
See [page:Geometry.computeBoundingSphere].
[property:null computeGroups]( [page:Geometry geometry] )
Compute the parts of the geometry that have different materialIndex.
See [page:BufferGeometry.groups].
[method:null dispose]()
Disposes the object from memory.
You need to call this when you want the directGeometry removed while the application is running.
[property:null fromGeometry]( [page:Geometry geometry] )
Pass in a [page:Geometry] instance for conversion.
Source
[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]