Main Page
Namespaces
Data Structures
Files
Directories
UVM-ML Directories
This directory hierarchy is sorted roughly, but not completely, alphabetically:
uvm_sc_adapter
common
ml_tlm2
tlm2_osci_patch
2.2
tlm_h
tlm_generic_payload
2.3
tlm_core
tlm_2
tlm_generic_payload
ncsc
osci
Generated on Wed Nov 13 23:37:23 2013 for UVM-ML by
1.4.7


Class Email List
Name
Email
Seth Farr
<EMAIL_ADDRESS>Cal Wilson
<EMAIL_ADDRESS>Copied to Clipboard
Copy to Clipboard


Gurgl was a team effort, working closely together to bring an idea to life. We had a week to build the site and were able to effectively implement short iterations and Agile project management.
I was responsible for a few things in this build. I tested it exhaustively using Istanbul for 95% coverage. It had complete error handling and fall backs.
Using React/Redux meant filtering, searching and pagination was instantaneous. The little things mattered in this build. This made for a high quality user experience and a finished project I was very proud of.


|
|
Model version
|
1.20
|
|
Simulink Coder version
|
8.6 (R2014a) 27-Dec-2013
|
|
C source code generated on
|
Mon May 4 10:53:09 2015
|
|
Configuration settings at the time of code generation:
click to open
click to open
|
|
Code generation objectives:
Unspecified
|
|
Validation result: Not run
|
|


At the age of 11, I learned to program in HTML. Ever since then, I've had a voracious interest in software development.
In 2012, at age 14, I began my studies as a dual enrollment student at Florida Atlantic University. If you have any questions about dual enrollment, please email me at<EMAIL_ADDRESS>I plan to graduate from FAU in December 2015 with my Bachelor's Degree in Computer Science.
I work on at least one web project per year and group projects are my favorite. A backwards chronological list of sites that I made and/or contributed to is under my portfolio, and the most impressive websites are also listed in my resume.
I have several hobbies outside of computer science. Are you interested?
Email me to guarantee a response in 24 hours or less.


Read-Only Domain Controller Kerberos
Using Mimikatz on a RODC, it’s possible to get the RODC’s krbtgt account (krbtgt_45703) password hashes.
Using the standard AD database dump capability in Mimikatz provides the RODC krbtgt data.
Using the Mimikatz command to just pull the krbtgt account data works against the RODC as well. There are a couple of errors though.


Page not found
The page you requested cannot be found (perhaps it was moved or renamed).
You may want to try searching to find the page's new location, or use the table of contents to find the page you are looking for.
The page you requested cannot be found (perhaps it was moved or renamed).
You may want to try searching to find the page's new location, or use the table of contents to find the page you are looking for.


First choose the type of tableau using the radio buttons.
Next, obtain a tableau via the Domino Robinson-Schensted algorithm, either randomly or by entering a parameter.
To obtain a randomly-generated tableau, simply enter the size in the textbox labelled "n".
Then, click the Run button to the right of that box, or press Enter.
Instead, you can enter a signed permutation (for example, 2 -5 3 6 -4 1) in the second textbox.
To do that, list the numbers of the signed permutation, separated by spaces.
Then, click the Run button to the right of that box, or press Enter.
The purpose of this page is to get a quick overview of what open cycles look like.
Each open cycle has a back square, marked in green, and a forward square, marked in purple.
If you hover your mouse over one of those squares, the cycle attached to that square will be highlighted.
You can use one of the animation cycle pages to see the process of moving the tableau through a cycle.
Pressing a button a second time, or a different button, will clear the previous result as it gives you a new result, as will pressing Enter while in a textbox.


List of all members.
Public Member Functions |
|
(void) | - download: |
|
(int) | - downloadingContentCount |
|
(NSArray *) | - allDownloadingContents |
|
(void) | - cancel: |
|
(void) | - updateProgressDelegate: |
|
(BOOL) | - isDownloading: |
|
(void) | - endBackground |
Protected Attributes |
|
UA_ASINetworkQueue * | downloadNetworkQueue |
|
UA_ASINetworkQueue * | networkQueue |
|
UIBackgroundTaskIdentifier | bgTask |
|
BOOL | continueDownloadsInBackground |
Properties |
|
id< UADownloadManagerDelegate > | delegate |
The documentation for this class was generated from the following file:


{% extends 'selia_registration/base.html' %} {% load i18n %} {% block content %}
{% blocktrans %} We have sent an email with instructions on how to reset your password. {% endblocktrans %}
{% blocktrans %} It should arrive shortly. If not, please make sure that you have input the correct address or check your spam directory. {% endblocktrans %}
{% trans 'Back' %} {% endblock %}


Our story
Lorem ipsum dolor sit amet, consectetuer adipisc ing elit, sed diam nonummy nibh euismod tincidunt ut laoreet.
Dolore magna aliquam erat volutpat. Lorem ipsum dolor sit amet, consectetuer adipisc ing elit, sed diam
nonummy nibh euismod tincidunt ut laoreet. Dolore magna aliquam erat volutpat. Lorem ipsum dolor
sit amet, consectetuer adipisc ing elit, sed diam nonummy nibh euismod tincidunt ut laoreet.
Dolore magna aliquam erat volutpat.
Meet us
Lorem ipsum dolor sit amet, consectetuer
dipisc ing elit, sed diam nonummy nibh
euismod tincidunt ut laoreet.
Mike is a local Reno businessman who has been involved with this community for many years. His interest in wine also started several years ago - both drinking it and making it ! Mike has also had the dream of having a winery for awhile and was very excited when this could be a reality in Reno. Alynn moved to Reno 3 years ago and also got involved in the dream. She’s been helping out in the vineyard and winery ever since. Together they’ve managed to grow and harvest grapes in Fallon, get the paperwork done and re-furbish their building into the beautiful space it is today for production, tasting and events. Mike’s and Alynn’s kids have also been a great help - as well as many friends who now know how to crush and press grapes !


--- title: About Goldydocs linkTitle: About menu: main: weight: 10 --- {{< blocks/cover title="About COAsT" image_anchor="bottom" height="min" >}}
A site using the Docsy Hugo theme.
{{< /blocks/cover >}} {{% blocks/lead %}} This site was based off the Docsy Hugo theme. {{% /blocks/lead %}}


