Money
Lover
My Wallets
Transactions
Report Month
Update Avatar
Change Password
Log Out
Change Password
Forgotten your password?
Save
Cancel
--Select Month--
1
2
3
4
5
6
7
8
9
10
11
12
Report Month
Tiền thu
Tiền chi
Shopping
Travel
Gifts
Friends and lover
food
May
Thu-Chi
categories


| | |
- gdata.tlslite.TLSRecordLayer.TLSRecordLayer
-
- TLSConnection
class TLSConnection(gdata.tlslite.TLSRecordLayer.TLSRecordLayer) |
| |
This class wraps a socket and provides TLS handshaking and data
transfer.
To use this class, create a new instance, passing a connected
socket into the constructor. Then call some handshake function.
If the handshake completes without raising an exception, then a TLS
connection has been negotiated. You can transfer data over this
connection as if it were a socket.
This class provides both synchronous and asynchronous versions of
its key functions. The synchronous versions should be used when
writing single-or multi-threaded code using blocking sockets. The
asynchronous versions should be used when performing asynchronous,
event-based I/O with non-blocking sockets.
Asynchronous I/O is a complicated subject; typically, you should
not use the asynchronous functions directly, but should use some
framework like asyncore or Twisted which TLS Lite integrates with
(see
L{tlslite.integration.TLSAsyncDispatcherMixIn.TLSAsyncDispatcherMixIn} or
L{tlslite.integration.TLSTwistedProtocolWrapper.TLSTwistedProtocolWrapper}). |
| |
Methods defined here:
- __init__(self, sock)
- Create a new TLSConnection instance.
@param sock: The socket data will be transmitted on. The
socket should already be connected. It may be in blocking or
non-blocking mode.
@type sock: L{socket.socket}
- handshakeClientCert(self, certChain=None, privateKey=None, session=None, settings=None, checker=None, async=False)
- Perform a certificate-based handshake in the role of client.
This function performs an SSL or TLS handshake. The server
will authenticate itself using an X.509 or cryptoID certificate
chain. If the handshake succeeds, the server's certificate
chain will be stored in the session's serverCertChain attribute.
Unless a checker object is passed in, this function does no
validation or checking of the server's certificate chain.
If the server requests client authentication, the
client will send the passed-in certificate chain, and use the
passed-in private key to authenticate itself. If no
certificate chain and private key were passed in, the client
will attempt to proceed without client authentication. The
server may or may not allow this.
Like any handshake function, this can be called on a closed
TLS connection, or on a TLS connection that is already open.
If called on an open connection it performs a re-handshake.
If the function completes without raising an exception, the
TLS connection will be open and available for data transfer.
If an exception is raised, the connection will have been
automatically closed (if it was ever open).
@type certChain: L{tlslite.X509CertChain.X509CertChain} or
L{cryptoIDlib.CertChain.CertChain}
@param certChain: The certificate chain to be used if the
server requests client authentication.
@type privateKey: L{tlslite.utils.RSAKey.RSAKey}
@param privateKey: The private key to be used if the server
requests client authentication.
@type session: L{tlslite.Session.Session}
@param session: A TLS session to attempt to resume. If the
resumption does not succeed, a full handshake will be
performed.
@type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
@param settings: Various settings which can be used to control
the ciphersuites, certificate types, and SSL/TLS versions
offered by the client.
@type checker: L{tlslite.Checker.Checker}
@param checker: A Checker instance. This instance will be
invoked to examine the other party's authentication
credentials, if the handshake completes succesfully.
@type async: bool
@param async: If False, this function will block until the
handshake is completed. If True, this function will return a
generator. Successive invocations of the generator will
return 0 if it is waiting to read from the socket, 1 if it is
waiting to write to the socket, or will raise StopIteration if
the handshake operation is completed.
@rtype: None or an iterable
@return: If 'async' is True, a generator object will be
returned.
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
@raise tlslite.errors.TLSAuthenticationError: If the checker
doesn't like the other party's authentication credentials.
- handshakeClientSRP(self, username, password, session=None, settings=None, checker=None, async=False)
- Perform an SRP handshake in the role of client.
This function performs a TLS/SRP handshake. SRP mutually
authenticates both parties to each other using only a
username and password. This function may also perform a
combined SRP and server-certificate handshake, if the server
chooses to authenticate itself with a certificate chain in
addition to doing SRP.
TLS/SRP is non-standard. Most TLS implementations don't
support it. See
U{http://www.ietf.org/html.charters/tls-charter.html} or
U{http://trevp.net/tlssrp/} for the latest information on
TLS/SRP.
Like any handshake function, this can be called on a closed
TLS connection, or on a TLS connection that is already open.
If called on an open connection it performs a re-handshake.
If the function completes without raising an exception, the
TLS connection will be open and available for data transfer.
If an exception is raised, the connection will have been
automatically closed (if it was ever open).
@type username: str
@param username: The SRP username.
@type password: str
@param password: The SRP password.
@type session: L{tlslite.Session.Session}
@param session: A TLS session to attempt to resume. This
session must be an SRP session performed with the same username
and password as were passed in. If the resumption does not
succeed, a full SRP handshake will be performed.
@type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
@param settings: Various settings which can be used to control
the ciphersuites, certificate types, and SSL/TLS versions
offered by the client.
@type checker: L{tlslite.Checker.Checker}
@param checker: A Checker instance. This instance will be
invoked to examine the other party's authentication
credentials, if the handshake completes succesfully.
@type async: bool
@param async: If False, this function will block until the
handshake is completed. If True, this function will return a
generator. Successive invocations of the generator will
return 0 if it is waiting to read from the socket, 1 if it is
waiting to write to the socket, or will raise StopIteration if
the handshake operation is completed.
@rtype: None or an iterable
@return: If 'async' is True, a generator object will be
returned.
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
@raise tlslite.errors.TLSAuthenticationError: If the checker
doesn't like the other party's authentication credentials.
- handshakeClientSharedKey(self, username, sharedKey, settings=None, checker=None, async=False)
- Perform a shared-key handshake in the role of client.
This function performs a shared-key handshake. Using shared
symmetric keys of high entropy (128 bits or greater) mutually
authenticates both parties to each other.
TLS with shared-keys is non-standard. Most TLS
implementations don't support it. See
U{http://www.ietf.org/html.charters/tls-charter.html} for the
latest information on TLS with shared-keys. If the shared-keys
Internet-Draft changes or is superceded, TLS Lite will track
those changes, so the shared-key support in later versions of
TLS Lite may become incompatible with this version.
Like any handshake function, this can be called on a closed
TLS connection, or on a TLS connection that is already open.
If called on an open connection it performs a re-handshake.
If the function completes without raising an exception, the
TLS connection will be open and available for data transfer.
If an exception is raised, the connection will have been
automatically closed (if it was ever open).
@type username: str
@param username: The shared-key username.
@type sharedKey: str
@param sharedKey: The shared key.
@type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
@param settings: Various settings which can be used to control
the ciphersuites, certificate types, and SSL/TLS versions
offered by the client.
@type checker: L{tlslite.Checker.Checker}
@param checker: A Checker instance. This instance will be
invoked to examine the other party's authentication
credentials, if the handshake completes succesfully.
@type async: bool
@param async: If False, this function will block until the
handshake is completed. If True, this function will return a
generator. Successive invocations of the generator will
return 0 if it is waiting to read from the socket, 1 if it is
waiting to write to the socket, or will raise StopIteration if
the handshake operation is completed.
@rtype: None or an iterable
@return: If 'async' is True, a generator object will be
returned.
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
@raise tlslite.errors.TLSAuthenticationError: If the checker
doesn't like the other party's authentication credentials.
- handshakeClientUnknown(self, srpCallback=None, certCallback=None, session=None, settings=None, checker=None, async=False)
- Perform a to-be-determined type of handshake in the role of client.
This function performs an SSL or TLS handshake. If the server
requests client certificate authentication, the
certCallback will be invoked and should return a (certChain,
privateKey) pair. If the callback returns None, the library
will attempt to proceed without client authentication. The
server may or may not allow this.
If the server requests SRP authentication, the srpCallback
will be invoked and should return a (username, password) pair.
If the callback returns None, the local implementation will
signal a user_canceled error alert.
After the handshake completes, the client can inspect the
connection's session attribute to determine what type of
authentication was performed.
Like any handshake function, this can be called on a closed
TLS connection, or on a TLS connection that is already open.
If called on an open connection it performs a re-handshake.
If the function completes without raising an exception, the
TLS connection will be open and available for data transfer.
If an exception is raised, the connection will have been
automatically closed (if it was ever open).
@type srpCallback: callable
@param srpCallback: The callback to be used if the server
requests SRP authentication. If None, the client will not
offer support for SRP ciphersuites.
@type certCallback: callable
@param certCallback: The callback to be used if the server
requests client certificate authentication.
@type session: L{tlslite.Session.Session}
@param session: A TLS session to attempt to resume. If the
resumption does not succeed, a full handshake will be
performed.
@type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
@param settings: Various settings which can be used to control
the ciphersuites, certificate types, and SSL/TLS versions
offered by the client.
@type checker: L{tlslite.Checker.Checker}
@param checker: A Checker instance. This instance will be
invoked to examine the other party's authentication
credentials, if the handshake completes succesfully.
@type async: bool
@param async: If False, this function will block until the
handshake is completed. If True, this function will return a
generator. Successive invocations of the generator will
return 0 if it is waiting to read from the socket, 1 if it is
waiting to write to the socket, or will raise StopIteration if
the handshake operation is completed.
@rtype: None or an iterable
@return: If 'async' is True, a generator object will be
returned.
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
@raise tlslite.errors.TLSAuthenticationError: If the checker
doesn't like the other party's authentication credentials.
- handshakeServer(self, sharedKeyDB=None, verifierDB=None, certChain=None, privateKey=None, reqCert=False, sessionCache=None, settings=None, checker=None)
- Perform a handshake in the role of server.
This function performs an SSL or TLS handshake. Depending on
the arguments and the behavior of the client, this function can
perform a shared-key, SRP, or certificate-based handshake. It
can also perform a combined SRP and server-certificate
handshake.
Like any handshake function, this can be called on a closed
TLS connection, or on a TLS connection that is already open.
If called on an open connection it performs a re-handshake.
This function does not send a Hello Request message before
performing the handshake, so if re-handshaking is required,
the server must signal the client to begin the re-handshake
through some other means.
If the function completes without raising an exception, the
TLS connection will be open and available for data transfer.
If an exception is raised, the connection will have been
automatically closed (if it was ever open).
@type sharedKeyDB: L{tlslite.SharedKeyDB.SharedKeyDB}
@param sharedKeyDB: A database of shared symmetric keys
associated with usernames. If the client performs a
shared-key handshake, the session's sharedKeyUsername
attribute will be set.
@type verifierDB: L{tlslite.VerifierDB.VerifierDB}
@param verifierDB: A database of SRP password verifiers
associated with usernames. If the client performs an SRP
handshake, the session's srpUsername attribute will be set.
@type certChain: L{tlslite.X509CertChain.X509CertChain} or
L{cryptoIDlib.CertChain.CertChain}
@param certChain: The certificate chain to be used if the
client requests server certificate authentication.
@type privateKey: L{tlslite.utils.RSAKey.RSAKey}
@param privateKey: The private key to be used if the client
requests server certificate authentication.
@type reqCert: bool
@param reqCert: Whether to request client certificate
authentication. This only applies if the client chooses server
certificate authentication; if the client chooses SRP or
shared-key authentication, this will be ignored. If the client
performs a client certificate authentication, the sessions's
clientCertChain attribute will be set.
@type sessionCache: L{tlslite.SessionCache.SessionCache}
@param sessionCache: An in-memory cache of resumable sessions.
The client can resume sessions from this cache. Alternatively,
if the client performs a full handshake, a new session will be
added to the cache.
@type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
@param settings: Various settings which can be used to control
the ciphersuites and SSL/TLS version chosen by the server.
@type checker: L{tlslite.Checker.Checker}
@param checker: A Checker instance. This instance will be
invoked to examine the other party's authentication
credentials, if the handshake completes succesfully.
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
@raise tlslite.errors.TLSAuthenticationError: If the checker
doesn't like the other party's authentication credentials.
- handshakeServerAsync(self, sharedKeyDB=None, verifierDB=None, certChain=None, privateKey=None, reqCert=False, sessionCache=None, settings=None, checker=None)
- Start a server handshake operation on the TLS connection.
This function returns a generator which behaves similarly to
handshakeServer(). Successive invocations of the generator
will return 0 if it is waiting to read from the socket, 1 if it is
waiting to write to the socket, or it will raise StopIteration
if the handshake operation is complete.
@rtype: iterable
@return: A generator; see above for details.
Methods inherited from gdata.tlslite.TLSRecordLayer.TLSRecordLayer:
- close(self)
- Close the TLS connection.
This function will block until it has exchanged close_notify
alerts with the other party. After doing so, it will shut down the
TLS connection. Further attempts to read through this connection
will return "". Further attempts to write through this connection
will raise ValueError.
If makefile() has been called on this connection, the connection
will be not be closed until the connection object and all file
objects have been closed.
Even if an exception is raised, the connection will have been
closed.
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
- closeAsync(self)
- Start a close operation on the TLS connection.
This function returns a generator which behaves similarly to
close(). Successive invocations of the generator will return 0
if it is waiting to read from the socket, 1 if it is waiting
to write to the socket, or will raise StopIteration if the
close operation has completed.
@rtype: iterable
@return: A generator; see above for details.
- getCipherImplementation(self)
- Get the name of the cipher implementation used with
this connection.
@rtype: str
@return: The name of the cipher implementation used with
this connection. Either 'python', 'cryptlib', 'openssl',
or 'pycrypto'.
- getCipherName(self)
- Get the name of the cipher used with this connection.
@rtype: str
@return: The name of the cipher used with this connection.
Either 'aes128', 'aes256', 'rc4', or '3des'.
- getpeername(self)
- Return the remote address to which the socket is connected
(socket emulation).
- getsockname(self)
- Return the socket's own address (socket emulation).
- gettimeout(self)
- Return the timeout associated with socket operations (socket
emulation).
- makefile(self, mode='r', bufsize=-1)
- Create a file object for the TLS connection (socket emulation).
@rtype: L{tlslite.FileObject.FileObject}
- read(self, max=None, min=1)
- Read some data from the TLS connection.
This function will block until at least 'min' bytes are
available (or the connection is closed).
If an exception is raised, the connection will have been
automatically closed.
@type max: int
@param max: The maximum number of bytes to return.
@type min: int
@param min: The minimum number of bytes to return
@rtype: str
@return: A string of no more than 'max' bytes, and no fewer
than 'min' (unless the connection has been closed, in which
case fewer than 'min' bytes may be returned).
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
- readAsync(self, max=None, min=1)
- Start a read operation on the TLS connection.
This function returns a generator which behaves similarly to
read(). Successive invocations of the generator will return 0
if it is waiting to read from the socket, 1 if it is waiting
to write to the socket, or a string if the read operation has
completed.
@rtype: iterable
@return: A generator; see above for details.
- recv(self, bufsize)
- Get some data from the TLS connection (socket emulation).
@raise socket.error: If a socket error occurs.
@raise tlslite.errors.TLSAbruptCloseError: If the socket is closed
without a preceding alert.
@raise tlslite.errors.TLSAlert: If a TLS alert is signalled.
- send(self, s)
- Send data to the TLS connection (socket emulation).
@raise socket.error: If a socket error occurs.
- sendall(self, s)
- Send data to the TLS connection (socket emulation).
@raise socket.error: If a socket error occurs.
- setsockopt(self, level, optname, value)
- Set the value of the given socket option (socket emulation).
- settimeout(self, value)
- Set a timeout on blocking socket operations (socket emulation).
- write(self, s)
- Write some data to the TLS connection.
This function will block until all the data has been sent.
If an exception is raised, the connection will have been
automatically closed.
@type s: str
@param s: The data to transmit to the other party.
@raise socket.error: If a socket error occurs.
- writeAsync(self, s)
- Start a write operation on the TLS connection.
This function returns a generator which behaves similarly to
write(). Successive invocations of the generator will return
1 if it is waiting to write to the socket, or will raise
StopIteration if the write operation has completed.
@rtype: iterable
@return: A generator; see above for details.
| |


George Michael was like an uncle to me, says Roman Kemp
The jungle star said Michael played a big role in getting his parents together.
Roman Kemp has said the late pop star George Michael was like an uncle to him as he was growing up.
The I’m A Celebrity contestant is the son of Spandau Ballet star Martin Kemp and singer Shirlie Holliman.
He told his fellow contestants on the ITV show that Michael played a big role in getting his parents together.
Kemp said his mother knew Michael through his Wham! bandmate Andrew Ridgeley, who she once dated.
He said: “My mother always said that she said to George Michael at a party that she was going to marry him (Martin).
“They were at some party and she didn’t want to speak to him (Martin) and one of George’s friends brought him over and they started talking and my dad gave my mum his phone number and my mum went back to George’s house and George forced my mum to call him.”
Kemp went on: “But their first date, George went with them.
“My mum didn’t want to go on her own. They went to see Sade at the Camden Palace. My dad spent the whole date trying to get rid of him.”
Kemp said his “uncle” Michael was “an amazing guy”.
He said: “You’d see him at dinners, Christmas, the lot. It is really nice that all the memories I have are so nice, going on holidays, and having my parents compete with Christmas presents.
“One year, I must have been four or five and my dad bought me a bike, a Raleigh bike.
“I remember George came round to the house and brought in my present and he’d gone to Harrods and bought one of those electric cars but not just that, it was a Batmobile. I’ve still got it.”
“Memories like that, they’re so nice to have but it’s strange because for me it was just my mum’s best mate,” he added.
Michael died at the age of 53 on Christmas Day 2016.


Description
I have managed to get some PCB’s designed based on my requirements. Here is some 3D models of the first few boards I am getting made.
Backplane PCB
This board is essentially the main component all other boards will plug into.
Some features I tried to nail on this one:
- Allowed for up to 4 boards to be plugged in.
- Each slot is addressable.
- Provide connectors for 24V, 3V3 and 5V to be connected directly into the backplane (This could be replaced by a plug in board).
By convention the CPU will be plugged into slot 1 and the PSU will be plugged into slot 4 though this is just by convention and allowed space the backplane board have none of these restrictions built in.
CPU PCB (RPI and STM32)
This is a board specifically designed for Raspberry Pi and STM32 based “Blue Pill” to interface with the backplane. I however imagine there will be a CPU board designed for each SBC/Microcontroller that needs to be interfaced with the backplane.
Some features I tried to nail on this one:
- Allow the controller to read what it is. This is done via an EEPROM chip.
- Expose all the low level peripheral(SPI, Serial, PWM etc) to the rest of the backplane.
By convention the CPU will be plugged into slot 1 and as explained above the backplane has no restriction that forces this other than physical space.


In HTML, there are two main types of lists:
The CSS list properties allow you to:
The list-style-type
property specifies the type of list item marker.
The following example shows some of the available list item markers:
ul.a {
list-style-type: circle;
}
ul.b {
list-style-type: square;
}
ol.c {
list-style-type: upper-roman;
}
ol.d {
list-style-type: lower-alpha;
}
Note: Some of the values are for unordered lists, and some for ordered lists.
The list-style-image
property specifies an image as the list item marker:
ul {
list-style-image: url('sqpurple.gif');
}
The list-style-position
property specifies whether the list-item markers should appear inside or outside the content flow:
ul {
list-style-position: inside;
}
The list-style
property is a shorthand property. It is used to set all the list properties in one declaration:
ul {
list-style: square inside url("sqpurple.gif");
}
When using the shorthand property, the order of the property values are:
list-style-type
(if a list-style-image is specified, the value of this property will be displayed if the image for some reason cannot be displayed)list-style-position
(specifies whether the list-item markers should appear inside or outside the content flow)list-style-image
(specifies an image as the list item marker)If one of the property values above are missing, the default value for the missing property will be inserted, if any.
We can also style lists with colors, to make them look a little more interesting.
Anything added to the <ol> or <ul> tag, affects the entire list, while properties added to the <li> tag will affect the individual list items:
ol {
background: #ff9999;
padding: 20px;
}
ul {
background: #3399ff;
padding: 20px;
}
ol li {
background: #ffe5e5;
padding: 5px;
margin-left: 35px;
}
ul li {
background: #cce5ff;
margin: 5px;
}
Result:


{% include head.html %}
{% include navbar.html %}
{% include pod_map.html %}
See Something Missing?
To add more resources to these lists, please submit them here.
GitHub repo


Abstract: 20mg of 4-Ac0-DiPT, taken on a full stomach as two 10-mg doses taken one hour apart, resulted in a smooth come-up and a very enjoyable trip that lasted approximately seven hours. Effects included marked enhancement of tactile sensation, marked enhancement of music appreciation, mild empathogenic effects, and closed-eye visuals. Insomnia was the only notable side effect, and there was no hangover the next day.
Report:
4-Ac0-DiPT, received from the usual source, was a grayish granular powder that tended to stick to instruments and the sides of the container. 10mg samples, measured on an electronic scale accurate to 2mg, were placed into gelcaps.
Approximately six mg, left over after repackaging, was taken in 6oz of cold water. The substance dissolved without difficulty. A markedly bitter taste was noted. Definite, albeit mild psychedelic effects were noted at approximately 45 minutes, characterized by slight muddle-headedness. The effect was approximately equal in intensity to a normal dose of an antihistamine. Noticeable effects lasted for about three hours. There may have been some enhancement of music appreciation during this time. There were no side effects or after effects.
About a week later, I had an opportunity to try a therapeutic dose. I ate dinner with some fairly good friends, and we all decided to hang out in the lounge together. My state of mind was far from ideal; I've had a lot of sticks in the fire lately, and the evening started off with considerable agitation because I thought I had lost my cell phone.
My first dose of 10mg was consumed at 9pm, about one hour after a dinner of chicken and rice. I took this along with one dose of immodium. First effects were noted at the half hour mark, with slight non-linearity, and very slight clumsiness. I noticed a considerable amount of 'psychedelic disorganization' by which I refer to the tendency to lose things easily, which prompts me to check my pockets every five minutes. I noticed a slightly increased sweat production. Nevertheless, I noticed a bit of euphoria.
One hour post dose, not noticing any adverse effects, I took a second 10 mg dose. Over the next hour, there was a very gradual come-up to a plateau that lasted for hours. There was no detectable peak; I was still feeling pretty darn good when I finally went to bed at 4am. About two hours after the first dose, I noticed a feeling of slight tremulousness, which felt a lot like being intensely aroused sexually. There was no nausea, nor any other side effects.
Conversation was very easy. These were among the more appropriate conversations I've had while tripping. I met one very cute girl, and we got along well. She was kind of 'touchy' and I noticed it felt very good to be touched. After a while, the conversation turned to 'deep thoughts' and I took off on some tangent about Eastern philosophy. I think I got just a little too manicky, because she took off after a while, which I thought was just hilarious. I noticed that while speaking with people, I had a tendency to think the best of them, but I would not say that any deep bonding occurred.
Music just sounded extraordinarily good. There was a certain clarity and immediateness to music. Listening to Andain's 'Beautiful Things,' it was like the vocalist wrapped her arms around my neck and whispered the words into my ear. Selections from Schulz's 'Coldharbour Sessions' were so intense it was almost vertiginous, which after a point struck me as hilariously funny.
Other than occasional trails, no open eye visuals were noted.
I made it home to wifey to tell her all about it. She tells me I was quite perky, in an entertaining way. I suppose I did feel very euphoric; I had a good time explaining to her what a 'contact high' is. I found this substance to be somewhat of a stimulant, in fact is was very difficult to get to sleep that night.
I was pretty horny, something that started about an hour and a half after the first dose. That, combined with the enhanced tactile sensation made me very interested in sex, and I am pleased to report that the equipment worked just fine. Orgasm was not at all delayed, in fact everything felt so durn good it was difficult to make it last very long. The act of sex was absolutely incredible, setting off intricately detailed closed eye visuals of geometric patterns, which interestingly enough were in black-and-white at first. Later I noticed sheets and blooms of iridescent colors. As I was trying to go to sleep, it was like cartoons in my head, which struck me as funny. 'Settle down guys, can't you see I'm trying to sleep?'
I was rudely awakened about eight am -- four hours of sleep, if you can call it that -- but after a stiff jolt of caffeine, I was good to go. I noticed no side effects whatsoever, except for a warm glow that could have been related to the absolutely mind-blowing sex I had the night before, as much as the chemical.
Comparisons: 4-Aco-DiPT is less stimulating than amphetamine, MDMA, or 2C-I; but it is a stimulant nonetheless. Like MDMA, visuals are minimal. It is every bit the equal of MDMA as an entactogen, and is vastly superior as a sex enhancer because of the lack of anorgasmia. It is more empathogenic than 2C-I but much less than MDMA. Side effects were less than I've encountered with any PEA. I've not tried any other tryptamines and in particular, unfortunately i cannot compare this with 4-HO-DiPT.
Overall, I would say that this was an enjoyable experience. My mind-set was a setup for a bad trip I suppose, but instead I found myself in a very durable state of euphoria. Although I was stimulated, other than mild sweatiness, I did not notice much in the way of sympathetic overload, such as tachycardia. I would imagine that the energy surging through me (the tremulousness) could be tricky to handle if the dose were much higher though. This is a very social experience with the potential for insights if the conversation goes that way. It is a definite entactogen -- better than anything else I've tried -- and a modest empathogen. Definitely worth doing again.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Unit Testing React Applications with Mocha, Chai and Enzyme Talk
In April 2016, I gave a talk at Red Badger’s React London User Group meetup in London, on the topic of “Unit Testing React Applications with Mocha, Chai and Enzyme”.
The talk introduces the fundamentals of testing a React application with AirBnB’s excellent Enzyme library, and explains my approach to both unit and integration testing apps using the combination of Mocha, Chai and Enzyme.
Both the code samples, and the slides are available on GitHub.
You can watch the talk on YouTube or below:


{% extends "ralph_scrooge/base.html" %} {% load icons formats bob %} {% block extra_headers %} {{ block.super }} {% if got_query and progress < 100 %} {% endif %} {% endblock %} {% block base_sidebar %}{% endblock %} {% block content_span %}span12{% endblock %} {% block contentarea %}
Calculating the report, please wait...
Error! We are extremely sorry, but unfortunately, the calculation of this report could not be completed due to an error in the code. The people responsible for that will be severely punished.
Thank you and have a nice day.


jQuery Context Menu
Examples
This is a link!
JavaScript!
Left click here
accessibility_new
Item with Material Icon!
warning
Item with Material Icon!
Item with Font Awesome!
Item with Font Awesome!
Middle click here
This is sooooooooooooo long text!
🤗💕❤😎😁👌😂
╰(*°▽°*)╯
Right click here
Advanced
Advanced Context Menu
So many items..


UStudio
Sketchware 6.4.0 Beta
New aab import
Buggy
Beta vwrsion
Download
Posted By: ZenxDev
Owner
Skechware 6.3.6
Bug Fixed
New Block Added
Custom edit
Download
Posted By: NicksAven
Moderator
Sketchware V6.3.0
Bug Fixed
New Code Editor
Download
Posted By: UStudio
Server
API
About


We do not take any money for using the service. App is free for drivers and passengers.
No credit cards. Drivers get paid directly with cash. BitCoin integration is on the way!
No credit approval process. No vehicle restrictions. Start making money as a driver in one minute!
Win-win. Drivers can set their prices and offer discounts. Passengers can bargain before the ride is confirmed.
Works on iOS, Android, Mac, Web. Based on the Telegram messaging app.
LibreTaxi is free and open-source software under the AGPLv3 license, with minimal tracking.
With no GPS tracking goes easy on your phone's battery. Simple and minimalistic UI is implemented based on Telegram.
Works for English, Russian, Indonesian, Portuguese, Spanish, French. Help us translate LibreTaxi into your language.
Get the source, hack and tune it for your city. Add features specific to your region. Written with JavaScript (ES6).


155 different ingredients are used in the 147 madeleine recipes on Marmiton.com.
The 5 most common ingredients (flour, sugar, butter, egg, and yeast) are used in most recipes and are enough to make madeleines.
The list below shows how many recipes (or % of recipes) use each possible ingredient.


| Class and Description |
|---|
| org.apache.spark.ml.feature.ChiSqSelector
use UnivariateFeatureSelector instead. Since 3.1.1.
|
| org.apache.spark.scheduler.SparkListenerExecutorBlacklisted
use SparkListenerExecutorExcluded instead. Since 3.1.0.
|
| org.apache.spark.scheduler.SparkListenerExecutorBlacklistedForStage
use SparkListenerExecutorExcludedForStage instead. Since 3.1.0.
|
| org.apache.spark.scheduler.SparkListenerExecutorUnblacklisted
use SparkListenerExecutorUnexcluded instead. Since 3.1.0.
|
| org.apache.spark.scheduler.SparkListenerNodeBlacklisted
use SparkListenerNodeExcluded instead. Since 3.1.0.
|
| org.apache.spark.scheduler.SparkListenerNodeBlacklistedForStage
use SparkListenerNodeExcludedForStage instead. Since 3.1.0.
|
| org.apache.spark.scheduler.SparkListenerNodeUnblacklisted
use SparkListenerNodeUnexcluded instead. Since 3.1.0.
|
| org.apache.spark.sql.expressions.javalang.typed
As of release 3.0.0, please use the untyped builtin aggregate functions.
|
| org.apache.spark.sql.expressions.scalalang.typed
please use untyped builtin aggregate functions. Since 3.0.0.
|
| org.apache.spark.sql.expressions.UserDefinedAggregateFunction
UserDefinedAggregateFunction is deprecated.
Aggregator[IN, BUF, OUT] should now be registered as a UDF via the functions.udaf(agg) method.
|
| Constructor and Description |
|---|
| org.apache.spark.sql.SQLContext(JavaSparkContext)
Use SparkSession.builder instead. Since 2.0.0.
|
| org.apache.spark.sql.SQLContext(SparkContext)
Use SparkSession.builder instead. Since 2.0.0.
|


Hey kids!
I can't believe my Dev Bootcamp experience is already over. I'm currently in the process of finishing up my final project and working on a few new ones while engaging in the job hunt (see my GitHub for most recent information)
As I have permission, I hope to showcase these projects publicly here.


Total Time:       Prep:       Level: Easy      Serves: 4
This is so much faster and healthier than takeout.
This teriyaki chicken is so much better than takeout. It’s the easiest and most unbelievably
delicious chicken teriyaki that will be on your table in only 15 minutes!
Ingredients
For the Sauce
1/3 c. soy sauce
1/4 c. rice wine vinegar
1 tsp. sesame oil
1 1/2 tbsp. honey
2 cloves garlic, minced
2 tsp. finely minced fresh ginger
2 tsp. cornstarch
For the Chicken
1 tbsp. extra-virgin olive oil
1 lb. boneless skinless chicken breasts, cut into bite-sized pieces
kosher salt
Freshly ground black pepper
Sesame seeds, for garnish
Sliced green onions, for garnish
White rice, for serving
Steamed broccoli, for serving
Directions
Make the sauce: In a medium bowl, combine soy sauce, vinegar, sesame oil, honey, garlic, ginger and cornstarch.
Whisk until smooth.
In a large skillet, over medium heat, heat oil.
Add chicken to skillet and season with salt and pepper.
Cook until golden and almost cooked through, about 10 minutes.
Pour sauce over chicken and simmer until sauce has thickened slightly and chicken is cooked through.
Garnish with sesame seeds and sliced green onions. Serve over rice with broccoli.


{% load i18n %}
{% blocktrans %} The document {{ document_key }} will be send back to the Leader ({{ leader }}) for review. {% endblocktrans %}
{{ _('Are you sure you want to cancel the current review?') }}
{{ _('Comments already submitted will be deleted definitely.') }}


We re-design the website for local arts gallery in Hayward, CA; The Sun Gallery. Check out the full Sun Gallery website here.


src/client/js/global.js
import { MAP_LAYOUT } from './obj/tiles'
// Contains all global constants and functions for both the client and server.
export const GLOBAL = {
DEBUG: true, // REMEMBER to toggle this lmao if you dont want your entire pc crashing
VERBOSE_SOCKET: false, // true = debug clientside socket -> log if any socket method has been called
// Keys and other mathematical constants
KEY_ESC: 27,
KEY_ENTER: 13,
KEY_W: 87,
KEY_A: 65,
KEY_S: 83,
KEY_D: 68,
KEY_1: 49,
KEY_2: 50,
KEY_3: 51,
KEY_4: 52,
KEY_SPACE: 32,
// Blueprints
BP_SELECT: 'Blueprint Select - Slot ', // Text for blueprint select header
BP_MAX: 4, // Maximum number of blueprints a player can have in one game at a time
// Params that will not display on tooltip
BP_TOOLTIP_BLACKLIST: [
'evaporate',
'splashImage'
],
// Main menu
INPUT_COUNT: 3, // Number of input boxes on main menu
// Chat
PLACEHOLDER_NAME: 'Unnamed Player',
MAX_CHATS: 50, // Max number of chats to be displayed before deleting
// Server
SERVER_IP: 'atomblast.bananiumlabs.com:12002', // Change during production!!!!!
LOCAL_HOST: 'localhost:12002',
TEST_IP: 'https://iogame-test.herokuapp.com/',
NO_ROOM_IDENTIFIER: '$_NOROOM', // Pass to server if matchmaking is required
NO_TEAM_IDENTIFIER: '$_NOTEAM', // Pass to server if matchmaking is required
ROOM_DELETE_DELAY: 30000, // Time, in ms, between winning and room closing
// Cookies
COOKIES: [
'name', // 0
'room', // 1
'team', // 2
'bp-slot-1', // 3
'bp-slot-2', // 4
'bp-slot-3', // 5
'bp-slot-4', // 6
'room-type', // 7
'server' // 8
],
COOKIE_DAYS: 14, // Cookie lifetime
// Player Movement
MAX_SPEED: 6,
PLAYER_RADIUS: 100,
VELOCITY_STEP: 0.85, // speed multiplier when player is gliding to a stop
LERP_VALUE: 0.2,
DEADZONE: 0.1,
MAX_HEALTH: 100, // Starting health of players
PLAYER_ROTATION: 0.05,
PLAYER_EXPEDITED_ROTATION: 0.1,
// Atoms
ATOM_RADIUS: 30, // size of spawned atoms
MIN_POWERUPS: 150, // minimum number of powerups to be spawned (TEMPORARY)
MAX_POWERUPS: 300, // maximum number of powerups to be spawned (TEMPORARY)
ATTRACTION_RADIUS: 150, // Max distance for powerup to be attracted to player
ATTRACTION_COEFFICIENT: 100, // Multiplier for attraction strength
ATOM_SPAWN_SPEED: 15, // Speed that atom travels away from spawner
ATOM_SPAWN_DELAY: 3000, // Atom spawn delay, in milliseconds
ATOM_COLLECT_THRESHOLD: 100, // Distance away from center of player that the atom must be before being collected
// Map and Tiles
MAP_SIZE: 2000,
SPAWN_POINTS: [
{ x: 0, y: 0 },
{ x: 6, y: 6 },
{ x: 0, y: 6 },
{ x: 6, y: 0 }
], // Spawn points for different teams
MAX_SPAWNER_HEALTH: 100,
MAX_STRONGHOLD_HEALTH: 200,
MAX_NUCLEUS_HEALTH: 300,
STRONGHOLD_RADIUS: 100,
STRONGHOLD_DEFENSE: 5,
// Drawing
DRAW_RADIUS: 1000, // Radius around player in which to draw other objects
GRID_SPACING: 200, // space between each line on the grid
GRID_LINE_STROKE: 1,
FRAME_RATE: 60,
// Colors
TEAM_COLORS: [ // Purple, Green, Orange, Red. No prefixes
'673ab7',
'2e7d32',
'ff8f00',
'f44336'
],
IGNITE_SPRITE: 'placeholder_ignited.png',
// Atoms: ID's and Sprites. ATOM_SPRITES[id] returns the texture location of atom of that id.
ATOM_IDS: [
'h',
'he',
'c',
'cl',
'n',
'o'
],
ATOM_SPRITES: [
'atom_hydrogen.png',
'atom_helium.png',
'atom_carbon.png',
'testplayer2.png',
'atom_nitrogen.png',
'atom_oxygen.png'
],
// Location of spritesheet relative to pixigame
SPRITESHEET_DIR: '../assets/spritesheet.json',
// Used for main menu textures
COMPOUND_DIR: '../assets/spritesheet/compounds/',
// Each Value corresponds with the above event
EXPERIENCE_VALUES: {
CRAFT: 10,
KILL: 124
},
// The cutoffs for each level. Index 0 = level 1, 1 = level 2, etc
EXPERIENCE_LEVELS: [
0,
10,
20,
40,
100,
140,
160
],
MAINMENU_MUSICLIST: [
'assets/sfx/mainmenu/placeholder1.mp3',
'assets/sfx/mainmenu/placeholder2.mp3',
'assets/sfx/mainmenu/placeholder3.mp3'
// 'assets/sfx/mainmenu/placeholder4.mp3'
],
LOBBY_MUSICLIST: [
],
INGAME_MUSICLIST: [
],
// Deaths
KILL_SCORE: 6, // How many points are awarded to the player/team who dealt the most damage to the player
ASSIST_SCORE: 2, // How many points are awarded to all players who assist in killing the player
WINNING_SCORE: 20, // How many points are required to win the game per team. TODO increase
CAPTURE_SCORE: 5, // How many points are awarded to the team who captured a stronghold/vent
MAX_DEATH_ATOMS: 100 // How many atoms of each type can be ejected on death at maximum. Prevents testers from ejecting thousands of atoms at a time.
}
/**
* Returns the distance between two objects.
* Both objects must be GameObjects
* @param {GameObject} obj1 First object
* @param {GameObject} obj2 Second object
*/
export function distanceBetween (obj1, obj2) {
return Math.sqrt(Math.pow(obj1.posX - obj2.posX, 2) + Math.pow(obj1.posY - obj2.posY, 2))
}
/**
* Returns true if the object parameter is within the map boundaries.
* @param {GameObject} obj The object to test
* @return true if the object parameter is within the map boundaries
*/
export function isInBounds (obj) {
return obj.posX > 0 && obj.posY > -GLOBAL.GRID_SPACING * 2 && obj.posX < MAP_LAYOUT[0].length * GLOBAL.GRID_SPACING * 2 && obj.posY < (MAP_LAYOUT.length - 1) * GLOBAL.GRID_SPACING * 2
}
/**
* Gets the tile directly underneath any object.
* @param {*} obj Any valid GameObject.
* @returns {string} one-letter ID of current tile.
*/
export function getCurrTile (obj) {
let pos = getGlobalLocation(obj)
try {
return MAP_LAYOUT[pos.globalY][pos.globalX]
}
catch (error) {
return 'E'
}
}
/**
* Gets the coordinates of the tile directly underneath the object.
* @param {*} obj Any valid GameObject.
*/
export function getGlobalLocation (obj) {
return {
globalY: Math.floor(obj.posY / (GLOBAL.GRID_SPACING * 2)) + 1,
globalX: Math.floor(obj.posX / (GLOBAL.GRID_SPACING * 2))
}
}
/**
* Returns a random number between between 10000000 and 99999999, inclusive.
* TODO Make every ID guaranteed unique
* @returns random id between 10000000 and 99999999
*/
export function generateID() {
return Math.floor(Math.random() * 90000000) + 10000000
}


EASTERN design office stacks concrete square tubes for house in kyoto
by sofia lekka angelopouloulocated in a residential area of kyoto city, japan, the concrete square tube house by EASTERN design office combines a series of stacked square volumes, piled up in two vertical lines. planned as a single-family home, the project comprises four horizontal lines of cubes, each of which in a size suitable to provide inner spatial comfort. when looking at the house from the front, the tubes appear to be stacked without overlapping, while the square tubes serve as cantilevers, with the one on the second floor cantilevering 5.5 meters, and the one on the third floor 3.6 meters.
all images by koichi torimura
EASTERN design office has built the residence in a kyoto neighborhood where modern houses, old wooden houses and middle size apartment houses are lined up next to each other. the project benefits from a great view on the third floor, as a 500-meter mountain range opens to the north and west side, and the cityscape to the south and east side. a fake window on the 4th floor frames the city landscape like scenery in a picture, making it a symbolic view.
piled up in four horizontal lines and two vertical, to match the appropriate housing size, the cubes also serve as structural elements, as their square form is strong and sturdy. the ground floor of the house encloses an entrance area, which runs from the doorway to the back garden, where a maple tree – the symbol of the house – is planted at the center of this square tube. one level above, the cubes of both vertical lines contain three bedrooms and one walk- in closet, while each bedroom has a big opening on its front side.
two tubes are connected to create the spacious second floor, while two openings on the ceiling, each two square meters in size, bring natural light in through the moving water of the pool, which is located on the third floor. the light that comes in from these skylights changes its color and moves around the room depending on the time of the day and the season. a square window at the end of the pool on the last tube frames the city that lies ahead.
project info:
name: concrete square tube house
architect: EASTERN design office
location: kyoto, japan
site area: 236.64m2
total floor area: 522.10m2
structural engineering: ryoma murata building studio ltd.
constructor: fukasaka co., ltd


This is a example of FLOAT not BLOAT the image is ment to go to the right of this paragraph since the cammand is float. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text.
| ISBN | foods | Price |
|---|---|---|
| 3476896 | cookie | $666 |
| 5869207 | sandwich | $3432 |
Note: this is a footer CSS.


Easyreadwrite Workshops are designed to improve the quality of life for people over fifty five by adding another dimension to the range of activities and services on offer for people as they age. Language skills empower and enable us to communicate, to forge links, make connections and express our view of the world we live in.
With Easyreadwrite Workshops Theresa McKenna designs and presents a series of themed workshops which incorporate oral, written and reading activities in an enjoyable and entertaining format to stimulate and engage people as they age. Theresa is an English Teacher. She has been teaching for over thirty years, and is passionate about positive ageing, lifelong learning and literature.
Engaging with language can help prevent and delay the onset of conditions such as Alzheimer’s and Dementia. The social interaction involved in a Workshop helps promote better mental health and wellbeing. Workshops will enrich the lives of the participants through enjoyable language activities, designed around themes. Methodologies and content of the workshops is tailored to suit the individual needs of people in Retirement Villages, Nursing Homes, Day Care Centres, Resource Centres and Community Halls. Memoir, autobiographical writing, biography, short story writing, novel, diary, research, magazine/newspaper article, letter, poetry and drama or other genre can be explored in the workshops.
It is most important that the individual needs of the group are met and they engage in the activities in a way that is comfortable and enjoyable for them. Speaking about our growing older population in Ireland Dr. Stephanie O’Keefe, HSE National Director, Health and Wellbeing referred to tapping into the wealth of knowledge and experience, engaging and capturing the views and experience of our older citizens.
“Tapping into the wealth of knowledge and experience of this key demographic is vital as we aim to put in place services that will efficiently meet the needs of our changing population in the future. With the number of those aged 65 and over projected to increase by 167% to 1.42 million people by 2046, this demographic is growing approximately 20,000 a year and will have increased by 111,200 people in 2022. It is vital we engage and capture their views and experiences.
BA, H Dip, CTG
An English and History teacher for over thirty years, Theresa is passionate about both literacy and literature. During her dynamic career, Theresa has enjoyed working with a variety of mature students on Creative Writing and Reading Workshops. Easy ReadWrite provides Theresa with the opportunity to combine her love of language and desire to help people retain and develop the interest and passion they have in reading and writing as they age.
Theresa has been branching out her work to show her love of literature in many different forms. Some of her work includes numerous short story readings on RTE Radio, participation in features on television, being featured in RTE's September Sundays, a book filled with stories exploring the passions of those who hold Ireland dear, and recently in her role as chief editor of two published books:
The fascinating and often touching memories of the late Annette O'Brien, a beloved community figure in Killeeter, Mullagh and a dear friend sadly missed by all who knew her.
A book which is dear to Theresa's heart as someone who truly loves the village of Moynalty and it's storied history


machine learning | embedded systems | Application
Vigilant Driving
An application that assists in support to achieving self-driving vehicles. Various trained models are deployed on ARM64 and mobile devices for the user to see what is happening.
machine learning | embedded systems | Application
An application that assists in support to achieving self-driving vehicles. Various trained models are deployed on ARM64 and mobile devices for the user to see what is happening.
Machine Learning
Turning research to code. This is a stabilizing transformer(Gated Transformer-XL)used for reinforcement learning agents. Reformats typical architectures by adding gated layers and residuals.
Machine Learning
An agent that uses GTrXL to trade different types of currencies profitably. The environment takes prices and turns them into an image at the time (t). The agent uses the image to perform the optimal trade.
Web Application
A mobile application that enables emergency alerts, headcounts, and live updates via chat between educators and administrators about the active crisis on campus.
Embedded Systems | Web Development | Machine Learning
A safety device for children's car seats that improve supervision, evaluates driving, notifications signal, real-time location tracking, and predicts dangerous situations.
Web Development
The source code for alantessier.com.
Machine Learning
Real life example of applying Double Q-Learning in the crypto space.
Machine Learning
A CNN model is used to detect images with users with blonde hair. The model uses the celeb_a dataset so it can be modified to be trained on any characteristic. These characteristics can be for people with eyeglasses, bald heads, facial hair, rosy cheeks, young faces, etc.


Comparing to another activity is useful if it helps you formulate questions, it's dangerous when you use it to justify answers. --Martin Fowler [ source]


---
layout: post
title: Upgraded to MS Office 2008
tags:
- Mac
status: publish
type: post
published: true
meta: {}
---
I've just bitten the bullet and upgraded from MS Office 2004 (for the Mac) to Office 2008. I actually prefer NeoOffice and Thunderbird, but we use Exchange for our corporate email and I am desperate for better calendar and address book support.
I can now check colleagues availability when making appointments, however I can't view shared calendars.
At the moment it keeps asking for access to my keychain every 10 mins and the normal fix does not work :-(
So far I can't access our global address book either.
I wish we used Zimbra!


×
Wheel of Misfortune is a game that aims to build confidence to oncall engineers via simulated
outage scenarios.
With the game, you practice problem debugging under stress, the understanding of the incident
management protocol, and effective communication with other engineers
of your team and organization. It is a great way to train new hires, interns, and seasoned
engineers to become well-rounded oncall engineers.
Terminology
- Scenario: A past or fictional incident case.
- Game Master: The host-coordinator of the session.
- Volunteer: The trainee oncall engineer.
Feel free to fork the repository or download the stable release.
Insert your incident scenarios into the general_incidents.json
file inside the incidents/
folder. The file has the following format:
| title |
the title of the incident. |
| scenario |
the description of the incident. It is useful to include URLs from monitoring
systems, dashboards, time-series databases and playbooks. |
| difficulty |
the difficulty level of the outage. |
| ID |
the unique ID of the outage (you can just auto-increment). |
Game Master
- Choose a volunteer to be the primary oncall engineer in front of the group.
- Find a balance between volunteer's experience and incident's difficulty.
- Assist volunteer by answering questions that may arise in each theoritical action or
dashboard observation.
- Engage with the rest of the team and ask for different ways to debug the problem
following volunteer's explanation.
- Team members may be made available over time for assistance in various topics.
- At the end, have a debrief on the learnings of the session.
Volunteer
- Spin the wheel and attempt to fix the theoretical outage scenario.
- Explain to the Game Master and the rest of the group, what actions you would take (lookup
queries, checks in dashboards, etc.) to find the root causes, and eventually solve the
incident.
- Always keep an eye on the time, since it is simulated incident response scenario and not a
routine troubleshooting process. During a real incident you might have an SLA or SLO
breach and therefore, you should take timing into account.
- Engage with the rest of the group. Keep them in the loop. Ask questions to different
members depending on their expertise.
Most importantly, have fun!
You can read a comprehensvie example on how to conduct the exercise here.


Jessica is a passionate data driven storyteller who is currently residing in Singapore.
To pursue her passion in data and analytics, she is working as an Insights Analyst at LinkedIn. She is a strategic advisor to LinkedIn reps and clients, to help them achieve their hiring successes.
In her spare time, Jessica likes to watch movies, do yoga, cycling, and running. She is also passionate about travelling; she has lived in seven cities and six countries and travelled to more than twenty countries. Some of the pctures from her life journey and travels are displayed in the slideshow above.
The holiday season is around the corner! Yipppeee!!
Merry Christmas and Happy New Year 2017! Eat, drink, and be merry!
Have a wonderful break and be energised for the new year! :)


Hong Kong police use water cannon as protesters throw petrol bombs - video
by Reuters, APHong Kong riot police fired teargas rounds and used a water cannon on Saturday to break up a rally by thousands of masked protesters after Beijing indicated it might tighten its grip on the territory


Click the button below. A popup will appear and -- after a short duration -- will have content added to it dynamically. Verify that the popup arrow points directly at the button both before and after the update.


--- layout: compress --- {% comment %} This replaces pieces of rendered page with new pieces, all at compile time. {% endcomment %} {% assign output = content | replace: '


RUNNING OUT OF SWEET EXPRESSIONS!
For your next task, solve this logic puzzle! You don't have to use code, but you can't look up the answer! You must show all characteristics of the fish keeper to go on.
Facts:
1. There are 5 houses (along the street) in 5 different colors:
blue, green, red, white and yellow.
2. In each house lives a person of a different nationality:
Brit, Dane, German, Norwegian and Swede.
3. These 5 owners
drink a certain beverage:
beer, coffee, milk, tea and water,
smoke a certain brand of cigar:
Blue Master, Dunhill, Pall Mall, Prince and blend,
and keep a certain pet:
cat, bird, dog, fish and horse.
4. No owners have the same pet, smoke the same brand of cigar, or drink the same beverage.
Hints:
1. The Brit lives in a red house.
2. The Swede keeps dogs as pets.
3. The Dane drinks tea.
4. The green house is on the left of the white house (next to it).
5. The green house owner drinks coffee.
6. The person who smokes Pall Mall rears birds.
7. The owner of the yellow house smokes Dunhill.
8. The man living in the house right in the center drinks milk.
9. The Norwegian lives in the first house.
10. The man who smokes blend lives next to the one who keeps cats.
11. The man who keeps horses lives next to the man who smokes Dunhill.
12. The owner who smokes Blue Master drinks beer.
13. The German smokes Prince.
14. The Norwegian lives next to the blue house.
15. The man who smokes blend has a neighbor who drinks water.
Who keeps fish?
The person's nationality is the name of the next file.
Good luck!


AQUARIUM : The Laboratory Operating System
Aquarium allows a researcher to specify precisely how to perform an experimental protocol so that lab personnel will run the protocol the same way, every time.
Protocols, written in a Ruby DSL called Krill, encode how to manipulate Aquarium's inventory system (LIMS), compute formulae such as volumes, molarities, temperatures, and timing, as well as present lab technicians with images and detailed instructions. Protocols define formal unit operation types with typed inputs and outputs – allowing the researcher to construct a complex workflow by linking an output sample of one protocol to an input of another using the Aquarium graphical workflow designer.
Protocols and processes are scheduled and presented to technicians on touchscreen monitors placed throughout the lab. Every step is logged: who performed the step, which items were used, what data was gathered by which instruments, and how long it took -- data that can be used to debug and improve the experiment. More importantly, Aquarium provides a complete, executable description of the results obtained – one that could be used by another lab running Aquarium to reproduce the result.
Aquarium is the operating system of the UW BIOFAB, a service of the Klavins Lab at the University of Washington.
Users
Users should start at the Getting Started page of Aquarium.bio.
Developers
Developers should start with the developer documentation.


Download
Grab the latest release of Punchdrunk from the releases page!About
Have you ever made a Love game and wished that you could easily show it to people without them having to download an executable? Well now they can! ... maybe. Punchdrunk is a project that aims to replicate most part of the Love API in the browser and enable to you to run your original Lua code in the browser via a Lua Virtual Machine named Moonshine.
Punchdrunk is still very early alpha software. It works well with a limited subset of Love's API. If it doesn't work with the game you made, please consider sending me your game to test against or forking the project. I am working to expand which portions of the Love API that Punchdrunk supports but I will prioritize feature requests from actual users when possible. However, certain elements of the API will require a lot of additional work (i.e. Shaders) or be altogether impossible (full filesystem integration).
Please check out the Github page for more information on how to get your own game running in the browser.


CD-HIT package can perform various jobs like clustering a protein database, clustering a DNA/RNA database, comparing two databases (protein or DNA/RNA), and generating protein families. More infomation is available at home page.
CD-HIT clusters proteins that meet a similarity threshold, usually a sequence identity. Each cluster has one representative sequence. The input is a protein dataset in fasta format. It generates a fasta file of representative sequences and a text file of list of clusters.
Multiple CD-HIT runs. Proteins are first clustered at a high identity (like 90%), the non-redundant sequences are further clustered at a low identity (like 60%). A third cluster can be performed at lower identity. Multi-step run is more efficient and more accurate than a single run.
CD-HIT-2D compares 2 protein datasets (db1, db2). It identifies the sequences in db2 that are similar to db1 at a certain threshold. The input are two protein datasets (db1, db2) in fasta format and the output are two files: a fasta file of proteins in db2 that are not similar to db1 and a text file that lists similar sequences between db1 & db2.
CD-HIT-EST clusters a nucleotide sequences that meet a similarity threshold, usually a sequence identity. The input is a DNA/RNA dataset in fasta format It generates a fasta file of representative sequences and a text file of list of clusters. It can not be used for very long sequences, like full genomes.
Multiple CD-HIT-EST runs.
Like CD-HIT-2D, CD-HIT-EST-2D compares 2 nucleotide datasets. For same reason as CD-HIT-EST, CD-HIT-EST-2D is not good for very long sequences.
1. Ying Huang, Beifang Niu, Ying Gao, Limin Fu and Weizhong Li. CD-HIT Suite: a web server for clustering and comparing biological sequences. Bioinformatics, 2010(26): 680-682. full text
2. Weizhong Li and Adam Godzik. Cd-hit: a fast program for clustering and comparing large sets of protein or nucleotide sequences. Bioinformatics, 2006(22): 1658-1659. full text
3. Weizhong Li, Lukasz Jaroszewski and Adam Godzik. Tolerating some redundancy significantly speeds up clustering of large protein databases. Bioinformatics, 2002(18): 77-82. full text
4. Weizhong Li, Lukasz Jaroszewski and Adam Godzik. Clustering of highly homologous sequences to reduce the size of large protein databases. Bioinformatics, 2001(17): 282-283. full text


| Home | Trees | Indices | Help |
|
|---|
|
|
Version: $Revision$
Date: 24 Jun 2008
Author: Antti Haapala<EMAIL_ADDRESS>Copyright: 2008 Red Innovation Ltd.
License: 3-clause BSD
|
|||
|
FixedOffset Fixed offset in minutes east from UTC. |
|||
|
datetime Time zone aware subclass of Python datetime.datetime |
|
|||
|
|||
|
|||
|
|
|||
__doc__ =
|
|||
_utc = _pytz.utc
|
|||
_default_tz = _pytz.utc
|
|||
_fixed_offset_tzs = {}
|
|||
_iso8601_parser = _re.compile(
|
|
Sets the default time zone used by the objects contained in this module. new_tz may be either a pytz-compatible tzinfo (requires normalize and localize methods), or a time zone name known to pytz. |
For internal use only: Returns a tzinfo with the given fixed offset. This creates only one instance for each offset; the zones are kept in a dictionary |
|
__doc__
|
_iso8601_parser
|
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Sun May 30 23:29:54 2010 | http://epydoc.sourceforge.net |


The dndLib would be good foe doing some tests where you have to move something somewhere, and here i tried to fund the most difficult variant of test, so it supposed to be difficult of doing it, but i am sure that dndLib will make this task much easier, so lets see what have i decided to do.
So you can see that this example is kind a difficult on ots making, bau using the dbdLib it takes just 80 lines of code. Go here to see a next example.


We are Swiss-based data scientists who have jointly spent over 25 years doing data science with R for both research and industry. Our goal is to help you learn the skills needed to discover and communicate insights from data and join the data revolution.
We offer various courses for everyone interested in starting their journey into Data Science. For more information see upcoming courses.
You have a Data Science problem? We might be able to help. Send us a message and we will get back to you right away.
We are active R developers and share R's open philosophy. That's why you will find all our materials are publicly available at all times.
For professionals and academics!
Balancing short, interactive presentations and longer hands-on, step-by-step practicals our courses are designed to cater to your specific level and needs, may you be a beginner or advanced data analyst. There will be multiple instructors to ensure that no one gets lost. Please contact us, if you have questions, and explore our open materials.
200CHF @ Uni Basel
790CHF @ Uni Basel
"Many thanks for the excellent course, I really learnt a lot. The documents were super useful and the examples really interesting. In addition you guys were all awesome, super helpful, engaging and the atmosphere was really stimulating."
BRUNO, Head of Clinical Development
"A perfect course if you would like to get a good understanding about machine learning and how to apply it in R. The course covers the most important topics regarding machine learning and is very well organized. In the end you will be able to create meaningful machine learning models, to evaluate and to optimize them. The lecturers are enthusiastic about the topic and explained everything in an understandable way."
FREDERIK, Senior consultant
"You really deserve all compliments: for presentation, for teaching, for your help and last but not least and friendly attitude. The course was above my expectations! The material presented was hands-on and up-to-date!"
STEFAN, Senior Risk Modeller & Researcher
"I learned from the basics to really cool stuff like interactive plots. Right after the bootcamp I decided to move fully into R. Really great bootcamp!"
EDGAR, Associate Professor
"Every participant will have found something he or she could relate to, be it statistics, visualizations, presentations or web apps. It certainly made me want to take my computer and get cracking right away!"
JOHAN, Analyst
"Learning R at The R Bootcamp has offered me [...] the feeling of staying relevant in the changing finance industry"
IRENA, Credit Officer
"I had no experience with programming, but through The R Bootcamp (after only half a day!) was R made accessible to me in a relaxed and comfortable manner. I am looking forward to the next steps with R and The R Bootcamp."
SARAH, Researcher, Pharma
Founder & Lead instructor
I work as a researcher at the University of Basel, specialising in decision science and big data approaches to understanding human behavior.
Favorite R package
Rcpp to make R lightning fast.
My own R packages
cstab for clustering methods.
memnet for the analysis of memory networks.
mousetrap for analysing movement trajectories.
Instructor @ Bern
I am a senior lecturer for methodology at the department of Business Administration, University of Bern. I specialise in tracing human decision processes through eye- and movement-tracking.
Favorite R package
tidyverse to make Data Science efficient.
My own R packages
mousetrap for analysing movement trajectories.
Instructor @ Berlin
I am a PhD student at University of Basel and work on semantic networks at the Max Planck Institute for Human Development in Berlin.
Favorite R-package
ggplot2 for systematic plots.
Learn Data Science with R from the ground up
Description
Data are the gold of the 21st century. With access to data and the knowledge to analyze it, you may contribute to the advance of science and technology in health care or via the use of intelligent marketing secure critical advantages over your competition. No matter what your goal is, whether you work in management or R&D, expertise in the area of modern data analytics is becoming a decisive faktor. This afternoon course offers an entry point into the world of Data Science and Big Data through the open programming language R, which not only has been developed for data analytics, but also is one of the most sought after skills in this field. You will learn the the basic principles of the R language and you will begin to use them in several small interactive session. In the end, you will also learn how to best continue your journey into modern data analytics.
Audience
Participation in this course requires no prior knowledge. Participants are requested to bring their own laptop.
Details
| Language | German |
| Times | 1-day course: Fr, 1pm-6pm |
| Location | Online (Zoom) |
| Class | Max. 20 students |
| Price | 200CHF |
Structure
The course will take place from 1pm to 6pm and consists of a mix of short presentations and interactive sessions, allowing you to acquire hands-on-experience. All course materials, examples, exercises and solutions will be available to you online during and after the course.
Schedule & Materials (subject to change)
| Tag 1 | |
|---|---|
| 1300 | Welcome |
| 1320 | Why R? |
| 1340 | R(Studio) |
| 1425 | Assignments |
| 1520 | Functions |
| 1555 | Data I/O |
| 1630 | Data analysis |
| 1700 | Next steps |
| 1745 | Wrap-up |
Key packages
| base | Simply base R. |
| stats | R's standard for statistics. |
| graphics | Rs standard for visualizations (not to be confused with ggplot2). |
Explore and visualize data with R
Description
Every data-driven project begins with gathering and exploring data. This fundamental step encompasses the cleaning and joining of multiple data sets and the visualization of descriptive patterns present within the combined data. For tasks like these no analytics tool can hold a candle to the programming language R. In this packaged you will learn all elements of gathering and exploring data with R. You will learn how to read data from your hard drive or a remote location, how to clean and organize data, how to run simple descriptive analyses, and, finally, how to create aesthetically-pleasing, publication-ready visualization.
Audience
Participants should possess basic knowledge of the R language. If you are interested in participating, but you have no or to little experience with R, we recommend participating in our afternoon course “Introduction to modern data analytics with R”. If you are unsure whether you meet the prerequisites for this course get in contact with us or participate in this QUIZ. Participants are requested to bring their own laptop with software installation rights.
Details
| Language | German |
| Times | 2-day course: Sat-Sun, 9am-6pm |
| Location | Online (Zoom) |
| Class | Max. 20 students |
| Price | 790CHF |
Structure
This course takes place from 9am to 6pm on two course days. Each day will contain a series of short lectures and examples to introduce you to new topics. The bulk of each day will be dedicated to hands-on exercises to help you ‘learn by doing’. With multiple instructors on site dedicated time will be given for 1:1 feedback. All course materials, tutorials, examples, exercises, and solutions will be available online for you to view at any time during, and after the course. Find our past materials under the See our past materials button on our webpage.
Schedule & Materials (Feb, 2019, subject to change)
| Day 1 | Day 2 | |
|---|---|---|
| 0900 | Welcome | Recap |
| 0930 | Data + | Plotting I + |
| 1200 | Lunch | Lunch |
| 1300 | Wrangling I + | Plotting II + |
| 1530 | Wrangling II + | Plotting III + |
| 1745 | Wrap-up | Wrap-up |
Key packages
| tidyverse | A collection of cutting-edge Data Science packages prominently including readr, dplyr, and ggplot2. |
| readr | Convenient package for reading in text file formats such as .csv and .txt. |
| dplyr | R's go to data wrangling package for cleaning, organizing, and joining data sets. |
| ggplot2 | Arguably the best visualization package across all programming language, not just R. |
Learn to make data-driven decisions with R
Description
This course teaches you the logic of common statistical procedures, how to implement various statistical analyses in R, including Regression, ANOVA, and robust tests, how to evaluate their assumptions, and how to interpret their results.
Audience
Participants should possess basic knowledge of the R language. If you are interested in participating, but you have no or to little experience with R, we recommend participating in our afternoon course “Introduction to modern data analytics with R”. If you are unsure whether you meet the prerequisites for this course get in contact with us or participate in this QUIZ. Participants are requested to bring their own laptop with software installation rights. Basic knowledge of statistics is helpful but not strictly necessary.
Details
| Language | German |
| Times | 2-day course: Sat-Sun, 9am-6pm |
| Location | Online (Zoom) |
| Class | Max. 20 students |
| Price | 790CHF |
Structure
This course takes place from 9am to 6pm on two course days. Each day will contain a series of short lectures and examples to introduce you to new topics. The bulk of each day will be dedicated to hands-on exercises to help you ‘learn by doing’. With multiple instructors on site dedicated time will be given for 1:1 feedback. All course materials, tutorials, examples, exercises, and solutions will be available online for you to view at any time during, and after the course. Find our past materials under the See our past materials button on our webpage.
Schedule & Materials (Apr, 2019, subject to change)
| Day 1 | Day 2 | |
|---|---|---|
| 0900 | Welcome | Recap |
| 0930 | Intro to Statistics | Linear models III + |
| 1200 | Lunch | Lunch |
| 1300 | Linear models I + | Robust statistics + |
| 1530 | Linear models II + | New statistics + |
| 1745 | Wrap-up | Wrap-up |
Key packages
| stats | Containing |
| lme4 | Extends lm to implement hierarchical models. |
| boot | Multi-purpose tool to conduct robust bootstrapping analyses. |
| pwr | Conduct sample size calculation in R. |
Learn to build predictive algorithms with R
Description
Machine learning is the basis for groundbreaking developments and technologies in many branches of business and research. Would you like to know what makes machine learning so successful and how you can reap its benefits using the open programming language R? In this intensive course, you will learn the fundamental principles of machine learning and how to apply them using R: from reading in data, to the application of various algorithms and their evaluation based on key performance measures. You will learn about the characteristics of popular algorithms such as regression, decision trees, and random forests. You will hear about recent developments, such as Deep Learning, and gain an overview over typical machine learning problems, such as regression, classification, and clustering, and discuss with us the risks and benefits of machine learning for society and business.
Audience
Participants should possess basic knowledge of the R language. If you are interested in participating, but you are unsure whether you meet the prerequisites for this course get in contact with us or participate in this Quiz. Participants are requested to bring their own laptop with software installation rights. Basic knowledge of statistics is helpful, but not strictly necessary.
Details
| Language | German |
| Times | 2-day course: Sat-Sun, 9am-6pm |
| Location | Online (Zoom) |
| Class | Max. 20 students |
| Price | 790CHF |
Structure
This course takes place from 9am to 6pm on two course days. Each day will contain a series of short lectures and examples to introduce you to new topics. The bulk of each day will be dedicated to hands-on exercises to help you ‘learn by doing’. With multiple instructors on site dedicated time will be given for 1:1 feedback. All course materials, tutorials, examples, exercises, and solutions will be available online for you to view at any time during, and after the course. Find our past materials under the See our past materials button on our webpage.
Schedule & Materials (Oct, 2019, subject to change)
| Day 1 | Day 2 | |
|---|---|---|
| 0900 | Welcome | Recap |
| 0930 | What is ML? | Optimization + |
| 1200 | Lunch | Lunch |
| 1300 | Fitting + | Features + |
| 1530 | Prediction + | Look ahead + |
| 1745 | Wrap-up | Wrap-up |
Key packages
| caret | R's Swiss army knife for training and evaluating more than 200 machine learning algorithms. |
Learn to create dynamic, interactive Reports with R.
Description
One of the most important tasks in data-driven projects is the communication of the results. This can be in the form of reports, presentations or interactive dashboards. The programming language R and R Studio are among the best tools available for this purpose. In this intensive two-day course, you will learn how to use RMarkdown to easily create and design dynamic reports and slides in different formats such as .html, .pdf, .docx, or .pptx. You will learn how to create analyses, visualizations, and text in a single document that can be reproduced as desired. You will also learn how to create interactive dashboards with Shiny so that you can easily explore data and visualisations and make them available for exploration.
Audience
Participants should possess basic knowledge of the R language. If you are interested in participating, but you have no or to little experience with R, we recommend participating in our courses “Introduction to modern data analytics with R” and “Exploratory data analytics with R”. If you are unsure whether you meet the prerequisites for this course get in contact with us or participate in this QUIZ. Participants are requested to bring their own laptop with software installation rights.
Details
| Language | Deutsch |
| Times | Zweitageskurs: Fr-Sa, 09.00-18.00 Uhr |
| Location | Online (Zoom) |
| Class | Max. 20 students |
| Price | 790CHF |
Structure
This course takes place from 9am to 6pm on two course days. Each day will contain a series of short lectures and examples to introduce you to new topics. The bulk of each day will be dedicated to hands-on exercises to help you ‘learn by doing’. With multiple instructors on site dedicated time will be given for 1:1 feedback. All course materials, tutorials, examples, exercises, and solutions will be available online for you to view at any time during, and after the course. Find our past materials under See our past materials button on our webpage.
Programm & Materialien (Feb, 2020, Änderungen vorbehalten)
| Day 1 | Day 2 | |
|---|---|---|
| 0900 | Welcome | Recap |
| 0930 | Dynamic reports with Markdown I | Slides with Markdown |
| 1200 | Lunch | Lunch |
| 1300 | Dynamic reports with Markdown II | Dashboards with Shiny |
| 1530 | Styling dynamic reports | Dashboards with Shiny II |
| 1745 | Wrap-up | Wrap-up |
Wichtige Pakete
| rmarkdown | Create reproducible reports in .html, .doc, .ppt, or .pdf formats. |
| shiny | Create interactive dashboards. |
5 reasons why you should learn R today.
1. R was designed for analytics
R was designed first and foremost as a language for analytics and statistics. For that reason, R makes it easy for you to run statistical analyses, may it be an A/B test or a complex machine learning algorithm, with minimal code. Thanks to modern packages such as dbplyr and RHadoop, R also enables you to use virtually the same code when analysing Gigabytes of data stored on databases as you would on a data from a small Excel spreadsheet.
2. R has an unrivaled set of free packages
As great as R’s core framework is, the language would not be nearly as popular as it is today if it weren’t for R’s unrivaled collection of (freely available!) packages. What is an R package? An R package is a collection of code designed to help you, the programmer, solve a particular task without having to program a solution yourself. It really is difficult to overstate comprehensiveness of the R package universe.
3. R enables you to make striking visualisations
As good as R is for statistics, it is as good, if not better, for data visualisation. Why? One word: ggplot2. The ggplot2 package makes it easy for anyone to create colorful, complex, striking visualisations with minimal code. For example, you can create the plot below with essentially only 5 lines of code.
4. R works great with other languages
There are cases where you may want to take advantage of the features of other languages, such as C++ for its blinding speed or SQL for querying relational databases. Thankfully, with packages such as Rcpp for C++ or dbplyr for SQL combined with the amazing RStudio integrated developer environment, you can easily supplement your R code with these and other languages.
5. R has a passionate, open community
Without question, one of the best things about R is its community of passionate users, developers and bloggers who will jump at the chance to show you all of the amazing things they are doing with R. With hundreds of bloggers sharing their code at r-bloggers.com or local meetup groups such as R-Ladies or Michael's Bern R Meetup, the opportunities to meet with and learn from other R users are really endless.
using the amazing tidyverse
According to many estimates, data scientists spend most time not on the implementation of sophisticated algorithms, but on the preceding steps: first, cleaning and organizing the data, and then mining and visualizing their important trends. There are many tools to carry out these steps, but there is no better in R or any other language than the amazing tidyverse.
What is the tidyverse?
The tidyverse is a meta-package that combines several individual R packages - packages are free and openly available collections of functions - each geared towards an elementary Data Science task. For example, the readr package allows you to read in data files from your hard-drive, the dplyr package efficiently handles all cleaning, organization, and joining of data sets, and the ggplot2 package makes creating striking, publication-ready visualizations a piece-of cake.
The tidyverse is more
The tidyverse is also a new framework of working in R. The tidyverse comes with a novel, improved coding style centering on modular programming using the pipe operator
Tidyverse vs. classic R
For these and other reasons, we focus our bootcamp on R for Data Science predominantly on the tidyverse rather than the classic functionality within R. Not convinced about the beauty of the tidyverse? Check out the example below comparing the same analysis in tidyverse and more basic R style or join our course on R for Data Science.
Tidyverse
# 1. Load tidyverse & data library(tidyverse) # makes all tidyverse packages available titanic <- read_csv("https://osf.io/aupb4/download") # load data # 2. data transformation and aggregation using dplyr titanic <- titanic %>% mutate(sex = case_when(Sex == "male" ~ "Male", TRUE ~ "Female"), age = case_when(Age >= 18 ~ "Adult", Age < 18 ~ "Minor"), class = factor(PClass)) %>% drop_na() %>% rename(gender = sex) %>% group_by(class, gender, age) %>% summarise(survival = mean(Survived)) # 3. plot using ggplot2 ggplot(titanic, aes(class, survival, fill = gender)) + geom_bar(stat = "identity", position = position_dodge()) + labs(x = "Class", y = "Proportion Survived", title = "Titanic Survivors") + facet_wrap(~ age) + theme_light()
Classic R
# 1. Load data titanic <- read.csv("https://osf.io/aupb4/download") # load data # 2. data transformation and aggregation using base R titanic$gender = titanic$Sex titanic$gender[titanic$gender == "male"] <- "Male" titanic$gender[titanic$gender == "female"] <- "Female" titanic$age <- ifelse(titanic$Age >= 18, "Adult", "Minor") titanic$class <- factor(titanic$PClass) titanic <- aggregate(titanic$Survived, list(class = titanic$class, gender = titanic$gender, age = titanic$age), mean) names(titanic)[4] <- "survival" # 3. plot using base R layout(matrix(c(1,2,3), nrow = 1), width = c(.4,.4,.2)) par(mar <- c(5.1, 4.1, 6.1,0)) cols <- c(rgb(232, 125, 114, maxColorValue = 255), rgb(84, 188, 194, maxColorValue = 255)) barplot(survival ~ gender + class, data = subset(titanic, age == "Adult"), beside = TRUE, ylim = c(0, 1), ylab = "Proportion Survived", xlab = "Class", main = "Titanic Survivors", las = 1, cex.lab = 1.5, cex.axis = 1.25, cex.main = 1.8, col = cols, border = NA) axis(side = 1, at = c(-1, 12)) rect(0.68, 1.01, 9, 1.08, col = "lightgrey", border = NA, xpd = TRUE) text(5, 1.04, "Adult", xpd = TRUE, cex = 1.6) barplot(survival ~ gender + class, data = subset(titanic, age == "Child"), beside = TRUE, ylim = c(0, 1), ylab = "Proportion Survived", xlab = "Class", las = 1, cex.lab = 1.5, cex.axis = 1.25, col = cols, border = NA) axis(side = 1, at = c(-1, 12)) rect(0.68, 1.01, 9, 1.08, col = "lightgrey", border = NA, xpd = TRUE) text(5, 1.04, "Minor", xpd = TRUE, cex = 1.6) plot.new() plot.window(xlim = c(0, 1), ylim = c(0, 1)) par(mar = c(0, 0, 0, 0)) points(c(-.5, -.5), c(.525, .445), pch = 15, col = cols, cex = 4, xpd = TRUE) text(c(-.25, -.25), c(.525, .445), labels = c("Female", "Male"),offset = 0, cex = 1.8, adj = 0) text(-.55, .65, "Gender", cex = 2, font = 2, adj = 0, offset = 0)
Analyse sentiment using tidytext
Sentiment analysis is a powerful tool with diverse areas of application that allows one to assess the affective content of pieces of text. For example, say you are interested in the impact of a novel compaign targeted at improving your companies image. One way to track the success of your compaign would be to analyze the sentiment that customers express on social media posts or product reviews.
R is great for natural language processing
Turns out that R has a number of tidyverse-related packages that make carrying out such analyses surprisingly easy. The packages xml2 and rvest help you pull any kind of information from the internet and, once text is imported into R, the tidytext package allows you to very efficiently perform many natural langugage processing tasks including sentiment analysis.
Sentiment of Swiss companies
The example below illustrates the ease of conducting sentiment analysis of text available online. The analysis first downloads the English Wikipedia pages of the twelve highest-grossing Swiss companies. Then, in just five lines, the code computes the average sentiment of each company based on the words available in the respective articles.
# 0. load packages require(tidyverse) require(xml2) require(rvest) require(tidytext) # 1. get website urls companies <- c( "Glencore", "Vitol", "Trafigura", "Mercuria_Energy_Group", "Nestlé", "Gunvor_(company)", "Hoffmann-La_Roche", "Novartis", "ABB_(company)", "Coop_(Switzerland)", "Migros", "LafargeHolcim") urls <- paste0("https://en.wikipedia.org/wiki/", companies) # 2. read Wikipedia articles texts <- map(urls, function(x){ x %>% read_html() %>% html_node("body") %>% html_text()}) texts<- tibble(company = companies, text = unlist(texts))
# 3. get sentiments using tidytext sentiment <- texts %>% unnest_tokens(word, text) %>% inner_join(get_sentiments("afinn")) %>% group_by(company) %>% summarize(sentiment = mean(score))
created easily using tidytext
The critical, final stage of any analysis is communication. In one way or another, the collected insights must find their way into a document or presentation, may for it be a periodical report or a research project. This achieved by transferring the numerical results and figures into another software used for creating the report by hand. Clearly, however, this is unnecessarily tedious, inflexible, and prone to errors. That is, if you knew R Markdown.
What is R Markdown?
R Markdown is an extension to Markdown, a lightweight markup language (https://en.wikipedia.org/wiki/Markdown). R Markdown provides you with a very simple syntax for creating and formatting documents that allows you to combine your R analysis code, the output that it produces, and plain text surrounding analysis. This means that when using R Markdown there is no more copy and pasting, everything is in one place.
Creating dynamic reports with R Markdown
Using R Markdown has loads of advantages. The most important one is that your documents become reproducible and dynamic. When you have everything in one place, making changes to the analysis or using a different set of data becomes entirely hassle-free. All you need to do is to make these changes and then re-”knit” the document, which will automatically re-create your document with all changes incorporated. Another benefit is that you can be sure your document reflects with 100% accuracy the results of your analysis. Typos in any of the important numbers? Not possible.
R Markdown is amazingly versatile
We rely heavily on R Markdown to create the diverse materials for our Bootcamps. All slides used for our presentations are entirely created using R Markdown, and so are documents that guide through the coding exercises. Both elements we produce as .html files so that our materials can be made accessible online. See, for instance, our slides on What is Machine Learning? or our exercise on Data Wrangling (includes solutions). However, you can use R Markdown to generate many different types of formats including nicely formatted PDF or Word documents.
Want to learn more about R Markdown, and reporting using R in general? Check out the freely available book R Markdown - The Definitive Guide, or join our course on Reporting with R, which we hope offer in the near future.
In the spirit of R's open philosophy, we keep the materials of our courses publicly available. Feel free to explore the materials of our past courses below.
Begin your journey into modern analytics with R
October 2022 | 1/2-dayLearn to explore and visualize data with R
March 2022 | 2-dayLearn to make data-driven decisions with R
April 2022 | 2-dayLearn to build predictive algorithms with R
October 2020 | 2-dayLearn to create dynamic, interactive Reports with R.
Februar 2021 | 2 Tage13 June 2019
Agreement to terms
You agree that by accessing the Site. you have read, understood, and agreed to be bound by all of these Terms of Use. Supplementary terms and conditions or documents that may be posted on the Site from time to time are hereby expressly incorporated herein by reference. You will be deemed to have been made aware of and have accepted the changes in any revised Terms of Use by your continued use of the Site.
License
Unless otherwise indicated, the Site and its contents are licensed under the Creative Commons Attribution 4.0 licensing terms. If you are interested in using content on this size, please take a moment to read the full Creative Commons Attribution 4.0 licensing terms.
Third-party content
The site may contain links to other websites and conent belonging to third parties. Such websites and content are not investigated by us and we are not responsible for any third-party websites or content accessed through the Site.
Term and termination
These Terms of Use shall remain in full force and effect while you use the Site.
Modifications
We reserve the right to change, modify, or remove the contents of the Site at any time or for any reason at our sole discretion without notice. However, we have no obligation to update any information on our Site. We also reserve the right to modify or discontinue all or part of the Site without notice at any time.
Contact us
In order to resolve complaint regarding the Site or to receive further information regarding use of the site, please contuct us at:
The R Bootcamp
Faculty of Psychology
Missionstrasse 64A
CH-4055 Basel
Mail
13 June 2019
This page informs you of our policies regarding the collection, use and disclosure of Personal Information we receive from users of the Site. We use your Personal Information only for providing and improving the Site. By using the Site, you agree to the collection and use of information in accordance with this policy.
Information collection and use
While using our Site, we may ask you to provide us with certain personally identifiable information that can be used to contact or identify you. Personally identifiable information may include, but is not limited to your name.
Log data
Like many site operators, we collect information that your browser sends whenever you visit our Site. This Log Data may include information such as your computer's Internet Protocol address, browser type, browser version, the pages of our Site that you visit, the time and date of your visit, the time spent on those pages and other statistics. In addition, we may use third party services such as Google Analytics that collect, monitor and analyze this data.
Communications
We may use your Personal Information to contact you with newsletters, marketing or promotional materials and other information pertaining to our training and consultinig services.
Cookies
Cookies are files with small amount of data, which may include an anonymous unique identifier. Cookies are sent to your browser from a web site and stored on your computer's hard drive. Like many sites, we use "cookies" to collect information. You can instruct your browser to refuse all cookies or to indicate when a cookie is being sent. However, if you do not accept cookies, you may not be able to use some portions of our Site.
Securities
The security of your Personal Information is important to us, but remember that no method of transmission over the Internet, or method of electronic storage, is 100% secure. While we strive to use commercially acceptable means to protect your Personal Information, we cannot guarantee its absolute security.
Changes to this privacy policy
This Privacy Policy is effective and will remain in effect except with respect to any changes in its provisions in the future, which will be in effect immediately after being posted on this page. We reserve the right to update or change our Privacy Policy at any time and you should check this Privacy Policy periodically. Your continued use of the Service after we post any modifications to the Privacy Policy on this page will constitute your acknowledgment of the modifications and your consent to abide and be bound by the modified Privacy Policy.
Contact us
In order to resolve complaint regarding the Site or to receive further information regarding use of the site, please contact us at:
The R Bootcamp
Faculty of Psychology
Missionstrasse 64A
CH-4055 Basel
Mail


Schedule
This is the tentative schedule of the workshop. All slots are provided in Pacific Time (PT) using a 12h format. Use this time zone converter to convert these times to your local time zone.
| Time (PT) | Event |
| 08:45 am - 09:00 am | Opening Remarks |
| Session 1 | |
| 09:00 am - 09:35 am | Invited Talk #1 |
| 09:35 am - 10:10 am | Invited Talk #2 |
| 10:10 am - 10:20 am | Contributed Talk #1 |
| Session 2 | |
| 10:20 am - 10:55 am | Invited Talk #3 |
| 10:55 am - 11:30 am | Invited Talk #4 |
| 11:30 am - 12:00 pm | Panel Discussion #1 |
| 12:00 pm - 01:00 pm | Poster Session #1 |
| 01:00 pm - 02:00 pm | Lunch Break |
| Session 3 | |
| 02:00 pm - 02:35 pm | Invited Talk #5 |
| 02:35 pm - 03:10 pm | Invited Talk #6 |
| 03:10 pm - 03:45 pm | Invited Talk #7 |
| 03:45 pm - 03:55 pm | Contributed Talk #2 |
| Session 4 | |
| 03:55 pm - 04:30 pm | Invited Talk #8 |
| 04:30 pm - 05:05 pm | Invited Talk #9 |
| 05:05 pm - 05:35 pm | Panel Discussion #2 |
| 05:35 pm - 06:35 pm | Poster Session #2 |


|
|
BeagleBone AI:® Putting Artificial Intelligence
in the palm of your hand
Breaking new ground on AI takes performance, community and a
low cost platform that is easy to use. BeagleBone® AI
brings it all to the palm of your hand.
|
|
|
|
|
|
|
The new BeagleBone®
AI provides advances in both hardware acceleration,
real-time functionality and software support for deep
learning.
BeagleBoard.org®
is providing the basis for the same democratization in
access to deep learning and artificial intelligence that
this global community has been known for providing for
Linux.
Visit www.beagleboard.org/ai;
to purchase a board.
|
|
|
|
|
|
Always Innovating
The new BeagleBone® AI has high performance
features needed for Artificial Intelligence applications at a
price to put a board in every project.
- Dual Arm® Cortex®-A15
microprocessor subsystem
- 2 C66x floating-point VLIW DSPs
- 2.5MB of on-chip L3 RAM
- 2x dual Arm® Cortex®-M4
co-processors
- 4x Embedded Vision Engines (EVEs)
- 2x dual-core Programmable Real-Time Unit and Industrial
Communication SubSystem (PRU-ICSS)
- 2D-graphics accelerator (BB2D) subsystem
- Dual-core PowerVR® SGX544™ 3D GPU
- IVA-HD subsystem (4K @ 15fps encode and decode support for
H.264, 1080p60 for others)
|
|
|
|
|
|
BeagleBone® Black Form Factor and Ease of
Use
- Zero-download out-of-box software experience
- Mechanical and header compatibility
- 1GB RAM and 16GB on-board eMMC flash with high-speed
interface
- USB type-C for power and superspeed dual-role controller;
and USB type-A host
- Gigabit Ethernet, 2.4/5GHz WiFi, and Bluetooth
- microHDMI
|
|
|
|
|
|
Activating Imagination
Everyday automation in industrial, commercial and home
applications need new, more powerful and low cost embedded
devices. By utilizing open source processes and community
support, BeagleBone® AI
brings data and model collaboration to embedded developers
providing greater mitigation of risks.
BeagleBoard.org®
community enables collaboration and sharing of practical
knowledge to provide entrepreneurs easy access to solutions that
leverage AI technologies.
|
|
|
|
|