|
SSD1306 OLED display driver
1.8.2
This library is developed to control SSD1306/SSD1331/SSD1351/IL9163/PCD8554 RGB i2c/spi LED displays
|
#include <canvas.h>
Public Member Functions | |
| NanoCanvasOps () | |
| NanoCanvasOps (lcdint_t w, lcdint_t h, uint8_t *bytes) | |
| void | begin (lcdint_t w, lcdint_t h, uint8_t *bytes) |
| void | setOffset (lcdint_t ox, lcdint_t oy) |
| const NanoPoint | offsetEnd () const |
| const NanoRect | rect () const |
| void | putPixel (lcdint_t x, lcdint_t y) |
| void | putPixel (const NanoPoint &p) |
| void | drawVLine (lcdint_t x1, lcdint_t y1, lcdint_t y2) |
| void | drawHLine (lcdint_t x1, lcdint_t y1, lcdint_t x2) |
| void | drawLine (lcdint_t x1, lcdint_t y1, lcdint_t x2, lcdint_t y2) |
| void | drawLine (const NanoRect &rect) |
| void | drawRect (lcdint_t x1, lcdint_t y1, lcdint_t x2, lcdint_t y2) |
| void | drawRect (const NanoRect &rect) |
| void | fillRect (lcdint_t x1, lcdint_t y1, lcdint_t x2, lcdint_t y2) |
| void | fillRect (const NanoRect &rect) |
| void | drawBitmap1 (lcdint_t x, lcdint_t y, lcduint_t w, lcduint_t h, const uint8_t *bitmap) |
| Draws monochrome bitmap in color buffer using color, specified via setColor() method Draws monochrome bitmap in color buffer using color, specified via setColor() method The bitmap is expected in Native ssd1306 controller format. More... | |
| void | drawXBitmap1 (lcdint_t x, lcdint_t y, lcduint_t w, lcduint_t h, const uint8_t *bitmap) |
| Draws monochrome bitmap in color buffer using color, specified via setColor() method Draws monochrome bitmap in color buffer using color, specified via setColor() method The bitmap is expected in XBMP format. More... | |
| void | drawBitmap8 (lcdint_t x, lcdint_t y, lcduint_t w, lcduint_t h, const uint8_t *bitmap) |
| Draws 8-bit color bitmap in color buffer. Draws 8-bit color bitmap in color buffer. More... | |
| void | clear () |
| size_t | write (uint8_t c) override |
| uint8_t | printChar (uint8_t c) |
| void | printFixed (lcdint_t xpos, lcdint_t y, const char *ch, EFontStyle style=STYLE_NORMAL) |
| void | printFixedPgm (lcdint_t xpos, lcdint_t y, const char *ch, EFontStyle style=STYLE_NORMAL) |
| void | setMode (uint8_t modeFlags) |
| Sets canvas drawing mode Sets canvas drawing mode. The set flags define transparency of output images. More... | |
| void | setColor (uint16_t color) |
| Public Member Functions inherited from Print | |
| Print () | |
| size_t | print (const char *str) |
| size_t | print (int n) |
| size_t | println (const char *str) |
| size_t | println (int data) |
Public Attributes | |
| NanoPoint | offset = { 0, 0 } |
Static Public Attributes | |
| static const uint8_t | BITS_PER_PIXEL = BPP |
Protected Attributes | |
| lcduint_t | m_w |
| width of NanoCanvas area in pixels | |
| lcduint_t | m_h |
| height of NanoCanvas area in pixels | |
| lcduint_t | m_p |
| number of bits, used by width value: 3 equals to 8 pixels width | |
| lcdint_t | m_cursorX |
| current X cursor position for text output | |
| lcdint_t | m_cursorY |
| current Y cursor position for text output | |
| uint8_t | m_textMode |
| Flags for current NanoCanvas mode. | |
| EFontStyle | m_fontStyle |
| currently active font style | |
| uint8_t * | m_buf |
| Canvas data. | |
| uint16_t | m_color |
| current color for monochrome operations | |
NanoCanvasOps provides operations for drawing in memory buffer. Depending on BPP argument, this class can work with 1,8,16-bit canvas areas.
|
inline |
|
inline |
| void NanoCanvasOps< BPP >::begin | ( | lcdint_t | w, |
| lcdint_t | h, | ||
| uint8_t * | bytes | ||
| ) |
Initializes canvas object. Width can be of any value. Height should be divided by 8. Memory buffer must be not less than w * h.
| w | - width |
| h | - height |
| bytes | - pointer to memory buffer to use |
| void NanoCanvasOps< BPP >::clear | ( | ) |
Clears canvas
| void NanoCanvasOps< BPP >::drawBitmap1 | ( | lcdint_t | x, |
| lcdint_t | y, | ||
| lcduint_t | w, | ||
| lcduint_t | h, | ||
| const uint8_t * | bitmap | ||
| ) |
Draws monochrome bitmap in color buffer using color, specified via setColor() method Draws monochrome bitmap in color buffer using color, specified via setColor() method The bitmap is expected in Native ssd1306 controller format.
| x | - position X in pixels |
| y | - position Y in pixels |
| w | - width in pixels |
| h | - height in pixels |
| bitmap | - monochrome bitmap data, located in flash |
| void NanoCanvasOps< BPP >::drawBitmap8 | ( | lcdint_t | x, |
| lcdint_t | y, | ||
| lcduint_t | w, | ||
| lcduint_t | h, | ||
| const uint8_t * | bitmap | ||
| ) |
Draws 8-bit color bitmap in color buffer. Draws 8-bit color bitmap in color buffer.
| x | - position X in pixels |
| y | - position Y in pixels |
| w | - width in pixels |
| h | - height in pixels |
| bitmap | - 8-bit color bitmap data, located in flash |
| void NanoCanvasOps< BPP >::drawHLine | ( | lcdint_t | x1, |
| lcdint_t | y1, | ||
| lcdint_t | x2 | ||
| ) |
Draws horizontal or vertical line
| x1 | - position X |
| y1 | - position Y |
| x2 | - position X |
| void NanoCanvasOps< BPP >::drawLine | ( | lcdint_t | x1, |
| lcdint_t | y1, | ||
| lcdint_t | x2, | ||
| lcdint_t | y2 | ||
| ) |
Draws line
| x1 | - position X |
| y1 | - position Y |
| x2 | - position X |
| y2 | - position Y |
| void NanoCanvasOps< BPP >::drawLine | ( | const NanoRect & | rect | ) |
Draws line
| rect | - structure, describing rectangle area |
| void NanoCanvasOps< BPP >::drawRect | ( | lcdint_t | x1, |
| lcdint_t | y1, | ||
| lcdint_t | x2, | ||
| lcdint_t | y2 | ||
| ) |
Draws rectangle
| x1 | - position X |
| y1 | - position Y |
| x2 | - position X |
| y2 | - position Y |
| void NanoCanvasOps< BPP >::drawRect | ( | const NanoRect & | rect | ) |
Draws rectangle
| rect | - structure, describing rectangle area |
| void NanoCanvasOps< BPP >::drawVLine | ( | lcdint_t | x1, |
| lcdint_t | y1, | ||
| lcdint_t | y2 | ||
| ) |
Draws horizontal or vertical line
| x1 | - position X |
| y1 | - position Y |
| y2 | - position Y |
| void NanoCanvasOps< BPP >::drawXBitmap1 | ( | lcdint_t | x, |
| lcdint_t | y, | ||
| lcduint_t | w, | ||
| lcduint_t | h, | ||
| const uint8_t * | bitmap | ||
| ) |
Draws monochrome bitmap in color buffer using color, specified via setColor() method Draws monochrome bitmap in color buffer using color, specified via setColor() method The bitmap is expected in XBMP format.
| x | - position X in pixels |
| y | - position Y in pixels |
| w | - width in pixels |
| h | - height in pixels |
| bitmap | - monochrome bitmap data, located in flash |
| void NanoCanvasOps< BPP >::fillRect | ( | lcdint_t | x1, |
| lcdint_t | y1, | ||
| lcdint_t | x2, | ||
| lcdint_t | y2 | ||
| ) |
Fills rectangle area
| x1 | - position X |
| y1 | - position Y |
| x2 | - position X |
| y2 | - position Y |
| void NanoCanvasOps< BPP >::fillRect | ( | const NanoRect & | rect | ) |
Fills rectangle area
| rect | - structure, describing rectangle area |
|
inline |
Returns right-bottom point of the canvas in offset terms. If offset is (0,0), then offsetEnd() will return (width-1,height-1).
| uint8_t NanoCanvasOps< BPP >::printChar | ( | uint8_t | c | ) |
Draws single character to canvas
| c | - character code to print |
| void NanoCanvasOps< BPP >::printFixed | ( | lcdint_t | xpos, |
| lcdint_t | y, | ||
| const char * | ch, | ||
| EFontStyle | style = STYLE_NORMAL |
||
| ) |
Print text at specified position to canvas
| xpos | position in pixels |
| y | position in pixels |
| ch | pointer to NULL-terminated string. |
| style | specific font style to use |
| void NanoCanvasOps< BPP >::printFixedPgm | ( | lcdint_t | xpos, |
| lcdint_t | y, | ||
| const char * | ch, | ||
| EFontStyle | style = STYLE_NORMAL |
||
| ) |
Print text at specified position to canvas
| xpos | position in pixels |
| y | position in pixels |
| ch | pointer to NULL-terminated string, located in flash |
| style | specific font style to use |
| void NanoCanvasOps< BPP >::putPixel | ( | lcdint_t | x, |
| lcdint_t | y | ||
| ) |
Draws pixel on specified position
| x | - position X |
| y | - position Y |
| void NanoCanvasOps< BPP >::putPixel | ( | const NanoPoint & | p | ) |
|
inline |
|
inline |
|
inline |
|
inline |
|
overridevirtual |
|
static |
| NanoPoint NanoCanvasOps< BPP >::offset = { 0, 0 } |
Fixed offset for all operation of NanoCanvasOps in pixels