--- title: "Feature columns" output: rmarkdown::html_vignette: default vignette: > %\VignetteIndexEntry{Feature columns} %\VignetteEngine{knitr::rmarkdown} %\VignetteEncoding{UTF-8} type: docs repo: https://github.com/rstudio/tfdatasets menu: main: name: "Feature columns" identifier: "feature-columns" parent: "data-feature-spec-top" weight: 20 aliases: - /tools/tfdatasets/feature-spec - /tools/tfdatasets/articles/feature_columns.html ---
This document is an adaptation of the official TensorFlow Feature Columns guide.
This document details feature columns and how they can be used as inputs to neural networks using TensorFlow. Feature columns are very rich, enabling you to transform a diverse range of raw data into formats that neural networks can use, allowing easy experimentation.
What kind of data can a deep neural network operate on? The answer is, of course,
numbers (for example, tf$float32
). After all, every neuron in a neural network
performs multiplication and addition operations on weights and input data. Real-life
input data, however, often contains non-numerical (categorical) data. For example,
consider a product_class
feature that can contain the following three non-numerical
values:
ML models generally represent categorical values as simple vectors in which a 1 represents
the presence of a value and a 0 represents the absence of a value. For example, when
product_class
is set to sports, an ML model would usually represent product_class
as
[0, 0, 1]
, meaning:
So, although raw data can be numerical or categorical, an ML model represents all features as numbers.
This document explains nine of the feature columns available in tfdatasets. As the
following figure shows, all nine functions return either a categorical_column
or a
dense_column
object, except bucketized_column
, which inherits from both classes:
Let’s look at these functions in more detail.
We are going to use the feature_spec
interface in the examples. The feature_spec
interface is an abstraction that makes it easier to define feature columns in R.
You can initialize a feature_spec
with:
library(tfdatasets)
hearts_dataset <- tensor_slices_dataset(hearts)
spec <- feature_spec(hearts_dataset, target ~ .)
We then add steps in order to define feature_columns
. Read the feature_spec
vignette for more information.
We use step_numeric_column
to add numeric columns to our spec
.
spec %>%
step_numeric_column(age)
## ── Feature Spec ──────────────────────────────────────────────────────────────────────────────
## A feature_spec with 1 steps.
## Fitted: FALSE
## ── Steps ─────────────────────────────────────────────────────────────────────────────────────
## StepNumericColumn: age
## ── Dense features ────────────────────────────────────────────────────────────────────────────
## Feature spec must be fitted before we can detect the dense features.
By default, a numeric column creates a single value (scalar). Use the shape argument to specify another shape. For example:
# Represent a 10-element vector in which each cell contains a tf$float32.
spec %>%
step_numeric_column(bowling, shape = 10)
# Represent a 10x5 matrix in which each cell contains a tf$float32.
spec %>%
step_numeric_column(my_matrix, shape = c(10, 5))
A nice feature of step_numeric_column
is that you can also specify normalizer functions.
When using a scaler, the scaling constants will be learned from data when fitting
the feature_spec
.
# use a function that defines tensorflow ops.
spec %>%
step_numeric_column(age, normalizer_fn = function(x) (x-10)/5)
# use a scaler
spec %>%
step_numeric_column(age, normalizer_fn = scaler_standard())
Often, you don’t want to feed a number directly into the model, but instead split
its value into different categories based on numerical ranges. To do so, create a
bucketized_column
. For example, consider raw data that represents the year a
house was built. Instead of representing that year as a scalar numeric column, we
could split the year into the following four buckets:
Why would you want to split a number — a perfectly valid input to your model — into a categorical value? Well, notice that the categorization splits a single input number into a four-element vector. Therefore, the model now can learn four individual weights rather than just one; four weights creates a richer model than one weight. More importantly, bucketizing enables the model to clearly distinguish between different year categories since only one of the elements is set (1) and the other three elements are cleared (0). For example, when we just use a single number (a year) as input, a linear model can only learn a linear relationship. So, bucketing provides the model with additional flexibility that the model can use to learn.
The following code demonstrates how to create a bucketized feature:
# First, convert the raw input to a numeric column.
spec <- spec %>%
step_numeric_column(age)
# Then, bucketize the numeric column.
spec <- spec %>%
step_bucketized_column(age, boundaries = c(30, 50, 70))
Note that specifying a three-element boundaries vector creates a four-element bucketized vector.
Categorical identity columns are to tfdatasets
what factors
are to R.
Put differently, they can be seen as a special case of bucketized columns.
In traditional bucketized columns, each bucket represents a range of values
(for example, from 1960 to 1979). In a categorical identity column, each bucket
represents a single, unique integer. For example, let’s say you want to represent
the integer range [0, 4). That is, you want to represent the integers 0, 1, 2, or 3.
In this case, the categorical identity mapping looks like this:
As with bucketized columns, a model can learn a separate weight for each class in
a categorical identity column. For example, instead of using a string to represent
the product_class
, let’s represent each class with a unique integer value. That is:
Call step_categorical_column_with_identity
to add a categorical identity column to
the feature_spec
. For example:
# Create categorical output for an integer feature named "my_feature_b",
# The values of my_feature_b must be >= 0 and < num_buckets
spec <- spec %>%
step_categorical_column_with_identity(my_feature_b, num_buckets = 4)
We cannot input strings directly to a model. Instead, we must first map strings to numeric or categorical values. Categorical vocabulary columns provide a good way to represent strings as a one-hot vector. For example:
As you can see, categorical vocabulary columns are kind of an enum version of
categorical identity columns. tfdatasets
provides two different functions to create
categorical vocabulary columns:
step_categorical_column_with_vocabulary_list
step_categorical_column_with_vocabulary_file
categorical_column_with_vocabulary_list
maps each string to an integer based on an explicit vocabulary list. For example:
spec <- spec %>%
step_categorical_column_with_vocabulary_list(
thal,
vocabulary_list = c("fixed", "normal", "reversible")
)
Note that the vocabulary_list
argument is optional in R and the vocabulary will be
discovered when fitting the featture_spec
which saves us a lot of typing.
You can also place the vocabulary in a separate file that should contain one line for each vocabulary element. You can then use:
spec <- spec %>%
step_categorical_column_with_vocabulary_file(thal, vocabulary_file = "thal.txt")
So far, we’ve worked with a naively small number of categories. For example, our
product_class example has only 3 categories. Often though, the number of categories
can be so big that it’s not possible to have individual categories for each vocabulary
word or integer because that would consume too much memory. For these cases, we can
instead turn the question around and ask, “How many categories am I willing to have
for my input?” In fact, the step_categorical_column_with_hash_bucket
function enables you to specify the number of categories. For this type of feature
column the model calculates a hash value of the input, then puts it into one of
the hash_bucket_size categories using the modulo operator, as in the following
pseudocode:
# pseudocode
feature_id = hash(raw_feature) % hash_bucket_size
The code to add the feature_column
to the feature_spec
might look something
like this:
spec <- spec %>%
step_categorical_column_with_hash_bucket(thal, hash_bucket_size = 100)
At this point, you might rightfully think: “This is crazy!” After all, we are forcing the different input values to a smaller set of categories. This means that two probably unrelated inputs will be mapped to the same category, and consequently mean the same thing to the neural network. The following figure illustrates this dilemma, showing that kitchenware and sports both get assigned to category (hash bucket) 12:
As with many counterintuitive phenomena in machine learning, it turns out that hashing often works well in practice. That’s because hash categories provide the model with some separation. The model can use additional features to further separate kitchenware from sports.
Combining features into a single feature, better known as feature crosses, enables the model to learn separate weights for each combination of features.
More concretely, suppose we want our model to calculate real estate prices in Atlanta, GA. Real-estate prices within this city vary greatly depending on location. Representing latitude and longitude as separate features isn’t very useful in identifying real-estate location dependencies; however, crossing latitude and longitude into a single feature can pinpoint locations. Suppose we represent Atlanta as a grid of 100x100 rectangular sections, identifying each of the 10,000 sections by a feature cross of latitude and longitude. This feature cross enables the model to train on pricing conditions related to each individual section, which is a much stronger signal than latitude and longitude alone.
The following figure shows our plan, with the latitude & longitude values for the corners of the city in red text:
For the solution, we used a combination of the bucketized_column we looked at earlier,
with the step_crossed_column
function.
spec <- feature_spec(dataset, target ~ latitute + longitude) %>%
step_numeric_column(latitude, longitude) %>%
step_bucketized_column(latitude, boundaries = c(latitude_edges)) %>%
step_bucketized_column(longitude, boundaries = c(longitude_edges)) %>%
step_crossed_column(latitude_longitude = c(latitude, longitude), hash_bucket_size = 100)
You may create a feature cross from either of the following:
categorical_column_with_hash_bucket
(since crossed_column hashes the input).When the feature columns latitude_bucket_fc
and longitude_bucket_fc
are crossed,
TensorFlow will create (latitude_fc, longitude_fc)
pairs for each example. This would
produce a full grid of possibilities as follows:
(0,0), (0,1)... (0,99)
(1,0), (1,1)... (1,99)
... ... ...
(99,0), (99,1)...(99, 99)
Except that a full grid would only be tractable for inputs with limited vocabularies.
Instead of building this, potentially huge, table of inputs, the crossed_column
only
builds the number requested by the hash_bucket_size argument
. The feature column assigns
an example to a index by running a hash function on the tuple of inputs, followed by a
modulo operation with hash_bucket_size
.
As discussed earlier, performing the hash and modulo function limits the number of categories, but can cause category collisions; that is, multiple (latitude, longitude) feature crosses will end up in the same hash bucket. In practice though, performing feature crosses still adds significant value to the learning capability of your models.
Somewhat counterintuitively, when creating feature crosses, you typically still should include the original (uncrossed) features in your model (as in the preceding code snippet). The independent latitude and longitude features help the model distinguish between examples where a hash collision has occurred in the crossed feature.
Indicator columns and embedding columns never work on features directly, but instead take categorical columns as input.
When using an indicator column, we’re telling TensorFlow to do exactly what we’ve seen in our categorical product_class example. That is, an indicator column treats each category as an element in a one-hot vector, where the matching category has value 1 and the rest have 0s:
Here’s how you create an indicator column:
spec <- feature_spec(dataset, target ~ .) %>%
step_categorical_column_with_vocabulary_list(product_class) %>%
step_indicator_column(product_class)
Now, suppose instead of having just three possible classes, we have a million. Or maybe a billion. For a number of reasons, as the number of categories grow large, it becomes infeasible to train a neural network using indicator columns.
We can use an embedding column to overcome this limitation. Instead of representing the data as a one-hot vector of many dimensions, an embedding column represents that data as a lower-dimensional, ordinary vector in which each cell can contain any number, not just 0 or 1. By permitting a richer palette of numbers for every cell, an embedding column contains far fewer cells than an indicator column.
Let’s look at an example comparing indicator and embedding columns. Suppose our input examples consist of different words from a limited palette of only 81 words. Further suppose that the data set provides the following input words in 4 separate examples:
In that case, the following figure illustrates the processing path for embedding columns or indicator columns.
When an example is processed, one of the categorical_column_with_[…] functions maps the example string to a numerical categorical value. For example, a function maps “spoon” to [32]. (The 32 comes from our imagination — the actual values depend on the mapping function.) You may then represent these numerical categorical values in either of the following two ways:
As an indicator column. A function converts each numeric categorical value into an 81-element vector (because our palette consists of 81 words), placing a 1 in the index of the categorical value (0, 32, 79, 80) and a 0 in all the other positions.
As an embedding column. A function uses the numerical categorical values (0, 32, 79, 80) as indices to a lookup table. Each slot in that lookup table contains a 3-element vector.
How do the values in the embeddings vectors magically get assigned? Actually, the assignments happen during training. That is, the model learns the best way to map your input numeric categorical values to the embeddings vector value in order to solve your problem. Embedding columns increase your model’s capabilities, since an embeddings vector learns new relationships between categories from the training data.
Why is the embedding vector size 3 in our example? Well, the following “formula” provides a general rule of thumb about the number of embedding dimensions:
embedding_dimensions = number_of_categories**0.25
That is, the embedding vector dimension should be the 4th root of the number of categories. Since our vocabulary size in this example is 81, the recommended number of dimensions is 3:
3 = 81**0.25
Note: This is just a general guideline; you can set the number of embedding dimensions as you please.
Call step_embedding_column
to create an embedding_column as suggested by the
following snippet:
spec <- feature_spec(dataset, target ~ .) %>%
step_categorical_column_with_vocabulary_list(product_class) %>%
step_embedding_column(product_class, dimension = 3)
Embeddings is a significant topic within machine learning. This information was just to get you started using them as feature columns.
After creating and fitting a feature_spec
object you can use the dense_features
to get the Dense features from the specifications. You can then use the layer_dense_features
function from Keras to create a layer that will automatically initialize values.
Here is an an example of how it would work:
##
## Attaching package: 'dplyr'
## The following objects are masked from 'package:stats':
##
## filter, lag
## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, union
spec <- feature_spec(hearts, target ~ .) %>%
step_numeric_column(
all_numeric(), -cp, -restecg, -exang, -sex, -fbs,
normalizer_fn = scaler_standard()
) %>%
step_categorical_column_with_vocabulary_list(thal) %>%
step_bucketized_column(age, boundaries = c(18, 25, 30, 35, 40, 45, 50, 55, 60, 65)) %>%
step_indicator_column(thal) %>%
step_embedding_column(thal, dimension = 2) %>%
step_crossed_column(c(thal, bucketized_age), hash_bucket_size = 10) %>%
step_indicator_column(crossed_thal_bucketized_age)
spec <- fit(spec)
input <- layer_input_from_dataset(hearts %>% select(-target))
output <- input %>%
layer_dense_features(feature_columns = dense_features(spec)) %>%
layer_dense(units = 1, activation = "sigmoid")
model <- keras_model(input, output)
model %>%
compile(
loss = "binary_crossentropy",
optimizer = "adam",
metrics = "accuracy"
)
model %>%
fit(
x = hearts %>% select(-target), y = hearts$target,
validation_split = 0.2
)
## Train on 242 samples, validate on 61 samples
## Epoch 1/10
##
32/242 [==>...........................] - ETA: 6s - loss: 0.8009 - accuracy: 0.3438
242/242 [==============================] - 1s 5ms/sample - loss: 0.7781 - accuracy: 0.4298 - val_loss: 0.7310 - val_accuracy: 0.5574
## Epoch 2/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.7911 - accuracy: 0.3750
242/242 [==============================] - 0s 212us/sample - loss: 0.7587 - accuracy: 0.4545 - val_loss: 0.7162 - val_accuracy: 0.5738
## Epoch 3/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6832 - accuracy: 0.5312
242/242 [==============================] - 0s 121us/sample - loss: 0.7407 - accuracy: 0.4752 - val_loss: 0.7025 - val_accuracy: 0.5902
## Epoch 4/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.7768 - accuracy: 0.3750
242/242 [==============================] - 0s 128us/sample - loss: 0.7231 - accuracy: 0.4959 - val_loss: 0.6894 - val_accuracy: 0.5738
## Epoch 5/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6872 - accuracy: 0.5312
242/242 [==============================] - 0s 120us/sample - loss: 0.7068 - accuracy: 0.5372 - val_loss: 0.6767 - val_accuracy: 0.5738
## Epoch 6/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6885 - accuracy: 0.6250
242/242 [==============================] - 0s 127us/sample - loss: 0.6911 - accuracy: 0.5661 - val_loss: 0.6647 - val_accuracy: 0.5902
## Epoch 7/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6150 - accuracy: 0.7188
242/242 [==============================] - 0s 119us/sample - loss: 0.6762 - accuracy: 0.6033 - val_loss: 0.6535 - val_accuracy: 0.6066
## Epoch 8/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6720 - accuracy: 0.5625
242/242 [==============================] - 0s 117us/sample - loss: 0.6624 - accuracy: 0.6322 - val_loss: 0.6428 - val_accuracy: 0.6230
## Epoch 9/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6823 - accuracy: 0.5938
242/242 [==============================] - 0s 122us/sample - loss: 0.6494 - accuracy: 0.6529 - val_loss: 0.6328 - val_accuracy: 0.6393
## Epoch 10/10
##
32/242 [==>...........................] - ETA: 0s - loss: 0.6710 - accuracy: 0.5625
242/242 [==============================] - 0s 115us/sample - loss: 0.6365 - accuracy: 0.6529 - val_loss: 0.6233 - val_accuracy: 0.6393


