A better tool to compare different attributes.
Course Project, Partnered with ebay
Oct. 2015, 2 Weeks
Information overload and unlimited choices make anxious shoppers harder to make choices.
User flow
User needs
The seekers want to find all the options meet their criteria.
The seekers want to compare attributes between options.
The seekers want to make sure they made the right choice.
Pin item for comparison
The user can pin the interested item on the top of the screen and compare factors with other items.
Show comparison of factors
While the user scrolls the list, there are indicators showing the differences between the pinned item and the item at the top of the scroll list
Criteria list
User can swipe to see detail information about each factor. User can also customize factors in the heading.
Visualized filter
When setting criteria, users can see a brief visualization of the result of this criteria, including how many items will be in the result.
Third-Party rating
User can view item rating from their trusted third-party website. This not only redeems the reality that ebay doesn't have a rating system, but also offers more trust since the rating is from users trusted website.
We had an extra challenges in this project. We are assigned one fine art student with little experience in UX/UI in our team. It was the first time we ever worked with fine art people. We were glad that the new member really engaged into design process, rather than just take charge of visual part. It's quite interesting to see how people from different background think about a user experience problem.


Modules
otter
otter_app
otter_config
otter_conn_zipkin
otter_filter
otter_span_id_api
otter_span_mpdict_api
otter_span_pdict_api
otter_sup


While TensorFlow models are typically defined and trained using R or Python code, it is possible to deploy TensorFlow models in a wide variety of environments without any runtime dependency on R or Python:
TensorFlow Serving is an open-source software library for serving TensorFlow models using a gRPC interface.
CloudML is a managed cloud service that serves TensorFlow models using a REST interface.
RStudio Connect provides support for serving models using the same REST API as CloudML, but on a server within your own organization.
TensorFlow models can also be deployed to mobile and embedded devices including iOS and Android mobile phones and Raspberry Pi computers.
The R interface to TensorFlow includes a variety of tools designed to make exporting and serving TensorFlow models straightforward. The basic process for deploying TensorFlow models from R is as follows:
Train a model using the keras, tfestimators, or tensorflow R packages.
Call the export_savedmodel()
function on your trained model to write it to disk as a TensorFlow SavedModel.
Use the serve_savedmodel()
from the tfdeploy package to run a local test server that supports the same REST API as CloudML and RStudio Connect.
Deploy your model using TensorFlow Serving, CloudML, or RStudio Connect.
Begin by installing the tfdeploy package from GitHub as follows:
devtools::install_github("rstudio/tfdeploy")
First we’ll walk through an end-to-end example that: trains a Keras model with the MNIST dataset, exports the saved model, and then serves the exported model locally for predictions with a REST API. After that we’ll describe in more depth the specific requirements and various options associated with exporting models. Finally, we’ll cover the various deployment options and provide links to additional documentation.
We’ll use a Keras model that recognizes handwritten digits from the MNIST dataset as an example. MNIST consists of 28 x 28 grayscale images of handwritten digits like these:
The dataset also includes labels for each image. For example, the labels for the above images are 5, 0, 4, and 1.
Here’s the complete source code for the model:
library(keras)
# load data
c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_mnist()
# reshape and rescale
x_train <- array_reshape(x_train, dim = c(nrow(x_train), 784)) / 255
x_test <- array_reshape(x_test, dim = c(nrow(x_test), 784)) / 255
# one-hot encode response
y_train <- to_categorical(y_train, 10)
y_test <- to_categorical(y_test, 10)
# define and compile model
model <- keras_model_sequential()
model %>%
layer_dense(units = 256, activation = 'relu', input_shape = c(784),
name = "image") %>%
layer_dense(units = 128, activation = 'relu') %>%
layer_dense(units = 10, activation = 'softmax',
name = "prediction") %>%
compile(
loss = 'categorical_crossentropy',
optimizer = optimizer_rmsprop(),
metrics = c('accuracy')
)
# train model
history <- model %>% fit(
x_train, y_train,
epochs = 35, batch_size = 128,
validation_split = 0.2
)
In R, it is easy to make predictions using the the trained model and R’s predict
function:
preds <- predict(model, x_test[1:5,])
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] 0 0 0 0 0 0 0 1 0 0
[2,] 0 0 1 0 0 0 0 0 0 0
[3,] 0 1 0 0 0 0 0 0 0 0
[4,] 1 0 0 0 0 0 0 0 0 0
Each row represents an image, each column represents a digit from 0-9, and the values represent the model’s prediction. For example, the first image is predicted to be a 7.
What if we want to deploy the model in an environment where R isn’t available? The next sections cover exporting and deploying the model with the tfdeploy package.
After training, the next step is to export the model as a TensorFlow SavedModel using the export_savedmodel()
function:
library(tfdeploy)
export_savedmodel(model, "savedmodel")
This will create a “savedmodel” directory that contains a saved version of your MNIST model. You can view the graph of your model using TensorBoard with the view_savedmodel()
function:
view_savedmodel("savedmodel")
To test the exported model locally, use the serve_savedmodel
function.
serve_savedmodel('savedmodel', browse = TRUE)
The model is served at http://localhost:8989 along with a webpage that describes the REST interface to the model. The REST interface is based on the CloudML predict request API.
The model can be used for prediction by making HTTP POST requests. The body of the request should contain the new instances of data and the HTTP response provides the model’s predictions. The data in the request body should be pre-processed and formatted in the same way as the original training data. For MNIST, the request body could be a JSON file containing one or more pre-processed images:
{
"instances": [
{
"image_input": [0.12,0,0.79,...,0,0]
}
]
}
The HTTP POST request would be:
curl -X POST -H "Content-Type: application/json" -d @new_image.json http://localhost:8089/serving_default/predict
Similar to R’s predict function, the response includes an array representing the digits 0-9. The image in new_image.json
is predicted to be a 7:
{"predictions":[{"prediction":[1.3306e-24,4.9968e-26,1.8917e-23,1.7047e-21,0,8.963e-33,0,1,2.3306e-32,2.0314e-22]}]}
Once you are satisifed with local testing, the next step is to make the model available to others. There are a number of available options for this including TensorFlow Serving, CloudML, and RStudio Connect. For example, to deploy the saved model to CloudML we could use the cloudml package:
library(cloudml)
cloudml_deploy("savedmodel", name = "keras_mnist", version = "keras_mnist_1")
The same HTTP POST request we used to test the model locally can be used to generate predictions on CloudML, provided the proper access to the CloudML API.
Now that we’ve deployed a simple end-to-end example, we’ll describe the process of Model Export and Model Deployment in more detail.
TensorFlow SavedModel defines a language-neutral format to save machine-learned models that is recoverable and hermetic. It enables higher-level systems and tools to produce, consume and transform TensorFlow models.
The export_savedmodel()
function creates a SavedModel from a model trained using the keras, tfestimators, or tensorflow R packages. There are subtle differences in how this works in practice depending on the package you are using.
The Keras Example above includes complete example code for creating and using SavedModel instances from Keras so we won’t repeat all of those details here.
To export a TensorFlow SavedModel from a Keras model, simply call the export_savedmodel()
function on any Keras model:
export_savedmodel(model, "savedmodel")
Keras learning phase set to 0 for export (restart R session before doing additional training)
Note the printed output. Exporting a Keras model requires setting the Keras “learning phase” to 0. In practice, this means that after calling export_savedmodel
you can not continue to train the model in the same R session.
It is important to assign reasonable names to the the first and last layers. For example, in the model code above we named the first layer “image” and the last layer “prediction”.
model %>%
layer_dense(units = 256, activation = 'relu', input_shape = c(784),
name = "image") %>%
layer_dense(units = 128, activation = 'relu') %>%
layer_dense(units = 10, activation = 'softmax',
name = "prediction")
The layer names are reflected in the structure of requests and responses to and from the deployed model.
Exporting a TensorFlow SavedModel from a TF Estimators model works exactly the same way as exporting a keras model, simply call export_savedmodel()
on the estimator. Here is a complete example:
library(tfestimators)
mtcars_input_fn <- function(data, num_epochs = 1) {
input_fn(data,
features = c("disp", "cyl"),
response = "mpg",
batch_size = 32,
num_epochs = num_epochs)
}
cols <- feature_columns(column_numeric("disp"), column_numeric("cyl"))
model <- linear_regressor(feature_columns = cols)
indices <- sample(1:nrow(mtcars), size = 0.80 * nrow(mtcars))
train <- mtcars[indices, ]
test <- mtcars[-indices, ]
model %>% train(mtcars_input_fn(train, num_epochs = 10))
export_savedmodel(model, "savedmodel")
Generating predictions is done in the same way as with exported Keras models. First, use serve_savedmodel
to host the model locally. Once running, an HTTP POST request can be made:
curl -X POST "http://<IP_ADDRESS>:8089/predict/predict/" -H "accept: application/json" -H "Content-Type: application/json" -d "{ \"instances\": [ { \"disp\": [ 160 ], \"cyl\": [ 4 ] } ]}"
Each instance of new data should be formatted as a json array, and each element in the array should be a named array corresponding to the feature columns. This structure is similar to a named list in R.
The response is the predicted MPG:
{
"predictions": [
{
"predictions": [
8.4974
]
}
]
}
The tensorflow package provides a lower-level interface to the TensorFlow API. You can also use the export_savedmodel()
function to export models created with this API, however you need to provide some additional parmaeters indicating which tensors represent the inputs and outputs for your model.
For example, here’s an MNIST model using the core TensorFlow API along with the requisite call to export_savedmodel()
:
library(tensorflow)
sess <- tf$Session()
datasets <- tf$contrib$learn$datasets
mnist <- datasets$mnist$read_data_sets("MNIST-data", one_hot = TRUE)
# Note that we define x as the input tensor
# and y as the output tensor that will contain
# the scores. These are referenced in export_savedmodel
x <- tf$placeholder(tf$float32, shape(NULL, 784L))
W <- tf$Variable(tf$zeros(shape(784L, 10L)))
b <- tf$Variable(tf$zeros(shape(10L)))
y <- tf$nn$softmax(tf$matmul(x, W) + b)
y_ <- tf$placeholder(tf$float32, shape(NULL, 10L))
cross_entropy <- tf$reduce_mean(
-tf$reduce_sum(y_ * tf$log(y), reduction_indices=1L)
)
optimizer <- tf$train$GradientDescentOptimizer(0.5)
train_step <- optimizer$minimize(cross_entropy)
init <- tf$global_variables_initializer()
sess$run(init)
for (i in 1:1000) {
batches <- mnist$train$next_batch(100L)
batch_xs <- batches[[1]]
batch_ys <- batches[[2]]
sess$run(train_step,
feed_dict = dict(x = batch_xs, y_ = batch_ys))
}
export_savedmodel(
sess,
"savedmodel",
inputs = list(image_input = x),
outputs = list(scores = y))
Once the model is exported, the same process of using serve_savedmodel
can be used, and the same HTTP requests demonstrated in the Keras example can be used against the tensorflow model.
There are a variety of ways to deploy a TensorFlow SavedModel, each of which are described below. Of the 3 methods described, 2 of them (CloudML and RStudio Connect) share the same REST interface that we have been using with serve_savedmodel
to test locally. The REST interface is described in detail here: https://cloud.google.com/ml-engine/docs/v1/predict-request.
You can deploy TensorFlow SavedModels to Google’s CloudML service using functions from the cloudml package. For example:
library(cloudml)
cloudml_deploy("savedmodel", name = "keras_mnist")
Once deployed to CloudML, predictions can be made using the same REST interace we previously used locally. The HTTP POST requests will be similar to the sample requests, but CloudML additiobnally requires proper authorization.
See the Deploying Models article on the CloudML package website for additional details.
RStudio Connect is a publishing platform for applications, reports, and APIs created with R. Connect runs on-premise or in your own cloud infrastructure, giving you full control of the deployment environment. Connect can also integrate with your own security services and user management tools.
An upcoming version of RStudio Connect will include support for hosting TensorFlow SavedModels, using the same REST interface as is supported by the local server and CloudML.
Exported models will be published to Connect using the rsconnect
package, for example:
rsconnect::deployTFModel('savedmodel', account = <username>, server = <internal_connect_server>)
If you would like to preview the feature, or get more information, contact<EMAIL_ADDRESS>TensorFlow Serving is an open-source library and server implementation that allows you to serve TensorFlow SavedModels using a gRPC interface as opposed to the REST interface offered by the previous deployment tools.
Once you have exported a TensorFlow model using export_savedmodel()
it’s straightforward to deploy it using TensorFlow Serving. See the documentation at https://www.tensorflow.org/serving for additional details.


