Making audio complicated |
Introduction |
This chapter could be called "Advanced audio programming"
as well. However I'm trying to avoid advertising features described here
too much. These features are very useful or even necessary when used in
the right place. However they don't automatically make your application
better if used in situations when they are not necessary. Some of the features
to be presented below don't work with all devices (full
duplex audio and direct DMA access among
others) or make your application very operating system dependent (direct
DMA access).
It is assumed that you have perfect understanding about the features described in the introduction and basic audio sections of this guide. The features described here will work only if the guidelines defined in the basic sections have been followed carefully. |
Audio Internals |
Application program doesn't (normally) access audio hardware directly.
All data being recorded or played back is stored in a kernel DMA buffer
while the device is accessing it. The application uses normal read
and write calls to transfer data between the kernel buffer and
the buffer in the application's data segment.
The audio driver uses improved version of so called double buffering method. In the basic double buffering method there are two buffers. One of them is being accessed by the device while the other is being read or written by the application. When the device gets the first buffer processed, it moves to the other one. This process is repeated as long as the device is in use. This method gives the application time to do some processing at the same time when the device is running. This makes it possible to record and playback without pauses. The amount of time the application can spend on processing the buffer half depends on the buffer size and the data rate. For example when a program is recording audio using 8 kHz/8 bits/mono sampling, the data rate is 8 kilobytes/second. If there is 2*4 kbytes of buffer, it gives the application more than 0.5 seconds of time to store the data to disk and to come back to read from the device. If it spends more than 0.5 seconds, the buffer overruns and the driver has to discard some data. 0.5 seconds is pretty much of time to store 4 kbytes of data to disk. However things become more complicated when data rate is increased. For example with audio CD quality the data rate is 172 kilobytes/second the available time is just 23 milliseconds. It is about the same than worst case seek time of normal disk drives which means that recording is likely to fail. better results can be achieved by using larger buffers but it increases latencies related to the buffering. The method used by the audio driver of OSS could be called as multi-buffering. In this method the available buffer space is divided to several equally sized blocks which are called as fragments. In this way it is possible to increase available buffer size without increasing latencies related to the buffering. By default the driver computes the fragment size so that latencies are about 0.5 seconds (for output) or about 0.1 seconds (for input) using the current data rate. There is a ioctl call for adjusting the fragment size in case the application wants to use different size. [TODO: Insert an illustration here] Normal operation when writing to the deviceWhen the program calls write first time after opening the device, the driver performs the following steps:
When the application calls write second time, the data is simply stored to the playback buffer and internal pointers of the driver are updated accordingly. If the application has attempted to write more data than there is currently free space on the buffer, it will be forced to wait until one fragment gets completely played by the device. This is the normal situation with programs that work properly. They usually write data at least slightly faster than the device plays it. Sooner or later they get the buffer completely filled and the driver forces them to work at the same speed with the device. A playback underrun situation occurs when the application fails to write more data before the device gets earlier data completely played. This kind of underrun occurs if:
Normal operation when reading from the deviceWhen the program calls read first time after opening the device, the driver performs the following steps:
A recording overrun situation occurs if the device fills the recording buffer completely. If this happens, the device is stopped and further samples being recorded will be discarded. Reasons of recording overruns are very similar than causes of playback underruns. A very common situation where playback overrun may occur is recording of high speed audio directly to disk. In Linux this doesn't work except with very fast disk (in other environments this should not be a problem). |
Buffering - Improving real time performance |
Normally programs don't need to care about buffering parameters of
audio devices. However most of the features presented in this document
have been designed to work with full fragments. For this reason your program
may work better if it reads and writes data one buffer fragment at time
(please note that this is not normally required).
Determining buffering parametersThe driver computes the optimum fragment size automatically depending on sampling parameters (speed, bits and number of channels) and amount of available memory. Application may ask the buffer size by using the following ioctl call.int frag_size; if (ioctl(audio_fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) == -1) error();The fragment size in bytes is returned in the frag_size. The application may use this value as the size when allocating (malloc) buffer for audio data and the count when reading from or writing to the device. NOTE! This ioctl call also computes the fragment size in case it has not already been done. For this reason you should call it only after setting sampling parameters or setting fragment size explicitly. NOTE2! Some (old) audio applications written for Linux check that the returned fragment size is between arbitrary limits (this was necessary with version 0.1 of the driver). New applications should not make this kind of test. The above call returns the "static" fragment size. There are two additional calls which return information about the live situation. audio_buf_info info; ioctl(audio_fd, SNDCTL_DSP_GETISPACE, &info); ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info);The above calls return information about output and input buffering (respectively). The audio_buf_info record contains the following fields:
Number of full fragments that can be read or written without blocking. Note that this field is reliable only when the application reads/writes full fragments at time. Total number of fragments allocated for buffering. Size of a fragment in bytes. This is the same value than returned by ioctl(SNDCTL_DSP_GETBLKSIZE). Number of bytes that can be read or written immediately without blocking. Selecting buffering parametersIn some cases it may be desirable to select the fragment size explicitly. For example in real time applications (such as games) it is necessary to use relatively short fragments. Otherwise delays between events on the screen and their associated sound effects become too long. OSS API contains an ioctl call for setting the fragment size and maximum number of fragments.int arg = 0xMMMMSSSS; if (ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &arg)) error();Argument of this call is an integer encoded as 0xMMMMSSSS (in hex). The 16 least significant bits determine the fragment size. The size is 2SSSS. For example SSSS=0008 gives fragment size of 256 bytes (28). The minimum is 16 bytes (SSSS=4) and the maximum is total_buffer_size/2. Some devices or processor architectures may require larger fragments in this case the requested fragment size is automatically increased. The 16 most significant bits (MMMM) determine maximum number of fragments. By default the deriver computes this based on available buffer space. The minimum value is 2 and the maximum depends on the situation. Set MMMM=0x7fff if you don't want to limit the number of fragments. NOTE! This ioctl call must be used as early as possible. The optimum location is immediately after opening the device. It is NOT possible to change fragmenting parameters second time without closing and reopening the device. Also note that calling read(), write() or the above three ioctl calls "locks" the buffering parameters which may not be changed after that. NOTE2! Setting the fragment size and/or number of fragments too small may have unexpected results (at least in slow machines). UNIX is multitasking environment where other processes may use CPU time unexpectedly. The application must ensure that the selected fragmenting parameters provide enough "slack" so that other concurrently running processes don't cause underruns. Each underrun causes a click or pause to the output signal. With relatively short fragments this may cause whining sound which is very difficult to identify. Using fragment sizes shorter than 256 bytes is not recommended as the default mode of application. Short fragments should only be used when explicitly requested by user. Obtaining buffering information (pointers)In some cases it is necessary for application to know exactly how much data has been played or recorded. The OSS API provides two ioctl calls for these purposes. Information returned by these calls are not precise in all cases. Some sound devices use internal buffering which make the returned pointer value very imprecise. In addition some operating systems don't allow obtaining value of the actual DMA pointer. Using these calls in applications is likely to make it non-portable between operating systems and makes them incompatible with many popular devices (such as the "original" Gravis Ultrasound). Applications should use ioctl(SNDCTL_DSP_GETCAPS) to check device capabilities before using these calls.count_info info; ioctl(audio_fd, SNDCTL_DSP_GETIPTR, &info); ioctl(audio_fd, SNDCTL_DSP_GETOPTR, &info);These calls return information about recording and playback pointers (respectively). The count_info structure contains the following fields:
Number of bytes processed since opening the device. This field divided by the number of bytes/sample can be used as a precise timer. However underruns, overruns and calls to some ioctl calls (SNDCTL_DSP_RESET, SNDCTL_DSP_POST and SNDCTL_DSP_SYNC) decrease precision of the value. Also some operating systems don't permit reading value of the actual DMA pointer so in these cases the value is truncated to previous fragment boundary. Number of fragment transitions (hardware interrupts) processed since previous call to this ioctl (the value is reset to 0 after each call). This field is valid only when using direct access to audio buffer. This field is a byte offset of current playback/recording position from the beginning of audio buffer. This field has little value except when using direct access to audio buffer. Non-blocking reads and writesAll audio read and write calls are non-blocking as long as there is enough space/data in the buffer when the application makes the call.. The application may use SNDCTL_DSP_GETOSPACE and SNDCTL_DSP_GETISPACE to check device's status before making the call. The bytes field tells how many bytes can be read or written without blocking. It is highly recommended to read and write full fragments every time when using select. |
Using select() |
OSS driver supports standard select() system call. With audio
devices select returns 1 in the read or write descriptor bitmask
when it is possible to read or write at least one byte without blocking.
The application should SNDCTL_DSP_GETOSPACE
and SNDCTL_DSP_GETISPACE to
check the actual situation. Reading and writing full fragments at time
is recommended when select() is used.
Calling select() with the audio_fd bit set in the readfds parameter has an important side effect. This call starts recording immediately if it has not already started and recording is enabled. (Due to a bug in OSS versions earlier than 3.6 this may not work with all cards.) Some operating systems (such as Solaris) don't support select(). In these case the poll() system call can be used in place of select. |
Checking device capabilities |
There are some features in the OSS API that don't work with all devices
and/or operating systems. For this reason it is important to check that
the features are available before trying to use them. Effect of using features
not supported by current hardware/operating system combination is undefined.
It is possible to check availability of certain features by using the SNDCTL_DSP_GETCAPS ioctl as below: int caps; ioctl(audio_fd, SNDCTL_DSP_GETCAPS, &caps);This call returns a bitmask defining the available features. The possible bits are:
|
Synchronization issues |
In some applications it is necessary to synchronize audio playback/recording
with screen updates, MIDI playback or some other "external" events.
This section describes some ways how it is possible to implement this kind
of features. When using the features described in this section it is very
important to access the device by writing and reading full fragments at
time. Using partial fragments is possible but it may introduce problems
which are very difficult to handle.
There are several different reasons for using synchronization:
Avoiding blocking in audio operationsThe recommended method for implementing non-blocking reads or writes is to use select(). Further instructions for using this method has been given above.Synchronizing external events with audioWhen there is need to get audio recording and playback to work in sync with screen updates, it is easier play audio at it is own speed and to synchronize screen updates with it. To do this, you can use the SNDCTL_DSP_GETxPTR calls to obtain the number of bytes that have been processed since opening the device. Then divide the bytes field returned by the call by number of bytes per sample (for example 4 in 16bits stereo mode). To get the number of milliseconds since start you need to multiply the sample count by 1000 and to divide this by the sampling rate.In this way you can use normal UNIX alarm timers or select()to control the interval between screen updates while still being able to obtain exact "audio" time. Note that any kind of performance problems (playback underruns and recording overruns) disturb audio timing and decrease it is precision. Synchronizing audio with external eventsIn games and some other real time applications there is need to keep sound effects playing at the same time with the game events. For example sound of an explosion should be played exactly at the time (or slightly later) with the flash on the screen.The recommended method to be used in this case is to decrease the fragment size and maximum number of fragments used with the device. In most cases this kind of applications work best with just 2 or 3 fragments. A suitable fragment size can be determined by dividing the byte rate of audio playback by number of frames/second to be displayed by the game. It is recommended to avoid too tight timing since otherwise random performance problems may degrade audio output seriously. Another way to synchronize audio playback with other events is to use direct access to audio device buffer. However this way is not recommended since it is not possible with all devices and operating systems. When using the methods described above, there may be need to start playback and/or recording precisely at the right time (this should be somehow rare requirement). This is possible by using the trigger feature described below. Synchronizing recording and playback togetherIn full duplex applications it may be necessary to keep audio playback and recording synchronized together. For example it may be necessary to play back earlier recorded material at the same time when recording new audio tracks. Note that this kind of applications are possible only with devices supporting full duplex operation or by using two separate audio devices together. In the second case it is important that both devices support precisely the sampling rate to be used (otherwise synchronization is not possible). Use the trigger feature when you need this kind of synchronization.Implementing real time effect processors and other odditiesTerm "real time" means here an application which records audio data, performs some kind of processing on it and outputs it immediately without practically any delays. Unfortunately this kind of applications are not possible using UNIX like multitasking operating system and general purpose computer hardware. There is always some delay between recording a sample and before it is available for processing by the application (the same is true with playback too). In addition multitasking overhead (other simultaneously running processes) cause unexpected pauses in operation of the application itself. Normally this kind of operations are done with dedicated hardware with system software designed for this kind of use.It is possible to decrease the delay between input and output by decreasing the fragment size. In theory the fragment size can be as short as 16 bytes with a fast machine. However in practice it is difficult to get fragment sizes shorter than 128 to 256 bytes to work. Using direct access to the hardware level audio buffer may provide better results in systems where this feature works. If you still want to implement this kind of application, you should use short fragments together with select(). The shortest fragment size that works depends on situation and the only way to find it out is making some experiments. And (of cause) you should use a device with full duplex capability or two separate devices together. Starting audio playback and/or recording with precise timingThe SNDCTL_DSP_SETTRIGGER ioctl call has been designed to be used in applications which require starting recording and/or playback with precise timing. Before you use this ioctl, you should check that DSP_CAP_TRIGGER feature is supported by the device. Trying to use this ioctl with a device not supporting it will give undefined results.This ioctl accepts an integer parameter where two bits are used to enable and disable playback, recording or both. The PCM_ENABLE_INPUT bit controls recording and PCM_ENABLE_OUTPUT controls playback. These bits can be used together provided that the device supports full duplex and the device has been opened for O_RDWR access. In other cases the application should use only one of these bits without reopening the device. The driver maintains these bits for each audio device (supporting this feature). Initially (after open) these bits are set to 1 which makes the device to work normally. Before the application can use the trigger ioctl to start device operations, the bit to be used should be set to 0. To do this you can use the following code. It is important to note that this can be done only immediately after opening the device (before writing to or reading from it). It is currently NOT possible to stop or restart a device that has already been active without first reopening the device file. int enable_bits = ~PCM_ENABLE_OUTPUT; /* This disables playback */ ioctl(audiofd, SNDCTL_DSP_SETTRIGGER, &enable_bits);After the above call writes to the device dont start the actual device operation. The application can fill the audio buffer by outputting data using write(). Write will return -1 with errno set to EAGAIN if the application tries to write when the buffer is full. This permits preloading the buffer with output data in advance. Calling read()when PCM_ENABLE_INPUT is not set will always return EAGAIN. To actually activate the operation, call SNDCTL_DSP_TRIGGER with the appropriate bits set. This will start the enabled operations immediately (provided that there is already data in the output buffer). It is also possible to leave one of the directions disabled while starting the another one. Starting audio recording or playback in sync with /dev/sequencer or /dev/musicIn some cases it is necessary to synchronize playback of audio sequences with MIDI output (this is possible with recording too). To do this you need to suspend the device before writing to or reading from it. This can be done by calling ioctl(audiofd, SNDCTL_DSP_SETSYNCRO, 0). After this the device works just like when both the recording and the playback trigger bits (see above) have been set to 0. The difference is that it is not possible to reactivate the device without using features of /dev/sequencer or /dev/music (SEQ_PLAYAUDIO event). |
Full duplex mode |
Full duplex means audio devices capability to do input and output
in parallel.
Most audio devices are half duplex which means that they support both recording and playback but cant do them simultaneously due to hardware level limitations (some devices can't do recording at all). In this cases it is very difficult to implement applications which do both recording and playback. It is recommended that the device is reopened when switching between recording and playback. It is possible to get full duplex features by using two separate devices. In context of OSS this is not called full duplex but simultaneous use of two devices. Full duplex does _NOT_ mean that the same device can be used twice. With current OSS it is not possible to open device that is already open. This feature can possibly be implemented in future versions. In this kind of situations you will need to use two separate devices. Some applications require full duplex operation. It is important that such applications verify that full duplex is possible (using DSP_CAP_DUPLEX) before trying to use the device. Otherwise behaviour of the application will be unpredictable. Application should switch the full duplex feature on immediately after opening the device using ioctl(audiofd, SNDCTL_DSP_SETDUPLEX, 0). This call switches the device to full duplex mode and makes the driver to be prepared for full duplex access. This must be done before checking the DSP_CAP_DUPLEX bit since otherwise the driver may report that the device doesn't support full duplex. Using full duplex is simple in theory. The application just:
|
Accessing DMA buffer directly |
In some (rather rare) cases it is possible to map audio device's hardware
level buffer area into the address space of an application. This method
is very operating system dependent and it is currently available only in
Linux. To for more info about this method (in Linux) you should look at
a demonstration
program provided by 4Front Technologies.
The direct mapping method is possible only with devices that have a hardware level buffer which is directly accessible from host CPU's address space (for example a DMA buffer or a shared memory area). The basic idea is simple. The application uses an operating system dependent method to map the input or the output buffer into it is own virtual address space. In case of full duplex devices, there are two separate buffers (one for input and one for output). After that it triggers the desired transfer operation(s). After that the buffer will be continuously accessed by the hardware until the device is closed. The application can access the buffer area(s) using pointers but normal read() and write() calls can no longer be used. The buffer area is continuously scanned by the hardware. When the pointer reaches the end of the buffer, the pointer is moved back to the beginning. The application can read and write the data using the SNDCTL_DSP_GETxPTR calls. The bytes field tells how many bytes the device has processed since beginning. The ptr field gives an offset relative from the beginning of the buffer. This pointer must be aligned to nearest sample boundary before accessing the buffer using it. The pointer returned by this call is not absolutely precise due to possible delays in executing the ioctl call and possible FIFOs inside the hardware device itself. For this reason the application should assume that the actual pointer is few samples ahead the returned value. When using direct access the blocks field returned by the SNDCTL_DSP_GETxPTR calls has special meaning. The value returned in this field is number of fragments that have been processed since previous call to the same ioctl (the counter is cleared after the call). Also select() works in special way with mapped access. Select returns a bit in the readfds or writefds parameter after each interrupt generated by the device. This happens when the pointer moves from a buffer fragment to another. However the application should check the actual pointer very carefully. It is possible that the select call returns relatively long time after the interrupt. It is even possible that another interrupts occur before the application gets control again. Note that the playback buffer is never cleaned by the driver. If the application stops updating the buffer, its present contents will be played in loop again and again. Sufficient play-ahead is recommended since otherwise the device may play uninitialized (old) samples if there are any performance problems. No software based sample format conversions are performed by the driver. For this reason the application must use a sample format that is directly supported by the driver. |


Functions to handle the keyboard
◆ kbc_ih()
- Keyboard interrupt handler: collects information from keyboard
◆ keyb_subscribe_int()
| int keyb_subscribe_int |
( |
uint8_t * |
bit_no | ) |
|
Subscribe keyboard interruptions.
- Parameters
-
| bit_no | - address of memory to be initialized with the bit number to be set in the mask returned upon an interrupt |
- Returns
- int - Return 0 upon success and non-zero otherwise
◆ keyboard_unsubscribe_int()
| int keyboard_unsubscribe_int |
( |
| ) |
|
Unsubscribe keyboard interruptions.
- Returns
- int - Return 0 upon success and non-zero otherwise


Contact Us
If you have questions or feedback about NCL, we'd love to hear from you!
Phone :
+65 6601 1056
Address:
13 COMPUTING DRIVE, COM1 #01-16 Singapore 117417
Email:


§431:10C-307 Reimbursement of duplicate benefits. Whenever any person effects a tort liability recovery for accidental harm, whether by suit or settlement, which duplicates personal injury protection benefits already paid under the provisions of this article, the motor vehicle insurer shall be reimbursed fifty per cent of the personal injury protection benefits paid to or on behalf of the person receiving the duplicate benefits up to the maximum limit. [L 1987, c 347, pt of §2; am L 1989, c 83, §1; am L 1997, c 251, §44; am L 1998, c 275, §24]
Case Notes
Cited: 73 H. 403, 833 P.2d 890.
Discussed: 76 H. 304, 875 P.2d 921.


In this exercise you have a function that accepts 2 parameters an array and a number (n), the function should return the n element of the array, if there is no n element in the array the function should return the sentence "Array doesn't have n (this should be the value of n) element"


OpenReplica provides easily launch for concoord on remote machines, and it is especially built to launch concoord instances on Amazon EC2 servers easily. In this section we cover how you can setup a set of machines and launch concoord remotely using OpenReplica.
You can easily launch your EC2 instances using the web interface provided by Amazon AWS. In this example we launch an instance running 64-bit Amazon Linux. Before you launch your instance, you will have to create a keypair to login to your instances, make sure to keep your private key safe. The best way is to move your key-pair to the .ssh directory once you download the [my-key-pair].pem file:
$ mv [my-key-pair].pem ~/.ssh/
$ ssh-add ~/.ssh/[my-key-pair].pem
Once you did these, now is the time to connect to your instance:
$ ssh -i [my-key-pair].pem ec2-user@[public_dns_name]
After this point on, you should be able to connect to your instance without explicitly passing the key as a parameter, as follows:
$ ssh ec2-user@[public_dns_name]
To enable execution of remote sudo commands SSH into your instance and run:
$ sudo visudo
In the file that opens find the line Defaults requiretty and add line Defaults:ec2-user !requiretty below it. Save the file and exit. The file opens with the vi editor. If you are not familiar with vi commands, to insert new text press i to go into insert mode and add the new line. After you are done, press ESC and ZZ to save and exit.
At this point, your EC2 instance should be easily accessible.
Using OpenReplica developers can configure and remotely launch ConCoord instances on remote machines easily. Firstly, OpenReplica keeps the configuration information of machines that will be running the ConCoord instance. Secondly, using ConCoord developers can easily start replica and nameserver nodes on the machines that are added to the configuration. And lastly, using OpenReplica developers can easily manage EC2 instances.
Like ConCoord, OpenReplica can be used as a commandline script. It supports the following commands:
openreplica config - prints config file openreplica addsshkey [sshkeyfilename] - adds sshkey filename to config openreplica addusername [ssh username] - adds ssh username to config openreplica addnode [publicdns] - adds public dns for node to config openreplica setup [publicdns] - downloads and sets up concoord on the given node openreplica replica [concoord arguments] - starts a replica node on EC2 openreplica nameserver [concoord arguments] - starts a nameserver node on EC2
To use OpenReplica, you should first register the nodes you want to use. To register nodes, you will need the filename of the sshkey you use to ssh into these nodes, as well as the username.
To add the sshkey:
$ openreplica addsshkey [my-key-pair].pem
To add the username:
$ openreplica addusername ec2-user
To add a node:
$ openreplica addnode [public_dns_name]
When adding nodes to OpenReplica, it automatically checks the nodes for eligibility to run ConCoord and warns the user if an update or change is required. Similarly, if ConCoord cannot connect to the node, it lets the user know.
$ openreplica addsshkey concoord.pem
Adding SSHKEY to CONFIG: concoord.pem
$ openreplica addusername ec2-user
Adding USERNAME to CONFIG: ec2-user
$ openreplica addnode ec2-54-186-26-155.us-west-2.compute.amazonaws.com
Adding NODE to CONFIG: ec2-54-186-26-155.us-west-2.compute.amazonaws.com
Cannot connect to node, check if it is up and running.
Once OpenReplica is set up, nodes can be started as if they are being started on the local machine.
To start a bootstrap replica node that doesn’t need to be connected to another replica:
$ openreplica replica -o concoord.object.counter.Counter -a <IP_ADDRESS> -p 14000
To start replica nodes to join an active ConCoord instance:
$ openreplica replica -o concoord.object.counter.Counter -b <IP_ADDRESS>:14000 -a <IP_ADDRESS> -p 14001
The nodes can also be run in the debug mode or with a logger with the commands shown below:
Usage: openreplica replica [-h] [-a ADDR] [-p PORT] [-b BOOTSTRAP] [-o OBJECTNAME] [-l LOGGER] [-n DOMAIN] [-r] [-w] [-d]
-h, --help show this help message and exit
-a ADDR, --addr ADDR address for the node
-p PORT, --port PORT port for the node
-b BOOTSTRAP, --boot BOOTSTRAP address:port tuple for the bootstrap peer
-o OBJECTNAME, --objectname OBJECTNAME client object dotted name
-l LOGGER, --logger LOGGER logger address
-n DOMAIN, --domainname DOMAIN domain name that the name server will accept queries for
-r, --route53 use Route53
-w, --writetodisk writing to disk on/off
-d, --debug debug on/off
You can dynamically locate nodes in a given ConCoord instance using DNS queries if the instance includes replicas that can act as name servers. There are two ways you can run a ConCoord Replica as a name server.
To use a replica node as a master name server first you have to setup the name server delegations (you can do this by updating the domain name server information of any domain name you own from the domain registrar you use (godaddy, namecheap etc.)). Once all the delegations are setup for the ip address the replica uses, you can start a replica node as a name server for counterdomain.com as follows:
$ openreplica replica -o concoord.object.counter.Counter -a <IP_ADDRESS> -n counterdomain.com
And to start the replica to join an already running ConCoord instance, provide the bootstrap:
$ openreplica replica -o concoord.object.counter.Counter -a <IP_ADDRESS> -b <IP_ADDRESS>:14000 -n counterdomain.com
When the replica starts running, you can send queries for counterdomain.com and see the most current set of nodes as follows:
$ dig -t a counterdomain.com # returns set of Replicas
$ dig -t srv _concoord._tcp.counterdomain.com # returns set of Replicas with ports
$ dig -t txt counterdomain.com # returns set of all nodes
$ dig -t ns counterdomain.com # returns set of name servers
First make sure that boto is installed on the machine you want to run the Route53 name server. OpenReplica tries to do this automatically when a replica is run as a Route53 name server, but if it fails to do so, you can easily install boto on the machine you want as follows:
$ pip install boto
Before starting a name server connected to Amazon Route53, you should have a Route53 account set up and ready to receive requests. This is done through the AWS Console (http://console.aws.amazon.com/route53), by creating a new Hosted Zone to host your domain name.
After your Route53 account is set up, the name server can update Route53 records every time the view of the system changes.
To use the Name Server to update Amazon Route53, you should provide your AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY. You can retrieve these from the AWS Console (http://console.aws.amazon.com/iam/), by looking under the security credentials of the username that you used while creating the Hosted Zone for your domain name. Once you have the information, you can set up Route53 configuration easily as follows:
$ openreplica route53 [public_dns AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY]
Once you make sure that your Route53 account is set up and the configuration file includes your AWS credentials, you can start the replica with a name server as follows:
$ openreplica replica -o concoord.object.counter.Counter -n counterdomain.com -r
When the replica starts running, you can send queries for counterdomain.com and see the most current set of nodes as follows:
$ dig -t a counterdomain.com # returns set of Replicas
$ dig -t srv _concoord._tcp.counterdomain.com # returns set of Replicas with ports
$ dig -t txt counterdomain.com # returns set of all nodes
$ dig -t ns counterdomain.com # returns set of name servers


new RequestAnimationFrame(game, forceSetTimeOut) Abstracts away the use of RAF or setTimeOut for the core game update loop. Parameters: Name Type Argument Default Description game Phaser.Game A reference to the currently running game. forceSetTimeOut boolean <optional> false Tell Phaser to use setTimeOut even if raf is available. Source - system/RequestAnimationFrame.js, line 15 Members forceSetTimeOut :boolean Tell Phaser to use setTimeOut even if raf is available. Source - system/RequestAnimationFrame.js, line 33 game :Phaser.Game The currently running game. Source - system/RequestAnimationFrame.js, line 22 isRunning :boolean true if RequestAnimationFrame is running, otherwise false. Source - system/RequestAnimationFrame.js, line 28 Methods isRAF() ? {boolean} Is the browser using requestAnimationFrame? Returns: boolean - Source - system/RequestAnimationFrame.js, line 162 isSetTimeOut() ? {boolean} Is the browser using setTimeout? Returns: boolean - Source - system/RequestAnimationFrame.js, line 153 start() Starts the requestAnimationFrame running or setTimeout if unavailable in browser Source - system/RequestAnimationFrame.js, line 70 stop() Stops the requestAnimationFrame from running. Source - system/RequestAnimationFrame.js, line 134 updateRAF() The update method for the requestAnimationFrame Source - system/RequestAnimationFrame.js, line 103 updateSetTimeout() The update method for the setTimeout. Source - system/RequestAnimationFrame.js, line 119


A self-motivated IT professional with a master's degree in computer engineering with a twelve-year career in Information Technology as analyst, project, team manager and programmer. Recently having experience in programming using JavaScript, React, Node.js and Express.
View ResumeResponsible for creating and designing the back-end for the website in Node.js based on the requirements of the business owner.
This project was created in Javascript with Node.js using Express and EJS. Authentication is done by passport. Users are saved to mongoDB in Atlas with mongoose.
This project was created in Javascript with Node.js using Express and EJS. Posts are saved to mongoDB in Atlas with mongoose.
This project was created in Javascript with Node.js using Express and EJS. Tasks are saved to mongoDB in Atlas with mongoose.
The aim of this project is to download pictures through the NASA open API. It was created in Javascript with Node.js using Express and EJS.
The goal of this project is to search articles through the NY TIMES public API. User is able to search in the article database with one or more search keywords. The result set can be narrowed down with defining a time interval of the creaton of the given article. It was created in Javascript with Node.js using Express and EJS.


Auth0 is a great authentication-as-a-service platform for free!
auth: {
strategies: {
auth0: {
domain: 'domain.auth0.com',
client_id: '....',
audience: 'https://my-api-domain.com/'
}
}
}
Anywhere in your application logic:
User will be redirected to a page like this:
💁 This provider is based on oauth2 scheme and supports all scheme options.
client_id
, domain
, and
audience
client_id
and domain
are
REQUIRED. Your application needs some details about this
client to communicate with Auth0.
audience
is required unless you’ve explicitly set a
default audience
on your Auth0 tenent.
You can get your client_id
and domain
the
Settings section for your client in the
Auth0 API dashboard.
Your audience is defined on your
client’s API.
Auth0 tenants created in 2018 and earlier had an optional tenant setting
Enable Seamless SSO
. This setting is automatically enabled
for new tenants and cannot be disabled.
If enabled and a user logs out and logs back in a short while later, they will not need to re-enter their credentials. They’ll be logged in automatically.
You can force Auth0 to present the login page:
Tenant Settings
> Advanced
Allowed Logout URLs
enter the allowed URL(s) you can
redirect to, such as http://localhost:3000
Wherever you have a logout feature do two things:
returnTo
parameter
https://mytenant.auth0.com/v2/logout?returnTo=http%3A%2F%2Flocalhost:3000


Launch Cloudify on AWS
Edit (pull request)THIS SECTION IS BEING WRITTEN AND IS NOT YET COMPLETED.
In this first going further tutorial we will explain how you can bootstrap an open-source TOSCA orchestrator that is a bit more heavy than Puccini and that we currently recommend for production environments. This orchestrator is cloudify.
Some features that are not yet supported by puccini are supported in Cloudify so this will probably be your choice for more advanced scenarios with alien4cloud. But first of all let’s look how to bootstrap it.
Bootstraping cloudify
To bootstrap cloudify on Amazon we will actually leverage puccini as it provides support for every features requested to actually launch a TOSCA recipe that describe a cloudify orchestrator.
Security groups configuration
As a pre-requisite we will configure Security Groups for our cloudify manager so he can communicate with it’s other components.
- cfy_manager_agents: Security group to open the ports on the manager machine so agents can communicate to it.
| Type | Protocol | Port Range | Source |
|---|---|---|---|
| Custom TCP Rule | TCP | 53229 | cfy_agents |
| Custom TCP Rule | TCP | 53333 | cfy_agents |
| Custom TCP Rule | TCP | 5671 | cfy_agents |
| Custom TCP Rule | TCP | 8101 | cfy_agents |
- cfy_agents: Security group to use on every agent machine so the manager can communicate with the agent machine.
| Type | Protocol | Port Range | Source |
|---|---|---|---|
| SSH | TCP | 22 | cfy_manager_agents |
| WinRM-HTTPS | TCP | 5986 | cfy_manager_agents |
- cfy_manager_ssl_client: Security group so that clients can access the cloudify manager on ssl (we will configure a secured manager)
| Type | Protocol | Port Range | Source |
|---|---|---|---|
| SSH | TCP | 22 | <IP_ADDRESS>/0 |
| HTTPS | TCP | 443 | <IP_ADDRESS>/0 |
- cfy_manager_cluster: Security group to cluster the cloudify manager
| Type | Protocol | Port Range | Source |
|---|---|---|---|
| Custom TCP Rule | TCP | 8300 | <IP_ADDRESS>/0 |
| Custom TCP Rule | TCP | 15432 | <IP_ADDRESS>/0 |
| Custom TCP Rule | TCP | 2.1.0 | <IP_ADDRESS>/0 |
| Custom UDP Rule | UDP | 8301 | <IP_ADDRESS>/0 |
| Custom TCP Rule | TCP | 8301 | <IP_ADDRESS>/0 |
| Custom TCP Rule | TCP | 8500 | <IP_ADDRESS>/0 |
Configure puccini to deploy on aws
In the basic getting started we auto-configured a local docker location for you so you can match compute nodes on local docker containers. We want to deploy the cloudify manager on Amazon, in order to do so we will go to the admin section and configure a puccini location. But first there is a configuration file to manually edit in order to configure aws support in puccini.
Go to the alien4cloud-getstarted/puccini-cli-{version}/conf/providers/aws/default folder and copy the provider.conf.tpl file to provider.conf then edit the file to fill in your access_key_id, access_key_secret and region.
In alien4cloud ui got to , then . You should see the list of orchestrators with a single Puccini simple orchestrator orchestrator, select it. Go to and then click on .
Click on to open the on demand resources configuration tab and drag-and-drop a org.alien4cloud.puccini.aws.nodes.Instance to the left section.
The cloudify types requires a red hat or centos host, in order to allow puccini deploy on these OS you need to configure a cloud init to remove the requiretty option. These option was added in red hat operating system for Security reasons, has been recognized as inefficient and is removed from latests version. It prevent non-interactive ssh connections as the puccini orchestrator is doing.
Edit the user_data field that will setup the VM cloud init using the following code:
#cloud-config
runcmd:
- echo 'Defaults:ec2-user !requiretty' > /etc/sudoers.d/999-puccini-cloud-init-requiretty
Import cloudify TOSCA types
You have learned in the getting started how to import archives from git so import the cloudify types archive from: * https://github.com/alien4cloud/samples/tree/master/cloudify-types
Configure your topology
Drag and drop a Compute node, dra


WITNESS LIST Pensions & Investments Committee February 29, 2000-10:00A ERS Overview and Interim Charges On: Beckett, Sheila (Employees Retirement System) Interim Charges On: Raab, Ted Melina (Texas State Employees Union) PRB Overview and Interim Charges On: Goralski, Craig (State Pension Review Board) Shivers, Shari (State Pension Review Board) SSB Overview and Interim Charges On: Crawford, Denise Voigt (State Securities Board) TRS Overview and Interim Charges On: Dunlap, Charles (Teacher Retirement System)


SHADOW MAGIC
Reviewed by Harvey Karten Sony Pictures Classics Director: Ann Hu Writer: Ann Hu, Huang Dan, Tang Louyi, Kate Raisz, Bob McAndrew Cast: Jared Harris, Xia Yu, Xing Yufei, Liu Peiqi, Li Yusheng
When I was a kid, the first time I heard the juke box in the local coffee house, some song or other of Frank Sinatra's was on. Sinatra sounded happy, so I told my mom to ask the owner to unlock the back of the machine so that I could see the guy who sounded so good. The owner smiled as though he heard the request a hundred times before, and opened the back of the unit. I looked in and was depressed for days. Despite the shattering of my illusions, when I saw my first movie--I think it starred either Lassie or Rin Tin Tin, can't recall--I was sure that the characters were acting out their little story behind the big white screen--didn't you? I never did get to look there but had to take my dad's word that I would only get depressed once again.
So there...those experiences were not for nought because as I watched the charming Chinese movie (which won their equivalent of the Oscar for best picture), "Shadow Magic," I could appreciate the fascination that the people of that Asian nation felt in 1902 when they heard a phonograph for the first time, the year the events of the story took place. And when I watched the absolutely astounded faces on these simultaneously bemused and amused folks in the makeshift theater in what was then called Peking, my mind wandered back to those happy days of my childhood when everything in the world was new, fresh, exciting.
"Shadow Magic" is the creation of Ann Hu, who was allowed to leave mainland China after the so-called Cultural Revolution, came to the U.S. in 1979 for her Business Administration degree from NYU, was a success trading commodities and used the capital she acquired to finance films. (She is currently working on "Red Guards," a doc about the Cultural Revolution with interviews never before seen in the West.)
"Shadow Magic" takes as its implicit theme the idea that while East is East and West is West, the twain can sometimes meet--if the players in the human drama have enough patience to work out particular differences in their traditions. The movie is beautifully photographed, emphasizing a rich array of costumes, courtesy of the well- stocked Beijing Film Studio. The story deals with several conflicts: the traditions of the East vs. the technology of the West; the clash between believers of arranged marriages and those who prefer to choose their own life's partners; the competition between individuals whose prestige and income come from years of pleasing their audience and others whose prestige and income depend on the success of new forms of diversion. The romantic tension is intriguing; the partnership between a bright and therefore erratic worker and a disappointed British expatriate promotes hope in today's troubled times.
The central character, Liu (Xia Yu), works for a photographer's studio under the proprietorship of Master Ren (Liu Peiqi), but has no rigid regard for the state of current technology.  "Not refined like our own music," sniffs Lord Tan (Li Yusheng), who has a large following for his brilliantly-costumed performances in Chinese opera but who is evidently threatened by all new technology. Liu, concerned about criticism but not ready to give up his tinkering, has a thing for Tan's attractive daughter, Ling (Xing Yufei), but Liu's dad wants him to hitch up with a rich widow--who looks like the usual older-woman butt of Gilbert and Sullivan's satires. When the unhappily divorced Raymond Wallace (Jared Harris) arrives in Peking hoping to make it big financially with his motion picture projector (which no one in China had ever seen before)-- presuming a large audience would pay to see his shadow magic on the screen of a makeshift movie house--he and Liu hit it off, form a partnership, and fight the Luddites who want to kick them both out of their lives.
While the two entrepreneurs struggle to attract an audience propagandized against purported Western cultural imperialism, they effect changes on each other. Wallace nudges his Asian pal to go for it, to make a big play for the woman of his dreams and to shuck off the old ways years before a revolution against the Manchu Dynasty would free him and millions of others from pigtails and bound feet. For his part, Liu makes a human being out of a westerner whose failed marriage has made him hard and cynical and sometimes inebriated.
The most amusing scene during the two hours of stunning cinematography--which embraces a most enjoyable history lesson--occurs when a fairly large group of Chinese witness their first film, a silent, of course, given riotous dimensions when two of the stand-up comedians who have been photographed by Liu and Wallace get up from their seats in the audience and fill in the dialogue that they had pursued while before the lens. I like the way Wallace seduced the attention of the would-be actors by telling one of them that one hundred years from now, he would appear before an audience (in 2002) without having aged a day although he would be 170 years old. Now, why couldn't he have seduced Lord Tan in a similar way, but saying that the movies would expose his operative talents to the whole nation if not the world?
The pace is brisk, the acting convincing, and here's one movie written by five scripters that doesn't look as though it were written by a committee. When Wallace looks at the Great Wall (which can be seen and walked, I believe, just 20 miles outside Beijing) and tells the folks that they don't need to keep invaders out but should be welcoming new ideas in, you can't help thinking of the nut cases of the world today like the Taliban who are threatened by big stone statues that are alien to their belief. All in all, a thrilling experience, a history lesson for those who don't like history as well as those who are intrigued by the past.
Rated PG. Running time: 119 minutes. (C) 2001 by Harvey Karten<EMAIL_ADDRESS>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


Migrating to 1.1
ColorPickerConfiguration
A variety of configuration options have been added, configured on a new ColorPickerConfiguration
class.
Code that looks like this:
let colorPicker = ColorPickerViewController()
colorPicker.color = UIColor(red: 1, green: 0, blue: 1, alpha: 0)
present(colorPicker, animated: true, completion: nil)
Should now become:
let configuration = ColorPickerConfiguration(color: UIColor(red: 1, green: 0, blue: 1, alpha: 0))
// Do any other configuration you want here…
let colorPicker = ColorPickerViewController(configuration: configuration)
present(colorPicker, animated: true, completion: nil)
Delegate changes
ColorPickerDelegate.colorPicker(_:didSelect:)
is now fired with every change made within the color picker interface. Ensure any work done in this method does not assume the value is the user’s final selection. You might use this to update your user interface based on the current selection. If there is nothing useful you can do to improve the user experience, don’t implement this method.
The new ColorPickerDelegate.colorPicker(_:didAccept:)
method is now used to signal the user dismissing the color picker with a positive response, by tapping the Done button or dismissing the popover.
For compatibility, if the color is set via the deprecated ColorPickerViewController.color
API, the delegate behaves as it did in Alderis 1.0.
Popover style
Alderis now uses popovers, providing a more integrated interface design on iPad and Mac Catalyst. In order to support this, some popover presentation parameters must be set. If they are not set, UIKit throws an exception on presenting the view controller.
For example:
@IBAction func presentColorPicker(_ sender: UIView) {
let configuration = ColorPickerConfiguration(color: UIColor(red: 1, green: 0, blue: 1, alpha: 0))
let colorPicker = ColorPickerViewController(configuration: configuration)
colorPicker.popoverPresentationController?.sourceView = sender
present(colorPicker, animated: true, completion: nil)
}


How to open multple items from match list at once
-
anonymous
Once I hit c-t to open a selected file. it closes the match list and switches to the buffer. Fuzzy...But how I open multiple files at once from the match list?
-
Greg Hurrell
There isn't any way to do this currently. It would have to be added as a feature.
I made a ticket for it (issue #1945).
Reply
This topic is now closed.


Hello World!
Here are some routes below for you to explore.
Multiply
Static Text
Dynamic Text
Json Dictionary
Json Dictionary for display


|
UMI3D Unity SDK
2.5.b.221125
A UMI3D sdk implementation using Unity
|
Environment representation of a binding, linking two objects. More...
Public Member Functions | |
| UMI3DBinding () | |
| UMI3DBinding (UMI3DBinding b) | |
| Bytable | ToByte (UMI3DUser user) |
| BoneBindingDto | ToDto (UMI3DUser user) |
| bool | IsCountable () |
| Could the number of elements be deduced from a size parameter? More... | |
| Bytable | ToBytableArray (params object[] parameters) |
| Convert the parameters to an array of Bytable. More... | |
Public Attributes | |
| uint | boneType |
| UMI3D bone type in BoneType More... | |
| bool | isBinded = true |
| bool | syncPosition = true |
| bool | syncRotation = true |
| bool | freezeWorldScale = true |
| UMI3DAbstractNode | node |
| string | rigName = "" |
| Vector3 | offsetPosition = Vector3.zero |
| Quaternion | offsetRotation = Quaternion.identity |
| Vector3 | offsetScale = Vector3.zero |
Environment representation of a binding, linking two objects.
| umi3d.edk.userCapture.UMI3DBinding.UMI3DBinding | ( | ) |
| umi3d.edk.userCapture.UMI3DBinding.UMI3DBinding | ( | UMI3DBinding | b | ) |
| BoneBindingDto umi3d.edk.userCapture.UMI3DBinding.ToDto | ( | UMI3DUser | user | ) |
| uint umi3d.edk.userCapture.UMI3DBinding.boneType |
UMI3D bone type in BoneType
| bool umi3d.edk.userCapture.UMI3DBinding.freezeWorldScale = true |
| bool umi3d.edk.userCapture.UMI3DBinding.isBinded = true |
| UMI3DAbstractNode umi3d.edk.userCapture.UMI3DBinding.node |
| Vector3 umi3d.edk.userCapture.UMI3DBinding.offsetPosition = Vector3.zero |
| Quaternion umi3d.edk.userCapture.UMI3DBinding.offsetRotation = Quaternion.identity |
| Vector3 umi3d.edk.userCapture.UMI3DBinding.offsetScale = Vector3.zero |
| string umi3d.edk.userCapture.UMI3DBinding.rigName = "" |
| bool umi3d.edk.userCapture.UMI3DBinding.syncPosition = true |
| bool umi3d.edk.userCapture.UMI3DBinding.syncRotation = true |


Fast Infoset ProjectPart of Project GlassFish in the JWSDP subcommunity |
Welcome to the Fast Infoset Project, an Open Source implementation of the Fast Infoset Standard for Binary XML.
Fast Infoset specifies a standardized binary encoding for the XML Information Set. An XML infoset (such as a DOM tree, StAX events or SAX events in programmatic representations) may be serialized to an XML 1.x document or, as specified by the Fast Infoset standard, may be serialized to a fast infoset document. Fast infoset documents are generally smaller in size and faster to parse and serialize than equivalent XML documents.
Further information on Fast Infoset and this implementation may be found in the following sub-sections and links:
Features. Fast Infoset has many features that have been detailed in the XTech 2005 conference paper and presentation. The How to use section explains how to take advantage of some of these features;
Performance reports using Japex;
Testing (TODO).
Tasks to be considered.
The various parsers and serializers are considered robust and pass tests performed using a data consisting of a wide range of XML infosets.
There is a basic implementation of Fast Infoset for J2ME, called FIME, in the SVN repository. This requires work to improve the implementation and provide a friendly build environment with regular builds and distributions available for download. Help wanted!
If you want to get involved in the development of this project or just want to use the implementation then add yourself as an observer to this project and subscribe to the users list, where general questions about Fast Infoset can be asked and discussed. Adding yourself to the annouce list is suitable if you just want to get updates on the project.
For development add yourself to the dev list, where development questions and ideas can be discussed and agreed. Looking at the archives is useful to see what needs to be done and what is in progress.
The FI code is made available under the terms of the Apache Source License, version 2.0 (ASL 2.0). ASL is a widely accepted and very flexible license; version 2.0 adds explicit terms to cover the conditions for accepting contributions, reflecting experience gathered with the previous versions of the ASL. There is a single copyright owner, Sun Microsystems; multiple copyright owners can lead to very complicated legal situations.
The project has two main goals: encourage adoption of the FI standards and deliver an implementation that can be used directly in production quality form by Sun's products. We will do our outmost to balance both goals. Obviously, the more help we get from the wider community, the more easily we can achieve both goals.


| Category name | Accuracy | Sample training images | Sample true positives | False positives with true label | False negatives with wrong predicted label | ||||
|---|---|---|---|---|---|---|---|---|---|
| Kitchen | 0.560 | Street |
InsideCity |
InsideCity |
Bedroom |
||||
| Store | 0.650 | Industrial |
Kitchen |
Mountain |
InsideCity |
||||
| Bedroom | 0.420 | Office |
Kitchen |
Office |
LivingRoom |
||||
| LivingRoom | 0.580 | Bedroom |
Suburb |
Bedroom |
Store |
||||
| Office | 0.960 | LivingRoom |
LivingRoom |
LivingRoom |
LivingRoom |
||||
| Industrial | 0.660 | Kitchen |
Bedroom |
Kitchen |
InsideCity |
||||
| Suburb | 0.950 | InsideCity |
InsideCity |
LivingRoom |
InsideCity |
||||
| InsideCity | 0.710 | Highway |
Industrial |
TallBuilding |
Suburb |
||||
| TallBuilding | 0.700 | InsideCity |
Store |
Store |
LivingRoom |
||||
| Street | 0.860 | TallBuilding |
TallBuilding |
Bedroom |
InsideCity |
||||
| Highway | 0.730 | Street |
OpenCountry |
OpenCountry |
TallBuilding |
||||
| OpenCountry | 0.610 | InsideCity |
Coast |
Forest |
Bedroom |
||||
| Coast | 0.900 | Highway |
Industrial |
Mountain |
OpenCountry |
||||
| Mountain | 0.860 | Store |
Industrial |
Forest |
Forest |
||||
| Forest | 0.950 | OpenCountry |
Highway |
Mountain |
Suburb |
||||
| Category name | Accuracy | Sample training images | Sample true positives | False positives with true label | False negatives with wrong predicted label |


dataView data empty
mobi:dataViewColumn data empty test
ReactivePriority is not functional or included in the tlddoc at this time. ICE-9893 is open.
Goto Main page


--- layout: page title: About Us subtitle: And our robot friends ---
Behind every good robot is a better team. Uppercut is being built by a dedicated group of students and alumni from MIT with help from the Combat Robotics club. Our members have built everything from 1lb featherweight robots to 250lb monsters.
Alex is a mechanical engineer in his senior year. When he isn't leading the team or working on robotic actuators, he's winning yoyo competitions and abusing our local CNC mill.
Mason is a mechanical engineer in his junior year. His spare time is mostly dedicated to building silly vehicles, using a MIG as a hot glue gun, and screaming at Alex.
Jackson is a sophmore from Arizona that is enthusiastic about power electronics, electric motors, and controls.
Sofia is a freshman studying mechanical engineering. She likes robots, photography, and dancing to Latin music.
Jared likes working on silly projects, like robot arms, gameboy emulators, and electric vehicles. He is a senior and is studying electrical engineering and computer science.
Amy is a junior at MIT studying mechanical engineering. She likes Cane's sweet iced tea, the color black, and reading biographies.
Sarah is a senior studying Electrical Engineering and Computer Science with a focus on embedded systems. She really likes her motorcycle, but can also be found working on silly electric vehicles and robots.
Dev is a junior on exchange at MIT from Imperial College London studying AeroAstro.
Chetan enjoys building useless machines and finding increasingly creative ways of injuring himself.


for(E c : E.values()) System.out.println(c);
for(E c : E.values()) System.out.println(c);
Returns: | an array containing the constants of this enum type, in the order they're declared |
Inferred annotations: | @org.jetbrains.annotations.Contract(value = " -> new", pure = true) |


OOMK ZINE
2013 - Current
OOMK Zine is a publication about women, art and activism, the first issue was published in 2013 by Sofia Niazi, Sabba Khan and Rose Nordin. Printed biannually, its content pivots upon the imaginations, creativity and spirituality of women. Each issue centers around a different creative theme, with more general content exploring topics of faith, activism and identity.
The Library Was
OOMK (2016)
Published by Book Works
The Library Was sees OOMK reimagining the function, aesthetic and user culture of the library. Opening in an austerity-stricken future in which all public libraries have closed, it goes on to assert the continued importance of libraries via interviews with London-based library enthusiasts, a profile of the revolutionary Cuban librarian Marta Terry González, a re-assessment of The Five Laws of Library Science, 1931, as they do and don't apply to the collection of contemporary zines, and an account of the stolen library of the late Saudi novelist Abd al-Rahman Munif. It also documents the publications donated to the Open School East Library during OOMK‘s Future Library Fair held in December 2015, and describes the work of a semi-fictional group of readers and activists, who have pooled their resources to establish The Library of Aimless Yet Meaningful Pursuit, a space for meeting and learning outside of the algorithmic ‘Grid’.
TA Study of Publishing Practices in Malaysia:
KL, Penang and Ipoh
Published by OOMK (2016)
In summer 2016 we teamed up with Kuala Lumpur based Odd One Out Magazine to research independent publishing practices in Malaysia. We met many artists, magazine makers and galleries at the forefront of self publishing in KL, Ipoh and Penang to get a better understanding of self publishing practices outside of London. We've spent the last few months transcribing the interviews, scanning the publications we collected and putting together a petty unique publication about our research. Supported by Arts Council England and the British Council.


Airstrikes kill 5 in northwest rebel-held Syrian village
by The Associated PressBEIRUT — Syrian opposition activists say airstrikes on a rebel-held village in the country’s northwest killed five people.
The Syrian Civil Defence and the Britain-based Syrian Observatory for Human Rights said three women were among the victims.
Sunday’s airstrike hit the village of Mallaja in Idlib province, the last major rebel stronghold in Syria.
Last week, Syrian President Bashar Assad said his forces will soon retake Idlib.
Assad said in an interview that they are now giving civilians some time to leave the area, which is dominated by al-Qaida-linked militants.
Syrian troops launched a four-month offensive on the province earlier this year, forcing hundreds of thousands of civilians to flee their homes.
A fragile cease-fire stopped the government offensive on Idlib at the end of August.
The Associated Press


Explore the JWQL API
What is the JWQL API?
An Application Programming Interface (API) accepts requests for services from a system, gathers the items in the request, and returns a response to the user. A
popular example used to describe the
functionality of an API is describing the role of a waiter in a restaurant. When you enter a restaurant and sit at your table, you are typically
provided a menu containing all of the drink and food options. But how do you communicate your food and drink order to
the kitchen staff? This is where the waiter (API) comes in, you provide the waiter with your order (request), they will communicate
your order to the kitchen staff (system), and bring your food and drinks when they are prepared (the response). The waiter (API) disguises
all of the steps that are necessary to getting your final product delivered (cooking the food, counting stock, knowing recipes, etc.) but, is the
link to the user and the response they wish to obtain from a system.
JWQL allows users to access some JWST proposal and filename information through our web-based API. Note that JWQL does
not have a programmatic API due to security concerns and the authorization layer between the app and the outside world. The services listed
below will return lists of proposal numbers or filenames in json format when the appropriate URL is entered into the browser.
List of Available Services
- All Proposals (
https://jwql.stsci.edu/api/proposals/
) - Instrument Proposals (
https://jwql.stsci.edu/api/<instrument>/proposals/
) - Filenames by Proposal (
https://jwql.stsci.edu/api/<proposal>/filenames/
) - Preview Images by Proposal (
https://jwql.stsci.edu/api/<proposal>/preview_images/
) - Thumbnails by Proposal (
https://jwql.stsci.edu/api/<proposal>/thumbnails/
) - Filenames by Rootname (
https://jwql.stsci.edu/api/<rootname>/filenames/
) - Preview Images by Rootname (
https://jwql.stsci.edu/api/<rootname>/preview_images/
) - Thumbnails by Rootname (
https://jwql.stsci.edu/api/<rootname>/thumbnails/
) - Look Status by Instrument (
https://jwql.stsci.edu/api/<instrument>/looks/
) - Viewed Data by Instrument (
https://jwql.stsci.edu/api/<instrument>/looks/viewed/
) - New Data by Instrument (
https://jwql.stsci.edu/api/<instrument>/looks/new/
)
where <instrument>, <rootname>, <proposal>
are the values for the instrument name, rootname and proposal ID respectively.


{% load i18n %}
{% blocktrans trimmed with docs_link="https://docs.readthedocs.io/page/versions.html#version-states" %} Learn more about states here. {% endblocktrans %}


Sanket Thakur
PhD student at
PAVIS, IIT
home
blogs
contact
pap series
My Thoughts
Articles I've written.
My experience as a ML fellow for fellowship.ai
Dec 26, 2020


{% extends "base.html" %} {% block header %}
Crate is a distributed database that allows you to create a flexible and scalable backend suited to a wide variety of purposes.
Here you can find all the tools and resources you need to develop scalable {{ name }} applications with a Crate backend.
Crate is 100% open source.
Crate is a powerful, complete backend solution for tabular data, semi-structured records, and binary objects (BLOBs).
Crate is highly available and offers massively parallel access in real-time, enabling sub-second responses on billions of records.
Adding nodes on commodity hardware or in the cloud is as simple as a single command in your terminal.
“{{ testimonial_quote }}”
| {{ post.title }} |
Read more on our blog!
| {{ post.title }} |
Meet us at other upcoming events!
{% else %}| {{ event.title|title }} |
Meet us at other upcoming events!
{% endif %}Start using Crate with your application now!
Any questions? Feel free to get in touch with us!


A simple Python S3 upload library. Inspired by one of my favorite packages, requests.
tinys3 is used at Smore to upload more than 1.5 million keys to S3 every month.
Usage example:
import tinys3 conn = tinys3.Connection(S3_ACCESS_KEY, S3_SECRET_KEY, tls=True, endpoint='s3-eu-west-1.amazonaws.com') f = open('some_file.zip','rb') conn.upload('some_file.zip',f,'my_bucket')
$ pip install tinys3
Or if you're using easy_install:
$ easy_install tinys3
Uploading a single file:
import tinys3 # Creating a simple connection conn = tinys3.Connection(S3_ACCESS_KEY,S3_SECRET_KEY) # Uploading a single file f = open('some_file.zip,'rb') conn.upload('some_file.zip',f,'my_bucket')
Some more options for the connection:
# Specifying a default bucket conn = tinys3.Connection(S3_ACCESS_KEY,S3_SECRET_KEY,default_bucket='my_bucket') # So we could skip the bucket parameter on every request f = open('some_file.zip','rb') conn.upload('some_file.zip',f) # Controlling the use of TLS conn = tinys3.Connection(S3_ACCESS_KEY,S3_SECRET_KEY,tls=True)
Specifying a different endpoint
conn = tinys3.Connection(S3_ACCESS_KEY,S3_SECRET_KEY,endpoint='s3-website-us-west-2.amazonaws.com')
Setting expiry headers.
# File will be stored in cache for one hour conn.upload('my_awesome_key.zip',f,bucket='sample_bucket', expires=3600) # Passing 'max' as the value to 'expires' will make it cachable for a year conn.upload('my_awesome_key.zip',f,bucket='sample_bucket', expires='max') # Expires can also handle timedelta object >from datetime >import timedelta t = timedelta(weeks=5) # File will be stored in cache for 5 weeks conn.upload('my_awesome_key.zip',f,bucket='sample_bucket', expires=t)
tinys3 will try to guess the content type from the key (using the mimetypes package), but you can override it:
conn.upload('my_awesome_key.zip',f,bucket='sample_bucket', content_type='application/zip')
Setting additional headers is also possible by passing a dict to the headers argument:
conn.upload('my_awesome_key.zip',f,bucket='sample_bucket', headers={ 'x-amz-storage-class': 'REDUCED_REDUNDANCY' })
For more information, see Amazon's S3 Documentation
Use the 'copy' method to copy a key or update metadata.
# Simple copy between two buckets conn.copy('source_key.jpg','source_bucket','target_key.jpg','target_bucket') # No need to specify the target bucket if we're copying inside the same bucket conn.copy('source_key.jpg','source_bucket','target_key.jpg') # We could also update the metadata of the target file conn.copy('source_key.jpg','source_bucket','target_key.jpg','target_bucket', metadata={ 'x-amz-storage-class': 'REDUCED_REDUNDANCY'}) # Or set the target file as private conn.copy('source_key.jpg','source_bucket','target_key.jpg','target_bucket', public=False)
# Updating metadata for a key conn.update_metadata('key.jpg',{ 'x-amz-storage-class': 'REDUCED_REDUNDANCY'},'my_bucket') # We can also change the privacy of a file, without updating it's metadata conn.update_metadata('key.jpg',bucket='my_bucket',public=False)
# Deleting keys is simple conn.delete('key.jpg','my_bucket')
tinys3 will try to use lxml if it's available, otherwise it will fallback to xml python module (slower and not secure against maliciously constructed data)
# This will return an iterator over the metadata of the files starting with 'prefix' in 'my_bucket' # The iterator will yield dicts with the following keys: key, etag, size, last_modified, storage_class conn.list('prefix', 'my_bucket')
Creating a pool:
pool = tinys3.Pool(S3_ACCESS_KEY,S3_SECRET_KEY)
The pool can use the same parameters as Connection:
pool = tinys3.Pool(S3_ACCESS_KEY,S3_SECRET_KEY,tls=True, default_bucket='my_bucket')
The pool uses 5 worker threads by default. The 'size' parameter allows us to override it:
pool = tinys3.Pool(S3_ACCESS_KEY,S3_SECRET_KEY,size=25)
Using the pool to perform actions:
# Let's use the pool to delete a file r = pool.delete('a_key_to_delete.zip','my_bucket') Future at 0x2c8de48L state=pending # Futures are the standard python implementation of the promise pattern # You can read more about them here: # http://docs.python.org/3.3/library/concurrent.futures.html#future-objects # Did we finish? r.done() False # Block until the response is completed r.result() Response [200] # Block until completed with a timeout # If the response is not completed until the timeout has passed, a TimeoutError will be raised r.result(timeout=120) Response [200]
Using as_completed and all_completed
# First we'll create a lot of async requests requests = [] for i in range(100) requests.append(pool.delete('key' + str(i), 'my_bucket')) # The helper methods as_completed and all_completed helps us work # with multiple Future objects # This will block until all the requests are completed # The results are the responses themselves, without the Future wrappers pool.all_completed(requests) [Response [200], ... ] # The as_completed generator will yield on every completed request. for r in pool.as_completed(requests) # r is the response object itself, without the Future wrapper print r
Happy coding!


1.2. Quick Start¶
Examples come with the pyslgr installation. If you used the Anaconda install option, you will find the example script in the following directory:
slgr_cython/example_<some_example>.py
If you installed from file, the example script can be found at:
examples/example_<some_example>.py
To see the example simply run:
python example_<some_example>.py
The following sections walk you through the examples using the python interpreter.
1.2.1. example_signal¶
Open the python interpreter and import the following:
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from pyslgr.LLSignal import LLSignal
To create an instance of LLSignal
>>> sig = LLSignal()
We can read the a test signal from file. Pyslgr has a few example signals already built in, we will use one of these.
>>> sig.load_pcm_wav('../slgr_test/test/dlpt-ara-D4m-RZ.wav')
We will visualize the signal in the time domain. We will calculate and display the first 10 seconds.
>>> seconds = 10
>>> sf = sig.sampling_frequency()
>>> z = range(0, seconds*int(sf))
>>> t = (1.0/sf)*np.array(z)
>>> plt.plot(t, sig[0:len(z)])
>>> plt.xlabel("Time in seconds")
>>> plt.show()
The signal looks like this:
To get the pitch of the signal, use f0_get(min_f0,max_f0,window_dur,frame_step)
>>> f0 = sig.get_f0(100,650,0.010,0.005)
>>> f0[0][130:135]
array([196,29374695,<PHONE_NUMBER>4,<PHONE_NUMBER>5,<PHONE_NUMBER>7,<PHONE_NUMBER>7])
Signals can be sliced using the same syntax as numpy. For instance, sig[0:10] returns the first 10 samples of the signal
>>> sig[0:10]
Using negative indices will give the last n values of the signal
>>> sig[-1]
returns the last value in sig.
Slices [m:n] where m >= n will return empty arrays. To test this, try
>>> sig[3:1]
>>> sig[3:3]
For a slice [m:n] where n > sig.length(), clipping will occur and only m:sig.length() is returned
>>> sig[-1:sig.length()+10]
array([72.])
>>> sig[-1]
72.0
Strides and reversals are also possible. sig[20::3] returns every 3rd element starting with the 20th element. sig[10:-2] returns every second element starting at the 10th element as indices decrease.
Using slices, we can plot portions of the signal. Here we look at 5 seconds of the signal from 3 seconds to 8 seconds.
>>> min_seconds = 3
>>> max_seconds = 8
>>> z = range(min_seconds*int(sf), max_seconds*int(sf))
>>> t = (1.0/sf)*np.array(z)
>>> plt.plot(t, sig[min_seconds*int(sf):max_seconds*int(sf)])
>>> plt.xlabel("Time in seconds")
>>> plt.show()
To check the frequency at which the signal was sampled, use the following
>>> sig.sampling_frequency()
16000.0
We can downsample by resampling
>>> sig.resample_8k()
>>> sig.sampling_frequency()
8000.0
>>> sig.save_pcm_wav(<filename>)
There also several options for pre-processing the data, including mean removal, amplitude normalization, and preemphasis.
>>> sig.remove_mean()
>>> sig.normalize()
>>> sig.preemphasize(0.97)
1.2.2. example_mfcc¶
Note
We will use the LLSignal class in this example. To familiarize yourself with this class, please see example_signal.
Note
MFCCFeatures extends LLFeatures
To begin we will want to import the relevent modules:
>>> import json
>>> from pyslgr.LLSignal import LLSignal
>>> from pyslgr.MFCCFeatures import MFCCFeatures
Processing the signal in order to obtain mel-frequency cepstral coefficient (MFCC) features, requires a config file (in json format). We will load in the default feature config file and make modifications. Then we will restore it for use.
We begin by loading the config file.
>>> fp = open('../config/lid_config.json','r')
>>> c = json.load(fp)
>>> fp.close()
For the purpose of this example we will set fb_only to true. To see all the config options, see process()
fb_only produces the ‘raw’ filter bank outputs instead of producing cepstral coefficients.
>>> feat_config = c['lid_config']['feat_config']
>>> feat_config['fb_only'] = 'true'
Now we save this a new config file.
>>> mfcc_config = json.dumps(feat_config)
To check whether our change took effect,
>>> print 'MFCC features configuration: {}'.format(mfcc_config)
MFCC features configuration: {"fb_only": "true", "fb_hi": "3140", "win_inc_ms": "10", "linear": "false", "feat_type": "mfcc", "fb_low": "300", "win_len_ms": "20", "alpha": "1", "num_cep": "6", "keep_c0": "true", "dither": "1"}
And, indeed fb_only has been set to true. We can also review the other configuration settings.
We now load in the sample signal just as in example_signal.
>>> fn = '../slgr_test/test/dlpt-ara-D4m-RZ.wav'
>>> sig = LLSignal()
>>> sig.load_pcm_wav(fn)
To get features, we make an instance of the MFCCFeatures class and call process()
>>> feats = MFCCFeatures()
>>> feats.process(sig, mfcc_config)
To get features...
>>> feats = MFCCFeatures()
>>> feats.process(sig, mfcc_config)
>>> feats.delta(2)
>>> feats.accel(2)
See MFCC Features for more information on the delta() and accel().
You can also try out the various slicing and indexing operations.
Note
Single vectors are printed to console as a list of entries read from left to right. Multiple vectorss are printed to console as columns, each column represents a vector.
Here are some examples:
>>> feats[0] #gets the first vector
>>> feats[-1] #gets the last vector
>>> feats[0:3] #gets vectors 0 through 3
>>> feats[-3:-1] #gets third to last vector through last vector
>>> feats[0:5:2] #gets vectors 0,2,4
>>> feats[1:1] #produces an empty array
1.2.3. example_lid_gmm¶
To begin this example, we will want to import all the relevant modules
>>> from pyslgr.LLSignal import LLSignal
>>> from pyslgr.MFCCFeatures import MFCCFeatures
>>> from pyslgr.GMMModel import GMMModel
>>> import json
>>> import os
>>> import operator
Now we would like to load our example signal.
>>> sig = LLSignal()
>>> sig.load_pcm_wav('../slgr_test/test/dlpt-ara-D4m-RZ.wav')
As in example_mfcc, we need to set up the config file for our MFCC features.
>>> slgr_config_fn = '../config/lid_config.json'
>>> fp = open(slgr_config_fn,'r')
>>> c = json.load(fp)
>>> fp.close()
>>> mfcc_config = json.dumps(c['lid_config']['feat_config'])
For this example, we will also need models. These models can be found in the /nmec/slgr/model directory
>>> model_dir = '../model'
>>> model_names = sorted(c['lid_config']['models'].values())
We initialize the MFCC features as in example_mfcc. For more details on how to use the set_outfeat function, see .
>>> feat = MFCCFeatures()
>>> feat.process(sig, mfcc_config)
>>> feat.rasta()
>>> feat.delta2point(1)
>>> feat.sdc(3,7)
>>> feat.xtalk(-10.0,5.0)
>>> feat.apply_sad()
>>> feat.feat_norm()
>>> feat.set_outfeat('fs')
Now we will create the GMM model object.
>>> g_ubm = GMMModel()
>>> g_ubm.load(os.path.join(model_dir,"language", "sbkg.o1024-sdc-rasta-fn-fnap.mod"))
To get models for all available languages.
>>> g_langs = []
>>> for i in xrange(0, len(model_names)):
g_langs.append(GMMModel())
g_langs[i].load(os.path.join(model_dir, model_names[i]))
To get the scores:
>>> allScores = g_ubm.score_models(feat, g_langs, 5, True, 10.0)
>>> modelScores = allScores.scores
>>> scores_out = []
>>> for i in xrange(0,modelScores.size,2):
scores_out.append((model_names[i], modelScores[i+1]-modelScores[i]))
>>> scores_out = sorted(scores_out, key=operator.itemgetter(1))
>>> print 'scores: {}'.format(scores_out)
>>> print "UBM score =", allScores.ubm_score
UBM score = -71.553314209


Are you sure you want to delete this comment ?
If you delete it, it will no longer be wisplayed on the website. This action is irreversible
{% include("header.html") %} {% include("js/check_comment.html") %}
{{ i.comment }}
There is no comment for this section


| ic-action |
This attribute allows you to make client-side modifications (e.g. element removal) to the DOM without
a server request. |
| ic-add-class |
This attribute allows you to add one or many classes to an element after a specified time delay. |
| ic-append-from |
When triggered this attribute will issue a GET and append all content returned to the
children of the element it is on. |
| ic-attr-src |
Like ic-style-src , this attribute allows you bind to a URL. However, this attribute binds
an attribute value to a URL. The syntax is "attribute:url". For
example,
to bind the style of an element to "/style/random", you would say
ic-attr-src="style:/style/random" |
| ic-confirm |
This attribute can be used to confirm an action with a user before proceeding. |
| ic-delete-from |
This attribute allows you to bind the "action" of an element to a given URL. Once it is bound, when an
"action" occurs (e.g. clicking a button) Intercooler will issue
a DELETE to the URL and replace the element with the new content.
Intercooler will detect any other elements that the DELETE effects and automatically refresh them.
|
| ic-deps |
This attribute allows you to express additional path dependencies for a given element, beyond the
implied ones. |
| ic-get-from |
This attribute allows you to bind the "action" of an element to a given URL. Once it is bound, when an
"action" occurs (e.g. clicking a button) Intercooler will issue
a GET to the URL and replace the element with the new content.
|
| ic-global-include |
This attribute can be used to add data to all requests made by Intercooler |
| ic-include |
A selector attribute that can be used to include additional input with an action request (e.g. can be
used to include a form with an unrelated button.) |
| ic-indicator |
This attribute can be used to show a progress indicator while an Intercooler AJAX request is in flight. |
| ic-limit-children |
Limits the number of children that an element is allowed to have after an ic-prepend-from or
ic-append-from fires. |
| ic-local-vars |
A comma separated list of variables from localStorage to include intercooler requests. |
| ic-on-beforeSend |
This attribute allows a script to be evaluated during the beforeSend stage of AJAX requests
made on behalf of Intercooler. |
| ic-on-beforeTrigger |
This attribute allows a script to be evaluated before a trigger is processed. |
| ic-on-complete |
This attribute allows a script to be evaluated after any AJAX requests
made on behalf of Intercooler. |
| ic-on-error |
This attribute allows a script to be evaluated after unsuccessful AJAX requests
made on behalf of Intercooler. |
| ic-on-success |
This attribute allows a script to be evaluated after successful AJAX requests
made on behalf of Intercooler. |
| ic-patch-to |
This attribute allows you to bind the "action" of an element to a given URL. Once it is bound, when an
"action" occurs (e.g. clicking a button) Intercooler will issue
a PATCH to the URL and replace the element with the new content.
Intercooler will detect any other elements that the PATCH effects and automatically refresh them.
|
| ic-pause-polling |
If true then an ic-poll attribute will not start polling. This can be
used to implement a Pause/Play UX. |
| ic-poll |
This attribute tells Intercooler to poll the source URL for the element it is on in a given interval,
expressed as milliseconds or seconds. (e.g. '500ms' or '2s') |
| ic-poll-repeats |
This attribute limit the number of polling calls (e.g. '5') |
| ic-post-errors-to |
Allows you to specify a URL to post javascript errors to that occur when intercooler is making requests
and swapping content. |
| ic-post-to |
This attribute allows you to bind the "action" of an element to a given URL. Once it is bound, when an
"action" occurs (e.g. clicking a button) Intercooler will issue
a POST to the URL and replace the element with the new content.
Intercooler will detect any other elements that the POST effects and automatically refresh them.
|
| ic-prepend-from |
When triggered this attribute will issue a GET and prepend all content returned to the
children of the element it is on. |
| ic-prompt |
This attribute allows you to prompt the user before intercooler issues a request. |
| ic-push-url |
This attribute tells Intercooler to update the current location with the target URL of the element
after a successful AJAX request, with history support. |
| ic-put-to |
This attribute allows you to bind the "action" of an element to a given URL. Once it is bound, when an
"action" occurs (e.g. clicking a button) Intercooler will issue
a PUT to the URL and replace the element with the new content.
Intercooler will detect any other elements that the PUT effects and automatically refresh them.
|
| ic-remove-after |
This attribute tells Intercooler to remove the element it is on after the given amount of time has elapsed. |
| ic-remove-class |
This attribute allows you to remove one or many classes to an element after a specified time delay. |
| ic-replace-target |
If this attribute is set to "true", the target element of the intercooler request will be replaced
entirely with the server response, rather than replacing the inner HTML of the element. This is useful
in cases where you cannot wrap an element around a potential target easily, like table rows. |
| ic-scroll-offset |
An offset in pixels to adjust the scroll position when using the ic-scroll-to-target attribute |
| ic-scroll-to-target |
An offset in pixels to adjust the scroll position when using the ic-scroll-to-target attribute |
| ic-select-from-response |
This attribute tells Intercooler to filter the servers response to content matching the
given CSS selector. This can be useful for making a full HTML response act like a partial response. |
| ic-src |
This attribute allows you to bind an element to a given URL. Once it is bound, when a change occurs that
Intercooler recognizes as affecting the URL (or given an event such as a poll), Intercooler will issue
a GET to the URL and replace the element with the new content.
|
| ic-sse-src |
This attribute allows you to bind an element to a given Server Sent Event endpoint and update the
elements content or trigger Server Sent events on child elements. |
| ic-style-src |
Like ic-src , this attribute allows you bind to a URL. However, this attribute binds a
style attribute to a URL. The syntax is "style-attribute:url". For
example,
to bind the color of an element to "/color/random", you would say
ic-style-src="color:/color/random" |
| ic-swap-style |
Allows you to specify the swap mechanism that intercooler will use with content received from the
server |
| ic-target |
This attribute is often used with an action attribute (e.g. ic-post-to ) in order to target
the content of another element for replacement. |
| ic-transition-duration |
An amount of time to wait between starting a transition and executing a content swap. |
| ic-trigger-delay |
This attributes delays the execution of a trigger and, if the trigger occurs again within the
given interval, cancels the original trigger in favor of the new one, which will begin waiting
for the interval again. |
| ic-trigger-from |
This attribute can be used to listen for events on other elements in the DOM, or the document
or window. |
| ic-trigger-on |
This attributes changes the event on which the element is loaded via ic-src . It can be
used to implement lazy loading of images or charts, infinite scrolling, etc. |
| ic-verb |
This attribute allows you to override the HTTP verb to use in a request. |


The Worlds Rising retrospective series continues, as pros reflect on how Season 3 Worlds brought with it a changing of the guard and a coming-of-age for the esport. Learn more.
Grab your double Doran’s Blades and enter our pumpkin carving contest! Learn more.
To commemorate all the epic moments of this season, we’re releasing Championship Shyvana along with the 2014 Championship Ward and Icon from now through October 31. Learn more.
Pros reflect on the big changes ushered in by Season 2. Learn more.
The TL;DR for those of you who just want to get back into game: we’re making some changes to Refer-a-Friend in the upcoming weeks to combat abuses like botting and fraud. Learn more.
Dunkmaster Darius doesn’t play the game, he is the game. Learn more.
Wanna know more about League of Legend? Click Here.


3. Built in directives
3.2. Event based directives
Output on console
Events
ng-click
ng-dblclick
ng-mousedown
ng-mouseenter
ng-mouseleave
ng-mousemove
ng-mouseover
ng-mouseup
{{keyCode}}
{{keyCode}}
{{keyCode}}
ng-change
ng-submit


- Basics
- Stack: Array Implementation
- Stack: Linked List Implementation
- Queues: Array Implementation
- Queues: Linked List Implementation
- Lists: Array Implementation (available in java version)
- Lists: Linked List Implementation (available in java version)
- Indexing
- Binary Search Trees
- AVL Trees (Balanced binary search trees)
- Red-Black Trees
- Splay Trees
- Open Hash Tables (Closed Addressing)
- Closed Hash Tables (Open Addressing)
- Closed Hash Tables, using buckets
- B Trees
- B+ Trees
- Sorting
- Comparison Sorting
- Bubble Sort
- Selection Sort
- Insertion Sort
- Shell Sort
- Merge Sort
- Quck Sort
- Bucket Sort
- Counting Sort
- Radix Sort
- Heap-like Data Structures
- Graph Algorithms
- Breadth-First Search
- Depth-First Search
- Connected Components
- Dijkstra's Shortest Path
- Prim's Minimum Cost Spanning Tree
- Topological Sort (Using Indegree array)
- Topological Sort (Using DFS)
- Floyd-Warshall (all pairs shortest paths)
- Kruskal Minimum Cost Spanning Tree Algorithm
- Dynamic Programming
- Calculating nth Fibonacci number (available in java version)
- Others ...
- Disjoint Sets
- Huffman Coding (available in java version)


VR Tests
BIM - Toy Houses
House walkthrough
RVT House
Factory (2M)
BakedLighting-house
Skyscraper
Manufacturing
Oblivion Copter
Shaver
Toy Plane
Catepillar
Drone
Bosche Saw
Manufacturing - High Poly count
Lego-Animation
Toy Car
turbofan (5.6M)
Rover (2.7M)
Vertical Up issue
BIM - Navis190M
Fusion - Rally Car


We extend mices!
- scale bricks-and-clicks bandwidth
- streamline web-enabled platforms
- redefine collaborative web-readiness
- recontextualize impactful interfaces
- utilize viral architectures
- seize proactive infomediaries
- deliver open-source e-markets
- visualize visionary methodologies


Uncategorized
Bringing you the latest pop culture, entertainment and music news. It's all for the love of music.
Entertainment
_
Remember when Drake was just a disabled ex-basketball star attending a fictional Canadian high school? Nobody would ever have guessed that he would eventually become one of the most beloved and successful icons.
From barely scraping by to getting into bar fights with Chris Brown over Rhianna, the rollercoaster ride that is Drake’s life has taken many twists and turns in a relatively short period of time. We’ve examined Drake’s life and found some little-known facts about what has happened to him on his way to becoming the pinnacle of artistry within his genre of music.
Drake isn’t the only famous musician in his family. Keep reading to learn more.
The True Identity of Drake
Photo Credits: champagnepapi/Instagram
Most people know him as “Jimmy” from Degrassi or “Drake” from his music career. However, he was born Aubrey Drake Graham on October 24, 1986, Ontario, Canada. In order to still keep part of his given name for his music career, he decided to use his middle name for his musical identity.
His father is an African American from Memphis, Tennessee and his mother is a Jewish Canadian. As a boy, he attended a Jewish day school and even had a Bar Mitzvah ceremony. He also holds dual citizenship to both the United States and Canada.
Music Runs in his Family
Photo Credits: David Livingston/Getty Images
If you thought that Drake was the only successful musician in the family, you’d be sadly mistaken. Music was a big part of Drake’s upbringing with his father Dennis Graham working as a drummer for rock and roll superstar Jerry Lee Lewis. Also, his uncle played the bass guitar for Sly and the Family Stone and Prince.
Even on his mother’s side, there was a lot of musical influence on Drake as a boy. Music even brought his parents together, and the two met after Dennis performed at the Clue Bluenote where he first interacted with his mother, Sandra.
Were you ever a fan of Canadian teen dramas?
High School was a Tough Time for Drake


Primary font: "Museo Slab", Georgia, Times, "Times New Roman", serif
Primary font italic: "Museo Slab", Georgia, Times, "Times New Roman", serif
Primary font bold: "Museo Slab", Georgia, Times, "Times New Roman", serif
Hover: Duration: 0.3s Easing: ease-out (Hover to see effect)
Fade: Duration: 0.3s Easing: ease-out (Hover to see effect)
Movement: Duration: 0.8s Easing: ease-in-out; (Hover to see effect)


--- layout: new title: Product Tour ---
Opsee sends you notifications when you need them, and stays out of your way when you don't. Send to email, Slack, or wherever your team communicates.
When you create a health check for a service, Opsee automatically applies it to the right instances and keeps track of new instances for you using AWS APIs.
When there's a problem, you can take action from any device.
Once you add our Bastion Instance to your environment, it runs your health checks and watches for new instances and services automatically.
There’s no software to install on your systems.


Do you know what's happening upstairs? This is all a result of your former partner. Do you understand now? Do you see why this can't continue? There will be an appropriate response.  I understand your preoccupation, but Jesse, I am running a business. I need you back at the lab to complete the cook. You can return when you're done. It is, as you must know, in both of our best interests.
I... am very sorry. Is there anything I can do? I am on the board of this hospital. I can recommend doctors. Make sure he gets whatever he needs. The best treatment. How did that happen? This current batch is surely ruined now, correct? Stay with the boy. Tyrus will dump what's there and clean the tanks. You will start a new batch when you are ready to return. Next week.
What kind of man talks to the DEA? No man. No man at all. A crippled little rata. What a reputation to leave behind. Is that how you want to be remembered? Last chance to look at me, Hector. Can I help you sir? What can I do for you? I'm... sorry, I'm not following.  Sir, if you have a complaint, I suggest you submit it through our email system. I will be happy to refer you to our website.
I don't think we're alike at all, Mr. White. You are not a cautious man at all. Your partner was late and he was high. He's high often, isn't he? You have poor judgement. I can't work with someone with poor judgement. I've been told, it's excellent. That is not the only factor. I have to ask... why? Why him? How much product do you have on hand? I have your numbers. You can never trust a drug addict.