SurveyMe
Lipsum dolor sit amet consectetur adipisicing elit. Odit
Name
E-Mail
Age
Which option best describes your current role?
Would you recommend freeCodeCamp to a friend?
Not Sure
Not Sure
Not Sure
What is your favorite feature of freeCodeCamp?
What would you like to see improved?
ADSFSF
ADSFSF
ADSFSF
Any comment you have should go here
Submit


{% seo %}
{{ site.description | default: site.github.project_tagline }}
© UNLV School of Life Sciences


Movie Time
A curated List Of Awesome Movies
Movies To watch
The Intern
Delete
The Forgoten Battle
Delete
The Avengers
Delete
The Tomorrow War
Delete
The Boys
Delete
Add


Stories
-
8-year-old Ahmed is a refugee from Syria, temporarily living on the Greek island of Samos. Despite poor living conditions on the island, it is still safer than returning home.
-
8-year-old Saron is refugee from Yei, South Sudan. She currently attends the Ofonze Primary School in Bidibidi refugee settlement in northern Uganda.
-
Rashid Ahbedi, age 85, was once a stateless man in Burundi. He came to Kenya in 1941 to work and ended up meeting his wife, Umazi. They have lived together in Kenya ever since.
Facts
-
What is a Refugee?
A refugee is someone who has been forced to flee his or her country because of persecution, war, or violence. A refugee has a well-founded fear of persecution for reasons of race, religion, nationality or political opinion.
Read more -
Refugee Statistics
By the end of 2017, 68.5 million were forcibly displaced worldwide as a result of persecution, conflict or violence. This is a record level of displacement.
Read more -
What is a Refugee Camp?
A refugee camp is often the first accommodation for people who have been forced to flee their home because of violence and persecution.
Read more


BoatTracker is a fleet management system for rowing and paddling clubs. It uses the BookedScheduler system as a platform for managing the reservation and use of the club's equipment. On top of that, BoatTracker adds a conversational front end for club members to make and manage their reservations, and to check into and check out of their reservations. The bot can be accessed via Skype, Facebook Messenger, and SMS. In addition, a web page showing upcoming, active, and overdue reservations can be displayed on a kiosk (iPad or Android) in the boathouse. A daily report is emailed to the club's designated administrator listing unused reservations as well as various policy violations.
For more information about BoatTracker, see our web site, which also contains our terms of use and our privacy policy.


Travelling Salesman Debug Page
This page has the minified script your project makes when your run 'npm run build' linked. Use it to debug your code.
This page has the minified script your project makes when your run 'npm run build' linked. Use it to debug your code.


MULAN
Release Date: June 19, 1998 The Voices of: Ming-Na Wen, Eddie Murphy, B.D. Wong, Harvey Fierstein, Jerry Tondo, Gedde Watanabe, James Hong Directed by: Tony Bancroft, Barry Cook Distributed by: Buena Vista Pictures MPAA Rating: G URL: http://www.execpc.com/~kinnopio/reviews/1998/mulan.htm
The second of this year's two leading-female animated motion pictures (besides the in-the-rough QUEST FOR CAMELOT), and the third of the last three (counting 1997's ANASTASIA), MULAN was an animated picture that had, perhaps, a bit to live up to. Although those last two pictures weren't really a benchmark, they were a trend, and Disney was charged with distancing themselves from "normal" fare. Not only that, but as soon as previews and advance showings began filtering down through the ranks of the critics, MULAN was hailed as the best Disney animation since THE LION KING. And while this one isn't as enjoyable as the African epic of 1994, it is probably the best animated movie since then.
Disney's animated films have progressively become more refined from the typical children's movies - ones adults hate to see in theaters because they know the same films will infest their VCRs like parasites after release on videocasette - to complete crowd-pleasers. In addition to the easily-gotten under-12 demographic, Disney has nailed the too-cool-to-care date crowd, the Gen-Xers, and the middle-aged chaperone folks. They've done this through clever writing and a well-manicured storytelling style, all of which is very present in MULAN. From the opening scene, a rather dark and ominous one showing the Huns invading China, to the pastel-colored plates of lowland Asia, this movie is crafted very nicely. The animation quality here, although not outstandingly different from Disney's last feature, Hercules, is the up-to-snuff look we've come to expect from the original animators.
Early on it was made clear that even though MULAN sported a female in the lead role, this would be no SNOW WHITE. And indeed it's not, as the main woman here - the 18-year-old Mulan (voiced by Ming-Na Wen) - cuts her hair, puts on some battle armor, and enlists into the Imperial Army as a boy to save her ailing father from having to serve. She does this, of course, against every societal convention in place at the time, but she oes it quite well - managing to become a national hero after all but saving China from the evil-doing Huns. Along for the ride is a tiny dragon sent by Mulan's ancestors. Named Mushu and voiced by Eddie Murphy, he's the movie's main comic relief source, and for the most part he does it well. Murphy's also one of the only familiar names in the cast (apart from Harvey Fierstein, who voices a stout soilder but also played the quivering news chief in INDEPENDENCE DAY).
The lack of familiar names was spun as good for the movie, but it may cost the movie some box office dollars in comparison to PRINCE OF EGYPT, the later-this-year animated film from DreamWorks. That film sports the largest collection of big names since THE LION KING, and one of the most enjoyable aspects of that movie was hearing A-list actors do what they could with just their voices. Normally something Disney would not have to worry about, they now are - or will be soon - in direct competition with other studios' animated features. Up to this point, they've had the top call; no one's been able to challenge them. But it won't be long before the other studios pick up speed, and then Disney will need all the MULANs they can get.
FINAL AWARD FOR "MULAN": 3.0 stars - a good movie.
-- Craig Roush<EMAIL_ADDRESS>-- Kinnopio's Movie Reviews http://www.execpc.com/~kinnopio
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Jumo
Logout
Filter Groups
Hurdles
Long Jump
Pole Vault
Groups
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Hurdles
2
2
2
2
2
2
2
Long Jump
2
2
2
2
2
2
2
Pole Vault
2
2
2
2
2
2
2
Submit


Hello world!
I'm Robert, programmer, app developer and recently a web developer.
Currently I am a student at the Faculty of Organization and Informatics in Varaždin, studying information systems. Besides being a student I have a part-time job at the Croatian Telecom where I do everything from stacking papers to programming in C++.
I have always been interested in new technology and I always try to research and incoroporate them in my own work where possible. Also I'm a big fan of open source software so I mostly learn from there and also try to contribute when I can.


Who doesn't like to fly! --------- Programmers. That was easy.
In all seriousness judgements about combination of interests, such as between programming and flying are in bad taste. Especially considering this website is being written by a philosopher-programmer. It was just a joke, OK?
The idea behind a flight model is the ability to predict the rocket's path based on incomplete data. That includes both a break in communication, after receiving some data about flight and low refresh speed of the live data. Apart from interpolation, a live-update flight model could tell us things about current predicted apogee and predicted landing zone.
There's a lot of math involved and learning, so most of the things your parents warned you about... Or at least ours did. If you're interested in making reality on a computer, then you're either a digital God or passionate the same things we are.
Joining! Since we haven't achieved psychic mastery yet, we would like to kindly request that you add yourself to the project specific emailing list.


Take awesome photos
Share them with friends
Earn money for you
"An awesome app!" Satisfied Customer
"An awesome app!"


--- layout: default title: About ---
Industrial Fans, Exhaust Fans, Fans All Types, Air Circulator Fans, Axial Fans, Axial Flow Fans, Backward Curved Flow Fans, Ceiling Fans, Cooling Fans, Cross Flow Fans, Domestic Fans, Electric Fans, Energy Regulators, Fan Parts, Fans External Rotor Motors, Flameproof Ceiling Fans, Flameproof Exhaust Fans, Pedestal Fans Etc.
Advance Manufacturing System is one of the highly acclaimed Industrial Centrifugal Fan & Blower manufacturers from India. The company is driven by engineers with sound technical knowledge, and blend of vast experience in the field of Industrial Air Blowers.
We take efforts in understanding the customer’s requirement and offer them the right air blower. Centrifugal air blowers the company offers are well designed, critically analyzed and tested. Special Care is taken during design and manufacturing stages to increase efficiency and reliability of our fans and blowers. Our capability in offering superior technology at competitive price differs us from rest of the manufacturers of Industrial fans.
Quality is achieved by proper inspection checks right from material purchasing to final testing of air blowers. Our focus is to develop and continuously upgrade technology for thereby creating efficient and reliable product which will satisfy our customer’s needs to the fullest.