Maven Resources Plugin
Sample configuration
<plugin>
<groupId>org.bbqjs</groupId>
<artifactId>bbq-resources-maven-plugin</artifactId>
<version>${maven.plugin.bbq.version}</version>
<executions>
<execution>
<goals>
<goal>processResources</goal>
</goals>
</execution>
</executions>
<configuration>
<outputDirectory>${project.build.directory}/${project.build.finalName}/images</outputDirectory>
</configuration>
</plugin>
Woah. Let's break that down a little.
The bbq Maven plugin does three things:
- Compiles JavaScript
- Compiles CSS
- Compiles Language files
When we say "compile" we really mean "gloms a bunch of files together". See the bbq-compiler for more information on this.
Each task is done via an execution.
JavaScript compilation
<!-- Compile JavaScript -->
<execution>
<id>compileJavaScript</id>
<goals>
<goal>compileJavaScript</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/ROOT/js</outputDirectory>
</configuration>
</execution>
This execution looks for page classes to compile. By default, the package it examines is found at:
src/main/javascript/${js.page.package}
If yours lives somewhere else, specify an
<inputDirectory>${project.basedir}/path/to/directory</inputDirectory>
element in the configuration section
Each compiled JavaScript file (one per page) is outputted into the directory specified by the
<outputDirectory>path/to/directory</outputDirectory>
element.
CSS compilation
<execution>
<id>Compile CSS</id>
<goals>
<goal>compileCSS</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/ROOT/css</outputDirectory>
<libraries>
<library>reset.css</library>
</libraries>
</configuration>
</execution>
This works in a similar fashion to the JavaScript compilation execution, except instead of JavaScript files, it compiles CSS files.
Language compilation
<execution>
<id>Compile Language</id>
<goals>
<goal>compileLanguage</goal>
</goals>
<configuration>
<defaultLanguage>en_GB</defaultLanguage>
<supportedLanguages>
<supportedLanguage>en_GB</supportedLanguage>
<supportedLanguage>en_US</supportedLanguage>
</supportedLanguages>
</configuration>
</execution>
Also similar to the JavaScript compiler execution, this execution compiles language translation files. Each JavaScript class should have one or more language translation files next to it in the source directory structure. So, for example:
src/main/javascript/com/myapp/MyClass.js
src/main/javascript/com/myapp/MyClass.en_GB.lang.xml
src/main/javascript/com/myapp/MyClass.en_US.lang.xml
The
<defaultLanguage>locale_code</defaultLanguage>
element defines which language is used when translations do not exist in the specified language. So, for example, with the configuration above you could put all of your translations in the enGB files, then override alternative spellings such as "color" in the enUS files.
Only languages defined in
<supportedLanguage>locale_code</supportedLanguage
elements will be compiled.
Language files are simple Java properties files. This ensures the translations support multibyte character sets. e.g:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key="com.myapp.hello">Hello</entry>
<entry key="com.myapp.world">World</entry>
</properties>