{#==========================================
Docs : "configuration"
==========================================#}
Spincast doesn't force you to configure your application in a specific way, but does
suggest a strategy. The only requirement is that
in order to modify the configurations used by the internals of Spincast itself
(for example the
If you don't bind a custom implementation for that
The strategy we suggest to configure your application allows you to both modify the default configurations and add
specific configurations to your application in a single location. This strategy involves creating a
standard Java class with getter methods for each configuration that is needed.
Compared to a simple
Configuration
port
the server is going to be started with), you need to bind
a custom implementation for the
SpincastConfig
interface. Spincast retrieves the values to use for its configurations through this interface.
SpincastConfig
interface, a
default one
will be used and will provide default values.
Configuration strategy - introduction
.properties
based configuration strategy, a class based one
requires more work (since you do have to define a getter method for each configuration),
but comes with three big advantages :
// Doesn't compile! The "getServerHost()" getter returns a String.
int port = configs.getServerHost();
.properties
based configuration
that will fail at runtime :
// Compiles... But boom at runtime!
int port = (int)properties.get("server.host");
// Some configuration getter...
public int getHttpServerPort() {
// We use another configuration to create the value
// of this one! You can use any logic you need...
if("local".equals(getEnvironmentName())) {
return 12345;
} else {
return 80;
}
}
// A configuration getter that returns a File object
public File getSpincastWritableDir() {
// ...
}
The first step is to create a custom AppConfig
interface that extends
SpincastConfig :
public interface AppConfig extends SpincastConfig { /** * An app specific configuration */ public String getSomeAppConfiguration(); /** * Another app specific configuration */ public int getAnotherAppConfiguration(); }
public class AppConfigDefault extends SpincastConfigDefault implements AppConfig { /** * An app specific configuration */ public String getSomeAppConfiguration() { ... } /** * Another app specific configuration */ public int getAnotherAppConfiguration() { ... } /** * Overrides a default Spincast configuration too! */ @Override public int getHttpServerPort() { return 12345; } }
Finally, you add the associated bindings to your Guice module :
public class AppModule extends SpincastGuiceModuleBase { @Override protected void configure() { bind(AppConfig.class).to(AppConfigDefault.class).in(Scopes.SINGLETON); //... } }
SpincastConfig
interface has been bound, and will automatically adjust the binding for this interface. You can bind SpincastConfig
to AppConfigDefault
by yourself if you want, but it is not required.
Have a look at the configuration of this very website for an example of how this strategy looks like!
Be careful with the dependencies you inject in your implementation class : the configurations are used by a lot of other components and it is therefore easy to create circular dependencies. One dependency that you can inject without any problem, and that is often useful in a configuration class, is the application arguments.
By using the strategy above, so by extending the SpincastConfigDefault base class, you also extend the ConfigFinder base class and get access to a lot of useful features to help you build your configuration. In particular, you gain access to an easy way to externalize the values of your configurations (ie : have different configurations depending on the environment the application runs on).
We'll see in the next section, Configuring the config plugin, that the way Spincast searches for external configurations is fully configurable.
To make configurations externalizable, the first thing to do in your implementation class is to remove any hardcoded values and, instead, use the provided getters. Those special getters are provided by the ConfigFinder class, from which SpincastConfigDefault extends. There are multiple getters, depending on the type of the configuration.
For example, in your implementation class, instead of this hardcoded value :
public class AppConfigDefault extends SpincastConfigDefault implements AppConfig { @Inject public AppConfigDefault(SpincastConfigPluginConfig spincastConfigPluginConfig) { super(spincastConfigPluginConfig); } /** * The HTTP server port to use */ @Override public int getHttpServerPort() { // Hardcoded value! return 12345; } // ... }
getInteger(...)
method, so the "port" configuration is
externalized :
public class AppConfigDefault extends SpincastConfigDefault implements AppConfig { @Inject public AppConfigDefault(SpincastConfigPluginConfig spincastConfigPluginConfig) { super(spincastConfigPluginConfig); } /** * The HTTP server port to use */ @Override public int getHttpServerPort() { // Makes this configuration externalizable // and provides a default value in case no // external value is found. return getInteger("server.port", 12345); } // ... }
By using the special getters provided by the ConfigFinder
base class, your configuration is now externalized. A getter
is provided for all common types : String
, Boolean
, Integer
,
Long
, BigDecimal
and Date
.
Note that date
configuration values must be using a valid ISO-8601 format.
Spincast will load externalized configurations from various sources, each source overriding the previous one, if a same configuration is found in both :
app-config.yaml
file is looked for on the classpath. This is where you generally will place
the default values of your externalizable configurations.
.jar
, Spincast will check if a app-config.yaml
file exists next to it. If your application is not running from an executable .jar
(for example
it is launched in an IDE), Spincast will check if a app-config.yaml
file exists at the root of the project.
Environnement variables
will be checked to see if some configurations are defined there.
An environment variable must start with "app.
" to be considered as a configuration
for a Spincast application. This prefix is configurable.
System properties
will be checked to see if some configurations have been passed to the application
when launched.
An system property must start with "app.
" to be considered as a configuration
for a Spincast application. This prefix is configurable.
System properties have the highest priority and overrides any existing configurations (except
of course for hardcoded/non-externalized configurations).
Both environment variables
and system properties
can have multiple prefixes.
In association with the feature that can strip those prefixes when getting the configurations (see next section),
this allows you to define variables for more than one application on the same server. For example, you could
have those environment variables :
app1.admin.email.address =<EMAIL_ADDRESS>app2.admin.email.address =<EMAIL_ADDRESS>common.admin.email.format = html
Here's an example of a app-config.yaml
file that could be used as a source of externalized configurations :
app: name: My Super app api: base: https://www.myApp.com databases: bd1: host: dbHost.com port: 12345 username: myDbUser password: # Empty! Must be provided at runtime...
Then in your AppConfigDefault
class, you could access the port for the
"db1" database using :
@Override public int getDb1Port() { return getInteger("app.databases.bd1.port"); }
In this example, the password for the "db1" database will have to be defined as an environment variable, or using any other mechanism that doesn't require the password to be defined as plain text and be committed to your version control system (which would be a really bad idea)! Since the configuration values are retrieved using standard Java methods, you can implement any mechanism you want in order to retrieve such "secret" configurations.
The steps described in the sources of configuration values section are configurable. You configure the way the Spincast Config plugin works by binding a custom implementation of the SpincastConfigPluginConfig interface. If you don't bind a custom implementation for this interface, a default implementation, SpincastConfigPluginConfigDefault, will be used.
Those are the methods you can tweak :
String getClasspathFilePath()
Defaults to "app-config.yaml
". This means you can simply create that file
in your project's /src/main/resources/
folder and it
will be used.
String getExternalFilePath()
The path can be relative or absolute. Spincast will check this using :
File configFile = new File(thePath); if(configFile.isAbsolute()) { // ... }
If the path is relative, it is from the executable .jar or, if not run from a .jar, from the root of the project.
Defaults to "app-config.yaml
".
List<String> getEnvironmentVariablesPrefixes()
Defaults to "app."
only.
boolean isEnvironmentVariablesStripPrefix()
environmentVariablesPrefixes()
indicates
that "app."
is an environment variable prefix, then "app.admin.email"
will result in a "admin.email" key.
Note that each environment variable key must be unique once the prefixes are stripped, otherwise an exception will be thrown when the application starts!
Defaults to false
.
List<String> getSystemPropertiesPrefixes()
Defaults to "app."
only.
boolean isSystemPropertiesStripPrefix()
systemPropertiesPrefixes()
indicates
that "app."
is an system property prefix, then "app.admin.email"
will result in a "admin.email" key.
Note that each system properties key must be unique once the prefixes are stripped, otherwise an exception will be thrown when the application starts!
Defaults to false
.
boolean isExternalFileConfigsOverrideEnvironmentVariables()
The default is false
: environment
variables have priority.
boolean isThrowExceptionIfSpecifiedClasspathConfigFileIsNotFound()
null
) but is not found.
If set to false
, a message will be logged but no
exception will be thrown.
Defaults to false
.
boolean isThrowExceptionIfSpecifiedExternalConfigFileIsNotFound()
null
) but is not found.
If set to false
, a message will be logged but no
exception will be thrown.
Defaults to false
.
To know all the core configurations required by Spincast, have a look at the SpincastConfig javadoc. Here, we're simply going to introduce the most important ones, and their default value :
getPublicUrlBase()
: This configuration is
very important and you should override it in your application and adjust
it from environment to environment! It tells Spincast what is the
base public URL used to reach your application.
For example, your application may be accessed using a URL such as
http://www.example.com
but can in fact be behind a reverse-router
and actually started on the "localhost"
host and on
port "12345"
.
The problem is that the public base URL ("http://www.example.com"
) can't be
automatically found, but Spincast still requires it to :
By default, the getPublicUrlBase()
configuration
will be "http://localhost:44419"
. This default can be used for development
purposes, but very should be changed when releasing to another environment.
It is so important to override this configuration that Spincast has a validation in place : when an application starts, an exception will be thrown if those conditions are all meet :
environment name
is not "local".
isDevelopmentMode()
configuration returns false
.
public host
is still "localhost"
.
Note that you can disable this startup validation using the
isValidateLocalhostHost()
configuration.
getServerHost()
: The host/IP the HTTP Server
will listen on. The default is <IP_ADDRESS>
, which
means the Server will listen on any IP.
getHttpServerPort()
: The port the Server
will listen to for HTTP
(unsecure) requests.
If <= 0
, the Server won't listen on HTTP
requests.
getHttpsServerPort()
: The port the Server
will listen to for HTTPS
(secure) requests.
If <= 0
, the Server won't listen on HTTPS
requests.
If you use HTTPS
, you also have to provide some extra
configurations related to the SSL
certificate to use.
isDevelopmentMode()
: If true
,
a development environment is taken for granted, and
internal error messages may be displayed publicly, no cache will be
used for the templates, etc. The default is true
, so make
sure you change this to false
before deploying to
production!


You’ve been invited to send live emergency alerts.
Members of the public will receive alerts you send from this service.
{% from "service_navigation.html" import service_navigation %} {% extends "admin_template.html" %} {% block per_page_title %} You’ve been invited to send live emergency alerts. {% endblock %} {% set mainClasses = "govuk-!-padding-top-0 govuk-!-padding-bottom-0" %} {% block main %}


managealooma - Programmatically manage the Alooma ETL tool¶
About Manage Alooma¶
managealooma
is a wrapper for the Alooma ETL tool API that makes it easy to programmatically manage the tool and provides functions for transforming events.
About Alooma¶
Alooma is an ETL tool for building out datawarehouses. Alooma does the basic tasks of connecting to sources for you such as replicating a database, receiving a webhook or connecting to a cloud app API. Alooma also inserts your data to a datawarehouse such as Snowflake, Redshift, or Bigquery. In between those steps Alooma allows you to transform your data any way you want using real Python code. This package contains may functions to make programmatic management of Alooma easy!
Contents¶
- License
- Help
- Getting Started
- Column DDL
- Consolidations
- Events
- Inputs
- Print Sorted List
- Get All Inputs
- Get Input
- View Inputs
- Delete Input
- Pause Input
- Resume Input
- List Inputs
- List Tables
- Create Input Database
- Edit Input Configuration
- Add Table to Input
- Change Auto Mapping Mode
- Add Template to Parameter Configuration
- Edit Parameter Configuration
- Preview Input Changes
- Apply Input Changes
- Mappings
- Get Mapping For Event
- Get Mapping For Event
- Change Mapping Mode
- Change Mapping Consolidation Settings
- Change Mapping Consolidation Key
- Change Mapping to Use Log
- Change Mapping for Manual Consolidation Creation
- Delete Field From Mapping
- Change Field Mapping Settings
- Change Field Varchar Length
- Change Field Null Constraint
- Check Consolidation Uses Log
- Copy Mapping
- Set Mapping from Existing Mapping
- Add Field To Mapping
- Preview Mapping Changes
- Apply Mapping Changes
- Remove Unmapped Fields and Clear Table Stats
- Samples
- Build Sample File Path and File Name
- Print Samples
- Get Samples for Event from Alooma API
- View Samples for Event from Alooma API
- Get Samples from File
- Get Samples from Saved Sample Files
- View Samples from File
- Save Alooma Samples to Files
- Write Alooma Samples to Files
- Get Sample from Any API
- Get Sample from PostgreSQL Database
- Secrets
- System
- Transformation Functions
- Add Column Based On Null
- Add Columns with Default
- Add Composite Key
- Add Duplicate Fields
- Add Suffix
- Convert All Event Fields to Snake Case
- Convert Dictionary Fields to String
- Convert Null to Zero
- Convert Spaces and Special Characters to Underscore
- Convert String to Snake Case
- Convert Values to None
- Convert Empty Value to None
- Convert Event Type Case
- Flatten JSON
- Flatten JSON 1 Level
- Map Key in Dictionary to Value
- Map Value in List to Dictionary Key
- Mark for Delete
- Parse List of JSON and Concat
- Remove Duplicate Field
- Remove Outer Key
- Remove Starting Characters from Keys
- Remove Whitespace
- Rename Fields
- Split Event to Multiple Events
- Split Field List to Multiple Events
- Whitelist or Blacklist Columns
- Transformation Test
- Credits


This example searches for jQuery locally at ../node_modules/jquery/dist/jquery.min.js
, but
jQuery was not found there. Please eather install jQuery (via npm or manually)
or modify this HTML file and change the src attribute of the script tag loading jQuery
to specify a different local path or a CDN URL.
In the following demos, the expand/toggle buttons are used to show or hide several child nodes of one selected node.
The selected node is the table row of the toggle button which has been pressed.
I.e., each click of a button first selects the table row containing that button. On this jQuery resultset
containing the table row, the showOrHideChildren()
function gets called. This function
takes at least one argument: a children selector, in this case: ".more"
.
This means that any child node inside the table row which has the class "more" will be shown or hidden.
In this case, each table row contains 4 table cells (td
), and each cell contains a first text and some
additional text, the latter wrapped in a <div class="more">
element.
So it's these div
s that get shown or hidden (constrained to the selected table row).
When loading, the visibility status of the .more
sections is initialized by an
immediate call of showChildren()
for the first row and hildeChildren()
for the second row. Both calls use the option duration: 0
in order to prevent
an animation during initial rendering. (This is actually only important for the hide command:
without this zero-duration, the hidden divs would show up on page load and then be reduced to zero height
with a transition.)
In this demo, all calls to showOrHideChildren()
(when button is clicked) as well as
showChildren()
and hideChildren()
(initialization on page load, see above)
all are completely configured by the function's parameters on each function call. (No central setup is stored.)
| … | Col1 | Col2 | Col3 |
|---|---|---|---|
| Some content in Col1… Even more detailed content (only visible when expanded) |
Some content in Col2… Even more detailed content (only visible when expanded) |
Some content in Col3… Even more detailed content (only visible when expanded) |
|
| Hello World… Hello Sun, Hello Moon, Hello Earth! |
Test More test content – visible if row is expanded |
And the answer is… 42! |
This demo should behave exactly the same as the first one. The script code, on the other hand, is different:
On page load, all common settings for initialization and button presses are saved as setup, and the
function calls are either parameterless (showOrHideChildren()
) or their parameters
contain only options that differ from the setup (duration: 0
for the initializations, see above).
See source of this HTML file for the code and compare both demos.
| … | Col1 | Col2 | Col3 |
|---|---|---|---|
| Some content in Col1… Even more detailed content (only visible when expanded) |
Some content in Col2… Even more detailed content (only visible when expanded) |
Some content in Col3… Even more detailed content (only visible when expanded) |
|
| Hello World… Hello Sun, Hello Moon, Hello Earth! |
Test More test content – visible if row is expanded |
And the answer is… 42! |


This is a control test file to verify that an ordinary link to a slow-responding stylesheet will block render. If this text is not visible for 5 seconds or so, assumptions about CSS blocking render are valid in your browser.


Inspire future generations by providing the most exciting and diverse speakers for your conference.
First and foremost, Welcome! Willkommen! Bienvenue!
This is a very, VERY early version of our website.
I'm sure you can tell that it doesn't have much functionality and needs much more information added to it!
We've written up a little bit about where we came from on our all about us page and there are a couple of youtube video clips that you can watch on our multimedia page.
If you'd like to know more please take a look at our README file for an overview of the idea, where it came from and where we want to go with it, our how to guide for contributors, and our list of issues that we need help with.
You can also learn a little more about Kirstie, Amy, Erin and Elizabeth - the founders of the STEMM Role Models app - in our meet the team file
You'll start at the home page and there will be three options:
There will also be links on every page to the code of conduct, privacy policy and how to contact us.
We have a long way to go from our design (huge thank yous to Erin for putting our thoughts into the wonderful schematic above) so please do get in touch with any suggestions you have.
And if you fancy hanging out with Kirstie in the STEMM Role Models room on gitter she would LOVE to have someone to talk to ;)
We're really excited to be able to thank all our contributors (not just the ones who add code) through our Let's All Build a Hat Rack page. We can't wait to see your name on there!
Would you like to help us develop this page?
Help with layout, content (text, images) and spelling mistakes all welcome!
Please
get in touch for more information on how to get involved.


Effective date: January 17, 2019
Divya Gupta ("us", "we", or "our") operates the Swiggy Chrome Extension (hereinafter referred to as the "Swiggy Companion Chrome Extension").
Your privacy is important to us. Therefore, we have created this privacy policy to disclose the kind of information we gather and the way we share it.
This statement provides an insight to the way we protect your privacy during your visit to Divya Gupta website.
All content present on this website has been prepared by Divya Gupta for informational purposes only.
Transmission of this information is not intended to create, and receipt does not constitute, a professional relationship. Internet subscribers and online readers should not act upon this information without seeking professional advice.
This page informs you of our policies regarding the collection, use and disclosure of personal data when you use our Swiggy Companion Chrome Extension and the choices you have associated with that data.
We use your data to provide and improve the Swiggy Companion Chrome Extension. By using the Swiggy Companion Chrome Extension, you agree to the collection and use of information in accordance with this policy.
Contents
Definitions Privacy Information Collection and Use Types of Data Collected Cookie Policy Use of Data Legal Basis for Processing Personal Data under the General Data Protection Regulation (GDPR) Retention of Data Transfer of Data Disclosure of Data Legal Requirements Security of Data Our Policy on "Do Not Track" Signals under the California Online Protection Act (CalOPPA) Your Data Protection Rights under the General Data Protection Regulation (GDPR) Service Providers Analytics Links to Other Sites Children's Privacy Changes to This Privacy Policy Contact UsSwiggy Companion Chrome Extension
Swiggy Companion Chrome Extension is the https://www.divyagupta.dev/ website operated by Divya Gupta
Personal Data
Personal Data means data about a living individual who can be identified from those data (or from those and other information either in our possession or likely to come into our possession).
Usage Data
Usage Data is data collected automatically either generated by the use of the Swiggy Companion Chrome Extension or from the Swiggy Companion Chrome Extension infrastructure itself (for example, the duration of a page visit)
Cookies
Cookies are small files stored on your device (computer or mobile device).
Data Controller
Data Controller means the natural or legal person who (either alone or jointly or in common with other persons) determines the purposes for which and the manner in which any personal information are, or are to be, processed. For the purpose of this Privacy Policy, we are a Data Controller of your Personal Data.
Data Processors (or Service Providers)
Data Processor (or Service Provider) means any natural or legal person who processes the data on behalf of the Data Controller. We may use the services of various Service Providers in order to process your data more effectively.
Data Subject (or User)
Data Subject is any living individual who is using our Swiggy Companion Chrome Extension and is the subject of Personal Data.
With respect to information submitted or collected on the Swiggy Companion Chrome Extension, you accept Divya Gupta’s privacy policy as set forth in this document. This does not pertain to, and Divya Gupta is not responsible for the privacy practices of, any third-party websites to which the Swiggy Companion Chrome Extension hyperlinks. Certain areas of the Swiggy Companion Chrome Extension may be subject to additional privacy-related provisions, links to which will be posted in those areas.
Activity Logging. When You use the Swiggy Companion Chrome Extension, which may be hosted in part or its entirety by a third party, the Swiggy Companion Chrome Extension will collect information indirectly and automatically (through, for example, the use of “cookies” or Your “IP address”) about Your activities. Divya Gupta uses this activity information (the “Activity Information”) for internal purposes such as to administer the Swiggy Companion Chrome Extension, improve the Swiggy Companion Chrome Extension, and help us understand how the Swiggy Companion Chrome Extension is being used including the demographics and “clickstreams” of its visitors. “Cookies” are small pieces of information stored on Your hard drive, not on the Swiggy Companion Chrome Extension. You are always free to decline cookies if Your browser permits, but in that case, some portions of the Swiggy Companion Chrome Extension may not operate properly. An “IP address” is a number that is automatically assigned to Your computer when You use the Internet.
Personally Identifiable Information. The Swiggy Companion Chrome Extension is designed so that You may generally browse it without providing any Personally Identifiable Information (defined below). Certain areas of the Swiggy Companion Chrome Extension, however, may require or allow the voluntarily submission of Personally Identifiable Information (for example, registration to receive Divya Gupta publications). Divya Gupta uses Your Personally Identifiable Information for the purposes for which it was submitted by You to Divya Gupta and for Divya Gupta to send you publications and invitations that may be of interest to you.
Removal of Personally Identifiable Information. Divya Gupta will use reasonable efforts to remove Your Personally Identifiable Information from our then current Swiggy Companion Chrome Extension at any time upon Your written request to<EMAIL_ADDRESS>Such removal of Personally Identifiable Information will not ensure the permanent removal of such Personally Identifiable Information from the Divya Gupta website. For example, such Personally Identifiable Information may remain in our archival or backup copies of the Swiggy Companion Chrome Extension.
Additional Disclosure of Personally Identifiable Information. We may share Personally Identifiable Information with third parties, including affiliated firms and third parties performing services for or on behalf of Divya Gupta. Such services may include communications, database, event management, hosting, mailing, and marketing services. Additionally, we cannot fully ensure that Your Personally Identifiable Information will not be disclosed to third parties. For example, we may be legally obligated to disclose information to the government or third parties under certain circumstances, third parties may circumvent our security measures to unlawfully intercept or access transmissions or private communications, or an error may occur in the administration of the Swiggy Companion Chrome Extension. In the unlikely event that Divya Gupta needs to investigate or resolve possible problems or inquiries, we may, and You authorize us to, disclose any information about You to government officials as permitted by applicable law.
Miscellaneous Privacy Terms. We’ve implemented and follow appropriate technical measures to protect against the risks of unauthorized access to, erroneous disclosure of, and unlawful interception of Personally Identifiable Information. You should know, however, that we cannot fully eliminate such risks.
We collect several different types of information for various purposes to provide and improve our Swiggy Companion Chrome Extension to you.
Personal Data
While using our Swiggy Companion Chrome Extension, we may ask you to provide us with certain personally identifiable information that can be used to contact or identify you ("Personal Data"). Personally identifiable information may include, but is not limited to:
We may use your Personal Data to contact you with newsletters, marketing or promotional materials and other information that may be of interest to you. You may opt out of receiving any, or all, of these communications from us by contacting us.
We may also collect information on how the Swiggy Companion Chrome Extension is accessed and used ("Usage Data"). This Usage Data may include information such as your computer's Internet Protocol address (e.g. IP address), browser type, browser version, the pages of our Swiggy Companion Chrome Extension that you visit, the time and date of your visit, the time spent on those pages, unique device identifiers and other diagnostic data.
We use cookies and similar tracking technologies to track the activity on our Swiggy Companion Chrome Extension and we hold certain information.
Cookies are files with a small amount of data which may include an anonymous unique identifier. Cookies are sent to your browser from a website and stored on your device. Other tracking technologies are also used such as beacons, tags, and scripts to collect and track information and to improve and analyze ourSwiggy Companion Chrome Extension.
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 Swiggy Companion Chrome Extension.
Examples of Cookies we use:
We only share the information obtained through the use of Google Analytics with Google. For more information on Google's use of your information, please see Types of Cookies Used by Google. The cookies we use for these purposes do not track your Internet usage after leaving our website and do not store your personal information. They will not be used in connection with any other information to identify you in any way.
Disabling Cookies
If you wish, you can usually adjust your browser so that your computer does not accept cookies:
Alternatively, you can adjust your browser to tell you when a website tries to put a cookie on your computer. How you adjust your browser to stop it accepting cookies or to notify you of them, will depend on the type of internet browser program your computer uses.
How to Disable Third-Party Cookies
Users based in the European Union can opt out of these third-party cookies. This website is not connected us and we are not responsible for its content. We only keep cookies for the duration of your visit to our Site, except in the case of cookies which remember you for future visits or where you save your login name as referred to above.
Your Consent to Cookies
By agreeing to this policy, you consent to the use of cookies by us as described above. Read more about cookies (but please remember that we are not responsible for external websites). Cookies do not contain confidential information such as your home address, telephone number or credit card details. We do not exchange cookies with any third-party websites or external data suppliers. If you do choose to disable cookies, you may find that certain sections of our Site do not work properly.
Divya Gupta uses the collected data for various purposes:
We use different methods to collect data from and about you through:
If you are from the European Economic Area (EEA), Divya Gupta, Inc’s legal basis for collecting and using the personal information described in this Privacy Policy depends on the Personal Data we collect and the specific context in which we collect it.
Divya Gupta will retain your Personal Data only for as long as is necessary for the purposes set out in this Privacy Policy. We will retain and use your Personal Data to the extent necessary to comply with our legal obligations (for example, if we are required to retain your data to comply with applicable laws), resolve disputes and enforce our legal agreements and policies
Divya Gupta will also retain Usage Data for internal analysis purposes. Usage Data is generally retained for a shorter period of time, except when this data is used to strengthen the security or to improve the functionality of our Swiggy Companion Chrome Extension, or we are legally obligated to retain this data for longer periods.
Your information, including Personal Data, may be transferred to — and maintained on — computers located outside of your state, province, country or other governmental jurisdiction where the data protection laws may differ from those of your jurisdiction
If you are located outside United States and choose to provide information to us, please note that we transfer the data, including Personal Data, to United States and process it there.
Your consent to this Privacy Policy followed by your submission of such information represents your agreement to that transfer.
Divya Gupta will take all the steps reasonably necessary to ensure that your data is treated securely and in accordance with this Privacy Policy and no transfer of your Personal Data will take place to an organisation or a country unless there are adequate controls in place including the security of your data and other personal information.
Legal Requirements
Divya Gupta may disclose your Personal Data in the good faith belief that such action is necessary to:
The security of your data 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 Data, we cannot guarantee its absolute security.
We do not support Do Not Track ("DNT"). Do Not Track is a preference you can set in your web browser to inform websites that you do not want to be tracked.
You can enable or disable Do Not Track by visiting the Preferences or Settings page of your web browser.
If you are a resident of the European Economic Area (EEA), you have certain data protection rights. Divya Gupta aims to take reasonable steps to allow you to correct, amend, delete, or limit the use of your Personal Data.
If you wish to be informed about what Personal Data we hold about you and if you want it to be removed from our systems, please contact us.
In certain circumstances, you have the following data protection rights:
The right to access, update or delete the information we have on you. Whenever made possible, you can access, update or request deletion of your Personal Data directly within your account settings section. If you are unable to perform these actions yourself, please contact us to assist you.
The right of rectification. You have the right to have your information rectified if that information is inaccurate or incomplete.
The right to object. You have the right to object to our processing of your Personal Data.
The right of restriction. You have the right to request that we restrict the processing of your personal information.
The right to data portability. You have the right to be provided with a copy of the information we have on you in a structured, machine-readable and commonly used format.
The right to withdraw consent. You also have the right to withdraw your consent at any time where Divya Gupta relied on your consent to process your personal information.
Please note that we may ask you to verify your identity before responding to such requests.
You have the right to complain to a Data Protection Authority about our collection and use of your Personal Data. For more information, please contact your local data protection authority in the European Economic Area (EEA).
We may employ third-party companies and individuals to facilitate our Swiggy Companion Chrome Extension ("Service Providers"), provide the Swiggy Companion Chrome Extension on our behalf, perform Swiggy Companion Chrome Extension-related services or assist us in analyzing how our Swiggy Companion Chrome Extension is used.
These third parties have access to your Personal Data only to perform these tasks on our behalf and are obligated not to disclose or use it for any other purpose
Analytics
We may use third-party Service Providers to monitor and analyse the use of our Swiggy Companion Chrome Extension.
Google Analytics
Google Analytics is a web analytics service offered by Google that tracks and reports website traffic. Google uses the data collected to track and monitor the use of our Swiggy Companion Chrome Extension. This data is shared with other Google services. Google may use the collected data to contextualize and personalize the ads of its own advertising network
You can opt-out of having made your activity on the Swiggy Companion Chrome Extension available to Google Analytics by installing the Google Analytics opt-out browser add-on. The add-on prevents the Google Analytics JavaScript (ga.js, analytics.js and dc.js) from sharing information with Google Analytics about visits activity.
For more information on the privacy practices of Google, please visit the Google Privacy Terms web page: https://policies.google.com/privacy?hl=en
Our Swiggy Companion Chrome Extension may contain links to other sites that are not operated by us. If you click a third-party link, you will be directed to that third-party's site. We strongly advise you to review the Privacy Policy of every site you visit.
We have no control over and assume no responsibility for the content, privacy policies or practices of any third-party sites or services.
Our Swiggy Companion Chrome Extension does not address anyone under the age of 18 ("Children").
We do not knowingly collect personally identifiable information from anyone under the age of 18. If you are a parent or guardian and you are aware that your Child has provided us with Personal Data, please contact us. If we become aware that we have collected Personal Data from children without verification of parental consent, we take steps to remove that information from our servers.
We may update our Privacy Policy from time to time. We will notify you of any changes by posting the new Privacy Policy on this page.
We will let you know via email and/or a prominent notice on our Swiggy Companion Chrome Extension, prior to the change becoming effective and update the "effective date" at the top of this Privacy Policy
You are advised to review this Privacy Policy periodically for any changes. Changes to this Privacy Policy are effective when they are posted on this page.
If you have any questions about this Privacy Policy, please contact us:


We're sorry but this project doesn't work properly without JavaScript enabled. Please enable it to continue.


+++ title = "Rurrenabaque" lat = -14.430000 lon = -67.505000 +++
My 5-years-behind Lonely Planet guide describes it as sleepy, lacking in services, and very rough. From looking at it now, in 2007, it's relaxed, abrim with an ever-expanding number of services (e.g. Internet, banks), and becoming more comfortable by the day. In another 5 years' time, it will no doubt be a jam-packed tourist mecca, alive with adventurers and with every services they could possibly need. Rurrenabaque is Bolivia's jungle destination hotspot, and it's growing at an alarming rate. Get to it while it's still wild!
{{< galleryphoto "2007-06-12-09-00-00--street-in-rurrenabaque.jpg" >}}


This report will cover a day long experience with the mindless bliss that is associated with opiate and synthetic based opiate substances. While I realize that my portions are quite high for the beginner or curious user, it should be noted that I have built a tolerance in the past few days to such opiates which would allow me to handle midline dosages. This meaning, the past few nights I dabbled with increasing dosages daily over a specific period. I would highly suggest to everyone to know how your body reacts to drugs, specifically pharmaceuticals, and do intense research to understand both why and when the dosages should be managed. Especially with a drug like oxycodone and hydrocodone, these can become extremely addictive if you have easy access and continue to repeat high dosages over time. Do not underestimate this drug and discourage access!
About My Usage
My access and use of substances is limited. Although I attend an Ivy League university, I find myself using less drugs than my fellow classmates. I don't like to smoke pot. I don't like to hallucinate. Rather, I do find that I enjoy the downer effects of pharmaceutical pills offer. Like most people, access to these pills is a once in a while find, usually the left over product of a broken bone or surgery. When I do get access, I find that both [synthetic]opiates and benzodiazepines provide an escape into mindless euphoria that can be enjoyable on occasion. This experience represents my first trip into the multiple usage of the drugs. While at most, I have only tried the drugs recreationally a few times before and NEVER in repetition (for fear of physical addiction).
The Experience
12:00 [20mg]= After having built up a tolerance for Oxycodone the past 2 nights, I felt that I should start the day with relatively high dosage of 20mg. I chewed both pills, knowing that the absence of acetaminophen would make them tolerable. After about 20 minutes, I felt that enjoyable warmth of the opiate kicking in. After eating lunch with some friends, I was completely comfortable and feeling a real nice kick coming ing. Knowing what to expect, I spent the next hour enjoying the escalation of effects.
13:30 [10mg]= The peak had occurred around 13:00, by which I felt one more pill would keep a warm feel going. While not as high at this point, I knew that my body could handle 30mg. After ingesting the third pill, I knew it would take around 20-30 minutes for the effect to take hold. At this point the body high is at it's peak, every major muscle in my body feels as though they've been elevated and ameliorated.
13:30= The third pill has extended the euphoria but has not provided the initial high that was felt with the first dosage at 12:00. I have yet to peak but the addition has definitely enhanced the experience. No negative effects at this point, the only downside is the occasional itch and forget fullness. Up to this point it has been both enjoyable and quite invigorating. I have felt more open with friends and felt much more comfortable in public.
15:00 [120]= The drug has peaked and I can begin to feel it wane. I still feel comfortable and quite happy with my surroundings but it is definitely not as strong as before. So, knowing that the biological half life of Oxycodone is 2.5-3 hours, i continued my opiate adventure by ingesting two Tylenol 4 pills with 60mg codeine and 750mg paracetamol.
15:30= I can feel the two Tylenol pills taking hold, while not as strong as the oxycodone they do ad on to the effect by providing a more mentally stimulating high. I can still focus and feel sober in my though process, but my mood is highly elevated. It is a nice feeling. Much more itching now then normal, but by this point a larger percentage of the oxycodone has metabolized through my system.
17:00= I can feel the effects beginning to wane. Much more itching then before.
19:00 [20mg]= I decided to finish my final two 10mg pills of oxycodone. My ingested the two (I never snort do to issues regarding pill binders and chemical additives). By now, the initial levels of my earlier oxycodone ingestion should have passed through do to the fast level of metabolism and half-life. I would never suggest to someone who is opiate naive to take such multiple dosages because not only will their tolerance not be able to handle such dosing, but the half life of the drug might be much longer do to lack of enzyme production in ones system.
19:30= I can feel the onset of the 20mg, a warm fuzzy feeling is beginning to take over my mind and all cares are once again out the window. The increase in feelings of the oxycodone mask the diminishing codeine as the two begin to flood my brain. Once again I feel much more at ease with conversation and I enjoy both everything and everyone around me. Opiates produce such a unique appreciation for life that makes me understand why people can choose to repeatedly do this daily.
20:15= The initial high is dwindling down.
23:30 [2.5]= I can feel the effects are wearing off, I am becoming much more tired. With each dosage I found the effects of the opiates to take a different level of feeling. From a scale of 1 to 10. The First dosage would be a 8, the second would be a 4 and the third would be a 6. The first dosage is always the best because it overflows your system with the necessary neurotransmitters to chemically induce euphoria. After that, the rest of the day was spent floating in a mindless bliss, creating a nice but temporary escape from the necessary pressures of life. Now I am about to fall asleep, I have a final usage of a half of teaspoon of Doxylamine Succinate. This will provide 2.5mg of hydrocodone and 2mg succinate. This has so far provided a nice relaxing body feeling and made me very sleepy. The Succinate has acted as an antihistamine and gotten rid of all the itches.
23:45 By this time I have calculated there should around 13.75mg of oxycodone still metabolized in my system along with 15mg of codeine.
This experience is a trial experience only. I do not suggest anybody repeat it. Doing too many opiates and high dosages without knowing your tolerance or how your body metabolizes each chemical can cause fatal results. While I was successful in titrating throughout the day, I believe i was because I have done deep research and begun to understand how such drugs work.
Also, be care with these drugs.  Know the difference between 'trying something new out' and 'trying something new to never stop the effects.'
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.


Writer of page 1 through 9, works cited, and credits page. Creator/coder of website and cool buttons.
Writer or pages 9 through 18 and editor of homepage. Main researcher.
Planner and researcher for information and photos.


Request Sent!
We'll email you once the host responds.
Or, we can shoot you a text instead.
Text Me
Skip


Student Name: {{student.name}}
Student ID: {{student.uwiid}}
Email: {{student.email}}
Degree: {{student.curr_degree}}
GPA: {{student.gpa}}


Note
Since 0.8.3 Spectre is licensed under BSD License.
Copyright (c) 2011, Xored Software, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.


Pokemon Type Chart
Our Javascript project was to create a Pokemon type matchup calculator. The first design step was to use two arrays, one for columns in the type chart (defending pokemon) and one for the rows (attacking pokemon), and match each type's effectiveness and display it in the Console window.
Once the type matching was working, text boxes were added so the user could choose which types they wanted to compare:
We then added the option to check type matchups for dual-type defending Pokemon and made a window alert for the output to go alongside the Console log.
"Gotta catch 'em all. Pokemon." - John Siegler & John Loeffler
Live demo:
Output


{{ loadingImport ? "Importing:" : "Select a file to import:" }}
Importing may take a while...
Export:
Exporting may take a while...


Your first Internet High 5 with the uArm Swift!
So the wait is finally over! The Internet High 5 Machine website is finally live!
Currently you can send a High 5 to anyone via their email address. You get the option of writing a short message, and recording a short GIF. They can then receive this High 5 by clicking the link in the email!
That’s pretty cool.
But, the Internet High 5 Machine is also about physical interaction with an attached device, and to that end we have added support for the uArm Swift.
I picked up one of these in their recent IndieGoGo campaign, and I quickly built an elegant High 5’ing extension:
Then, by playing around with one of the open-source libraries that they provided, I was able to get it to give me a High 5:
Now, if you’re willing to get down and funky with some code, you too can connect your uarm to the Internet High 5 Machine website!
Technical - Setup of uArm Swift with the High 5 Machine Website
Below we list a somewhat-involved process to connect the uArm to the High 5 website. This process will hopefully get simplier in the coming months as the uFactory company releases updated versions of it’s code and we release more of the High 5 Machine software.
Firstly, we need to get the program that can perform a High 5.
- Clone uArm-5
> git clone https://github.com/internet-high-five-machine/uArm-5.git
- Create, and activate, a conda environment (or otherwise use python 3.5) and install the the requirements
> cd uArm-5
uArm-5> conda create -n uArm-5 python=3.5
- Install the requirements, which is a fork of the official
pyuarm
library:
uArm-5> pip install -r requirements.txt
- Clone the high5-driver program, which is used to communicate directly with the High 5 website.
> git clone https://github.com/internet-high-five-machine/high5-driver.git
Install stack
Setup stack to build this project
high5-dirver> stack setup
- Build the
high5-driver
project
high5-dirver> stack build
- Point the
settings.yaml
file at theuarm-5.py
executable.
high5-driver> cat settings.yaml
exec:
machine-command : ["../uArm-5/uarm-5.py"]
- Run the
high5-driver
(note: you should be in the conda envirnoment you created earlier, because it will run the python script):
high5-dirver> stack exec -- high5-driver
- Send the
configure
command to the driver, so that it connects to the High 5 website. You’ll find thetoken
on your profile page:
configure {"server": "high5.cool", "url": "/", "email"<EMAIL_ADDRESS>"token":"your-token-goes-here"}
You’ll know this worked if it says websocket connected
.
- Bask in the joy of receiving Internet High 5s!
Once you’ve done the above steps, when you go to receive a High 5 on the website, you will see the “Receive High 5!” button under the “Via your device” option become available.
Enjoy!


This is a site that is currently hosted on WordPress, customized many plugins including the Pinboard theme, Jetpack, Yoast.
It is about to be overhauled, so stay tune for a fresh, hand-crafted site soon!
Until then, here is the current site: Francesca & Co. Travel


A 50x50 array is generated and randomly populated with either living or dead cells.
The array is displayed as a grid of <div> elements and then, every 0.5 s, the array of cells is processed using the rules set out in Conway's Game of Life.
The new generation of cells is then displayed. If they all die, you will be notified.


Happy
Anniversary!
December 8, 2016
It seems like it was only yesterday since you gave me your
“Yes”
.
And now, here we are celebrating
our
first
anniversary.
I want you to know that
I'm
very happy
being with you.
And everyday,
I
thank God
for you.
I love you so much,
Mi Amor!


--- layout: post title: no title date: '2016-09-27T13:44:10+02:00' categories: - Sketches - Rattrapage - Storyboards picture_url: https://film-Storyboards.tumblr.com/post/151018316191 ---


A11y Dialog
This page demonstrates how to make a dialog window as accessible as possible to assistive technology users. Dialog windows are especially problematic for screen reader users. Often times the user is able to “escape” the window and interact with other parts of the page when they should not be able to. This is partially due to the way screen reader software interacts with the browser.
To see this in action, you just need to . Once it’s open, you should not be able to interact with other links on the main page like going to the main GitHub page. The focus is said to be “trapped” inside the dialog until the user explicitely decides to leave it.
On top of that, this implementation provides all the usual mandatory bits from a dialog window: correct usage or ARIA landmarks, absolute freedom in regard to the styling, closing when pressing ESC
, closing when clicking the background overlay, closing when clicking the close button, a simple yet powerful DOM API, for half a kilobyte of JavaScript. Oh, and also it is fully tested using a headless browser to make sure it works as intended.
No more excuse now. Make your dialog windows accessible.


Home
Contact Us
(current)
Sign In
Sign Up
Game Page
Search
Contact Us
Name:
Email:
Message:
CORPORATE HEADQUARTERS
11730 Plaza America Dr
2nd Floor
Reston, VA 20190
©
Revature. All Rights Reserved.


The wren
Earns his living
Noiselessly.
- Kobayahsi Issa
The lamp once out
Cool stars enter
The window frame.
- Natsume Soseki
Consider me
As one who loved poetry
And persimmons.
- Masaoaka Shiki
An old silent pond...
A frog jumps into the pond,
splash! Silence again.
- Matsuo Bashō
Read more poems
The wren
Earns his living
Noiselessly.
- Kobayahsi Issa
The lamp once out
Cool stars enter
The window frame.
- Natsume Soseki
Consider me
As one who loved poetry
And persimmons.
- Masaoaka Shiki
An old silent pond...
A frog jumps into the pond,
splash! Silence again.
- Matsuo Bashō
Kobayashi Issa (小林 一茶?, June 15, 1763 – January 5, 1828),[1] was a Japanese poet and lay Buddhist priest of the Jōdo Shinshū sect known for his haiku poems and journals. He is better known as simply Issa (一茶?), a pen name meaning Cup-of-tea[2] (lit. "one [cup of] tea"). He is regarded as one of the four haiku masters in Japan, along with Bashō, Buson and Shiki - "the Great Four, Basho, Buson, Issa, Shiki".[3]
Reflecting the popularity and interest in Issa as man and poet, Japanese books on Issa outnumber those on Buson, and almost equal in number those on Bashō.[4]
The wren
Earns his living
Noiselessly.
- Kobayahsi Issa
The lamp once out
Cool stars enter
The window frame.
- Natsume Soseki


The reflecting random walk of the last section has states 0, 1, 2, 3, 4 arranged in sequence clockwise on a circle; at each step the chain moves to its clockwise neighbor with probability $p \in (0, 1)$ and to its counterclockwise neighbor with probability $q = 1-p$. The stationary distribution of the chain assigns chance 0.2 to each state.
If $p > 1/2$, then the chain is more likely to be moving clockwise than counterclockwise. For example, in steady state, the probability of the path $0, 1, 2, 3$ is
$$ P_0(0)P(0, 1)P(1, 2)P(2, 3) = 0.2p^3 $$The probability of the reversed path $3, 2, 1, 0$ is
$$ P_0(3)P(3, 2)P(2, 1)P(1, 0) = 0.2q^3 $$If $p > 1/2$, the original path has higher chance.
But if $p = 1/2$, the chance of the original path is the same as that of the reversed path; in steady state, the chain is just as likely to be running in either direction. If someone simulates the chain in steady state and shows you the original path as well as the reversed path, you will not be able to tell which is which.
In this section we define what it means for a Markov Chain to be reversible in this way.
Let $X_0, X_1, \ldots $ be an irreducible Markov Chain with a finite state space and stationary distribution $\pi$. Start the chain off with this stationary distribution; that is, let $X_0$ have distribution $\pi$. Then for all $n \ge 1$, the distribution of $X_n$ is also $\pi$.
Fix $n > 0$ and consider the reversed sequence $Y_0, Y_1, \ldots, Y_n$ defined by $Y_k = X_{n-k}$ for $k = 0, 1, \ldots, n$.
It is a wonderful fact that the reversed sequence is a Markov Chain. To see why, we will check that the Markov property holds.
Fix states $i$ and $j$ and an integer $m$ in the range 0 through $n-1$.
\begin{align*} & P(Y_{m+1} = j \mid Y_0 = i_0, Y_1 = i_1, \ldots, Y_{m-1} = i_{m-1}, Y_m = i) \\ \\ &= \frac{P(Y_0 = i_0, Y_1 = i_1 \ldots, Y_{m-1} = i_{m-1}, Y_m = i, Y_{m+1} = j)} {P(Y_0 = i_0, Y_1 = i_1 \ldots, Y_{m-1} = i_{m-1}, Y_m = i)} \\ \\ &= \frac{P(X_n = i_0, X_{n-1} = i_1, \ldots, X_{n-m+1} = i_{m-1}, X_{n-m} = i, X_{n-m-1} = j)} {P(X_n = i_0, X_{n-1} = i_1, \ldots, X_{n-m+1} = i_{n-m+1}, X_{n-m} = i)} \\ \\ &= \frac{\pi(j)P(j, i)P(i, i_{m-1}) \cdots P(i_1, i_0)} {\pi(i)P(i, i_{m-1}) \cdots P(i_1, i_0)} \\ \\ &= \frac{\pi(j)P(j, i)}{\pi(i)} \end{align*}This involves only $i$ and $j$, and not on $i_0, i_1, \ldots, i_{m-1}$ nor on $m$. So the Markov property is satisfied and the transition probabilities are time homogenous. The one-step "$i$ to $j$" transition probability for the reversed sequence is
$$ P(Y_{m+1} = j \mid Y_m = i) = \frac{\pi(j)P(j, i)}{\pi(i)} $$The original "forwards" Markov Chain $X_0, X_1, \ldots $ is called reversible if for every $n$, the reversed sequence $Y_0, Y_1, \ldots Y_n$ has the same one-step transition probabilities as the original; that is, if
$$ \frac{\pi(j)P(j, i)}{\pi(i)} = P(i, j) ~~~ \text{for all } i, j $$That is, the chain is reversible if
$$ \pi(i)P(i, j) = \pi(j)P(j, i) ~~~ \text{for all } i, j $$In other words:
The chain is reversible if the detailed balance equations have a positive solution. This is consistent with our image of particles moving according to this chain in steady state: at each instant, the proportion of particles moving from $i$ to $j$ is exactly the same as the proportion moving from $j$ to $i$, for every pair of states $i$ and $j$.
At the start of this section we looked at a random walk on a circle. Let's see what the definition of reversibility implies for this chain.
In the previous section we showed that when $p \ne 1/2$, the detailed balance equations have no positive solution. Therefore, when $p \ne 1/2$, the chain is not reversible. This is consistent with our earlier analysis.
When $p = 1/2$, the detailed balance equations do have a solution, and therefore the chain is reversible. This formalizes our idea that if $p = 1/2$ then in steady state the chain "looks the same run forwards or backwards."
Recall that a birth and death chain is a Markov Chain on the integers, with one-step transitions restricted to going up by 1, going down by 1, or staying in place. It is not hard to check that every irreducible birth and death chain with a finite state space is reversible. You can simply solve the detailed balance equations just as we did for the Ehrenfest chain in the previous section.
Go back and look through the examples in the text and exercises. The switching chains, the reflecting random walks (both lazy and not), both of the Ehrenfest chains, and the Bernoulli-Laplace chain are all irreducible birth and death chains, and hence are reversible.
Let's confirm this in the case of a birth and death chain which at first glance seems not to be reversible. Here is the transition diagram of a Markov Chain $X_0, X_1, \ldots $.
This chain moves right (that is, has births) with high probability, so it seems as though we should be able to tell whether it's moving forwards or backwards. But remember that time reversal happens in the steady state. In the steady state, the chain is overwhelmingly likely to be shuttling between states 3 and 4. You can see this by solving the detailed balance equations.
\begin{align*} \pi(1)\cdot 1 &= \pi(2) \cdot 0.1 ~~~~ \implies \pi(2) = 10\pi(1) \\ \pi(2) \cdot 0.9 &= \pi(3) \cdot 0.1 ~~~~ \implies \pi(3) = 90\pi(1) \\ \pi(3) \cdot 0.9 &= \pi(4) \cdot 1 ~~~~~~~ \implies \pi(4) = 81\pi(1) \end{align*}It will visit states 2 and 1 as well, but rarely, state 1 being particularly rare. These vists will intersperse the sojourns in 3 and 4, and the paths will be indistinguishable forwards and backwards.
Let's simulate paths of this process. First, we construct the transition matrix and confirm our calculations of $\pi$.
s = np.arange(1, 5)
def trans(i, j):
if i == 1:
if j == 2:
return 1
else:
return 0
elif i == 4:
if j == 3:
return 1
else:
return 0
elif j == i+1:
return 0.9
elif j == i-1:
return 0.1
else:
return 0
bnd = Table().states(s).transition_function(trans).toMarkovChain()
pi = bnd.steady_state()
pi
0.445055/0.00549451
The method simulate_chain
simulates a path of the chain. Its arguments are the initial distribution (provided as a distribution object) and the number of steps.
The graph below shows one path of length 200. Run the cell a few times and look at each path forwards as well as backwards. You won't find a systematic difference between the two.
plt.figure(figsize=(10,5))
n = 200 # the number of steps
x = np.arange(n+1) # the steps
y = bnd.simulate_chain(pi, n) # the simulated state at each step
plt.scatter(x, y, s=40) # a point at the state at each step
plt.plot(x, y, lw=1, color='k') # lines join the points, as a visual aid
# The rest of the code sets axis limits, styles, and labels.
plt.xlim(-0.5, n+0.5)
plt.ylim(0.9, 4.1)
plt.yticks(np.arange(1, 5))
plt.xlabel('$n$')
plt.ylabel('$X_n$', rotation=0)
plt.title('Reversibility: Path of Birth and Death Chain in Steady State');


CallProviderConfiguration
public struct CallProviderConfiguration
A CallProviderConfiguration object controls the native call UI for incoming and outgoing calls, including a localized name for the provider, the ringtone to be played for incoming calls, and the icon to be displayed during calls.
-
The localized name of the provider.
Declaration
Swift
public let localizedName: String
-
The icon image to be displayed for the provider.
The icon image should be a square with side length of 40 points. The alpha channel of the image is used to create a white image mask, which is used in the system native in-call UI for the button which takes the user from this system UI to the 3rd-party app.
Declaration
Swift
public let iconTemplate: UIImage?
-
The name of the sound resource in the app bundle to be used for the provider ringtone.
Declaration
Swift
public let ringtoneSound: String?
-
Whether or not calls from this provider should be included in the iOS Recents list.
Declaration
Swift
public let includesCallsInRecents: Bool
-
Instantiates a CallProviderConfiguration
Declaration
Swift
public init( localizedName: String, iconTemplate: UIImage?, ringtoneSound: String?, includesCallsInRecents: Bool )


1. Delta specification
This is a delta specification, meaning that it currently contains only the differences from CSS Animations Level 1 [CSS3-ANIMATIONS]. Once the Level 1 specification is closer to complete, it will be merged with the additions here into a complete level 2 specification.
2. Animations
2.1. Owning element
The owning element of an animation refers to the element or pseudo-element to which the animation-name property was applied that generated the animation.
If an animation was generated directly by script (e.g. using
the CSSAnimation
constructor) then it has no owning element.
If an animation generated using the markup defined in this specification is later disassociated from that markup by an update to the computed value of the animation-name property on the owning element, the animation is disassociated from its owning element (that is, it has no owning element from that point forwards).
In the example below, animation
’s initial owning element is elem
. animation
is disassociated from element
through an update to the computed value of elem
’s animation-name property.
elem. style. animation= 'spin 1s' ; let animation= elem. getAnimations()[ 0 ]; // animation’s owning element is elem elem. style. animation= '' ; // animation no longer has an owning element
Note that although the owning element is often equal to the target element of an animation’s target effect, this is not always the case. The following example demonstrates some of the situations where these two elements may differ.
elem. style. animation= 'move 1s' ; let animation= elem. getAnimations()[ 0 ]; // animation.effect.target == elem == animation’s owning element let mutableEffect= animation. effect. clone(); animation. effect= mutableEffect; animation. effect. target= elem2; // animation.effect.target == elem2 != animation’s owning element animation. effect= null ; // animation.effect.target is undefined != animation’s owning element
2.2. Animation composite order
Animations generated from the markup or interfaces
(e.g. the CSSAnimation
constructor) defined in this specification have an animation class of ‘CSS Animation’.
CSS Animations with an owning element have a later composite order than CSS Transitions but an earlier composite order than animations without a specific animation class.
Within the set of CSS Animations with an owning element, two animations A and B are sorted in composite order (first to last) as follows:
-
If the owning element of A and B differs, sort A and B by tree order of their corresponding owning elements. With regard to pseudo-elements, the sort order is as follows:
-
element
-
::marker
-
::before
-
::after
-
element children
-
-
Otherwise, sort A and B based on their position in the computed value of the animation-name property of the (common) owning element.
The composite order of CSS Animations without an owning element is based on their position in the global animation list.
This differs from the behavior defined for transitions. We should probably sort transitions first, then animation, then use the global animation list. The reason being that when developer tools etc. hang on to orphaned animations and transitions in order to replay them, they should maintain roughly the same composite order.
CSS Animations generated using the markup defined in this specification are not added to the global animation list when they are created. Instead, these animations are appended to the global animation list at the first moment when they transition out of the idle play state after being disassociated from their owning element. CSS Animations that have been disassociated from their owning element but are still idle do not have a defined composite order.
Note, this behavior relies on the fact that disassociating an animation from its owning element always causes it to enter (or remain) in the idle play state.
CSS Animations created using the CSSAnimation
constructor are appended
to the global animation list at the moment they are constructed.
3. Keyframes
3.1. The animation-play-state property
3.1.1. Interaction between animation-play-state and the Web Animations API
Both this specification and the Web Animations specification [WEB-ANIMATIONS] define mechanisms for pause control, specifically the animation-play-state property, and the play()
and pause()
methods
respectively.
The interaction of these methods can be summarized as follows:
-
Calling
pause()
is sticky. The animation will remain paused until there is a subsequent call toplay()
after which point the animation will begin tracking changes to the computed value of the animation-play-state property on the owning element from the next moment it becomes newly paused. -
If the computed animation-play-state on the owning element is paused, calling
play()
will temporarily override the animation-play-state until it next becomes running.
With regards to the pausing, an animation can be considered to be in one of five mutually-exclusive states:
- Running
- Running and temporarily overriding animation-play-state: paused
- Paused and sticky overriding animation-play-state: running
- Paused and sticky overriding animation-play-state: paused
- Paused by animation-play-state
A state transition chart follows:
| Initial state | ||||||
|---|---|---|---|---|---|---|
| Event | A | B | C | D | E | |
| Resulting state | play()
| A | B | A | B | B |
pause()
| C | D | C | D | D | |
| animation-play-state → running | A | A | C | C | A | |
| animation-play-state → paused | E | B | D | D | E |
If any change causes an animation to change from one of the running states (A, B) to one of the paused states (C, D, E), the user agent must run the pause an animation procedure on the animation.
Likewise, for any change from one of the the paused states to one of the running states, the user agent must run the play an animation procedure on the animation. If the change is due to a change in the computed value of animation-play-state (i.e. the transition E → A) the auto-rewind flag for that procedure must be set to false; otherwise it must be set to true.
3.2. The animation-composition property
The animation-composition property defines the composite operation used when multiple animations affect the same property simultaneously.
| Name: | animation-composition |
|---|---|
| Value: | <single-animation-composition># |
| Initial: | replace |
| Applies to: | all elements |
| Inherited: | no |
| Percentages: | N/A |
| Computed value: | list, each item a keyword as specified |
| Canonical order: | per grammar |
| Animation type: | not animatable |
<single-animation-composition> = replace | add | accumulate
The values of animation-composition have the meaning defined for the corresponding values of the composite operation defined in Web Animations [WEB-ANIMATIONS].
When specified in a keyframe, animation-composition defines the composite operation to use for each property specified in that keyframe until the next keyframe specifying each property.
@keyframes heartbeat { from { scale: 1; animation-timing-function: ease-out; } 30% { scale: 1.3; } } .heartbeat { animation: heartbeat 0.3s 2s infinite; } @keyframes throb { 50% { scale: 1.8; } } .icon:mouseover { animation: throb 0.4s add; }
If these two animations are applied to the same element, normally only one animation would apply, but by specifying add as the animation-composition on the second animation, the result of the two animations will be combined.
Since CSS Transitions [CSS3-TRANSITIONS] have a lower composite order, it is possible to use animation-composition to combine CSS Animations with underlying transitions as in the following example.
.icon { filter: blur(20px); transition: filter 0.5s; } .icon:hover { filter: blur(0px); animation: brightness-pulse 3s infinite add; } @keyframes pulse { 0% { scale: 1.1; filter: brightness(130%); } 10% { scale: 1; filter: brightness(100%); } }
Create pictures of these examples and verify they make sense.
4. Animation Events
4.1. Event dispatch
Note, this is a more general description of event dispatch than that of CSS Animations Level 1 [CSS3-ANIMATIONS] since it must account for the possibility of animations being seeked or reversed using the Web Animations API [WEB-ANIMATIONS].
For the purpose of determining which events to dispatch, the phases defined in the Web Animations model are used. These definitions apply to an animation effect, however, for the purpose of dispatching events, we consider a CSS Animation to have the same phase as its target effect. For example, a CSS Animation is in the before phase if its target effect is in the before phase.
A CSS Animation that does not have a target effect is considered to be in the idle phase if its current time is unresolved, in the before phase if its current time is less than zero, and in the after phase otherwise.
Similarly, subsequent references to the start delay, active duration, current iteration, iteration start, and iteration duration of a CSS animation should be understood to refer to the corresponding properties of the animation’s target effect.
For calculating the elapsedTime
of each event, the following
definitions are used:
-
interval start =
max(min(-start delay, active duration), 0)
-
interval end =
max(min(target effect end - start delay, active duration), 0)
Each time an animation is sampled and is not pending, the events to dispatch are determined by comparing the animation’s phase before and after the sample as follows:
| Change | Events dispatched | Elapsed time (ms) |
|---|---|---|
| idle or before → active | animationstart
| interval start |
| idle or before → after ٭ | animationstart
| interval start |
animationend
| interval end | |
| active → before | animationend
| interval start |
| active → active and the current iteration of the animation’s target effect has changed since the previous sample | animationiteration
| (See below) † |
| active → after | animationend
| interval end |
| after → active | animationstart
| interval end |
| after → before ٭ | animationstart
| interval end |
animationend
| interval start | |
| not idle and not after→ idle | animationcancel
| The active time of the animation at the moment it was cancelled calculated using a fill mode of both. |
٭ Where multiple events are listed for a state change, all events are dispatched in the order listed and in immediate succession.
† The elapsed time for
an animationiteration
event is defined as follows:
-
Let previous current iteration be the current iteration from the previous sample.
-
If previous current iteration is greater than current iteration, let iteration boundary be
current iteration + 1
, otherwise let it be current iteration. -
The elapsed time is the result of evaluating
(iteration boundary - iteration start) × iteration duration)
.
Since the elapsed time defined in the table and procedure above is
expressed in milliseconds, it must be divided by 1,000 to produce a value in
seconds before being assigned to the elapsedTime
member of
the AnimationEvent
.
5. DOM Interfaces
5.1. The CSSAnimation interface
[Exposed =Window ]interface :
CSSAnimation Animation {readonly attribute CSSOMString animationName ; };
animationName
, of type CSSOMString, readonly-
The key used to find matching keyframes rules that define target effect at the point when the animation was created. This is the value of the animation-name property that caused this object to be generated or, if this object was generated using the programming interface, the
animationName
argument that was passed to theCSSAnimation
constructor.
We need to define a constructor for CSSAnimation
.
Perhaps something like the following:
[Constructor (Animatable ?target ,CSSOMString animationName ,optional (unrestricted double or KeyframeEffectOptions )options ,optional CSSOMString defaultEasing = "ease"),Constructor (Animatable ?target ,CSSOMString animationName , (unrestricted double or KeyframeEffectOptions )options ,CSSOMString defaultEasing ,AnimationTimeline ?timeline )]partial interface CSSAnimation { };
The difficulty is with liveness. The most useful and least magical
(but most complicated) approach is to define a subclass of KeyframeEffectReadOnly
that has the special behavior of tracking changes
to all @keyframes rules that match the supplied name and automatically
updating the set of keyframes returned by getFrames()
after filling-in the default easing.
Something like,
[Exposed =Window ,Constructor (CSSOMString keyframesName ,CSSOMString defaultEasing )]interface :
CSSKeyframeEffectReadOnly KeyframeEffectReadOnly {readonly attribute CSSOMString ;
keyframesName readonly attribute CSSOMString ; };
defaultEasing
5.2. Requirements on pending style changes
Various operations may affect the computed values of properties on elements. User agents may, as an optimization, defer recomputing these values until it becomes necessary. However, all operations included in programming interface defined in this specification, as well as those operations defined in Web Animations [WEB-ANIMATIONS] that may return objects defined by this specification, must produce a result consistent with having fully processed any such pending changes to computed values.
elem
is initially updated, a user agent may defer recalculating
the computed value of the animation property.
However, the getAnimations()
method called on elem
is specified by Web Animations and can return CSSAnimation
objects as
defined in this specification.
Hence, as result of the requirements in this section, the user agent must
calculate the updated value of elem
’s animation property and
create the requested CSSAnimation
object before returning its result.
6. Privacy and Security Considerations
This specification introduces no new privacy or security considerations.


Display Moon image lit for correct Earth viewpoint, with full quantitative data in tabular form. See all features up close with Lunar Orbiter IV imagery.


TABLE OF INTERACTIONS WITH
HYPERKALEMIA INDUCING MEDICATIONS
Some medications or therapeutic classes are susceptible of promoting the onset of hyperkalemia: the potassium salts, hyperkalemia inducing diuretics, angiotensin converting enzyme inhibitors, angiotensin II receptor antagonists, non steroidal anti-inflammatories, heparins (low molecular weight or unfractionated), immunosuppressants such as ciclosporin or tacrolimus, trimethoprim.
These medications taken together increase the risk of hyperkalemia. This risk is especially large with the potassium sparing diuretics when they are taken with others of that same group or with potassium salts, whereas taking them with an ACE inhibitor or an NSAID, for example, poses a lower risk when the recommended precautions are observed.
To know the risks and the levels of constraint specific to the hyperkalemia inducing medications, consult the particular interactions for each substance.
Nevertheless, certain substances, such as trimethorprim, do not have specific interactions with regard to this risk. Even so, they can increase the risks when they are taken with other medications mentioned under this heading.
From the French ANSM drug interactions document of September 2016, p. 109
HYPERKALEMIA INDUCING MEDICATIONS CLASS CODE: M01A-001 |
OTHER HYPERKALEMIA INDUCING MEDICATIONS CLASS CODE: M01A-001 |
Risk of increase of hyperkalemia, potentially lethal. |
Take into account |


http://github.com/udacity/appify/
http://github.com/udacity/sunflower/
http://github.com/udacity/bokeh/


3 Getting Started with RStudio
Rstudio is what’s referred to as an Integrated Development Environment (IDE) for the R programming language. It provides a single interface for an R user to manage all aspects of an analysis (write code, manage and plot data. see outputs, get help, etc.).
3.1 RStudio Interface
There are four main panels in RStudio (Figure 1).
- Code Editor - This is where you write the code for your analysis. Each tab represents a different R script file (e.g.
snapper_analysis.R
) - Console - This is where R prints the output of your code when it’s run. You can also write code directly in the console after the
>
symbol - Environment/History - This panel generally has the following two tabs:
- Environment - Displays all your data, variables, and user-defined functions. These are created by the user either in the code editor or directly in the console.
- History - A list of your command history
- Files/Packages/Help/Viewer - This panel contains numerous helpful panels:
- Files - The list of all files contained in your current working directory. You can also navigate to different folders on your computer. This is where you can click on different R scripts to open them in the code editor.
- Plots - When you produce plots with your code they will be displayed here
- Packages - The list of packages (groups of functions) currently installed on your computer. You can install new packages or update existing packages from this tab by clicking
Install
orUpdate
. - Help - Where you can search the R documentation to get help using the different R functions. This is a very useful feature of RStudio! You can also get help for a function by typing
?
followed by the function name in the console (e.g.?data.frame()
).
3.2 Working Directory
The working directory is an important concept in R (and programming in general) and refers to the current directory (folder) that you are working in. Basically, R requires that you tell it where in your computer’s file system it should start looking for files from. This is important because the code used to load data and save results and plots will differ depending on your current working directory.
As an example, let’s imagine you are working on an analysis of coral reef fisheries and you have a folder on your Desktop called reef_fish
. Inside this reef_fish
directory is the file reef_fish_data.csv
that you want to analyze. Open RStudio and click Set Working Directory...
under the Session
menu in the toolbar. This asks you to specify the folder on your computer that R should consider to be the working directory.
3.2.1 Pathnames (Path)
Now that the working directory is set, you can load your reef fish data into RStudio by specifying the appropriate pathname to the file. In this case, the pathname is simply reef_fish_data.csv
since the file is in the working directory and the data could be loaded with read.csv(file = "reef_fish_data.csv")
. If, however, reef_fish_data.csv
was actually stored in a subfolder called data
the previous read.csv()
command will not work because reef_fish_data.csv
is not in the working directory. In this case, you can either tell R where the file is using the absolute, complete path (e.g. /Users/You/Desktop/reef_fish/data/reef_fish_data.csv
), or with the path relative to the working directory (e.g. data/reef_fish_data.csv
).
3.3 Packages
Packages are groups of functions that are designed to excel at certain tasks (making plots, standardizing dates, reading/writing large data files, etc.). Many useful packages come standard with R when you download it, however, many more are available online.
To install a new package, click on the “Install” button located under the “Packages” tab in RStudio. This will open a pop-up where you can search for and install R packages hosted on CRAN. Alternatively, if you know the name of the package you want to install, you can run install.packages('package_name')
.
Once installed, the packages you need for an analysis are loaded by the library('package_name')
function.
The following packages are commonly used by UCSB for fisheries analyses:
- tidyverse - Contains numerous seperate packages for loading and writing data files (readr), data processing (dplyr & tidyr), plotting (ggplot2), and functional programming (purrr)
- readxl - Reads and writes data from/to Excel workbooks, including workbooks with multiple worksheets
- lubridate - Helps R handle dates in an efficient and easy-to-understand manner
- sf, rgeos, rgdal - Key packages for spatial analyses similar to those done with ArcGIS
- rmarkdown - Uses R code to author reproducible reports, presentations, and websites
- shiny - Creates web applications using R


--- layout: post title: ! 'Apache: Configuring Tomcat' tags: [] status: publish type: post published: true meta: {} ---
In the following I shall talk you through configuring and installing Tomcat [at the time of writing the latest version was 3.2.1] (a JSP server) to run with your Apache server on your Windows box. Before we get started you will need to get the following files (and I am assuming that you have Apache installed and configured properly):
Once you have downloaded these files, start off with extracting the Tomcat source files and installing the JDK 1.3 files. For simplicities sake extract and install the files into the root of your drive. Once done you will need to edit the wrapper.properties file (usually located in: <drive letter>:\jakarta-tomcat-3.2.1\conf. You will need to specify both your tomcat home directory and your Java directory. Look for the following lines:
#
# wrapper.tomcat_home should point to the location where you
# installed tomcat. This is where you have your conf, webapps and lib
# directories.
#
wrapper.tomcat_home=<put your Tomcat home>
#
# wrapper.java_home should point to your Java installation. Normally
# you should have a bin and lib directories beneath it.
#
wrapper.java_home=<put your Java home>
Modify that section to refelect your installation directories:
#
# wrapper.tomcat_home should point to the location where you
# installed tomcat. This is where you have your conf, webapps and lib
# directories.
#
wrapper.tomcat_home=<drive letter>:\jakarta-tomcat-3.2.1\
#
# wrapper.java_home should point to your Java installation. Normally
# you should have a bin and lib directories beneath it.
#
wrapper.java_home=<drive letter>:\JDK1.3.0_02\
Save the file. Next extract the jk_nt_service file you downloaded into your tomcat home directory, open a command prompt window and change to that directory. Once there type the following command:
jk_nt_service -i Tomcat <Drive Letter>:\jakarta-tomcat-3.2.1\conf\wrapper.properties
Should your install directory include and spaces you will need to put your wrapper.properties path in quotation marks. OK, once done start the service by typing net start Tomcat. It should have started without any problems. Next locate the file called tomcat-apache (usually also located in <drive letter>:\jakarta-tomcat-3.2.1\conf) and open it. Copy and paste the content into your Apache http.conf (located in <drive letter>:\Program Files\Apache Group\Apache\conf\). Save the changes and stop your Apache server (net stop apache). The final step involves copying the ApacheModuleJServ.dll into the modules directory in your Apache install directory and restarting the Apache server.
OK, ready to test your work? Open a web browser and enter the following URL http://localhost/examples/jsp/. You should be presented with a list of examples. Try them out. If you installed everything correctly they should be working. Welcome to the world of JSP.


As of right now, the tutorials are still under construction. In the meantime, check out the few Javascript tutorials I have set up.


Fake News
Fake news is false or misleading information presented as news. It often has the aim of damaging the reputation of a person or entity, or making money through advertising revenue. However, the term does not have a fixed definition, and has been applied more broadly to include any type of false information, including unintentional and unconscious mechanisms, and also by high-profile individuals to apply to any news unfavourable to his/her personal perspectives.
Once common in print, the prevalence of fake news has increased with the rise of social media, especially the Facebook News Feed. Political polarization, post-truth politics, confirmation bias, and social media algorithms have been implicated in the spread of fake news. It is sometimes generated and propagated by hostile foreign actors, particularly during elections. The use of anonymously-hosted fake news websites has made it difficult to prosecute sources of fake news for libel. In some definitions, fake news includes satirical articles misinterpreted as genuine, and articles that employ sensationalist or clickbait headlines that are not supported in the text.
Fake news can reduce the impact of real news by competing with it; a Buzzfeed analysis found that the top fake news stories about the 2016 U.S. presidential election received more engagement on Facebook than top stories from major media outlets. It also has the potential to undermine trust in serious media coverage. The term has at times been used to cast doubt upon legitimate news, and former U.S. president Donald Trump has been credited with popularizing the term by using it to describe any negative press coverage of himself. It has been increasingly criticized, due in part to Trump's misuse, with the British government deciding to avoid the term, as it is "poorly-defined" and "conflates a variety of false information, from genuine error through to foreign interference".
Multiple strategies for fighting fake news are currently being actively researched, and need to be tailored to individual types of fake news. Effective self-regulation and legally-enforced regulation of social media and web search engines are needed. The information space needs to be flooded with accurate news to displace fake news. Individuals need to actively confront false narratives when spotted, as well as take care when sharing information via social media. However, reason, the scientific method and critical thinking skills alone are insufficient to counter the broad scope of bad ideas.  Inoculation theory shows promise in designing techniques to make individuals resistant to the lure of fake news, in the same way that a vaccine protects against infectious diseases.
Types
Claire Wardle of First Draft News, in preliminary findings, identifies seven types of fake news:
- satire or parody ("no intention to cause harm but has potential to fool")
- false connection ("when headlines, visuals or captions don't support the content")
- misleading content ("misleading use of information to frame an issue or an individual")
- false context ("when genuine content is shared with false contextual information")
- impostor content ("when genuine sources are impersonated" with false, made-up sources)
- manipulated content ("when genuine information or imagery is manipulated to deceive", as with a "doctored" photo)
- fabricated content ("new content is 100% false, designed to deceive and do harm")
Scientific denialism is another potential explanatory type of fake news, defined as the act of producing false or misleading facts to unconsciously support strong pre-existing beliefs.


--- layout: default title: 404 image: permalink: /404.html ---
The requested page could not be found.
Back to the Blog


@managedChild
@managedChild
<T extends ManagedObject>(target: T, propertyKey: any): void
Managed object property decorator: amend decorated property to turn it into a managed child reference.
This asserts a parent-child dependency between the referrer and the referenced object(s), recursively extending to objects in referenced managed lists, maps, and reference instances:
When the parent is destroyed, all children are also destroyed.
When the decorated property is set to another object, the previously referenced object is destroyed.
When the referenced object is assigned to another managed child reference (or list, map, or reference instance that is a child object), the decorated property is set to undefined.
The child object may refer to its parent using the
ManagedObject.getManagedParent
method, and observers can observe the managed parent reference using anonManagedParentChange[Async]
method.


Nazareth man killed after crashing into guard rail near Childress Thursday night
by Kaitlin JohnsonCHILDRESS COUNTY, Texas (KFDA) - One person has died after a crash near Childress on Thursday night.
Around 10:35 p.m., DPS officials say 59-year-old Glenn Earl Waldo of Nazareth was driving east on US 287 when he lost control of his vehicle for an unknown reason.

He was thrown from the pickup and pronounced dead on the scene.
DPS officials say he was not wearing a seat belt.