DH_INSTALLMAN(1) Debhelper DH_INSTALLMAN(1) NAME dh_installman - install man pages into package build directories SYNOPSIS dh_installman [debhelperÂ options] [manpageÂ ...] DESCRIPTION dh_installman is a debhelper program that handles installing man pages into the correct locations in package build directories. You tell it what man pages go in your packages, and it figures out where to install them based on the section field in their .TH or .Dt line. If you have a properly formatted .TH or .Dt line, your man page will be installed into the right directory, with the right name (this includes proper handling of pages with a subsection, like 3perl, which are placed in man3, and given an extension of .3perl). If your .TH or .Dt line is incorrect or missing, the program may guess wrong based on the file extension. It also supports translated man pages, by looking for extensions like .ll.8 and .ll_LL.8, or by use of the --language switch. If dh_installman seems to install a man page into the wrong section or with the wrong extension, this is because the man page has the wrong section listed in its .TH or .Dt line. Edit the man page and correct the section, and dh_installman will follow suit. See man(7) for details about the .TH section, and mdoc(7) for the .Dt section. If dh_installman seems to install a man page into a directory like /usr/share/man/pl/man1/, that is because your program has a name like foo.pl, and dh_installman assumes that means it is translated into Polish. Use --language=C to avoid this. After the man page installation step, dh_installman will check to see if any of the man pages in the temporary directories of any of the packages it is acting on contain .so links. If so, it changes them to symlinks. Also, dh_installman will use man to guess the character encoding of each manual page and convert it to UTF-8. If the guesswork fails for some reason, you can override it using an encoding declaration. See manconv(1) for details. FILES debian/package.manpages Lists man pages to be installed. OPTIONS -A, --all Install all files specified by command line parameters in ALL packages acted on. --language=ll Use this to specify that the man pages being acted on are written in the specified language. manpage ... Install these man pages into the first package acted on. (Or in all packages if -A is specified). NOTES An older version of this program, dh_installmanpages(1), is still used by some packages, and so is still included in debhelper. It is, however, deprecated, due to its counterintuitive and inconsistent interface. Use this program instead. SEE ALSO debhelper(7) This program is a part of debhelper. AUTHOR Joey Hess<EMAIL_ADDRESS>9.20120909 2012-04-24 DH_INSTALLMAN(1)


-
serverIsRunning
boolean serverIsRunning
-
clientConnected
boolean clientConnected
-
splash
sTestSplashScreen splash
-
logOutputPanel
javax.swing.JPanel logOutputPanel
-
logOutput
javax.swing.JTextPane logOutput
-
actionPanel
javax.swing.JPanel actionPanel
-
serverInfo
javax.swing.JPanel serverInfo
-
loadButtonPanel
javax.swing.JPanel loadButtonPanel
-
iterationPanel
javax.swing.JPanel iterationPanel
-
loadCountPanel
javax.swing.JPanel loadCountPanel
-
serverIP
javax.swing.JPanel serverIP
-
iterationLoadSetupPanel
javax.swing.JPanel iterationLoadSetupPanel
-
buttonPanel
javax.swing.JPanel buttonPanel
-
clientPanel
javax.swing.JPanel clientPanel
-
systemPanel
javax.swing.JPanel systemPanel
-
mySysInfo
systemInformation mySysInfo
-
setupNewClient
java.awt.event.ActionListener setupNewClient
-
serverManagerThread
sTestLoadServerManager serverManagerThread
-
serverIndi
sTestServerIndicator serverIndi
-
m_threadCount
javax.swing.JSpinner m_threadCount
A spinner to let users choose the number of threads they want to use
-
m_count
javax.swing.JSpinner m_count
A spinner to let the users choose the number of times they want the test
to run.
-
m_opCount
int m_opCount
This variable will hold the number of times have executed the test.
-
m_start
javax.swing.JButton m_start
The button allowing the user to start the test
-
startServer
javax.swing.JButton startServer
The button allowing the user to start the test
-
client
javax.swing.JButton client
The button allowing the user to start the test
-
m_url
javax.swing.JTextField m_url
A text field where the user can specify the URL to their server.
-
m_ip
javax.swing.JTextField m_ip
A text field where the user can specify the URL to their server.
-
m_shortTimer
javax.swing.Timer m_shortTimer
We will use this timer to know when to look at the threads and see which
ones need to be restarted.
-
m_threads
java.util.HashMap<K,V> m_threads
This HashMap will hold onto the threads which are running and the number
of times each of those threads has run.


Index
Product Information
Starblaster 5000
Ultrasonic dismantler
Gravity 2.0
Automatic circulating partitioner
Technical support
FAQ
User manuals
Software updates
Coprporate Information
Contact us


Codename V
Code I follow
About me
Atom Feed
Boom
Code I'm following
offline
Automatically display online/offline indication to your users. #hubspot-open-source
offline
HubSpot
Check it out
ddslick
A free light weight jQuery plugin that allows you to create a custom drop down with images and description.
ddslick
prashantchaudhary
Check it out
bootstrap-daterangepicker
Date range picker component for Twitter Bootstrap
bootstrap-daterangepicker
dangrossman
Check it out
PredictionIO
PredictionIO, a machine learning server for software developers and data engineers.
PredictionIO
PredictionIO
Check it out
odometer
Beautiful CSS3 Number Transitions #hubspot-open-source
odometer
HubSpot
Check it out
NodeOS
NodeOS
NodeOS
Check it out
gplus-photohunt-server-ruby
Photohunt Ruby is a sample server that demonstrates how to build a social application that uses Google+ Sign-In, personalization, app activities, over-the-air install, and interactive posts.
gplus-photohunt-server-ruby
googleplus
Check it out
coder
coder
googlecreativelab
Check it out
showterm.io
The website for showterm!
showterm.io
ConradIrwin
Check it out
showterm
The rubygem to upload to http://showterm.io
showterm
ConradIrwin
Check it out
xray-rails
A development tool that reveals your UI's bones
xray-rails
brentd
Check it out
accumulo
Mirror of Apache Accumulo
accumulo
apache
Check it out
psd.rb
Parse Photoshop files in Ruby with ease
psd.rb
layervault
Check it out
practicing-ruby-manuscripts
Collection of source manuscripts for publicly released Practicing Ruby articles
practicing-ruby-manuscripts
elm-city-craftworks
Check it out
trail-map
Trails to help designers and developers learn various topics.
trail-map
thoughtbot
Check it out
kandan
Kandan is an Open Source Alternative to HipChat
kandan
kandanapp
Check it out
hub
hub helps you win at git.
hub
github
Check it out
CaptionHoverEffects
A tutorial on how to create some subtle and modern caption hover effects.
CaptionHoverEffects
codrops
Check it out
dotfiles
dotfiles
crowdtap
Check it out
bigben
Threaded timer
bigben
crowdtap
Check it out
pollbooth
pollbooth
crowdtap
Check it out
parachute
parachute
crowdtap
Check it out
robust-redis-lock
A robust redis lock
robust-redis-lock
crowdtap
Check it out
Flat-UI
Flat UI - Design Framework (HTML, CSS, JS). Flat UI Kit is made on the basis of Twitter Bootstrap, a comfortable, responsive, and functional framework that simplifies the development of websites.
Flat-UI
designmodo
Check it out
Photoshop-CSS-Sprite
Photoshop script to create a css sprite from a psd file.
Photoshop-CSS-Sprite
euskadi31
Check it out
Blur.js
blur.js is a jQuery plugin that produces psuedo-transparent blurred elements over other elements.
Blur.js
jakiestfu
Check it out
Hyperlapse.js
JavaScript hyper-lapse utility for Google Street View.
Hyperlapse.js
TeehanLax
Check it out
public_activity
Easy activity tracking for models - similar to Github's Public Activity
public_activity
pokonski
Check it out
promiscuous
Replicate data across your applications
promiscuous
promiscuous-io
Check it out
sass-mediaqueries
It is a collection of useful media queries mixins for Sass. Great extension for compass or bourbon.
sass-mediaqueries
paranoida
Check it out


Newto Add a new layer
Currentto make selected layer current
Activeto make selected layers Editable
Staticto make selected layers Not editable
Hiddento make selected layers Not Visible
Nameto reName selected layer
Deleteto delete selected layer
Changeto change by-layer attributes
Meltto create a tracing from a layer