File path:
princeton-5/dspace-jspui/src/main/webapp/layout/navbar-default.jsp
Decision log:
* use of target=_blank
* not deleting existing about and help html, only changing the links
* There are links to help text across dspace (via the question marks in circles, usually linking to a particular section of the help text). I'm doing the main one just for now
closed
by Kevin McElwee at 2021-02-25 16:23:23.closed
by Kevin McElwee at 2021-02-25 16:23:14.Please note that the home button also does not work in DataSpace--not on any page.
This is preventing creating the dpul collection for Cairo Geniza, making this a priority
labeled
by Trey Pendragon at 2021-02-25 17:23:36.added_to_project
by Trey Pendragon at 2021-02-25 17:23:46.@hackartisan For the availability?mfhd=
Endpoint the fields we use are: barcode, location, copynumber, status, onreserve, itemtype, pickuplocationid, pickuplocationcode, enumdisplay, chron, status_label
Fields we do not use, but are currently present: id, itemsequencenumber, duedate, patrongroup_charged, enum, label(?), location(?). (I put question marks, because I do not see them at first glance, but they seem like things we might use...)
labeled
by None at 2021-02-25 19:28:29.assigned
by None at 2021-02-25 19:59:35.labeled
by None at 2021-02-25 21:00:24.Coverage increased (+0.08%) to 82.422% when pulling 010fd420fc56c8f03fe40a4b5770945d89d0fc79 on issue925feb23 into 567d9d76d4b060f85b44e0e79eb2c4d4559972e6 on alma.
@hackartisan Thanks for all the feedback and working around the nuances.
I added a test for the actual record enrichment in marc_record.rb
-- This should be the last review (famous last words)...
head_ref_force_pushed
by Hector Correa at 2021-02-25 15:38:34.mentioned
by None at 2021-02-25 20:59:01.subscribed
by None at 2021-02-25 20:59:01.referenced
by None at 2021-02-25 21:50:56.merged
by None at 2021-02-25 21:50:56.closed
by None at 2021-02-25 21:50:56.head_ref_deleted
by None at 2021-02-25 21:50:56.Coverage decreased (-1.5%) to 82.422% when pulling 414eb8d28fb49fd77c827bc3f8151a067cd11de2 on alma into f6627a2b1169dc639b8918699183d30e589a1c07 on main.
My initial shell script (via marcli) took 51 minutes to process all the MARC files and produce new ones.
If I parallelize the work with 4 concurrent marcli
processes via Linux's native wait and &
the times comes down to around 23-28 minutes (see shell script).
I'll try to run the Ruby and Java versions that @escowles posted and see what the performance looks like.
mentioned
by Esmé Cowles at 2021-02-25 22:56:03.subscribed
by Esmé Cowles at 2021-02-25 22:56:03.Coverage decreased (-0.02%) to 82.321% when pulling 333c610b05c5f61dbc188e056afcdb2dee10064d on 1084-courses into 567d9d76d4b060f85b44e0e79eb2c4d4559972e6 on alma.
review_requested
by None at 2021-02-25 16:01:30.convert_to_draft
by None at 2021-02-25 16:01:43.in EADs
referenced
by James R. Griffin III at 2021-02-25 21:23:11.merged
by James R. Griffin III at 2021-02-25 21:23:11.closed
by James R. Griffin III at 2021-02-25 21:23:11.head_ref_deleted
by James R. Griffin III at 2021-02-25 21:23:17.As long as the collection level restriction is coming into the call slips its fine to not be MVP. We in PS basically just need to see that something is restricted in the collection and then we can look at the component to see more. But this would be helpful in a next sprint.
@sdellis Pulfalight, I haven't submitted anything I just wasn't sure where they were going.
mentioned
by Shaun Ellis at 2021-02-25 14:51:31.subscribed
by Shaun Ellis at 2021-02-25 14:51:31.@tpendragon this one looks good but I did open a new ticket about a new issue. I will close this one.
closed
by Christa Cleeton at 2021-02-25 14:52:15.mentioned
by Trey Pendragon at 2021-02-25 14:52:15.subscribed
by Trey Pendragon at 2021-02-25 14:52:15.labeled
by James R. Griffin III at 2021-02-25 15:17:41.labeled
by James R. Griffin III at 2021-02-25 15:17:41.mentioned
by Princeton University Library at 2021-02-25 15:17:41.labeled
by James R. Griffin III at 2021-02-25 15:20:07.labeled
by James R. Griffin III at 2021-02-25 15:20:07.assigned
by Bess Sadler at 2021-02-25 15:20:18.labeled
by James R. Griffin III at 2021-02-25 15:34:10.mentioned
by Bess Sadler at 2021-02-25 15:34:11.subscribed
by Bess Sadler at 2021-02-25 15:34:11.@tpendragon Take another look?
head_ref_force_pushed
by Bess Sadler at 2021-02-25 16:26:42.mentioned
by Trey Pendragon at 2021-02-25 16:29:10.subscribed
by Trey Pendragon at 2021-02-25 16:29:10.referenced
by Trey Pendragon at 2021-02-25 17:47:05.merged
by Trey Pendragon at 2021-02-25 17:47:05.closed
by Trey Pendragon at 2021-02-25 17:47:06.head_ref_deleted
by Trey Pendragon at 2021-02-25 17:47:06.assigned
by Bess Sadler at 2021-02-25 15:29:19.labeled
by James R. Griffin III at 2021-02-25 15:29:36.unassigned
by Bess Sadler at 2021-02-25 19:11:32.closed
by Trey Pendragon at 2021-02-25 19:14:12.labeled
by Trey Pendragon at 2021-02-25 19:17:39.closed
by Trey Pendragon at 2021-02-25 19:18:00.@faithc I feel like the storage note should be displaying at the component level too. If a researcher gets to a component via a keyword they are not going to know it might not be onsite.
@ccleeton Yes, the collection-level storage note should display with child components as well like it does now. The note also indicates at which location/library materials are stored/accessible; this should continue to display in pulfalight as well. Ex. https://findingaids.princeton.edu/collections/C1596/c6 vs. https://findingaids-beta.princeton.edu/catalog/C1596_c6.
Closing this and opening #701 instead.
mentioned
by None at 2021-02-25 14:19:42.subscribed
by None at 2021-02-25 14:19:42.reopened
by None at 2021-02-25 14:51:58.mentioned
by Christa Cleeton at 2021-02-25 14:51:58.subscribed
by Christa Cleeton at 2021-02-25 14:51:58.closed
by Trey Pendragon at 2021-02-25 19:18:25.@faithc @ccleeton https://findingaids-beta.princeton.edu/catalog/C0033_c001 Look better? Can we close this?
mentioned
by None at 2021-02-25 19:19:16.subscribed
by None at 2021-02-25 19:19:16.mentioned
by Christa Cleeton at 2021-02-25 19:19:16.subscribed
by Christa Cleeton at 2021-02-25 19:19:16.assigned
by Bess Sadler at 2021-02-25 19:23:43.@sdellis Not sure if you saw my response in slack. Moving the FAQs to libanswers works for me. And agree to spelling out AV. I changed the SC website to remove the / between the words. I would be fine to copy the brief statement into the finding aids. Is it possible to do that only in collections where AV is known? @faithc Thoughts?
I think @sdellis is asking about the site, not specific finding aids? (ADAPT is planning to replace current AV notes in finding aids with a boilerplate note (once we get the language from public svs) and link to the statement/policy from there.)
@faithc the Statement on Audiovisual Materials seems like something that we might want to include in the Access and Use notes for A.V. collections, right?
We do currently have notes for AV materials in finding aids; however, ADAPT and PS recently agreed to change this approach to only having a brief note, something like "see SC's policy on..." with a link out to the statement/policy so that when the policy is revised, which often happens, we're not having to change the finding aid notes.
mentioned
by Shaun Ellis at 2021-02-25 14:48:23.subscribed
by Shaun Ellis at 2021-02-25 14:48:23.mentioned
by None at 2021-02-25 14:48:23.subscribed
by None at 2021-02-25 14:48:23.mentioned
by Shaun Ellis at 2021-02-25 14:57:32.subscribed
by Shaun Ellis at 2021-02-25 14:57:32.mentioned
by None at 2021-02-25 14:57:44.subscribed
by None at 2021-02-25 14:57:44.closed
by Trey Pendragon at 2021-02-25 19:27:58.deployed
by Trey Pendragon at 2021-02-25 19:14:40.referenced
by Trey Pendragon at 2021-02-25 19:27:58.merged
by Trey Pendragon at 2021-02-25 19:27:58.closed
by Trey Pendragon at 2021-02-25 19:27:58.head_ref_deleted
by Trey Pendragon at 2021-02-25 19:27:59.deployed
by Trey Pendragon at 2021-02-25 19:28:18.referenced
by Trey Pendragon at 2021-02-25 19:36:39.merged
by Trey Pendragon at 2021-02-25 19:36:39.closed
by Trey Pendragon at 2021-02-25 19:36:39.head_ref_deleted
by Trey Pendragon at 2021-02-25 19:36:39.milestoned
by Trey Pendragon at 2021-02-25 20:36:07.This is another example that Annalee and Rosalba experienced https://findingaids-beta.princeton.edu/catalog/C0035_c021 and https://findingaids-beta.princeton.edu/catalog/C0230_c021
It is also adding all of the info to the call slip. 2 barcodes, all that info in the notes field. tn 291225.docx
Oof. Yeah I just copied all the merging fields to pass to Aeon from PULFA2, but it wouldn't be a problem there because you can't request cross-collection. I'll take a look.
labeled
by Christa Cleeton at 2021-02-25 14:12:16.milestoned
by Christa Cleeton at 2021-02-25 14:12:16.assigned
by Trey Pendragon at 2021-02-25 19:23:39.referenced
by Trey Pendragon at 2021-02-25 19:44:27.closed
by James R. Griffin III at 2021-02-25 20:52:42.Awesome - glad the blog post was useful!
mentioned
by Hillel Arnold at 2021-02-25 19:45:08.subscribed
by Hillel Arnold at 2021-02-25 19:45:08.referenced
by James R. Griffin III at 2021-02-25 20:52:42.merged
by James R. Griffin III at 2021-02-25 20:52:42.closed
by James R. Griffin III at 2021-02-25 20:52:42.head_ref_deleted
by James R. Griffin III at 2021-02-25 20:52:43.I'm pretty surprised this passes the accessibility tests. Seems like we need some way to better see the title text. Maybe a darkened opacity on the image? Any suggestions @sdellis?
Good point. I'll try adding some opacity to the image.
Here it is with an opacity of .3 on the image, and I swapped the h1 color to be $black-pul.
I like this with the opacity!
I find it pretty hard to read the text with so much going on behind it, but I have no good suggestions for how to improve that. It might just be a personal problem too.
@tpendragon I think that darkening the image, keeping the white lettering, and adding a drop shadow should do the trick. I'm happy to give it a try if it helps.
@sdellis Would you please give that a shot? It sounds like your UI skills vastly exceed mine. Thank you!
mentioned
by Shaun Ellis at 2021-02-25 19:25:40.subscribed
by Shaun Ellis at 2021-02-25 19:25:40.mentioned
by Trey Pendragon at 2021-02-25 21:37:04.subscribed
by Trey Pendragon at 2021-02-25 21:37:04.mentioned
by Shaun Ellis at 2021-02-25 21:38:25.subscribed
by Shaun Ellis at 2021-02-25 21:38:25.closed
by Trey Pendragon at 2021-02-25 22:01:13.@faithc @ccleeton Can you look at this again? I think it's fixed with the reindex.
mentioned
by None at 2021-02-25 22:00:45.subscribed
by None at 2021-02-25 22:00:45.mentioned
by Christa Cleeton at 2021-02-25 22:00:45.subscribed
by Christa Cleeton at 2021-02-25 22:00:46.assigned
by Trey Pendragon at 2021-02-25 22:01:34.assigned
by Bess Sadler at 2021-02-25 19:05:22.referenced
by Bess Sadler at 2021-02-25 19:20:54.unassigned
by Bess Sadler at 2021-02-25 22:14:04.assigned
by Shaun Ellis at 2021-02-25 22:14:04.referenced
by Kevin Reiss at 2021-02-25 03:41:11.merged
by Kevin Reiss at 2021-02-25 03:41:11.closed
by Kevin Reiss at 2021-02-25 03:41:11.closed
by Kevin Reiss at 2021-02-25 03:41:11.Resolved: OAR is back up in 6088379
.
labeled
by Francis Kayiwa at 2021-02-25 11:24:39.labeled
by Francis Kayiwa at 2021-02-25 11:24:39.locked
by Francis Kayiwa at 2021-02-25 11:24:40.closed
by Francis Kayiwa at 2021-02-25 11:33:41.Resolved: Dataspace is back up in 39b30d9
.
Resolved: Dataspace is back up in 11e6a81
.
Resolved: Dataspace is back up in 4a5b4a3
.
Resolved: Dataspace is back up in 2b31b00
.
Resolved: OAR is back up in 719e496
.
labeled
by Francis Kayiwa at 2021-02-25 15:54:46.labeled
by Francis Kayiwa at 2021-02-25 15:54:46.locked
by Francis Kayiwa at 2021-02-25 15:54:47.closed
by Francis Kayiwa at 2021-02-25 16:01:45.


返回主页
Determination
In 1979, Redstone (1923) survived a Boston hotel fire. In 1987, Redstone won voting control of Viacom. I have an obsessive competitive spirit. Determination, physical or any other kind, is the key to survival. It’s fierce determination with a great deal of energy and a great deal of focus. Determination, Resourcefulness, a certain disregard for rules. The central thing is to get control of an asset, not necessarily cheaply. A lot of people are able to understand and work that formula of buying cheap and selling high. But the formula for the very rich is to get control of an asset and enhance its value.
God Secret Model:
Attraction & Attention, ASK, ANSWER, ALIGN, FEEDBACK;
Expression, Attention, Pentagon Topology, Systems Engineering.
 What you think and feel about will be attracted to you. It’s a lie to think you're not good enough. It's a lie to think you're not worth anything. I love my life, because I’ve seen my purpose.  As long as I try, there’s always a chance of getting up. It’s not the end until you give up. Failure is not important, how you overcome it is. Consider it pure joy, whenever you face trials. I am gonna try again and again, because the moment I give up, is the moment I fail. His belief is that God can use any willing heart to do his work.
返回页首
返回主页
version:1.0<EMAIL_ADDRESS>© retter2012.com