Comic Reader (Panel to Panel)
https://source.opennews.org/articles/pulp-press/
https://github.com/ajam/pulp
https://github.com/ajam/pulp-press
One of our big questions was how this comic would look online and on phones. We thought we would walk through some of design process and also document some of the code tricks we learned along the way.
The final products are a web viewer, Pulp, and the comic-maker interface, Pulp Press, that we have just released as a free and open source project.
Largely, the viewer works by adding a viewing
class to the
appropriate image container depending on the page number. Pulp also keeps
track of the window width and applies viewing
to the next
page if the window is wide enough to show two pages side-by-side. On
mobile, the viewer zooms from panel to panel by pre-defined regions (we’ll
get to that in a second) that are set as absolutely positioned divs (with
the units being percents so it’s still responsive).
Most, if not all, of the viewer’s states are set through data attributes on the body. This pattern worked well for Pulp because it allowed us to use the JavaScript to manage state (whether we were in double, single or mobile page mode, whether we were transitioning pages, drawer open / closed etc.) and then define the proper layout for those states in the CSS. That setup helped keep things easier to understand: the JavaScript sets a layout mode, the CSS adjusts the layout through CSS keyframes.
For example:
exit-to-left
classenter-from-right
and a viewing
classviewing
class is removed
along with the enter and exit classes.All of the pay positioning is defined in the combinations of CSS classes.
If we were in double page format, we would enter enter Page 5 as well and
give it a right-page
class.
Here’s an example of how these combinations were handled in the CSS for pages exiting to the left in single page mode.
.page-container.exit-to-left{
animation: exit-to-left 500ms cubic-bezier(0,0,.2,1);
}
And the CSS animation that is enabled
@keyframes exit-to-left {
from{
left: 0;
}
to{
left: -100%;
}
}
Here’s the more complex example for the right hand page in a double layout that’s exiting to the left. Bookend is the state for the cover page.
body[data-format="double"][data-bookend="false"] .page-container.right-page.exit-to-left{
animation: double-right-exit-to-left 500ms cubic-bezier(0,0,.2,1);
}
The animation double-right-exit-to-left
looks like this:
@keyframes double-right-exit-to-left {
from{
left: 50%;
}
to{
left: 'calc(-50% - %s)' % gutter_width;
}
}
Here’s an example of these classes at work with the page transitions slowed down.
We used a CSS preprocessor called Stylus
with a plug-in called Nib that
handled vendor prefixing and proved to be indispensable. Getting the page
transition animations to feel right took a lot of trial and error. Without
a CSS preprocessor that gave us variables and took care of prefixing, we
would have had to change dozens and dozens of lines of CSS during testing,
which would have dramatically slowed down the process and limited
experimentation. One @keyframe
block, like the one above, is
turned into five such blocks with various vendor prefixes such as Webkit
and Firefox. As in illustration, Stylus sheet is 900 lines and the process
CSS sheet is 1800.
(I hear similar plugins exist for SASS. I use Stylus, which is Node.js, because, like a percentage of the world’s population, my ruby installation hisses and growls whenever I go near it and the prospect of taming it gives me the chills. Less.js also exists but that’s a whole other discussion.)
We employed a few tricks to get the viewer to feel native on mobile. The first was finding a good library for detecting swipes.
Hammer.js came recommended but
we couldn’t get it to work quite right. We found a lighter weight solution
called detect_swipe.js
,
which got us most of the way there. We forked the original repository and
added a couple key features.
The first was pinch detection and the other was a new option we named swipeExceptionCondition
—essentially
a way to set a state where the library would ignore swipes. This exception
condition was a useful way to disregard swipes during page transitions (to
make things smoother) or when the endnotes drawer was open (since that
container had its own vertical overflow scroll).
This is what the swipeExceptionCondition
function looked
like for our use case. It says, ignore swiping when the drawer is open or
when we’re changing pages.
$.detectSwipe.swipeExceptionCondition = function(){
return ($('body').attr('data-side-drawer-open') == 'true' || $('body').attr('data-side-drawer-state') == 'changing' );
}
Setting overflow: scroll;
on iOS can be a huge pain,
especially if you want it to have momentum and rubber banding. In our
case, we had this drawer on mobile that needed to scroll independently.
This setup works fine on desktop but can cause the whole page to scroll on
iOS. If you ever need this type of functionality, the magic in the scrollFix
library can get you most of the way there. You might also want to
apply the CSS rule -webkit-overflow-scrolling; touch;
to
your container.
In its wisdom, iOS devices wait 300ms after the physical tap and the firing of the click handler. This delay is so that the device can wait to see if you’re double tapping. However, this delay leads to a really annoying user experience,as well as an odd gray selection box around your target.
The Financial Times Labs team has a really great library that removes this delay, called FastClick. It made our “tap the panel to zoom” feature and our “open drawer” handler feel like a real native app and not the sluggish bore of its previous life.
“What if you want to double tap” you ask? Our use case didn’t have a different behaviors for tapping vs double tapping and no consensus existed on whether “tap to zoom” or “double tap to zoom” was the more expected gesture. We went with a single tap since it requires less work and if you erroneously double tapped at the beginning, you would quickly learn that you only needed to single tap, whereas you couldn’t as easily intuit the reverse.
The other design feature we included are subtle page masks, which measure whether the panel is vertical or horizontal and extend the appropriate masks covering out the rest of the page.
They’re highlighted in magenta here so you can see how they function.
We mentioned above that the mobile version of the viewer zooms from panel to panel. How does it know where your panels are?
You define those regions through the maker interface we built called Pulp Press. To start making your own comic, select images from your local computer and load them into the interface. Your images aren’t uploaded to any server or saved anywhere—they’re simply read into the browser as data and displayed on the page.
Note: Images can be any format but they must be named according to the page-<NUMBER>
convention and start with page-1
as your cover image. For
example, page-1.jpg
, page-2.jpg
etc. This has
to do with the way Pulp Press generates the JSON file that will load your
pages and zoom regions.
Next, start clicking and dragging to define your zoom regions. You can
also set any alt text on a per-page basis or “Page text,” which will place
arbitrary text on the page wrapped in

tags. Page
text is most useful for the last page of the comic for including
hyperlinks to a comments section or further reading.
As a convention, you can also include some properly marked up text to show the endnotes, which is a nice prompt for readers if they haven’t previously discovered them.
The following markup, class as internal
and data-destination
as endnotes
will accomplish that:
Click here to view endnotes.
Once you’re done defining zoom regions, set some endnotes, if you like,
and then click “Download the data.” You should now have a pages.json
file which has all the information needed to load your comic into Pulp.
To get it up and running, follow these four steps
git clone
http://github.com/ajam/pulp
imgs/pages/
folder.pages.json
file in the data/
folder.python -m SimpleHTTPServer
into your console while in the Pulp folder.
We also included one little easter egg. To give the drawer a more native feel on mobile, we allow you to stretch it to the left and it “rubberband” snap closed. As you expose what is “below” the comic, there’s a little guy with a microphone looking right back. Data collection is everywhere.


Group explores route of Shrewsbury's proposed North West Relief Road
by Lucy TodmanA group of residents joined together to see for themselves the planned route of the North West Relief Road.
Many felt there was confusion over the exact rout the proposed road would take.
Mike Streetly of Better Shrewsbury Transport, an alliance of local organisations that arranged the visit, said: "So we thought this would be as a good way of seeing the whole environment."
See also:
- Shropshire Council defends decision to not attend Shrewsbury North West Relief Road meeting
- Action meeting on Shrewsbury North West Relief Road plans
- Spring 2023 date set for completion of Shrewsbury North West Relief Road
The route of the proposed road will cut across the green wedge of countryside which reaches into town and is easily accessed from several neighbourhoods. The group used Corporation Lane to get out into the countryside which still has features created in the ice age: a kettle hole formed as a result of blocks of ice left behind by a retreating glacier; the Old River Bed where the Severn ran before the glaciers forced it to change course and which is rich in wetland plants; glacial moraine.
“We had refreshments under an ancient oak on the moraine ridge high above Shrewsbury where the road would go, and had a wonderful view of the town," said Claus Best, one of the participants.
“But it makes you understand how the noise of the new road will become a constant background to the life of the town. We finished at Hencott Pool which is a Ramsar site - a wetland of international importance."
Unique
Shropshire Council has earmarked the eastern end of the new road as potential space for thousands of new homes, with the road providing for the extra cars. “Shrewsbury is almost unique as a town in England having this rich and accessible “green wedge” of historic environment which we can easily walk out into," said Claus.
“If we’re trying to attract people and businesses, we somehow have to come up with plans which don't destroy one of its most beautiful features."
Other walkers were concerned about a possible increase in traffic congestion.
Jan Dale, a resident of Coton Hill, said: “At first I thought the road would be great and give me a chance to drive around more easily. But now I realise that the links from the new road into Berwick Road and Ellesmere Road will increase traffic at peak times and actually make congestion worse.
"Also air pollution in Coton Hill is already bad and we will get even higher levels. I'm equally concerned that the flyover proposed for the river will be unsightly and carry traffic noise into town, and the unspoiled countryside around Coton Hill will be lost."
Shrewsbury Civic Society is offering everyone the chance to hear discussion for and against the new road at an event on November 30 1.30pm - 5pm at the University Centre Shrewsbury. Another walk is planned to see part of the Oxon Link Road section in Bicton, on Saturday starting at 10am from Bicton Village Hall and everyone is welcome.
A map of the route can be found at bettershrewsburytransport.org


We've now added the ability for verified users to submit family members! Just log in and go to the 'My Family' page from either menu to submit new individuals for our admins to approve. Help our collection grow!
In the near future we plan to include the ability to collect your favorites by watchlisting them for better visibility from your family page and periodic update emails. We will also be adding a feedback feature that will allow you to send your thoughts, opinions, and suggestions straight to the site administration for review.
(Note: Most new features will require verified membership. Please register and verify your email to gain access to them.)Dear reader, this is a family collection of stories and photos from many sources. We are always collecting photos and permissions to post new things here if you want to add to this collection. We do need to warn you that while we try very hard not to make mistakes in this collection, it is possible that you will find an error. Use this website at your own risk. We make no guarantees, but if you contact us with evidence, we will fix it here on the website because we want it to be right. Each person has basic information, a photo collection, a document collection, and a photo pedigree chart. Please enjoy learning more about our family! — Michele Law


EBay selling StubHub to Viagogo for $4.05-billion
EBay Inc will sell its ticketing unit, StubHub, in an all-cash $4.05 billion deal to ticket reseller Viagogo Ltd, the companies said on Monday, nearly a year after the ecommerce major came under pressure from activist investors to hive off some of its businesses.
In January, activist investors Elliott Management Corp and Starboard Value had urged eBay to sell its ticket sales business and eBay Classifieds Group as part of a plan that could double the company’s value.
Elliott valued StubHub between $3.5 billion and $4.5 billion, while eBay Classifieds between $8 billion and $12 billion.
Following the activist investors’ request, eBay made changes to its board of directors in March. It announced a review of its StubHub and eBay Classifieds businesses as part of an agreement with activist investors to avert a proxy contest.
Shares of eBay were up nearly 3 per cent at $36.02 in early trade on Monday.
Elliott Management declined to comment on the development, while Starboard Value did not immediately respond to Reuters’ request for a comment.
The deal, which is expected to close by the end of the first quarter of 2020, follows the exit of former Chief Executive Officer Devin Wenig in September, following his differences with the company’s revamped board.
Goldman Sachs & Co LLC acted as financial adviser to EBay, while Wachtell, Lipton, Rosen & Katz and Quinn Emanuel acted as legal advisers, according to the joint statement by the companies.
J.P. Morgan is acting as financial adviser to Viagogo, while Skadden, Arps, Slate, Meagher & Flom LLP and Kirkland & Ellis LLP are its legal advisers.


Intro to Programming
HTML and The Internet
HTML stands for Hypertext Markup Language. These documents are all stored on servers. When viewing a webpage your computer requests an HTTP from the server and then opens the appropriate file and displays the file through your web browser.
All HTML documents are divided in to multiple "invisible boxes" of content. These boxes can contain things such as images, text and even links to other pages. When creating an idea for a website, it can be useful to take something as simple as a pencil to draw out the overall design of the website. You can then take it one step further by drawing boxes around related content. This will help give you an idea as to how the website would be built. There are many ways to make these "invisible boxes". One way it to use what is called a "div" tag. You simply place a opening "div" tag at the begining of the content and a closing "div" tag at the end.
Tags and Elements
Tags and elements make up every page of HTML code. This is how computers read the documents. Tags consist of two parts. There is an opening tag and a closing tag. To create the opening tag you use the less than sign, put your command inside, and place a greater than symbol on the other side. You then place your content inside and close the tag by using the less than sign, backslash, your command, and the greater than sign. Everything from the begining less than symbol to the ending greater than symbol make up an element.
 They simply do what they are told to do by the coding within the HTML document. Therefore, having a period out of place or forgetting to close a tag can cause major problems. This is why you must be so precise with all coding.
Inline vs Block Elements
Elements of an HTML document are either Inline or Block. Block elements are used to create "invisible boxes" around the content inside of them. Inline elements generally only apply to the content in between the opening and closing of the tag.
Google Chrome
Google Chrome is a unique internet browser. Whenever you open a internet page using Chrome, a menu appears in the upper right hand corner. You can click on this menu and go to "tools". From there you can go to "developer tools". When you open developer tools on a webpage, you can see all of the HTML coding for that page. This is a great tool when you are first starting to code. By looking at existing code and changing the code, you can start to figure out how things are programed.
Avoiding Repetition
Avoiding repetition in HTML coding is very important. For instance, a programer that uses a lot of repetition will often write the exact same cases they will simply copy and paste code in to different parts of a document. When that programer decides to make changes to a document, they have to go through every line of code ensure that small change was replicated.
Consistency is another very good reason to avoid repetition when writing HTML code. If you want to give a document or a series of documents the same feel, then they must be coded the same. This is best done by assigning specific "classes" to each part of the document. By having different "classes" for each part of the document, you only have to change the class file in your CSS to make changes throughout the entire document.
CSS
CSS stands for cascading style sheets. These style sheets are what is used to determing how a page looks on the internet. When compared to a house lets day the CSS files would be the This page can be used as a resource for looking up different CSS. It would be almost impossible to learn every CSS variable, so it is common to use a website like this.
Checking HTML and CSS Code
This page can be used for checking the formatting of your HTML coding. At the bottom of the page, all of the errors in your HTML file will be revealed. Also,This page can be used to make sure that you CSS coding is correct.
Computer
In general, machines are designed to do a certain task. Unless you take the machine apart and alter it, the machine will only do what it was designed for. This is where computers are different from other machines. A computer can be programmed to do almost anything we want. If you are able to write a very specific sequence of instructions for a computer to follow, you can make a computer do whatever you tell it to do.
Computer Program
A computer program can best be described as a very precise sequence of steps that a computer can follow to complete a task. The web browser you are looking at this document in is a program. The software I am writing this code in is a program. The list can go on and on.
Programming Language
A programming language is what computer programmers use to tell a computer what to do. COBOL is an example of a programming language. It was one of the first high-level programming languages ever made. It was designed for the Harvard Mark I computer by Rear Admiral Grace Hopper and many of her former employees in 1959.
Python
Pyhton is one of many computer programming languages. Its name was derived from the T.V. series Monty Python's Flying Circus. You can enter Python code in to a Python Interpreter and press "Run" to see the results. The interpreter takes the code you wrote and converts it to instructions that the computer can read and execute or "Run".
Grammar
Programming languages, just like human languages, have grammar rules they must follow. These grammar rules tell us what is "correct" and what is "incorrect" for a particular language.  Humans can usually understand what someone is trying to say even if they don't use the correct structure. Computers cannot! Code must be written exact or it will not run in Python.
Creating a Structured Document with HTML
HTML elements are either inline or block. Block elements form an "invisible box" around the content inside of them.
The "tree-like structure" comes from the fact that HTML elements can have other elements inside of them. You can draw this relationship like a family tree. My mother had multiple children. So did her mother, and so on...
In a browser, this structure shows up as a series of nested boxes. There are boxes inside of boxes inside of boxes, and so on...
When you read an HTML document as text, you see a wave of changing indentations going up and down the left side of the document. The more indented an element is, the more deeply nested it's corresponding "box" is.


| DOSE: |
150 mg |
oral |
bk-MBDB |
(powder / crystals) |
| |
15 mg |
oral |
4-AcO-DMT |
(powder / crystals) |
| |
75 mg |
oral |
bk-MBDB |
(powder / crystals) |
A friend and I were celebrating his birthday, and he decided to try B1 for the first time. As we were peaking on our first 150 mg parachute, we decided that the high and duration would match well with 4-ACO-DMT. We then ingested 15 mg dissolved in water and decided to parachute another 75 mg B1. The interaction was strong and unexpected. Instead of lasting the usual 45 to an hour for B1 and 3.5-5 hours for 4ACO, the entire experience was at least a ++ for eight hours.
The initial euphoria was amazing, but I had some breathing issues that were kind of on the 'oh shit' side of the spectrum, and in the latter half of the trip, my friend, who has ADD had a strange mental reaction where he obviously was having troubles thinking, like a momentary loss of IQ. He's ok now, but it was as near to a mishap as I'd like to experience.  It was amazing, but I wouldn't recommend it.
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.