JavaScript is a dynamically typed language which comes with great power of expression, but it also comes with almost no help from the compiler. For this reason we feel very strongly that any code written in JavaScript needs to come with a strong set of tests. We have built many features into Angular which makes testing your Angular applications easy. So there is no excuse for not testing.
Unit testing, as the name implies, is about testing individual units of code. Unit tests try to answer questions such as "Did I think about the logic correctly?" or "Does the sort function order the list in the right order?"
In order to answer such a question it is very important that we can isolate the unit of code under test. That is because when we are testing the sort function we don't want to be forced into creating related pieces such as the DOM elements, or making any XHR calls to fetch the data to sort.
While this may seem obvious it can be very difficult to call an individual function on a typical project. The reason is that the developers often mix concerns resulting in a piece of code which does everything. It makes an XHR request, it sorts the response data and then it manipulates the DOM.
With Angular we try to make it easy for you to do the right thing, and so we provide dependency injection for your XHR requests, which can be mocked, and we provide abstractions which allow you to test your model without having to resort to manipulating the DOM. The test can then assert that the data has been sorted without having to create or look at the state of the DOM or wait for any XHR requests to return data. The individual sort function can be tested in isolation.
Angular is written with testability in mind, but it still requires that you do the right thing. We tried to make the right thing easy, but if you ignore these guidelines you may end up with an untestable application.
Angular comes with dependency injection built-in, which makes testing components much easier, because you can pass in a component's dependencies and stub or mock them as you wish.
Components that have their dependencies injected allow them to be easily mocked on a test by test basis, without having to mess with any global variables that could inadvertently affect another test.
For testing Angular applications there are certain tools that you should use that will make testing much easier to set up and run.
Karma is a JavaScript command line tool that can be used to spawn a web server which loads your application's source code and executes your tests. You can configure Karma to run against a number of browsers, which is useful for being confident that your application works on all browsers you need to support. Karma is executed on the command line and will display the results of your tests on the command line once they have run in the browser.
Karma is a NodeJS application, and should be installed through npm. Full installation instructions are available on the Karma website.
Jasmine is a behavior driven development framework for JavaScript that has become the most popular choice for testing Angular applications. Jasmine provides functions to help with structuring your tests and also making assertions. As your tests grow, keeping them well structured and documented is vital, and Jasmine helps achieve this.
In Jasmine we use the describe
function to group our tests together:
describe("sorting the list of users", function() {
// individual tests go here
});
And then each individual test is defined within a call to the it
function:
describe('sorting the list of users', function() {
it('sorts in descending order by default', function() {
// your test assertion goes here
});
});
Grouping related tests within describe
blocks and describing each individual test within an
it
call keeps your tests self documenting.
Finally, Jasmine provides matchers which let you make assertions:
describe('sorting the list of users', function() {
it('sorts in descending order by default', function() {
var users = ['jack', 'igor', 'jeff'];
var sorted = sortUsers(users);
expect(sorted).toEqual(['jeff', 'jack', 'igor']);
});
});
Jasmine comes with a number of matchers that help you make a variety of assertions. You should read the Jasmine documentation to see what they are. To use Jasmine with Karma, we use the karma-jasmine test runner.
Angular also provides the ngMock
module, which provides mocking for your tests. This is used
to inject and mock Angular services within unit tests. In addition, it is able to extend other
modules so they are synchronous. Having tests synchronous keeps them much cleaner and easier to work
with. One of the most useful parts of ngMock is $httpBackend
, which lets us mock XHR
requests in tests, and return sample data instead.
Because Angular separates logic from the view layer, it keeps controllers easy to test. Let's take a
look at how we might test the controller below, which provides $scope.grade
, which sets a property
on the scope based on the length of the password.
angular.module('app', [])
.controller('PasswordController', function PasswordController($scope) {
$scope.password = '';
$scope.grade = function() {
var size = $scope.password.length;
if (size > 8) {
$scope.strength = 'strong';
} else if (size > 3) {
$scope.strength = 'medium';
} else {
$scope.strength = 'weak';
}
};
});
Because controllers are not available on the global scope, we need to use angular.mock.inject
to inject our controller first. The first step is to use the module
function,
which is provided by angular-mocks. This loads in the module it's given, so it is available in your
tests. We pass this into beforeEach
, which is a function Jasmine provides that lets us run code
before each test. Then we can use inject
to access $controller
, the service that is responsible
for instantiating controllers.
describe('PasswordController', function() {
beforeEach(module('app'));
var $controller;
beforeEach(inject(function(_$controller_){
// The injector unwraps the underscores (_) from around the parameter names when matching
$controller = _$controller_;
}));
describe('$scope.grade', function() {
it('sets the strength to "strong" if the password length is >8 chars', function() {
var $scope = {};
var controller = $controller('PasswordController', { $scope: $scope });
$scope.password = 'longerthaneightchars';
$scope.grade();
expect($scope.strength).toEqual('strong');
});
});
});
Notice how by nesting the describe
calls and being descriptive when calling them with strings, the
test is very clear. It documents exactly what it is testing, and at a glance you can quickly see
what is happening. Now let's add the test for when the password is less than three characters, which
should see $scope.strength
set to "weak":
describe('PasswordController', function() {
beforeEach(module('app'));
var $controller;
beforeEach(inject(function(_$controller_){
// The injector unwraps the underscores (_) from around the parameter names when matching
$controller = _$controller_;
}));
describe('$scope.grade', function() {
it('sets the strength to "strong" if the password length is >8 chars', function() {
var $scope = {};
var controller = $controller('PasswordController', { $scope: $scope });
$scope.password = 'longerthaneightchars';
$scope.grade();
expect($scope.strength).toEqual('strong');
});
it('sets the strength to "weak" if the password length <3 chars', function() {
var $scope = {};
var controller = $controller('PasswordController', { $scope: $scope });
$scope.password = 'a';
$scope.grade();
expect($scope.strength).toEqual('weak');
});
});
});
Now we have two tests, but notice the duplication between the tests. Both have to
create the $scope
variable and create the controller. As we add new tests, this duplication is
only going to get worse. Thankfully, Jasmine provides beforeEach
, which lets us run a function
before each individual test. Let's see how that would tidy up our tests:
describe('PasswordController', function() {
beforeEach(module('app'));
var $controller;
beforeEach(inject(function(_$controller_){
// The injector unwraps the underscores (_) from around the parameter names when matching
$controller = _$controller_;
}));
describe('$scope.grade', function() {
var $scope, controller;
beforeEach(function() {
$scope = {};
controller = $controller('PasswordController', { $scope: $scope });
});
it('sets the strength to "strong" if the password length is >8 chars', function() {
$scope.password = 'longerthaneightchars';
$scope.grade();
expect($scope.strength).toEqual('strong');
});
it('sets the strength to "weak" if the password length <3 chars', function() {
$scope.password = 'a';
$scope.grade();
expect($scope.strength).toEqual('weak');
});
});
});
We've moved the duplication out and into the beforeEach
block. Each individual test now
only contains the code specific to that test, and not code that is general across all tests. As you
expand your tests, keep an eye out for locations where you can use beforeEach
to tidy up tests.
beforeEach
isn't the only function of this sort that Jasmine provides, and the documentation
lists the others.
Filters are functions which transform the data into a user readable format. They are important because they remove the formatting responsibility from the application logic, further simplifying the application logic.
myModule.filter('length', function() {
return function(text) {
return ('' + (text || '')).length;
}
});
describe('length filter', function() {
beforeEach(inject(function(_$filter_){
$filter= _$filter_;
}));
it('returns 0 when given null', function() {
var length = $filter('length');
expect(length(null)).toEqual(0);
});
it('returns the correct value when given a string of chars', function() {
var length = $filter('length');
expect(length('abc')).toEqual(3);
});
});
Directives in angular are responsible for encapsulating complex functionality within custom HTML tags, attributes, classes or comments. Unit tests are very important for directives because the components you create with directives may be used throughout your application and in many different contexts.
Let's start with an angular app with no dependencies.
var app = angular.module('myApp', []);
Now we can add a directive to our app.
app.directive('aGreatEye', function () {
return {
restrict: 'E',
replace: true,
template: '
lidless, wreathed in flame, {{1 + 1}} times
'
};
});
This directive is used as a tag
. It replaces the entire tag with the
template
lidless, wreathed in flame, {{1 + 1}} times

. Now we are going to write a jasmine unit test to
verify this functionality. Note that the expression {{1 + 1}}
times will also be evaluated in the rendered content.
describe('Unit testing great quotes', function() {
var $compile,
$rootScope;
// Load the myApp module, which contains the directive
beforeEach(module('myApp'));
// Store references to $rootScope and $compile
// so they are available to all tests in this describe block
beforeEach(inject(function(_$compile_, _$rootScope_){
// The injector unwraps the underscores (_) from around the parameter names when matching
$compile = _$compile_;
$rootScope = _$rootScope_;
}));
it('Replaces the element with the appropriate content', function() {
// Compile a piece of HTML containing the directive
var element = $compile("")($rootScope);
// fire all the watches, so the scope expression {{1 + 1}} will be evaluated
$rootScope.$digest();
// Check that the compiled element contains the templated content
expect(element.html()).toContain("lidless, wreathed in flame, 2 times");
});
});
We inject the $compile service and $rootScope before each jasmine test. The $compile service is used to render the aGreatEye directive. After rendering the directive we ensure that the directive has replaced the content and "lidless, wreathed in flame, 2 times" is present.
_$rootScope_
) is a convention wide spread in AngularJS
community to keep the variable names clean in your tests. That's why the
$injector
strips out the leading and the trailing underscores when
matching the parameters. The underscore rule applies only if the name starts and ends with
exactly one underscore, otherwise no replacing happens.
Directives that use transclusion are treated specially by the compiler. Before their compile function is called, the contents of the directive's element are removed from the element and provided via a transclusion function. The directive's template is then appended to the directive's element, to which it can then insert the transcluded content into its template.
Before compilation:

Some transcluded content

After transclusion extraction:

After compilation:

Some Template
Some transcluded content

If the directive is using 'element' transclusion, the compiler will actually remove the directive's entire element from the DOM and replace it with a comment node. The compiler then inserts the directive's template "after" this comment node, as a sibling.
Before compilation

Some Content

After transclusion extraction

After compilation:

Some Template
Some transcluded content