Mnesia is a heavy duty real-time distributed database management system.
Table of Contents
Overview
Mnesia is a Database Management System (DBMS) that ships with the Erlang Runtime System which we can use naturally with Elixir. The Mnesia relational and object hybrid data model is what makes it suitable for developing distributed applications of any scale.
When to use
When to use a particular piece of technology is often a confusing pursuit. If you can answer ‘yes’ to any of the following questions, then this is a good indication to use Mnesia over ETS or DETS.
- Do I need to roll back transactions?
- Do I need an easy to use syntax for reading and writing data?
- Should I store data across multiple nodes, rather than one?
- Do I need a choice where to store information (RAM or disk)?
Schema
As Mnesia is part of the Erlang core, rather than Elixir, we have to access it with the colon syntax (See Lesson: Erlang Interoperability):
iex> :mnesia.create_schema([node()])
# or if you prefer the Elixir feel...
iex> alias :mnesia, as: Mnesia
iex> Mnesia.create_schema([node()])
For this lesson, we will take the latter approach when working with the Mnesia API.
Mnesia.create_schema/1
initializes a new empty schema and passes in a Node List.
In this case, we are passing in the node associated with our IEx session.
Nodes
Once we run the Mnesia.create_schema([node()])
command via IEx, you should see a folder called Mnesia.nonode@nohost or similar in your present working directory.
You may be wondering what the nonode@nohost means as we haven’t come across this before.
Let’s have a look.
$ iex --help
Usage: iex [options] [.exs file] [data]
-v Prints version
-e "command" Evaluates the given command (*)
-r "file" Requires the given files/patterns (*)
-S "script" Finds and executes the given script
-pr "file" Requires the given files/patterns in parallel (*)
-pa "path" Prepends the given path to Erlang code path (*)
-pz "path" Appends the given path to Erlang code path (*)
--app "app" Start the given app and its dependencies (*)
--erl "switches" Switches to be passed down to Erlang (*)
--name "name" Makes and assigns a name to the distributed node
--sname "name" Makes and assigns a short name to the distributed node
--cookie "cookie" Sets a cookie for this distributed node
--hidden Makes a hidden node
--werl Uses Erlang's Windows shell GUI (Windows only)
--detached Starts the Erlang VM detached from console
--remsh "name" Connects to a node using a remote shell
--dot-iex "path" Overrides default .iex.exs file and uses path instead;
path can be empty, then no file will be loaded
** Options marked with (*) can be given more than once
** Options given after the .exs file or -- are passed down to the executed code
** Options can be passed to the VM using ELIXIR_ERL_OPTIONS or --erl
When we pass in the --help
option to IEx from the command line we are presented with all the possible options.
We can see that there is a --name
and --sname
options for assigning information to nodes.
A node is just a running Erlang Virtual Machine which handles it’s own communications, garbage collection, processing scheduling, memory and more.
The node is being named as nonode@nohost simply by default.
$ iex --name<EMAIL_ADDRESS>Erlang/OTP 22.0 [erts-10.5.3] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]
Interactive Elixir (1.10.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(learner@elixirschool.com)> Node.self
<EMAIL_ADDRESS>As we can now see, the node we are running is an atom called<EMAIL_ADDRESS>.
If we run Mnesia.create_schema([node()])
again, we will see that it created another folder called<EMAIL_ADDRESS>The purpose of this is quite simple.
Nodes in Erlang are used to connect to other nodes to share (distribute) information and resources.
This doesn’t have to be restricted to the same machine and can communicate via LAN, the internet etc.
Starting Mnesia
Now we have the background basics out of the way and set up the database, we are now in a position to start the Mnesia DBMS with the Mnesia.start/0
command.
iex> alias :mnesia, as: Mnesia
iex> Mnesia.create_schema([node()])
:ok
iex> Mnesia.start()
:ok
The function Mnesia.start/0
is asynchronous.
It starts the initialization of the existing tables and returns the :ok
atom.
In case we need to perform some actions on an existing table right after starting Mnesia, we need to call the Mnesia.wait_for_tables/2
function.
It will suspend the caller until the tables are initialized.
See the example in the section Data initialization and migration.
It is worth keeping in mind when running a distributed system with two or more participating nodes, the function Mnesia.start/1
must be executed on all participating nodes.
Creating Tables
The function Mnesia.create_table/2
is used to create tables within our database.
Below we create a table called Person
and then pass a keyword list defining the table schema.
iex> Mnesia.create_table(Person, [attributes: [:id, :name, :job]])
{:atomic, :ok}
We define the columns using the atoms :id
, :name
, and :job
.
The first atom (in this case :id
) is the primary key.
At least one additional attribute is required.
When we execute Mnesia.create_table/2
, it will return either one of the following responses:
{:atomic, :ok}
if the function executes successfully{:aborted, Reason}
if the function failed
In particular, if the table already exists, the reason will be of the form {:already_exists, table}
so if we try to create this table a second time, we will get:
iex> Mnesia.create_table(Person, [attributes: [:id, :name, :job]])
{:aborted, {:already_exists, Person}}
The Dirty Way
First of all we will look at the dirty way of reading and writing to a Mnesia table. This should generally be avoided as success is not guaranteed, but it should help us learn and become comfortable working with Mnesia. Let’s add some entries to our Person table.
iex> Mnesia.dirty_write({Person, 1, "Seymour Skinner", "Principal"})
:ok
iex> Mnesia.dirty_write({Person, 2, "Homer Simpson", "Safety Inspector"})
:ok
iex> Mnesia.dirty_write({Person, 3, "Moe Szyslak", "Bartender"})
:ok
…and to retrieve the entries we can use Mnesia.dirty_read/1
:
iex> Mnesia.dirty_read({Person, 1})
[{Person, 1, "Seymour Skinner", "Principal"}]
iex> Mnesia.dirty_read({Person, 2})
[{Person, 2, "Homer Simpson", "Safety Inspector"}]
iex> Mnesia.dirty_read({Person, 3})
[{Person, 3, "Moe Szyslak", "Bartender"}]
iex> Mnesia.dirty_read({Person, 4})
[]
If we try to query a record that doesn’t exist Mnesia will respond with an empty list.
Transactions
Traditionally we use transactions to encapsulate our reads and writes to our database.
Transactions are an important part of designing fault-tolerant, highly distributed systems.
An Mnesia transaction is a mechanism by which a series of database operations can be executed as one functional block.
First we create an anonymous function, in this case data_to_write
and then pass it onto Mnesia.transaction
.
iex> data_to_write = fn ->
...> Mnesia.write({Person, 4, "Marge Simpson", "home maker"})
...> Mnesia.write({Person, 5, "Hans Moleman", "unknown"})
...> Mnesia.write({Person, 6, "Monty Burns", "Businessman"})
...> Mnesia.write({Person, 7, "Waylon Smithers", "Executive assistant"})
...> end
#Function<20.54118792/0 in :erl_eval.expr/5>
iex> Mnesia.transaction(data_to_write)
{:atomic, :ok}
Based on this transaction message, we can safely assume that we have written the data to our Person
table.
Let’s use a transaction to read from the database now to make sure.
We will use Mnesia.read/1
to read from the database, but again from within an anonymous function.
iex> data_to_read = fn ->
...> Mnesia.read({Person, 6})
...> end
#Function<20.54118792/0 in :erl_eval.expr/5>
iex> Mnesia.transaction(data_to_read)
{:atomic, [{Person, 6, "Monty Burns", "Businessman"}]}
Note that if you want to update data, you just need to call Mnesia.write/1
with the same key as an existing record.
Therefore, to update the record for Hans, you can do:
iex> Mnesia.transaction(
...> fn ->
...> Mnesia.write({Person, 5, "Hans Moleman", "Ex-Mayor"})
...> end
...> )
Using indices
Mnesia support indices on non-key columns and data can then be queried against those indices.
So we can add an index against the :job
column of the Person
table:
iex> Mnesia.add_table_index(Person, :job)
{:atomic, :ok}
The result is similar to the one returned by Mnesia.create_table/2
:
{:atomic, :ok}
if the function executes successfully{:aborted, Reason}
if the function failed
In particular, if the index already exists, the reason will be of the form {:already_exists, table, attribute_index}
so if we try to add this index a second time, we will get:
iex> Mnesia.add_table_index(Person, :job)
{:aborted, {:already_exists, Person, 4}}
Once the index is successfully created, we can read against it and retrieve a list of all principals:
iex> Mnesia.transaction(
...> fn ->
...> Mnesia.index_read(Person, "Principal", :job)
...> end
...> )
{:atomic, [{Person, 1, "Seymour Skinner", "Principal"}]}
Match and select
Mnesia supports complex queries to retrieve data from a table in the form of matching and ad-hoc select functions.
The Mnesia.match_object/1
function returns all records that match the given pattern.
If any of the columns in the table have indices, it can make use of them to make the query more efficient.
Use the special atom :_
to identify columns that don’t participate in the match.
iex> Mnesia.transaction(
...> fn ->
...> Mnesia.match_object({Person, :_, "Marge Simpson", :_})
...> end
...> )
{:atomic, [{Person, 4, "Marge Simpson", "home maker"}]}
The Mnesia.select/2
function allows you to specify a custom query using any operator or function in the Elixir language (or Erlang for that matter).
Let’s look at an example to select all records that have a key that is greater than 3:
iex> Mnesia.transaction(
...> fn ->
...> Mnesia.select(Person, [{{Person, :"$1", :"$2", :"$3"}, [{:>, :"$1", 3}], [:"$$"]}])
...> end
...> )
{:atomic, [[7, "Waylon Smithers", "Executive assistant"], [4, "Marge Simpson", "home maker"], [6, "Monty Burns", "Businessman"], [5, "Hans Moleman", "unknown"]]}
Let’s unpack this.
The first attribute is the table, Person
, the second attribute is a triple of the form {match, [guard], [result]}
:
match
is the same as what you’d pass to theMnesia.match_object/1
function; however, note the special atoms:"$n"
that specify positional parameters that are used by the remainder of the query- the
guard
list is a list of tuples that specifies what guard functions to apply, in this case the:>
(greater than) built in function with the first positional parameter:"$1"
and the constant3
as attributes - the
result
list is the list of fields that are returned by the query, in the form of positional parameters of the special atom:"$$"
to reference all fields so you could use[:"$1", :"$2"]
to return the first two fields or[:"$$"]
to return all fields
For more details, see the Erlang Mnesia documentation for select/2.
Data initialization and migration
With every software solution, there will come a time when you need to upgrade the software and migrate the data stored in your database.
For example, we may want to add an :age
column to our Person
table in v2 of our app.
We can’t create the Person
table once it’s been created but we can transform it.
For this we need to know when to transform, which we can do when creating the table.
To do this, we can use the Mnesia.table_info/2
function to retrieve the current structure of the table and the Mnesia.transform_table/3
function to transform it to the new structure.
The code below does this by implementing the following logic:
- Create the table with the v2 attributes:
[:id, :name, :job, :age]
- Handle the creation result:
{:atomic, :ok}
: initialize the table by creating indices on:job
and:age
{:aborted, {:already_exists, Person}}
: check what the attributes are in the current table and act accordingly:- if it’s the v1 list (
[:id, :name, :job]
), transform the table giving everybody an age of 21 and add a new index on:age
- if it’s the v2 list, do nothing, we’re good
- if it’s something else, bail out
- if it’s the v1 list (
If we are performing any actions on the existing tables right after starting Mnesia with Mnesia.start/0
, those tables may not be initialized and accessible.
In that case, we should use the Mnesia.wait_for_tables/2
function.
It will suspend the current process until the tables are initialized or until the timeout is reached.
The Mnesia.transform_table/3
function takes as attributes the name of the table, a function that transforms a record from the old to the new format and the list of new attributes.
case Mnesia.create_table(Person, [attributes: [:id, :name, :job, :age]]) do
{:atomic, :ok} ->
Mnesia.add_table_index(Person, :job)
Mnesia.add_table_index(Person, :age)
{:aborted, {:already_exists, Person}} ->
case Mnesia.table_info(Person, :attributes) do
[:id, :name, :job] ->
Mnesia.wait_for_tables([Person], 5000)
Mnesia.transform_table(
Person,
fn ({Person, id, name, job}) ->
{Person, id, name, job, 21}
end,
[:id, :name, :job, :age]
)
Mnesia.add_table_index(Person, :age)
[:id, :name, :job, :age] ->
:ok
other ->
{:error, other}
end
end
Caught a mistake or want to contribute to the lesson? Edit this page on GitHub!


This page corresponds to 11.2 Help-Window Help.
The help window uses a four-frame implementation, and requires slightly different frameset parameters for the various browsers.
- None -


{% extends "templates/layout/customweb.html" %} {% block loader %} {% include "/templates/pages/defaultpageloader.html" %} {% endblock %} {% block content %} {% include "templates/layout/sidebar.html" %} {% if type=="new" %} Add Address {% else %} Edit Address {% endif %} Save {% if address %} {% for item in address %} Address title* Please enter address title Flat/House No, Building Number* Please enter Flat/House No, Building Number Road No, Road Name, Block No* Please enter Road No, Road Name, Block No Area* Please enter Area Governorate* Please enter Governorate Country* {% for countries in country %} {{countries.name}} {% endfor %} Please select country {% endfor %} {% else %} Address title* Please enter address title Address Flat/House No, Building Number* Please enter address Flat/House No, Building Number Road No, Road Name, Block No* Please enter Road No, Road Name, Block No Area* Please enter Area Governorate* Please enter Governorate Country* {% for countries in country %} {{countries.name}} {% endfor %} Please select country {% endif %} {% endblock %} {% block script %} {% endblock %}


Rx is a generic abstraction of computation expressed through Observable<Element>
interface, which lets you broadcast and subscribe to values and other events from an Observable
stream.
RxSwift is the Swift-specific implementation of the Reactive Extensions standard.
While this version aims to stay true to the original spirit and naming conventions of Rx, this project also aims to provide a true Swift-first API for Rx APIs.
Cross platform documentation can be found on ReactiveX.io.
Like other Rx implementations, RxSwift’s intention is to enable easy composition of asynchronous operations and streams of data in the form of Observable
objects and a suite of methods to transform and compose these pieces of asynchronous work.
KVO observation, async operations, UI Events and other streams of data are all unified under abstraction of sequence. This is the reason why Rx is so simple, elegant and powerful.
I came here because I want to …
… understand
- why use rx?
- the basics, getting started with RxSwift
- traits - what are
Single
,Completable
,Maybe
,Driver
, andControlProperty
… and why do they exist? - testing
- tips and common errors
- debugging
- the math behind Rx
- what are hot and cold observable sequences?
… install
- Integrate RxSwift/RxCocoa with my app. Installation Guide
… hack around
- with the example app. Running Example App
- with operators in playgrounds. Playgrounds
… interact
- All of this is great, but it would be nice to talk with other people using RxSwift and exchange experiences.
Join Slack Channel - Report a problem using the library. Open an Issue With Bug Template
- Request a new feature. Open an Issue With Feature Request Template
- Help out Check out contribution guide
… compare
… understand the structure
RxSwift is as compositional as the asynchronous work it drives. The core unit is RxSwift itself, while other dependencies can be added for UI Work, testing, and more.
It comprises five separate components depending on each other in the following way:
┌──────────────┐ ┌──────────────┐
│ RxCocoa ├────▶ RxRelay │
└───────┬──────┘ └──────┬───────┘
│ │
┌───────▼──────────────────▼───────┐
│ RxSwift │
└───────▲──────────────────▲───────┘
│ │
┌───────┴──────┐ ┌──────┴───────┐
│ RxTest │ │ RxBlocking │
└──────────────┘ └──────────────┘
- RxSwift: The core of RxSwift, providing the Rx standard as (mostly) defined by ReactiveX. It has no other dependencies.
- RxCocoa: Provides Cocoa-specific capabilities for general iOS/macOS/watchOS & tvOS app development, such as Shared Sequences, Traits, and much more. It depends on both
RxSwift
andRxRelay
. - RxRelay: Provides
PublishRelay
,BehaviorRelay
andReplayRelay
, three simple wrappers around Subjects. It depends onRxSwift
. - RxTest and RxBlocking: Provides testing capabilities for Rx-based systems. It depends on
RxSwift
.
Usage
| Here’s an example | In Action |
|---|---|
| Define search for GitHub repositories … | |
let searchResults = searchBar.rx.text.orEmpty
.throttle(.milliseconds(300), scheduler: MainScheduler.instance)
.distinctUntilChanged()
.flatMapLatest { query -> Observable<[Repository]> in
if query.isEmpty {
return .just([])
}
return searchGitHub(query)
.catchAndReturn([])
}
.observe(on: MainScheduler.instance) |
|
| … then bind the results to your tableview | |
searchResults
.bind(to: tableView.rx.items(cellIdentifier: "Cell")) {
(index, repository: Repository, cell) in
cell.textLabel?.text = repository.name
cell.detailTextLabel?.text = repository.url
}
.disposed(by: disposeBag) |
Requirements
- Xcode 12.x
- Swift 5.x
For Xcode 11 and below, use RxSwift 5.x.
Installation
RxSwift doesn’t contain any external dependencies.
These are currently the supported installation options:
Manual
Open Rx.xcworkspace, choose RxExample
and hit run. This method will build everything and run the sample app
CocoaPods
# Podfile
use_frameworks!
target 'YOUR_TARGET_NAME' do
pod 'RxSwift', '6.6.0'
pod 'RxCocoa', '6.6.0'
end
# RxTest and RxBlocking make the most sense in the context of unit/integration tests
target 'YOUR_TESTING_TARGET' do
pod 'RxBlocking', '6.6.0'
pod 'RxTest', '6.6.0'
end
Replace YOUR_TARGET_NAME
and then, in the Podfile
directory, type:
$ pod install
XCFrameworks
Each release starting with RxSwift 6 includes *.xcframework
framework binaries.
Simply drag the needed framework binaries to your Frameworks, Libraries, and Embedded Content section under your target’s General tab.
Note: If you’re using
RxCocoa
, be sure to also drag RxCocoaRuntime.xcframework before importingRxCocoa
.
Carthage
Add this to Cartfile
github "ReactiveX/RxSwift" "6.6.0"
$ carthage update
Carthage as a Static Library
Carthage defaults to building RxSwift as a Dynamic Library.
If you wish to build RxSwift as a Static Library using Carthage you may use the script below to manually modify the framework type before building with Carthage:
carthage update RxSwift --platform iOS --no-build
sed -i -e 's/MACH_O_TYPE = mh_dylib/MACH_O_TYPE = staticlib/g' Carthage/Checkouts/RxSwift/Rx.xcodeproj/project.pbxproj
carthage build RxSwift --platform iOS
Swift Package Manager
Note: There is a critical cross-dependency bug affecting many projects including RxSwift in Swift Package Manager. We’ve filed a bug (SR-12303) in early 2020 but have no answer yet. Your mileage may vary. A partial workaround can be found here.
Create a Package.swift
file.
// swift-tools-version:5.0
import PackageDescription
let package = Package(
name: "RxTestProject",
dependencies: [
.package(url: "https://github.com/ReactiveX/RxSwift.git", .exact("6.6.0"))
],
targets: [
.target(name: "RxTestProject", dependencies: ["RxSwift", "RxCocoa"])
]
)
$ swift build
To build or test a module with RxTest dependency, set TEST=1
.
$ TEST=1 swift test
Manually using git submodules
- Add RxSwift as a submodule
$ git submodule add git@github.com:ReactiveX/RxSwift.git
- Drag
Rx.xcodeproj
into Project Navigator - Go to
Project > Targets > Build Phases > Link Binary With Libraries
, click+
and selectRxSwift
,RxCocoa
andRxRelay
targets
References
- http://reactivex.io/
- Reactive Extensions GitHub (GitHub)
- RxSwift RayWenderlich.com Book
- RxSwift: Debunking the myth of hard (YouTube)
- Boxue.io RxSwift Online Course (Chinese 🇨🇳)
- Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx) (video)
- Reactive Programming Overview (Jafar Husain from Netflix)
- Subject/Observer is Dual to Iterator (paper)
- Rx standard sequence operators visualized (visualization tool)
- Haskell


ROHAN MAHARJAN
About
Projects
Resume
Contact
Linkedin Profile
Projects
Phage Visualization
See Full Project
Race VR
See Full Project
Interactive 3D Character
See Full Project
Hurdle
See Full Project
AR Book
See Full Project
AR Greeting Card
See Full Project
User Defined Target
See Full Project
Virtual Video Player
See Full Project
Virtual Button
See Full Project


Lebohang Kuenane
Software Developer
Full Stack Software Developer
Thinking out of the box to bring you innovative digital solutions.
Creative | Solution oriented | Grit
I am fascinated by the digital
Logical thinking skills
Great time management and planning skills
Debugging and troubleshooting skills
High attention to detail
Out-of-the-box thinking and creativity
Strong math skills
Persistence (aka stick-to-it-iveness)
Decent communication skills
I hold a higher certificate in software engineering from WeThinkCode
Read MorePortfolio of my work
I have worked on multiple projects using React, Swift and Javascript to name a few.
I love creating pixel perfect websites with an emphasis on great user experience and design.


New Nissan Rogue Rendering Strips Off Camo From Spy Shots
The new nose is significantly more eye-catching than the current, somewhat boring face.
by Chris BruceA new generation of the Nissan Rogue (also known as the X-Trail in some markets) is on the way. Now, the artists from Kolesa in Russia use the spy shots to imagine how the updated crossover might look.
Gallery: Nissan Rogue Rendering
Nissan's designers overhaul the Rogue's front end by giving it a more prominent V-shaped grille in the style of the brand's other recent vehicle debuts. The tips of the V lead to thin strips of lights that sit on the edge of the hood. Larger lamps in the corners appear to be the actual headlights. The crossover has simple, relatively flat flanks, but the windows appear to be large for the segment.
Spying The Next Nissan Rogue:
At the back, Kolesa imagines the Rogue with sharp-edged taillights that wrap around the side of the body. Prominent creases create a trapezoidal shape with the hatchback and lower fascia, which lends the tail a styling flair.
Gallery: Next-Gen Nissan Rogue Spy Shots
While not visible here, spy shots provide a glimpse into the cabin. There's a digital instrument cluster, and a large infotainment screen is directly next to it on the top of the center stack. Photos suggest that the system combines touchscreen controls with physical dials and buttons. In addition, the HVAC controls have their own electronic display. A shift-by-wire gearshift is on the console.
Save Thousands On A New Nissan Rogue
MSRP $ 26,115
MSRP $ 26,115
Save on average over $3,400 off MSRP* with
Motor1.com Car Buying Service
SEE PRICING
Powertrain updates for the Rogue aren't yet clear. A strong possibility is for crossover to get the more powerful 2.5-liter four-cylinder from the 2019 Altima that makes 188 horsepower (140 kilowatts). After axing the hybrid variant for the 2020 model year, it's not clear whether the electrified variant would make a return for the new generation.
Nissan isn't yet saying when the next-gen Rogue debuts, but we don't expect to see it at the upcoming Los Angeles Auto Show. Look for the crossover's unveiling to happen in 2020 and for the model to go on sale for the 2021 model year.
Source: Kolesa


Douglas Harris physics
Physics
-
The background is my learning in 1960 of a Theory of Time and Space
based on intervals of time and regions of space rather than mythical
"instants" and "points". This led me on a meandering path to becoming
a professional mathematician, turning a math department into a
math, statistics, and computer science department which I chaired for
21 years, through a research career in topology, and computer
networking to finally realizing how it all fits together.
- whitehead
Ron Desmet has spent his career explaining Whitehead, who
knew so many of the facts and figures
involved from the beginning.
- patterns
A short explanation of why formulas have not been the answer.
Much more detailed versions to follow soon.
event box
picture that convinced me. Trying to describe an event in terms of
what I sense about space, we find LR,UD,and NF. This gives the 8 vertices
RUF,RUN,RDF,RDN,LUF,LUN,LDF,LDN and 6 faces R,U,F,L,D,N familiar to us all
(since the time of Plato) and 12 edges (labelled in appropriate ways by a pair
of faces. Thinking topologically of the box with inside and outside,
it is easy to iew each edge as a small tube between vertices, and this picture
shows some of those tubes.
Now seeing "event-particles' as tiny volumes entering or leaving the box at
LDN/RUN, travelling one wa or the other along that tube(colored magenta),and
coloring the entry/exit edges apropriately red or blue indicating a gain or loss
of something(say energy?) and using green for intermediate paths, we find the
pattern (that much of my topological career has been buit upon).
This pattern can be viewed in terms of singlet-triplet rather easily,and that
is something spectroscopists have seen, and quantum-theorist have tried to
describe by viewing only formulas.
Lets say you are changing energy going between LDN and RUF. You follow the
pattern R--B, and to cross that gap you have only green. But following green
you can go straight or visit some neighbors, but only by singlet-or-triplet.
More detailed explanations will not change what actually happened. Nonsense
about "convex cumbinations" and "Hermitian conjugates" and so on mean I am
playing with symbols to make things seem more true; they are likely to be
symbols that get in the way!
/li
- One sad fact about me is that
everything reminds me of a story!
- elements
- rocksalt
test of a pdf image
- water
snapshot of asymptote in action. I have not yet tried posting asy itself to github as a runnable.
A water molecule in action illustrates what cooperation can meanand illustrates redox (reduction and oxidation).
`
The two oxygens alternate ib stealing one another's electrons, but only because they have made prior arranement to lend the electron to be stolen. It makes water a very energetic molecule, yet there is no fighting going on.
- "text version for reading the code"
-
Fredbird A drinking bird is an ideal pet for aomeone whoi needs to get comfortable with thermodynamics. I have named mine for Fred Astaire.


Editing Feedback Categories
How to edit categories in the Feedback module.
-
Select Edit > Edit Category/Subject Lists from the module actions menu. This opens the Edit Lists page.
- At List Type, select Categories.
- Click the Edit button beside the category to be edited.
- Edit the category details as required.
- Click the Save link. The new details for this category are now displayed to the left.
- Repeat Steps 2-5 to edit additional categories.
- Click the Return to Module button when you are finished.