It is important to be aware of this when writing tests for directives that use 'element'
transclusion. If you place the directive on the root element of the DOM fragment that you
pass to $compile
, then the DOM node returned from the linking function will be the
comment node and you will lose the ability to access the template and transcluded content.
var node = $compile('

')($rootScope);
expect(node[0].nodeType).toEqual(node.COMMENT_NODE);
expect(node[1]).toBeUndefined();
To cope with this you simply ensure that your 'element' transclude directive is wrapped in an
element, such as a

.
var node = $compile('

')($rootScope);
var contents = node.contents();
expect(contents[0].nodeType).toEqual(node.COMMENT_NODE);
expect(contents[1].nodeType).toEqual(node.ELEMENT_NODE);
If your directive uses templateUrl
, consider using
karma-ng-html2js-preprocessor
to pre-compile HTML templates and thus avoid having to load them over HTTP during test execution.
Otherwise you may run into issues if the test directory hierarchy differs from the application's.
See the angular-seed project for an example.


| testConstraints {mitml} | R Documentation |
Performs hypothesis tests for arbitrary functions of the model parameters using the Delta method.
testConstraints(model, qhat, uhat, constraints, method = c("D1", "D2"), ariv = c("default", "positive"), df.com = NULL)
model |
A list of fitted statistical models as produced by |
qhat |
A matrix or list containing the point estimates of the parameters for each imputed data set (see 'Details'). |
uhat |
An array or list containing the variance-covariance matrix of the parameters for each imputed data set (see 'Details'). |
constraints |
A character vector specifying constraints or functions of the vector of model parameters to be tested (see 'Details'). |
method |
A character string denoting the method by which the test is performed. Can be |
ariv |
A character string denoting how the ARIV is calculated. Can be |
df.com |
(optional) A single number or a numeric vector denoting the complete-data degrees of freedom for the hypothesis test (see 'Details'). Only used if |
This function performs tests of arbitrary functions (or constraints) of the model parameters using similar methods as testModels
.
The function relies on the Delta method (e.g., Casella & Berger, 2002) for testing functions of the parameters and assumes that their sampling distribution is approximately normal.
The parameters can either be extracted automatically from the fitted statistical models (model
) or provided manually as matrices, arrays, or lists (qhat
and uhat
, see 'Examples').
Constraints and other functions of the model parameters are specified in the constraints
argument.
The constraints must be supplied as a character vector, where each string denotes a function or a constraint to be tested (see 'Examples').
The Wald-like tests that are carried out by testConstraints
are pooled across the imputed data sets with the D_1 (Li, Raghunathan & Rubin, 1991) or D_2 (Li, Meng, Raghunathan & Rubin, 1991) method, where D_1 operates on the constrained point and variance estimates, and D_2 operates on the Wald-statistics (for additional details, see testModels
).
The pooled estimates and standard errors reported in the output are always based on D_1.
For D_1, the complete-data degrees of freedom can be adjusted for smaller samples by specifying df.com
(see testModels
).
This function supports general statistical models that define coef
and vcov
methods (e.g., lm
, glm
, lavaan
and others) as well as multilevel models estimated with lme4
or nlme
and GEEs estimated with geepack
.
The arguments qhat
and uhat
provide a general method for pooling parameter estimates regardless of model type (see 'Examples').
Support for further models may be added in future releases.
The ariv
argument determines how the average relative increase in variance (ARIV) is calculated (see testModels
).
If ariv = "default"
, the default estimators are used.
If ariv = "positive"
, the default estimators are used but constrained to take on strictly positive values.
A list containing the results of the model comparison.
A print
method is used for more readable output.
Simon Grund
Casella, G., & Berger, R. L. (2002). Statistical inference (2nd. Ed.). Pacific Grove, CA: Duxbury.
Li, K.-H., Meng, X.-L., Raghunathan, T. E., & Rubin, D. B. (1991). Significance levels from repeated p-values with multiply-imputed data. Statistica Sinica, 1, 65-92.
Li, K. H., Raghunathan, T. E., & Rubin, D. B. (1991). Large-sample significance levels from multiply imputed data using moment-based statistics and an F reference distribution. Journal of the American Statistical Association, 86, 1065-1073.
data(studentratings) fml <- MathDis + ReadDis + SchClimate ~ (1|ID) imp <- panImpute(studentratings, formula = fml, n.burn = 1000, n.iter = 100, m = 5) implist <- mitmlComplete(imp) # fit simple regression model fit.lm <- with(implist, lm(SchClimate ~ ReadDis + MathDis)) # apply Rubin's rules testEstimates(fit.lm) # * Example 1: test 'identity' function of two parameters (automatic) # test equivalent to model comparison with a restricted model (without 'ReadDis' # and 'MathDis') cons <- c("ReadDis", "MathDis") testConstraints(fit.lm, constraints = cons) # ... adjusting for finite samples testConstraints(fit.lm, constraints = cons, df.com = 749) # ... using D2 testConstraints(fit.lm, constraints = cons, method = "D2") # * Example 2: test for equality of two parameters # tests the hypothesis that the coefficients pertaining to 'ReadDis' and 'MathDis' # are equal (ReadDis = MathDis) cons <- c("ReadDis-MathDis") testConstraints(fit.lm, constraints = cons) # * Example 3: test against a fixed value # tests the hypothesis that the coefficient of "ReadDis" is equal to one # (i.e., 'ReadDis' - 1 == 0) cons <- c("ReadDis-1") testConstraints(fit.lm, constraints = cons) # * Example 4: test 'identity' function of two parameters (qhat, uhat) fit.lm <- with(implist, lm(SchClimate ~ ReadDis + MathDis)) qhat <- sapply(fit.lm, coef) uhat <- sapply(fit.lm, function(x) vcov(x), simplify = "array") cons <- c("ReadDis", "MathDis") testConstraints(qhat = qhat, uhat = uhat, constraints = cons)


GPT-2 Powered Trump Speech Generator
Seed:
I will not use this for malicious purposes
I will not hold the creators of this tool accountable for any of the text this model says


WITNESS LIST Veteran Affairs & Military Installations Committee March 26, 2003 - 1:30P SB 85 ON: Brunson, Jeane County Clerk; Legislative Cmte. Co-Chair (County & District Clerks Association of Texas), Weatherford, TX SB 719 FOR: Barrera, Enrique Councilman (City of San Antonio), San Antonio, TX Rasmussen, Bob Chief Operating Officer (Greater Kelly Development Authority), San Antonio, TX Rumora, Thomas Executive Director (Brooks Development Authority), San Antonio, TX Registering, but not testifying: For: Davis, Louis Economic Development Manager (City of San Antonio), San Antonio, TX Garza, Frank (Brooks Development Authority & Greater Kelly Development Authority), San Antonio, TX Igo, Shanna Director of Legislative Services (Texas Municipal League), Austin, TX Westerman, Lewis Secretary (Brooks Development Authority), San Antonio, TX SB 720 FOR: Barrera, Enrique Councilman (City of San Antonio), San Antonio, TX Rumora, Thomas Executive Director (Brooks Development Authority), San Antonio, TX Registering, but not testifying: For: Davis, Louis Economic Development Manager (City of San Antonio), San Antonio, TX Garza, Frank (Brooks Development Authority & Greater Kelly Development Authority), San Antonio, TX Igo, Shanna Director of Legislative Services (Texas Municipal League), Austin, TX Rasmussen, Bob Chief Operating Officer (Greater Kelly Development Authority), San Antonio, TX Westerman, Lewis Secretary (Brooks Development Authority), San Antonio, TX SB 814 FOR: Little, O. M. Citizen (Self), Dripping Springs, TX Montoya, Marco (Retired) (Self), Austin, TX Registering, but not testifying: For: Ingersoll, Deborah Citizen (Self), Austin, TX SB 938 FOR: Meisel, Robert Veteran (Self), Austin, TX Rogers, David CW5-AUS, Retired (Self), Austin, TX SB 983 ON: Blalock, Michael Deputy Executive Director (Adjutant General's Department), Austin, TX Registering, but not testifying: On: Dehnert, Allen Assistant Adjutant General (Adjutant General's Department), Austin, TX


This Project focuses on elevating NUVO Network’s social media presence. We focused on intaqgram becaused it showed higher levels of activity . We propose
a focus on instagram, to create a more cohesive and visually appealing layout. No matter where an individual
may be or what they are looking for, this space is where members and future members can see what NUVO has to offer.
Interactivity and community involvement are key.
In conducting this research, we intend to use various methods of research to collect information from different
members of NUVO Network (primary source), as well as other company examples (secondary sources). We will use this
information to develop a website that best suits the needs of NUVO Network.
How can we improve how NUVO interacts with tenants and potential members through their social media platforms?
Create a welcoming first impression of NUVO
To invite more people to share and connect
Promoting a active and thriving community to those passing by
The interview will be a very important aspect of our research still we will be able to get an account of who things work within the company and have the opinions of the staff and members. We will be able to create profiles based of of real people who attend these facilities. The interviews let us observe the reactions and the emotions of individual people and how they feel about the company. With this information we are capable of obtaining new and updated information on the company and members.
Amount of posts: 10
Average amount of tags per post: 6
Average amount of likes per post: 113
Number of post they were tagged in: 31
Project Spaces understands connecting on a personal level is important. They connect with their members by tagging the members and people in their photos. Consistency is another huge factor in their feed. The quality of the photos matches one another, the colours and subject matter are cohesive, they also post post frequently.
In conclusion, by analyzing other social media platforms of other co working spaces, we have discovered that using all features of the platform (stories, hashtags, reposting, etc.) can really increase community involvement and overall traffic of the platform. Should NUVO choose to implement these ideas, we believe they could benefit significantly.


Keith Stedman as a young adult
Keith Stedman Portfolio
Alaska is where I call home, I grew up in a small fishing town called Sitka. I graduated High school in 2006, went to the University of Oregon, where I majored in Digital Arts and graduated in 2012 with a BFA in Digital Arts! I decided on code because of its powerful and problem solving nauture.


PyOhio provides a community conference intended for networking and collaboration in the developer community.
We value the participation of each member of the Python community and want all attendees to have an enjoyable and fulfilling experience. Accordingly, we expect all attendees to show respect and courtesy to other attendees throughout the conference and at all conference events, whether officially sponsored by PyOhio or not.
All attendees, speakers, exhibitors, organizers, and volunteers at any PyOhio event must conform to the following Code of Conduct. Organizers will enforce this code throughout the event.
The Short Version
PyOhio provides a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, or religion. We do not tolerate harassment of conference participants in any form.
All communication should remain appropriate for a professional audience including people of many different backgrounds.
Be kind to others. Do not insult or put down other attendees. Behave professionally. We consider harassment and sexist, racist, or exclusionary jokes inappropriate.
Conference organizers may ask any attendees violating these rules to leave the conference.
Thank you for helping make this a welcoming, friendly event for all.

Participants asked to stop any harassing behavior should comply immediately.
Our anti-harassment policy includes exhibitors in the expo hall, sponsor or vendor booths, or similar activities. In particular, exhibitors should not use sexualized images, activities, or other material. Booth staff (including volunteers) should not use sexualized clothing/uniforms/costumes, or otherwise create a sexualized environment.
Be careful in the words that you choose.  We consider excessive swearing and offensive jokes inappropriate.
If a participant engages in behavior that violates this code of conduct, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference.
Contact Information
If you feel harassed, witness harassment, or have other concerns, please contact a member of conference staff. Conference staff will wear "PyOhio Staff" insignia.
If you consider the matter especially urgent, please immediately call:
- Jason Green<EMAIL_ADDRESS>at +1<PHONE_NUMBER>
or
- Brian Costlow<EMAIL_ADDRESS>at +1<PHONE_NUMBER>
Conference staff will help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.
Procedure for Handling Harassment
Derivation
This Code of Conduct derived from the PyCon Code of Conduct - which forked the example policy from the Geek Feminism wiki - created by the Ada Initiative and other volunteers.


{{gettext("A world-class team led by entrepreneurs and engineers from iconic tech companies")}}
{{gettext("Bringing NFTs and DeFi to the masses")}}
Origin's flagship products are Origin Story, which has powered numerous high-profile, record-breaking NFT drops, and Origin Dollar, the first stablecoin that earns a yield while it's still in your wallet.
Origin's platform and governance token is OGN that trades on Coinbase, Binance, Uniswap, and other top exchanges.")}}


Murder At 1600 Chad'z rating: **1/2 (out of 4 = OK) 1997, R, 104 minutes [1 hour, 44 minutes] [thriller/mystery] starring: Wesley Snipes (Detective Harlan Regis), Diane Lane (Nina Chance), Daniel Benzali (Nick Spikings), Dennis Miller (Detective Stengel), written by Wayne Beach, David Hodgin, produced by Arnold Kopelson, Arnon Milchan, directed by Dwight Little.
You may have noticed there's a trend happening among Hollywood thrillers, or more specifically, thrillers concerning the government. Filmmakers know audiences want detailed (read: "complicated") stories about conspiracies so that even if they can't understand them, they won't notice the cop-outs and cliches. "Murder At 1600" lies somewhere in between the trend setters and followers as it starts out as a standard detective story but eventually becomes another over-the-top thriller.
The opening sequence does a fine job in establishing a mysterious atmosphere as we see bits and pieces of a sex scene taking place somewhere in the White House. Soon we realize the girl involved in the scene was murdered and so the "whodunit?" routine kicks in. But what's so different and interesting here is the fact the murder took place in White House, which means everyone inside, including the First Family, could be suspected.
Wesley Snipes stars as Harlan Regis, a Washington, D.C. homicide detective who is called in to investigate the murder. And since this is a political thriller you know this won't be an easy case for anyone to solve because of the element of national security. The first act lays a good, basic framework of the power of the government while at the same time making supporting characters suspects.
Of course what's a strong male lead without a female counterpart? Diane Lane co-stars as Nina Chance, an Olympic sharpshooter now a Secret Service agent who is assigned to work with Regis. At first they bicker, then they get along, and by the end they find themselves saving each others lives (at least they don't fall in love!). Let's not forget Dennis Miller as Detective Stengel - Regis' wisecracking buddy who doesn't get nearly enough screen time.
The majority of the film goes through the motions you'd expect: a possible conspiracy crops up, Regis and Chance investigate and soon find themselves in over their heads, then the process repeats. Little seems to assume anyone who's seen films like "Clear And Present Danger" and "Patriot Games" should be able to figure out what's going on, or at least be entertained by the process.
There's also those moments of cliffhangers and sudden revelations, and interaction with characters who think Regis knows too much. But every time they think they've got a suspect, a motive, and evidence it turns out what they have points at someone or something else. The plot is also conducive to double-crosses which in turn lead to chase scenes and shootouts - which is what we critics call "movie convenient."
Everything comes together for the characters in the final act, but the rest of the film breaks down. Regis, Chance, and Stengel must break into the White House in order to "catch" the killer and save the president in the process. The fact the line "We've never had a security breach in 180 years" is uttered pretty much says it all.
I think the idea behind "Murder At 1600" was to combine the commercialism of "Mission: Impossible" with the intelligence of "JFK" and "The Fugitive." Had it not tried so hard to do both at the same time it could have been something original, but the net result is at least watchable.
Please visit Chad'z Movie Page @ http://members.aol.com/ChadPolenz - over 150 new and old movies reviewed in depth, not just blind ratings and quick capsules. Also, check out The FIRST Shay Astar Web Page @ http://members.aol.com/ChadPolenz/ShayAstar.html
e-mail<EMAIL_ADDRESS>(C) 1997 Chad Polenz
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


{% extends 'base.html' %} {% load crispy_forms_tags %} {% block content %}
Thanks for spending some quality time with the web site today.


#include <DataChunk.h>
Definition at line 70 of file DataChunk.h.
◆ cDataChunk()
| cDataChunk::cDataChunk |
( |
uint32_t |
maxSize = MAX_CHUNK_SIZE , |
|
|
const char * |
name = "PDAT" |
|
) |
| |
< Chunk group number
< Serial number
< Reserved
Definition at line 19 of file DataChunk.cpp.
◆ Clear()
| void cDataChunk::Clear |
( |
| ) |
|
|
virtual |
◆ GetByteCountAvailableToRead()
| uint32_t cDataChunk::GetByteCountAvailableToRead |
( |
| ) |
|
|
inline |
◆ GetByteCountAvailableToWrite()
| uint32_t cDataChunk::GetByteCountAvailableToWrite |
( |
| ) |
|
|
inline |
◆ GetDataPtr()
| uint8_t * cDataChunk::GetDataPtr |
( |
| ) |
|
◆ GetDataSize()
| uint32_t cDataChunk::GetDataSize |
( |
| ) |
|
|
inline |
◆ GetHeaderSize()
| int32_t cDataChunk::GetHeaderSize |
( |
| ) |
|
|
protectedvirtual |
◆ GetMaxSize()
| uint32_t cDataChunk::GetMaxSize |
( |
| ) |
|
|
inline |
◆ PopFront()
| bool cDataChunk::PopFront |
( |
uint32_t |
size | ) |
|
◆ PushBack()
| bool cDataChunk::PushBack |
( |
uint8_t * |
d1, |
|
|
uint32_t |
d1Size, |
|
|
uint8_t * |
d2 = NULL , |
|
|
uint32_t |
d2Size = 0 |
|
) |
| |
◆ ReadAdditionalChunkHeader()
| int32_t cDataChunk::ReadAdditionalChunkHeader |
( |
FILE * |
pFile | ) |
|
|
protectedvirtual |
◆ ReadFromFile()
| int cDataChunk::ReadFromFile |
( |
FILE * |
pFile | ) |
|
◆ SetMaxSize()
| void cDataChunk::SetMaxSize |
( |
uint32_t |
maxSize | ) |
|
|
inline |
◆ SetName()
| void cDataChunk::SetName |
( |
const char * |
name | ) |
|
◆ WriteAdditionalChunkHeader()
| int32_t cDataChunk::WriteAdditionalChunkHeader |
( |
FILE * |
pFile | ) |
|
|
protectedvirtual |
◆ WriteToFile()
| int cDataChunk::WriteToFile |
( |
FILE * |
pFile, |
|
|
int |
groupNumber = 0 |
|
) |
| |
◆ m_hdr
The documentation for this class was generated from the following files:


Course Outline: Overview of Software Engineering: history, nature, relation of software engineering to other discipline, software development life cycle, Programming language; Software nature and qualities: product qualities, project qualities, correctness, robustness, usability, maintainability, portability, quality measurements; Software development life cycle: requirement, design, development, testing, maintenance; Software development model: waterfall, agile, spiral, RDD, V model; Software engineering principles: modularity, abstraction, generality, object oriented, component oriented, structured.; Specification and Verification: requirement specification, descriptive specification, testing, analysis, debugging; Modeling and Design: basics of modeling diagram, UI design. Software Project Management: concepts, project metrics, estimation, risks management.


Map with a legend for plotted cities
Alternative content for the map
Alternative content for the legend
All example for jQuery Mapael are available
here
.


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.gatekeeper.controllers._ @import uk.gov.hmrc.gatekeeper.models._ @import uk.gov.hmrc.gatekeeper.config.AppConfig @import uk.gov.hmrc.apiplatform.modules.gkauth.domain.models._ @import uk.gov.hmrc.gatekeeper.controllers.routes @this(main: MainView, applicationConfig: AppConfig) @(unapprovedApis: Seq[APIApprovalSummary])(implicit request: LoggedInRequest[_], loggedInUser: LoggedInUser, messagesProvider: MessagesProvider) @main(title = s"${applicationConfig.title} - API Approval") {


By combining the power of `rem`
and a small JavaScript function to manipulate the `font-size`
of the `html`
element, we can achieve simple but effective parallaxing.
Setting all our positions and parallax movements in CSS, this technique minimises DOM manipulations to just one – on the `html`
element – boosting overall performance, although certainly not better than using 3D transforms.
The speed and direction of each element is set using margins (for this demo I've used `margin-top`
). Play around with the numbers yourself to get a better understanding.
This is just a proof of concept and hasn't been fully tested, though it should work everywhere that supports `rem`
(see here). Using `rem`
in this way does have its pitfalls – most notably the loss of its traditional usage – but it's a nice trick.


Winning numbers drawn in 'Rolling Cash 5' game
by The Associated PressCLEVELAND (AP) _ The winning numbers in Wednesday evening's drawing of the Ohio Lottery's "Rolling Cash 5" game were:
02-08-09-25-33
(two, eight, nine, twenty-five, thirty-three)
CLEVELAND (AP) _ The winning numbers in Wednesday evening's drawing of the Ohio Lottery's "Rolling Cash 5" game were:
02-08-09-25-33
(two, eight, nine, twenty-five, thirty-three)


{% load static %}
Bioshare was developed by the UC Davis Bioinformatics Core and is hosted on Github. Please report any issues to webmaster@example.com.


Inserts a placeholder for a tensor that will be always fed.
tf.compat.v1.placeholder( dtype, shape=None, name=None )
Important: This tensor will produce an error if evaluated. Its value must
be fed using the feed_dict
optional argument to Session.run()
,
Tensor.eval()
, or Operation.run()
.
x = tf.compat.v1.placeholder(tf.float32, shape=(1024, 1024)) y = tf.matmul(x, x) with tf.compat.v1.Session() as sess: print(sess.run(y)) # ERROR: will fail because x was not fed. rand_array = np.random.rand(1024, 1024) print(sess.run(y, feed_dict={x: rand_array})) # Will succeed.
dtype
: The type of elements in the tensor to be fed.shape
: The shape of the tensor to be fed (optional). If the shape is not
specified, you can feed a tensor of any shape.name
: A name for the operation (optional).A Tensor
that may be used as a handle for feeding a value, but not
evaluated directly.
RuntimeError
: if eager execution is enabledPlaceholders are not compatible with eager execution.


Zone 1 - Easy Basic Privacy
Zone 1 is compromised of steps that everyone with a smartphone, tablet, or computer should be taking. These are very basic steps that do not take much time or effort to do and go a very long way in protecting your online identity. Here are the things you should do on your devices to ensure maximum security in zone 1.
Password Manager
1. Make DIFFERENT secure passwords for all your accounts2. NEVER use the same password twice because you're basically saving the hacker some extra work that he would be doing to get into your accounts
3. Test how secure your password using the password tester provided in the links page
4. NEVER answer security question truthfully. Always use random answers and write them down in your password manager
Web Browser
1. Use 2-Factor authentication and if possible use google authenticator, if not use your phone2. You can use any browser in zone 1 BUT turn off any website data collection, cookies, or location trackers
3. Only use trusted add-ons
4. Use a paid VPN not the free ones
Social Media
1. Hide real information on social media2. DO NOT talk to strangers
3. DO NOT post in public comments, that could bring about unwanted attention
4. Disable permissions social media applications do not need such as location, SMS, etc.
5. Limits pictures of yourself
6. Never put in your phone number unless absolutely needed
Smartphones & Computers
1. DO NOT use short pin or easy password. Use a password with letters(upper and lowecase), numbers, and symbols2. Disable setting that send usage data to the app
3. Activate paid VPN
4. Disable bluetooth
5. Remove apps you don't use
Data Privacy Statistics:
1. Every 2 seconds there is a new victim of identity theft.
Nearly 60 million Americans have been affected by identity theft, according to a 2018 online survey by The Harris Poll.
Identity theft causes billions of dollars in total losses. The amount stolen from victims of identity theft was over $16 billion in 2017.


AIADMK sees many queue up for Mayor’s post
by Special CorrespondentA host of former MPs and MLAs belonging to the AIADMK have sought to be nominated for the post of Chennai Mayor.
Former Minister B. Valarmathi; former legislator J.C.D. Prabhakar; former Members of Parliament J. Jayavardhan, N. Balaganga and T.G. Venkatesh Babu and former functionary Adhi Rajaram are among the aspirants, said sources in the AIADMK.
Office-bearers of the party, who received applications from all over the State on Friday, will do so on Saturday too. There are reports that polls to local bodies will be held by the December-end.


package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func main() {
reader := bufio.NewReader(os.Stdin)
fmt.Println("Enter the value n upto your see the sum of series:")
valueofN, _ := reader.ReadString('\n')
valueofN = strings.TrimSpace(valueofN)
intValuneofN, _ := strconv.Atoi(valueofN)
sum := 0
sign := 1
firstTerm := 2
for counter := 1; counter <= intValuneofN; counter++ {
sum = sum + firstTerm
firstTerm = counter * 2 * sign
sign = sign * -1
}
fmt.Println("Sum of series:"sum)
}
//Output
Enter the value n upto your see the sum of series:
500
Sum of series: 502
In this program, we calculate the sum of series 2-4+6-8.....+N
using (for loop). We take the value of 'N'from user as an input
upto which user want the sum of a series.
As an output we calculate the sum a series.
Accordingly to the user input value.


| Module | ActionController::Resources |
| In: |
vendor/rails/actionpack/lib/action_controller/resources.rb
|
ActionController::Resources are a way of defining RESTful resources. A RESTful resource, in basic terms, is something that can be pointed at and it will respond with a representation of the data requested. In real terms this could mean a user with a browser requests an HTML page, or that a desktop application requests XML data.
RESTful design is based on the assumption that there are four generic verbs that a user of an application can request from a resource (the noun).
Resources can be requested using four basic HTTP verbs (GET, POST, PUT, DELETE), the method used denotes the type of action that should take place.
GET Requests for a resource, no saving or editing of a resource should occur in a GET request POST Creation of resources PUT Editing of attributes on a resource DELETE Deletion of a resource
# A GET request on the Posts resource is asking for all Posts GET /posts # A GET request on a single Post resource is asking for that particular Post GET /posts/1 # A POST request on the Posts resource is asking for a Post to be created with the supplied details POST /posts # with => { :post => { :title => "My Whizzy New Post", :body => "I've got a brand new combine harvester" } } # A PUT request on a single Post resource is asking for a Post to be updated PUT /posts # with => { :id => 1, :post => { :title => "Changed Whizzy Title" } } # A DELETE request on a single Post resource is asking for it to be deleted DELETE /posts # with => { :id => 1 }
By using the REST convention, users of our application can assume certain things about how the data is requested and how it is returned. Rails simplifies the routing part of RESTful design by supplying you with methods to create them in your routes.rb file.
Read more about REST at en.wikipedia.org/wiki/Representational_State_Transfer
Creates named routes for implementing verb-oriented controllers for a singleton resource. A singleton resource is global to its current context. For unnested singleton resources, the resource is global to the current user visiting the application, such as a user‘s /account profile. For nested singleton resources, the resource is global to its parent resource, such as a projects resource that has_one :project_manager. The project_manager should be mapped as a singleton resource under projects:
map.resources :projects do |project| project.resource :project_manager end
See map.resources for general conventions. These are the main differences:
For example:
map.resource :account
maps these actions in the Accounts controller:
class AccountsController < ActionController::Base # GET new_account_url def new # return an HTML form for describing the new account end # POST account_url def create # create an account end # GET account_url def show # find and return the account end # GET edit_account_url def edit # return an HTML form for editing the account end # PUT account_url def update # find and update the account end # DELETE account_url def destroy # delete the account end end
Along with the routes themselves, resource generates named routes for use in controllers and views. map.resource :account produces these named routes and helpers:
Named Route Helpers ============ ============================================= account account_url, hash_for_account_url, account_path, hash_for_account_path new_account new_account_url, hash_for_new_account_url, new_account_path, hash_for_new_account_path edit_account edit_account_url, hash_for_edit_account_url, edit_account_path, hash_for_edit_account_path
# File vendor/rails/actionpack/lib/action_controller/resources.rb, line 423 423: def resource(*entities, &block) 424: options = entities.extract_options! 425: entities.each { |entity| map_singleton_resource(entity, options.dup, &block) } 426: end
Creates named routes for implementing verb-oriented controllers for a collection resource.
For example:
map.resources :messages
will map the following actions in the corresponding controller:
class MessagesController < ActionController::Base # GET messages_url def index # return all messages end # GET new_message_url def new # return an HTML form for describing a new message end # POST messages_url def create # create a new message end # GET message_url(:id => 1) def show # find and return a specific message end # GET edit_message_url(:id => 1) def edit # return an HTML form for editing a specific message end # PUT message_url(:id => 1) def update # find and update a specific message end # DELETE message_url(:id => 1) def destroy # delete a specific message end end
Along with the routes themselves, resources generates named routes for use in controllers and views. map.resources :messages produces the following named routes and helpers:
Named Route Helpers ============ ===================================================== messages messages_url, hash_for_messages_url, messages_path, hash_for_messages_path message message_url(id), hash_for_message_url(id), message_path(id), hash_for_message_path(id) new_message new_message_url, hash_for_new_message_url, new_message_path, hash_for_new_message_path edit_message edit_message_url(id), hash_for_edit_message_url(id), edit_message_path(id), hash_for_edit_message_path(id)
You can use these helpers instead of url_for or methods that take url_for parameters. For example:
redirect_to :controller => 'messages', :action => 'index' # and <%= link_to "edit this message", :controller => 'messages', :action => 'edit', :id => @message.id %>
now become:
redirect_to messages_url # and <%= link_to "edit this message", edit_message_url(@message) # calls @message.id automatically
Since web browsers don‘t support the PUT and DELETE verbs, you will need to add a parameter ‘_method’ to your form tags. The form helpers make this a little easier. For an update form with a @message object:
<%= form_tag message_path(@message), :method => :put %>
or
<% form_for :message, @message, :url => message_path(@message), :html => {:method => :put} do |f| %>
or
<% form_for @message do |f| %>
which takes into account whether @message is a new record or not and generates the path and method accordingly.
The resources method accepts the following options to customize the resulting routes:
# products_path == '/productos' map.resources :products, :as => 'productos' do |product| # product_reviews_path(product) == '/productos/1234/comentarios' product.resources :product_reviews, :as => 'comentarios' end
You may directly specify the routing association with has_one and has_many like:
map.resources :notes, :has_one => :author, :has_many => [:comments, :attachments]
This is the same as:
map.resources :notes do |notes| notes.resource :author notes.resources :comments notes.resources :attachments end
# new_products_path == '/productos/nuevo' map.resources :products, :as => 'productos', :path_names => { :new => 'nuevo', :edit => 'editar' }
You can also set default action names from an environment, like this:
config.action_controller.resources_path_names = { :new => 'nuevo', :edit => 'editar' }
Weblog comments usually belong to a post, so you might use resources like:
map.resources :articles map.resources :comments, :path_prefix => '/articles/:article_id'
You can nest resources calls to set this automatically:
map.resources :articles do |article| article.resources :comments end
The comment resources work the same, but must now include a value for :article_id.
article_comments_url(@article) article_comment_url(@article, @comment) article_comments_url(:article_id => @article) article_comment_url(:article_id => @article, :id => @comment)
map.resources :tags, :path_prefix => '/books/:book_id', :name_prefix => 'book_' map.resources :tags, :path_prefix => '/toys/:toy_id', :name_prefix => 'toy_'
You may also use :name_prefix to override the generic named routes in a nested resource:
map.resources :articles do |article| article.resources :comments, :name_prefix => nil end
This will yield named resources like so:
comments_url(@article) comment_url(@article, @comment)
If map.resources is called with multiple resources, they all get the same options applied.
Examples:
map.resources :messages, :path_prefix => "/thread/:thread_id" # --> GET /thread/7/messages/1 map.resources :messages, :collection => { :rss => :get } # --> GET /messages/rss (maps to the #rss action) # also adds a named route called "rss_messages" map.resources :messages, :member => { :mark => :post } # --> POST /messages/1/mark (maps to the #mark action) # also adds a named route called "mark_message" map.resources :messages, :new => { :preview => :post } # --> POST /messages/new/preview (maps to the #preview action) # also adds a named route called "preview_new_message" map.resources :messages, :new => { :new => :any, :preview => :post } # --> POST /messages/new/preview (maps to the #preview action) # also adds a named route called "preview_new_message" # --> /messages/new can be invoked via any request method map.resources :messages, :controller => "categories", :path_prefix => "/category/:category_id", :name_prefix => "category_" # --> GET /categories/7/messages/1 # has named route "category_message"
The resources method sets HTTP method restrictions on the routes it generates. For example, making an HTTP POST on new_message_url will raise a RoutingError exception. The default route in config/routes.rb overrides this and allows invalid HTTP methods for resource routes.
# File vendor/rails/actionpack/lib/action_controller/resources.rb, line 349 349: def resources(*entities, &block) 350: options = entities.extract_options! 351: entities.each { |entity| map_resource(entity, options.dup, &block) } 352: end


#include <sparse_ops.h>
The gradient operator for the SparseAdd op.
The SparseAdd op calculates A + B, where A, B, and the sum are all represented as SparseTensor
objects. This op takes in the upstream gradient w.r.t. non-empty values of the sum, and outputs the gradients w.r.t. the non-empty values of A and B.
Arguments:
[nnz(sum)]
. The gradient with respect to the non-empty values of the sum.indices
of the SparseTensor
A, size [nnz(A), ndims]
.indices
of the SparseTensor
B, size [nnz(B), ndims]
.indices
of the sum SparseTensor
, size [nnz(sum), ndims]
.Returns:
Output
a_val_grad: 1-D with shape [nnz(A)]
. The gradient with respect to the non-empty values of A.Output
b_val_grad: 1-D with shape [nnz(B)]
. The gradient with respect to the non-empty values of B.
Constructors and Destructors |
|
|---|---|
SparseAddGrad(const ::tensorflow::Scope & scope, ::tensorflow::Input backprop_val_grad, ::tensorflow::Input a_indices, ::tensorflow::Input b_indices, ::tensorflow::Input sum_indices)
|
Public attributes |
|
|---|---|
a_val_grad
|
|
b_val_grad
|
|
operation
|
::tensorflow::Output a_val_grad
::tensorflow::Output b_val_grad
Operation operation
SparseAddGrad( const ::tensorflow::Scope & scope, ::tensorflow::Input backprop_val_grad, ::tensorflow::Input a_indices, ::tensorflow::Input b_indices, ::tensorflow::Input sum_indices )


--- layout: page title: Why I like functional programming (with an F# bias) ---
While I would consider myself to be of above average intelligence in certain areas, programming is not one of them. I would say that I am competent but nothing spectacular.
As such I have been able to identify a few areas, in no particular order, where I have been lacking and which are ultimately relevant to why I now prefer functional programming as opposed to OOP.
I got started with programming at a fairly late stage and my exposure to it was mainly during my university days.
During that time, I hated it because I am not a natural for reasons I attribute to the areas I listed above.
As part of my engineering course, I came across programming and really we only had a couple of courses on high level programming and I did struggle with it.
Hence, as it is only human, I neglected it and only did the bare minimum.
I would hack away at code until I would get the desired result and that would be it.
However after I took six months out in industry as part of my course, I came to the realisation that I would have to improve my programming skills.
As a result, I went to the University of Kent at Canterbury on a Computer Science conversion course very similar to this one.
This was a great programme whereby I learned a lot and my basics improved.
After that I started working as a developer mostly with Microsoft technologies and inevitably started using .NET and I have been programming in C# for a fair few years now.
It was maybe 3 years ago that I had anything to do with F# and that was foisted upon me when I had to deal with Fake.
Although it is claimed that it is easy easy for C# developers to pick up FAKE, it certainly was not my experience.
Therefore, I resisted it for a bit but then for a variety of reasons I had to understand FAKE better.
As a result, and having learned from my mistake about not getting solid basics, I started learning F# since FAKE is written using the latter.
While I am still a novice, I much prefer functional programming (F#) to OOP (C#).
For me it boils down to 2 issues:
which are interlinked.
I never realised it before learning about functional programming, but the paradigms upon which a language is based upon forces us to code in a certain way.
However what is more subtle and pernicious is that it also forces us to think a certain way which leads to us to writing complex code.
I have found that with C#, I have to fight with the language in order to do what I want to do as opposed to F#. With the latter I am able to focus more on the business problem at hand.
As developers, we are not only required to code business logic, we are also meant to do so in a maintainable and readable way.
Hence, in the development world, we have come up with the SOLID principles, design patterns, DRY, etc to address the maintenance and readability problem.
However, this is a problem in itself because this requires significant investment and practice.
For instance, when you first encounter the term "Strategy pattern" or "Liskov Substitution Principle", it can be a real slog to stop what you're doing, try to figure the concepts and then applying these concepts.
Moreover, consider the Dependency Inversion Principle whereby in the world of C#, the reference is this book by Steven van Deursen and Mark Seemann. While it is a fine book, I find it quite incomprehensible that we have to spend so much time and effort to learn this in order to address what I consider to be a language issue.
So in effect, we're introducing accidental complexity in order to compensate for language deficiencies.
This is an important one because we are talking about how we will model our solution to problem.
With OOP, we think in terms of Object which have state and behaviour while with functional programming we think in terms of functions.
This fundamental difference is very significant and this also somehow ties in to language.
One of the things that we do as programmers is that we come up with abstractions to structure our software and more often than not we do it in an organic ad-hoc way.
There is no guarantee that our abstractions are correct and they are generally superficial.
However, there is a discipline which is very good with formalising and proving abstractions and that is mathematics, and in particular, a branch of mathematics known as category theory.
The ideas of functional programming come from this discipline and hence why you have ideas such as pure functions i.e. for a bounded set of inputs you always have the same bounded set of outputs.
Hence functional programming builds upon a solid mathematical background in order to build predictable system.
I don't know about you but I much prefer to rely on the power of mathematics to write my system rather than relying on my own brain power.
Someone else has done the heavy lifting and I much rather take advantage of that.
From a language level point of view, there are 2 big items
This is one which is a so called no-brainer. We are often told to favour composition over inheritance.
Well since one of the pillars of OOP is inheritance, it would be fair to say that this main feature of OOP is forcing us to code in a way that will make our application more complex.
However, in OOP to do composition often requires us to perform code gymnastics and learn and apply design patterns thereby forcing us away from solving the business problem and instead come up with abstractions to compose our application.
With programming based upon functional principles, composition is much easier as it is usually built into the language.
Ignore the term "Algebraic sum types" for a minute and consider that in programming, we often have to model choices that we can have.
The classic example that is often given is related to payment.
For instance, we can pay by - Cash - Credit Card - Debit Card - Bit coin
etc
In F# this is trivial but in C# there is significantly more code that we have to write in order to achieve the same thing.
So for instance in pseudo F# we would write
1: 2: 3: 4: 5: |
|
And a customer, again in pseudo F#, would be modelled as:
1: 2: 3: 4: 5: |
|
Then when it came time to pay, we would simply extract the method of payment and based upon each of the latter we'd invoke a different code pathway.
1: 2: 3: 4: 5: 6: 7: 8: |
|
Effectively, you have the "Strategy Pattern" built into the language.
These are but two of the features of functional programming which I have personally found have made my programming life much more enjoyable.
It's a bit like having to write tests. We often do this because we want to gain greater confidence that our code is doing what it's supposed to do.
However, in terms of business logic, the tests are not bringing any value in terms of functionality.
So if you could get away with not writing any test code and still have the same level of confidence in your code, then I am sure you would do so.
This is what I believe Algebraic sum types bring in functional languages such as F#.
With F#, I have found that I have better flow meaning that I am able to concentrate more on solving the business problem rather than technical ones.
With F#, I have suitable building blocks with which I can compose together in a readable and maintainable way.
In fact, I have found that it's much easier and quicker to come back to legacy F# code as compared to C#.
Moreover with F#, I find myself writing less code in a more declarative fashion thanks to the many higher order functions available.
While there is certainly a learning curve to F#, I have found the concepts much more intuitive and straightforward than with C#.
This will be more a stream of consciousness rather than a polished blog which means that I plan on revisiting old posts and improving them when I can.


Table of Contents¶
1 Exploring different doubling tricks for different kinds of regret bounds
1.1 What do we want?
1.2 Dependencies
1.3 Defining the functions \(f\)
1.3.1 Cheating with a “safe” log
1.3.2 Geometric sequences
1.3.3 Exponential sequences
1.3.4 Generic function \(f\)
1.3.5 Some specific case of intermediate sequences
1.4 Defining the sequences and last term
1.4.1 Sequence \(f \mapsto (T_i)_i\)
1.4.2 Last term operator \(T \mapsto L_T\)
1.4.3 Helper for the plot
1.5 Plotting what we want
1.5.1 Plotting the values of the sequences
1.5.2 Plotting the ratio for our upper-bound
1.6 Results
1.6.1 Values of the doubling sequences
1.6.2 Bound in \(R_T \leq \mathcal{O}(\log(T))\)
1.6.3 Bound in \(R_T \leq \mathcal{O}(\sqrt{T})\)
1.6.4 Bound in \(R_T \leq \mathcal{O}(\sqrt{T \log(T)})\)
1.6.5 A last weird bound in \(R_T \leq \mathcal{O}(T^{2/3} \log(T))\) (just to try)
1.7 Conclusions
1.7.1 About geometric sequences
1.7.2 About exponential sequences
1.7.3 About intermediate sequences
Exploring different doubling tricks for different kinds of regret bounds¶
- Author: Lilian Besson and Emilie Kaufmann,
- License: MIT License.
- Date: 19 September 2018.


Hi. Here's the enterprise app.
http://localhost:8080/enterprise.
Here's a picture of the app for you to look at.


About Brandon Little
My History
- Born in Arizona
- Raised in the Pacific Northwest
- Spent 6 years in the US Navy
My Hobbies
My hobbies are varied and many, but generally fall within the construct of nerdy and geeky things. I enjoy playing Dungeons and Dragons, as well as a wide variety of video games in many genres and on several platforms. I enjoy most kinds of music, however I am not a particularly big fan of country music. I am a big fan of red pandas.
I really enjoy random trivia - the more unnecessary and irrelevant, the better! I consider myself to be pretty detail oriented.


Hey I am Ana, I work for Check Into Cash
Here are some of the technologies I enjoy writing day-to-day:
The easiest way to contact me is via e-mail ssambala@gmail.com


Things I created during a 9 year stint of trying to bootstrap my own startup.
In no particular order.
I miss them dearly.
🪦
Fully native macOS app that allows you take notes with the press of a shortcut. Tag if it feels good or bad and review the entries on a daily to yearly basis. Super fast. Could load hundreds of past entries in a few ms. All data was kept locally in an SQLite database.
Manage newsletter, collecting signups, paid subscriptions, selling sponsorship/ad slots. All of that while retaining full ownership. Payments made to your own Stripe account, access to all subscribers at all times. With the option to self host. Basically if you know Substack: That, with the option to self host it all if you wanted to.
Directly sell ad-space on your web properties to businesses without going through intermediaries like Google. Offer available time slots at specific prices business can sign up for to advertise. Review the ads and accept/reject ads based in your needs. Get paid directly to your own Stripe account.
1. Get a feature request about puppies. 2. Reply "Yes we can add puppies" and put<EMAIL_ADDRESS>as BCC recipient. 3. email of sender gets added to sheet under "puppies". Easy as that. Pretty cool! (* defunct, sadly)
A one time mailing list. Let people sign up, and once you're ready to announce your cool thing send one email to everyone on the list and the list self-destructs. Very useful for small announcements, followups multiple people are interested in, or to guarantee the other side they won't be spammed and only contacted about that one thing they signed up for.
Native iOS app to keep track of personal finances. Expenses and income. Group into categories. Quick and easy entry without having to think too much where to put things. Was accompanied with some basic financial tips as a blog.
Track and keep up with movies & tv shows you are watching. Made before trakt.tv was good.
iOS and Android mobile game. The game has you remember a growing list of objects you have to tap in order they first appeared. With bonus difficulties/points earned for having random items in the list hidden during rounds as well as going in reverse at the end.
…and a few more that never became functional at all.
Further tech used in pretty much all projects:
Git, Github, CI/CD, Ubuntu, Linux, Bash/Shell scripts, Ansible, Docker, nginx, Caddy, Photoshop, Sketch, NodeJS,…
❤ 🧡 💛 💚 💙 💜 🖤 🤍 🤎 👋
{{- end -}}


examples/main.ox
or using command line arguments. The latter requires knowing the index of options to code. See the script in /examples/my_estimate_rust_script
. | Public fields | ||
| filename | const | |
| Public methods | ||
| BusData | Create the data object. |
| Public fields | ||
| hat | static | list of parameter estimates. |
| Public methods | ||
| SetUp | static | Setup the DP model and first stage estimation. |
| Utility | Return U() at estimated (hat) parameter values. |
| Public fields | ||
| buses | static | bus data as a DataSet. |
| EMax | static | Value function iteration method. |
| mle | static | Optimization algorithm applied to nfxp. |
| nfxp | static | Panel Black Box objective using buses data. |
| plist | static | Parameter lists by stage. |
| targ | static | OxMenu menu for setting parameters interactively. |
| Public methods | ||
| menu | static | Creates the interactive menu items for choosing method, table, column, and row to replicate. |
| Run | static | Replicate bus estimation. |
| SetTarget | static | Get runtime options from the command line or through the interactive menu. |
RustEmet1987readdata2022.ox
This creates a OutcomeDataSet, which is a Panel of individual outcome with econometric objectives
and data-matching methods available.
hat) parameter values. This uses the same basic utility by setting the parameter values to the current values of estimated parameters.7


Preston choir to battle it out on TV for title of Gospel Choir of the Year
by Catherine MusgrovePreston’s One Voice Community Choir will battle it out on television this weekend for the title of Gospel Choir of the Year.
The choir, which formed 18 years ago and has a 70-strong membership, is one of four outfits performing over two episodes of Songs of Praise on BBC 1.
The performances were pre-recorded, and although the choir won’t reveal whether they won or not, they can reveal that on the first show they sing How Excellent, and on the second show they sing Down By The Riverside.
Louise Gooch, spokesperson for the choir, said: “We submitted a video for the competition in the summer and then were invited to film down in Reading after we were shortlisted.
“We were in the finals in 2013 and have followed the competition since it was launched. It’s a brilliant thing to be involved in. All the choirs mix together backstage and sing together. It’s a really nice atmosphere.
“In fact we all sang a song together on stage as part of the show, and I’m keen to see that back.”
To get competition-ready, the choir undertook workshops with well-known conductor Ken Burton.
The televised performances had a special significance as they were conducted musical director Tyndale Thomas, who has been unable to undertake the duty recently because of ill health.
Louise said: “What makes us special is the people who make up the choir, we’re like a family. That really comes across in our performances.
“Tyndale also likes to get the audience involved, getting them standing up and singing.”
Watch the choir on BBC1 from 1.15pm on Sunday, November 17 and 24.
About the choir:
The choir was set up 18 years ago, initially as a six-month project, but now has around 70 members and a waiting list.
Members are from a range of different backgrounds and ages, with some travelling from Yorkshire to take part.
Rehearsals take place at Priory Technology College in Penwortham, and the choir describe their music as “a blend of gospel and inspirational classics, with contemporary and original compositions.”
Achievements include being finalists in the BBC Gospel Choir of the year, recording the BBC Children In Need song for Lancashire and performing for the Queen.