{% extends "appfx:base_with_app_bar.html" %} {% load splunkui %} {% block title %}{{app_name}} Home Page{% endblock title %} {% block css %} {% endblock css %} {% block content %}
This app has multiple examples. Each one illustrates one task that is possible in the Application Framework. You can see how the examples behave, and then look at the underlying code for each example.
You'll find the code at $APPFX_HOME/server/apps/examples/templates
.
To try the examples, choose options from the menus at the top of this page.


public interface LocalTransaction
javax.resource.spi
package) is used by the container
for local transaction management.
A local transaction is managed internal to a resource manager. There is no external transaction manager involved in the coordination of such transactions.
A CCI implementation can (but is not required to) implement the
LocalTransaction interface. If the LocalTransaction interface is supported
by a CCI implementation, then the method
Connection.getLocalTransaction
should return a
LocalTransaction instance. A component can then use the
returned LocalTransaction to demarcate a resource manager local transaction
(associated with the Connection instance) on the underlying EIS
instance.
Connection
| Modifier and Type | Method and Description |
|---|---|
void |
begin()
Begins a local transaction on an EIS instance.
|
void |
commit()
Commits the current local transaction and release all locks held
by the underlying EIS instance.
|
void |
rollback()
Rollbacks the current resource manager local transaction.
|
void begin() throws ResourceException
ResourceException
- Failed to begin a local
transaction. Examples of
error cases are:
void commit() throws ResourceException
ResourceException
- Failed to commit a local
transaction. Examples of
error cases are:
void rollback() throws ResourceException
ResourceException
- Failed to rollback a local
transaction. Examples of
error cases are:


|
| | PIDF (double kP, double kD) |
| |
| | PIDF (double kP, double kI, double kD, double iMax) |
| |
| | PIDF (double kP, double kI, double kD, double kF, double dT, double iMax) |
| |
| void | reset () |
| |
| void | enable () |
| |
| void | disable () |
| |
| void | setPoint (double setPoint) |
| |
| void | setPID (double kP, double kI, double kD) |
| |
| void | setPIDF (double kP, double kI, double kD, double kF) |
| |
| double[] | getPID () |
| |
| double | update (double input) |
| |
| double | getError () |
| |
| void | setContinuous (boolean continuous) |
| |
| void | setInputRange (double minimumInput, double maximumInput) |
| |
| boolean | onTarget (double epsilon) |
| |
|
| static double | clamp (double value, double low, double high) |
| |
◆ PIDF() [1/3]
| frc.lib.drivers.PIDF.PIDF |
( |
double |
kP, |
|
|
double |
kD |
|
) |
| |
◆ PIDF() [2/3]
| frc.lib.drivers.PIDF.PIDF |
( |
double |
kP, |
|
|
double |
kI, |
|
|
double |
kD, |
|
|
double |
iMax |
|
) |
| |
◆ PIDF() [3/3]
| frc.lib.drivers.PIDF.PIDF |
( |
double |
kP, |
|
|
double |
kI, |
|
|
double |
kD, |
|
|
double |
kF, |
|
|
double |
dT, |
|
|
double |
iMax |
|
) |
| |
Complete PIDF constructor
- Parameters
-
| kP | |
| kI | |
| kD | |
| kF | Not yet implemented |
| dT | discrete time step for control loop |
| iMax | maximum integral windup |
◆ clamp()
| static double frc.lib.drivers.PIDF.clamp |
( |
double |
value, |
|
|
double |
low, |
|
|
double |
high |
|
) |
| |
|
staticprivate |
◆ disable()
| void frc.lib.drivers.PIDF.disable |
( |
| ) |
|
Stops the PID from returning a nonzero output
◆ enable()
| void frc.lib.drivers.PIDF.enable |
( |
| ) |
|
Allows the PID controller to return a nonzero output
◆ getContinuousError()
| double frc.lib.drivers.PIDF.getContinuousError |
( |
double |
error | ) |
|
|
protected |
Wraps error around for continuous inputs. The original error is returned if continuous mode is disabled.
- Parameters
-
| error | The current error of the PID controller. |
- Returns
- Error for continuous inputs.
◆ getError()
| double frc.lib.drivers.PIDF.getError |
( |
| ) |
|
◆ getPID()
| double [] frc.lib.drivers.PIDF.getPID |
( |
| ) |
|
◆ onTarget()
| boolean frc.lib.drivers.PIDF.onTarget |
( |
double |
epsilon | ) |
|
◆ reset()
| void frc.lib.drivers.PIDF.reset |
( |
| ) |
|
Resets values internal to the PID back to their default states. Also disables the PID if it was currently in use within the software
◆ setContinuous()
| void frc.lib.drivers.PIDF.setContinuous |
( |
boolean |
continuous | ) |
|
Sets the PID to use a continuous mode calculation that makes both ends of the range effectively the same point !!!YOU MUST MAKE SURE TO SET THE RANGE IF YOU USE THIS MODE!!!
- Parameters
-
◆ setInputRange()
| void frc.lib.drivers.PIDF.setInputRange |
( |
double |
minimumInput, |
|
|
double |
maximumInput |
|
) |
| |
Sets the min am maxium values defining the input range for this PID controller. Only needed for continuous PIDs
- Parameters
-
| minimumInput | |
| maximumInput | |
◆ setPID()
| void frc.lib.drivers.PIDF.setPID |
( |
double |
kP, |
|
|
double |
kI, |
|
|
double |
kD |
|
) |
| |
Sets the P, I and D gains
- Parameters
-
◆ setPIDF()
| void frc.lib.drivers.PIDF.setPIDF |
( |
double |
kP, |
|
|
double |
kI, |
|
|
double |
kD, |
|
|
double |
kF |
|
) |
| |
◆ setPoint()
| void frc.lib.drivers.PIDF.setPoint |
( |
double |
setPoint | ) |
|
◆ update()
| double frc.lib.drivers.PIDF.update |
( |
double |
input | ) |
|
Returns the current calculated output of this PID based on the current position
- Parameters
-
- Returns
- calculated motor power to apply (%)
◆ calculationMutex
| ReentrantLock frc.lib.drivers.PIDF.calculationMutex |
|
protected |
◆ continuous
| boolean frc.lib.drivers.PIDF.continuous |
|
protected |
◆ DEFAULT_DT
| final double frc.lib.drivers.PIDF.DEFAULT_DT = 0.010 |
|
staticprotected |
◆ error
| double frc.lib.drivers.PIDF.error |
|
protected |
◆ kP
| double frc.lib.drivers.PIDF.kP = 0 |
|
protected |
The documentation for this class was generated from the following file:
- RobotCode/src/main/java/frc/lib/drivers/PIDF.java


R is a programming language for statistical computing, and data wrangling. It is open-source, widely used in data science, has a wide range of functions and algorithms for graphing and data analyses.
We will use R in this course for generating plots from different biological data that are of higher quality and standard for publications. To do this, you will brush-up your memory on some important aspects of R that are important for this course below:
Before starting with the lab sessions of the entire course, you must have downloaded all the necessary files from here and make sure that the directory tree looks similar to the one displayed in that page
In that case, you can proceed with the exercise now and remember to have fun :)
Input and output of data and images is an important aspect with data analysis.
Data can come in a variety of formats which needs to be read into R and converted to an R data type.
Text files are the most commonly used input. Text files can be read in using the function read.table
. We have a sample file to use: iris.txt.
This reads in a tab-delimited text file with a header. The argument sep='\t'
is set by default to specify that the delimiter is a tab. stringsAsFactors=F
setting ensures that character columns are not automatically converted to factors.
It’s always a good idea to check the data after import.
output
## Sample_ID Sample_Name Time Replicate Cell
## 1 Sample_1 t0_A t0 A A431
## 2 Sample_2 t0_B t0 B A431
## 3 Sample_3 t0_C t0 C A431
## 4 Sample_4 t2_A t2 A A431
## 5 Sample_5 t2_B t2 B A431
## 6 Sample_6 t2_C t2 C A431
output
## 'data.frame': 12 obs. of 5 variables:
## $ Sample_ID : chr "Sample_1" "Sample_2" "Sample_3" "Sample_4" ...
## $ Sample_Name: chr "t0_A" "t0_B" "t0_C" "t2_A" ...
## $ Time : chr "t0" "t0" "t0" "t2" ...
## $ Replicate : chr "A" "B" "C" "A" ...
## $ Cell : chr "A431" "A431" "A431" "A431" ...
Check ?read.table
for other wrapper functions to read in text files.
Let’s filter this data.frame and create a new data set.
And we can write this as a text file.
sep="\t"
sets the delimiter to tab. row.names=F
denotes that rownames should not be written. quote=F
specifies that doubles must not be placed around strings.
You have probably learnt about data.frame
in your previous course and this is the most important data structure for generating plots using ggplot
. So, below you have some quick exercises on how to work with Data-Frames.
Vectors positions can be accessed using []
. R follows 1-based indexing, meaning that the indexing starts at 1.
Data-frame or matrix positions can be accessed using []
specifying row and column like [row,column]
.
output
## x y
## 1 1 a
## 2 2 b
## 3 3 c
## x y
## 1 1 a
## [1] 1 2 3
## [1] b
## Levels: a b c
The function cbind()
is used to join two data-frames column-wise.
dfr1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
dfr2 <- data.frame(p = 4:6, q = c("d", "e", "f"))
dfr1
dfr2
cbind(dfr1,dfr2)
output
## x y
## 1 1 a
## 2 2 b
## 3 3 c
## p q
## 1 4 d
## 2 5 e
## 3 6 f
## x y p q
## 1 1 a 4 d
## 2 2 b 5 e
## 3 3 c 6 f
Similarly, rbind()
is used to join two data-frames row-wise.
dfr1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
dfr2 <- data.frame(x = 4:6, y = c("d", "e", "f"))
dfr1
dfr2
rbind(dfr1,dfr2)
output
## x y
## 1 1 a
## 2 2 b
## 3 3 c
## x y
## 1 4 d
## 2 5 e
## 3 6 f
## x y
## 1 1 a
## 2 2 b
## 3 3 c
## 4 4 d
## 5 5 e
## 6 6 f
Two data-frames can be merged based on a shared column using the merge()
function.
dfr1 <- data.frame(x = 1:4, p = c("a", "b", "c","d"))
dfr2 <- data.frame(x = 3:6, q = c("l", "m", "n","o"))
dfr1
dfr2
merge(dfr1,dfr2,by="x")
merge(dfr1,dfr2,by="x",all.x=T)
merge(dfr1,dfr2,by="x",all.y=T)
merge(dfr1,dfr2,by="x",all=T)
output
## x p
## 1 1 a
## 2 2 b
## 3 3 c
## 4 4 d
## x q
## 1 3 l
## 2 4 m
## 3 5 n
## 4 6 o
## x p q
## 1 3 c l
## 2 4 d m
## x p q
## 1 1 a <NA>
## 2 2 b <NA>
## 3 3 c l
## 4 4 d m
## x p q
## 1 3 c l
## 2 4 d m
## 3 5 <NA> n
## 4 6 <NA> o
## x p q
## 1 1 a <NA>
## 2 2 b <NA>
## 3 3 c l
## 4 4 d m
## 5 5 <NA> n
## 6 6 <NA> o
In terms of the R (and other similar programming languages), the data can be viewed or stored in two main formats! They are called wide
and long
formats. Below you will see what exactly they stand for and why is it important for plotting in ggplot.
A quick preview:
Counts Table
| Sample_1 | Sample_2 | Sample_3 | Sample_4 | |
|---|---|---|---|---|
| ENSG00000000003 | 321 | 303 | 204 | 492 |
| ENSG00000000005 | 0 | 0 | 0 | 0 |
| ENSG00000000419 | 696 | 660 | 472 | 951 |
| ENSG00000000457 | 59 | 54 | 44 | 109 |
| ENSG00000000460 | 399 | 405 | 236 | 445 |
| ENSG00000000938 | 0 | 0 | 0 | 0 |
And we usually have our metadata related to the samples in another table like below:
Metadata Table
| Sample_ID | Sample_Name | Time | Replicate | Cell |
|---|---|---|---|---|
| Sample_1 | t0_A | t0 | A | A431 |
| Sample_2 | t0_B | t0 | B | A431 |
| Sample_3 | t0_C | t0 | C | A431 |
| Sample_4 | t2_A | t2 | A | A431 |
Below is glimpse how the long format of the same data look like:
| Gene | Samples | count |
|---|---|---|
| ENSG00000000003 | Sample_1 | 321 |
| ENSG00000000005 | Sample_1 | 0 |
| ENSG00000000419 | Sample_1 | 696 |
| ENSG00000000457 | Sample_1 | 59 |
| ENSG00000000460 | Sample_1 | 399 |
| ENSG00000000938 | Sample_1 | 0 |
| ENSG00000000003 | Sample_2 | 303 |
| ENSG00000000005 | Sample_2 | 0 |
| ENSG00000000419 | Sample_2 | 660 |
| ENSG00000000457 | Sample_2 | 54 |
Or to be even more complete and precise:
| Sample_ID | Sample_Name | Time | Replicate | Cell | Gene | count |
|---|---|---|---|---|---|---|
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000003 | 321 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000005 | 0 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000419 | 696 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000457 | 59 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000460 | 399 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000938 | 0 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000003 | 303 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000005 | 0 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000419 | 660 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000457 | 54 |
As for the biological data analysis, to be able to use tools such as ggplot, in simple terms we should learn to convert our data:
As per our previous examples: We should learn to convert
From this format
| Sample_1 | Sample_2 | Sample_3 | Sample_4 | |
|---|---|---|---|---|
| ENSG00000000003 | 321 | 303 | 204 | 492 |
| ENSG00000000005 | 0 | 0 | 0 | 0 |
| ENSG00000000419 | 696 | 660 | 472 | 951 |
| ENSG00000000457 | 59 | 54 | 44 | 109 |
| ENSG00000000460 | 399 | 405 | 236 | 445 |
| ENSG00000000938 | 0 | 0 | 0 | 0 |
To this format
| Sample_ID | Sample_Name | Time | Replicate | Cell | Gene | count |
|---|---|---|---|---|---|---|
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000003 | 321 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000005 | 0 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000419 | 696 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000457 | 59 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000460 | 399 |
| Sample_1 | t0_A | t0 | A | A431 | ENSG00000000938 | 0 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000003 | 303 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000005 | 0 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000419 | 660 |
| Sample_2 | t0_B | t0 | B | A431 | ENSG00000000457 | 54 |
Here we will only cover the conversion from wide
to long
, as this is more relevant to us. For the other way around, one can look into spread()
from the tidyr
package.
By using the melt()
function from the reshape2 package we can convert the wide-formatted data into long-formatted data! Here, to combine the metadata table to the gene counts table, we will also use the merge()
function like we did before!
library(reshape2)
gc <- read.table("data/counts_raw.txt", header = T, row.names = 1, sep = "\t")
md <- read.table("data/metadata_raw.csv", header = T, sep = ";")
rownames(md) <- md$Sample_ID
#merging gene counts table with metadata
merged_data_wide <- merge(md, t(gc), by = 0)
#removing redundant columns
merged_data_wide$Row.names <- NULL
merged_data_long <- melt(merged_data_wide, id.vars = c("Sample_ID","Sample_Name","Time","Replicate","Cell"), variable.name = "Gene", value.name = "count")
head(merged_data_long)
output
## Sample_ID Sample_Name Time Replicate Cell Gene count
## 1 Sample_1 t0_A t0 A A431 ENSG00000000003 321
## 2 Sample_10 t24_A t24 A A431 ENSG00000000003 950
## 3 Sample_11 t24_B t24 B A431 ENSG00000000003 760
## 4 Sample_12 t24_C t24 C A431 ENSG00000000003 1436
## 5 Sample_2 t0_B t0 B A431 ENSG00000000003 303
## 6 Sample_3 t0_C t0 C A431 ENSG00000000003 204
If you are more familiar with using tidyverse
or tidyr
packages, you can combine tables by join()
and then use gather()
to make long formatted data in the same command. This is a powerful and more cleaner way of dealing with data in R.
library(tidyverse)
gc_long <- gc %>%
rownames_to_column(var = "Gene") %>%
gather(Sample_ID, count, -Gene) %>%
full_join(md, by = "Sample_ID") %>%
select(Sample_ID, everything()) %>%
select(-c(Gene,count), c(Gene,count))
gc_long %>%
head(10)
output
## Sample_ID Sample_Name Time Replicate Cell Gene count
## 1 Sample_1 t0_A t0 A A431 ENSG00000000003 321
## 2 Sample_1 t0_A t0 A A431 ENSG00000000005 0
## 3 Sample_1 t0_A t0 A A431 ENSG00000000419 696
## 4 Sample_1 t0_A t0 A A431 ENSG00000000457 59
## 5 Sample_1 t0_A t0 A A431 ENSG00000000460 399
## 6 Sample_1 t0_A t0 A A431 ENSG00000000938 0
## 7 Sample_1 t0_A t0 A A431 ENSG00000000971 0
## 8 Sample_1 t0_A t0 A A431 ENSG00000001036 844
## 9 Sample_1 t0_A t0 A A431 ENSG00000001084 535
## 10 Sample_1 t0_A t0 A A431 ENSG00000001167 493
Task Here in this exercise we have used the counts_raw.txt
file, you can try to make similar R objects for each of the other three counts (counts_filtered.txt
, counts_vst.txt
and counts_deseq2.txt
) in long format
. So for example you would have gc_filt
, gc_vst
and gc_deseq2
R objects in the end.
Tip Remember to take a look at how these files are formatted, before you import!
Much of the data format explanations and exercises were obtained from the GitHub of Eric C. Anderson
?function
to get function documentation??bla
to search for a functionargs(function)
to get the arguments to a function## R version 3.6.3 (2020-02-29)
## Platform: x86_64-pc-linux-gnu (64-bit)
## Running under: Ubuntu 20.04.1 LTS
##
## Matrix products: default
## BLAS: /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.9.0
## LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.9.0
##
## locale:
## [1] LC_CTYPE=en_US.UTF-8 LC_NUMERIC=C
## [3] LC_TIME=en_US.UTF-8 LC_COLLATE=en_US.UTF-8
## [5] LC_MONETARY=en_US.UTF-8 LC_MESSAGES=en_US.UTF-8
## [7] LC_PAPER=en_US.UTF-8 LC_NAME=C
## [9] LC_ADDRESS=C LC_TELEPHONE=C
## [11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C
##
## attached base packages:
## [1] stats graphics grDevices utils datasets methods base
##
## other attached packages:
## [1] reshape2_1.4.4 kableExtra_1.1.0 forcats_0.5.0 stringr_1.4.0
## [5] purrr_0.3.4 readr_1.3.1 tidyr_1.1.2 tibble_3.0.4
## [9] ggplot2_3.3.2 tidyverse_1.3.0 dplyr_1.0.2 captioner_2.2.3
## [13] bookdown_0.20 knitr_1.29
##
## loaded via a namespace (and not attached):
## [1] tidyselect_1.1.0 xfun_0.18 haven_2.3.1 colorspace_1.4-1
## [5] vctrs_0.3.4 generics_0.0.2 htmltools_0.5.0 viridisLite_0.3.0
## [9] yaml_2.2.1 blob_1.2.1 rlang_0.4.8 pillar_1.4.6
## [13] glue_1.4.2 withr_2.3.0 DBI_1.1.0 dbplyr_1.4.4
## [17] modelr_0.1.8 readxl_1.3.1 plyr_1.8.6 lifecycle_0.2.0
## [21] munsell_0.5.0 gtable_0.3.0 cellranger_1.1.0 rvest_0.3.6
## [25] evaluate_0.14 fansi_0.4.1 highr_0.8 broom_0.7.0
## [29] Rcpp_1.0.5 scales_1.1.1 backports_1.1.10 webshot_0.5.2
## [33] jsonlite_1.7.1 fs_1.5.0 hms_0.5.3 digest_0.6.27
## [37] stringi_1.5.3 grid_3.6.3 cli_2.1.0 tools_3.6.3
## [41] magrittr_1.5 crayon_1.3.4 pkgconfig_2.0.3 ellipsis_0.3.1
## [45] xml2_1.3.2 reprex_0.3.0 lubridate_1.7.9 assertthat_0.2.1
## [49] rmarkdown_2.3 httr_1.4.2 rstudioapi_0.11 R6_2.5.0
## [53] compiler_3.6.3
End of document


This challenge is designed to test your ability to recall a hand sign from memory rather than your ability to replicate a sign from an image.
To begin, decide which letter you want to practice and place one hand over the Leap Motion Device to see it displayed on the screen.
Next, attempt to make the correct sign and run a test by pressing the letter that you chose on the keyboard.
Feel free to perform multiple trials of different letters!
Your feedback will appear here.


--- layout: page title: About header-img: "img/about-bg.png" ---
I'm an award winning and professional mixologist who decided she wanted more.


Aussies were developed on ranches in the western United States, and were seen as early as the 1800s. These pups are very focused, and need lots of attention, pawsitive reinforcement, and exercise. They can still be found working on the ranch, but also work as guide dogs, therapy dogs, drug detectors, and of course, man’s best friend. People often seek them out for their incredibly strong hunting abilities. They are excellent swimmers, too, so a nice lake or pool is A-OK! However, they do require regular exercise and would fit best with an active family.


Kanri
Kanri (lit. management) is a minimalist authorization framework inspired by others such as Kan and Pundit. It aims to accomplish most basic authorization tasks in as simple a manner as possible, without sacrificing functionality.
Installation
Add this line to your application's Gemfile:
gem 'kanri', git: 'https://github.com/Co-Chu/Kanri'
And then execute:
$ bundle
Usage
Kanri authorizes actions based on roles defined in a class. For example:
class SomeClass
include Kanri
role :admin do
detect { |user, _| user.admin? }
can :edit, Object
end
role :anyone do
can :read, Object
end
end
some_obj = SomeClass.new
some_obj.can?(:edit, some_object, user: some_admin) # => true
Role names are not currently used for anything in particular other than adding a readable tag to the permissions group.
Contributing
Bug reports and pull requests are welcome at Kanri on GitHub. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
License
The gem is available as open source under the terms of the MIT License.
Code of Conduct
Everyone interacting in the Kanri project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.


Select probe and marker:
Parsed Genotypes for probe , marker
Parsed phenotypes and lods for probe
Raw JSON for Pheno/Geno/individual for probe , marker
Raw Markers/LODs/gene for probe


26 February 2003
Disease Outbreak Reported
As of 25 February 2003, a total of 5 laboratory-confirmed and 90 probable cases, including 77 deaths (case fatality rate 81%) from Ebola haemorrhagic fever, has been reported in the districts of Mbomo and Kellé in Cuvette Ouest Region ( see previous report ).
Experts in clinical management and a logistician have joined the international team from the Global Outbreak Alert and Response Network, the Congolese Ministry of Health and WHO. Isolation wards have been set up in Kellé and Mbomo Hospitals, and are receiving patients.


 It will
pretty-format your HTML, fix many HTML problems, diagnose difficult problems,
and generally make your HTML much, much better.
- Starting Balthisar Tidy for the First Time
- The first time you start Balthisar Tidy, your computer may ask for permission.
- Start Using Balthisar Tidy
- A step-by-step walkthrough to getting started with Balthisar Tidy.
- Balthisar Tidy Use Cases
- Why do I want to use Balthisar Tidy anyway?
- How do I…?
- How to accomplish common tasks with Balthisar Tidy.
- Use Advanced Features of Balthisar Tidy
- Discover some of Balthisar Tidy for Work’s advanced features..
- Reference
- An overall reference to Balthisar Tidy.
- Presenting Balthisar Tidy for Work
- Balthisar Tidy for Work adds advanced capabilities to Balthisar Tidy.
- Credits and Acknowledgements
- Find out whom else Balthisar Tidy owes thanks to.
- Support and Bug Reports
- A step-by-step walkthrough to getting started with Balthisar Tidy.
Get the latest news about Balthisar Tidy at balthisar.com,
or write to us at balthisar@balthisar.com.


RETRO-GMAER-QUIZ
☘☘ GOOD LUCK ☘☘
🤔🤔 HMMMM 🤔🤔
🔥😎 TOO COOL 😎🔥
😨😨 OH NO! 😨😨
GAME OVER
You have died of
reasons
Question
Answer 1
Answer 2
Answer 3
Answer 4
Save
START QUIZ
NEXT QUESTION
PLAY AGAIN?


Eight: Ski Free Yeti Chase
On February 23, Crystal Mountain was getting dumped with snow. We were there, ready to shred, but found that most of the mountain was closed for avalanche control. Weak!
Unwilling to give up on a powder day, my brother-in-law Mike and I hiked up a slope to earn a few fresh turns. My wife, Chelsea, videotaped for evidence.

To make up for this atrocious skiing, I decided to spice up the footage with some classic Ski Free-inspired terror. Having never used them before, I learned a bit of Adobe Premier Pro and Adobe After Effects to give the Abominable Snow Monster life. Much more exciting!


Welcome to use ZKWeb MVVM Demo
Before start development, please read following pages:
Github: https://github.com/zkweb-framework/ZKWeb.MVVMDemo
Documents: https://github.com/zkweb-framework/ZKWeb.MVVMDemo/docs
If you have any question during development please submit an issue or join QQ group 522083886 to ask.


iron-page-url won't add extraneous entries to the browser's history when changes come in quick succession.
A new history entry will only be added if iron-query-url stays in the same state longer than dwellTime.


She claimed that standing in a particular pose for 2 minutes a day could make you more successful. This became known as the power pose.
Field study
Her claims were based on a field study she conducted which measured self-reported feelings of power, observed risk taking + cortisol and testosterone levels from a sample of 42. Participants stood in two poses for a minute each - half in power poses, the others in non-power (weak) poses.
High power poses
Her study claimed that holding the power pose was like super power, giving you a physical and psychological edge in all kids of high stress circumstances, like negotiations and job titles.
Low power poses
For a few years the power pose was catnip to corporate and boardroom types. all sorts of c-suites and execs were known to strike a pose to improve their success.
Reproducibility crisis
Meanwhile in Nov 2011 a movement kicked off challenging the status quo in science. A number of scientists were worried about the quality of results getting published, and asking whether enough work is being done to independently validate results.
Reproducibility project
Brian Nosek of Open Science Foundation U of Virginia wanted to try to reproduce published studies to see if they could replicate the effects. This issue has been raised before. Feynman 1970s - Cargo Cult lecture.
You'll never believe what happened when scientists attempted to replicate 100 experiments...
Just wait til you see their results
Psychologists tried to recreate 100 studies, all published recently in academic journals. the group went through extensive measures to remain true to the original studies, to the extent of consulting the original authors
"97% of the original results showed a statistically significant effect, this was reproduced in only 36% of the replication attempts"
digest.bps.org.uk
Their results were pretty poor.
And then this happened...
About a year after her viral TED fame, another researcher tried to replicate Amy Cuddy's results
This study failed to reproduce her findings on hormone changes with 4x the sample size. Her research partner Carney publically disavowed the work. Then everyone rushed to dubunk it.
What's to blame?
"Publish or perish"
No replication studies
Clickbait
Bad incentives! Scientific research in it's worst form: shitty, low-powered studies designed to be over-stated as click-bait titles and turned into scientific CV catnip
Sound similar to UXR?
"Prove me right"
Demanding shortcuts
Preferring 'hard data' over qual data
Bad incentives and a culture not set up for learning. Thinking numbers are more 'clean' or less biased than qual data.
UXR has different goals to Science
True. Maybe reproducibility isn't the goal. but it's good to know whats happening.
Science
Chipping away at the crystal of knowledge
Scientific research: in it's purest form, a pursuit to chip off a small shard off the crystal of knowledge
UXR
Reducing business risk
UX research: in it's purest form, a pursuit to reduce risk and help a team intimately understand the people using their product
So does reproducibility even matter in UXR?
Well yes...
we are
Science lite
Said with ❤
design thinking, double diamond, build-measure-learn loop, UX research - all inspired by the scientific method. Important to see what's happening in science as that's where we draw our legitimacy from.
Debunked ideas
Also great to keep in mind that we have lots of science 'truths' which are now debunked - don't want them to leak into our work accidentally
Method/problem mismatches
Make the hard problem of internal buy-in harder
UX Research is plagued by overgeneralisation and mismatches in tool / problem space. It's incredibly important to be specific about the things you can learn from any given research method
So, should UX Research be reproducible?
My answer is...
Sometimes!*
* It depends
It depends on what you mean by reproducibility
At least three levels to reproducibility
1. Experiment design
Model & Methodology
Sample size
Sample selection
Can I reproduce your experiment? As in methodology, model, sample set, sample size, research variables, etc
2. Data captured
Do I get equivalent results? As in raw data
3. Interpretation
Do I interpret the data the same way? As in do I draw the same conclusions from the raw data
UX Research types
Qualitative -vs- Quantitative
Depending on the type of research, we may not even be striving for 'statistical significance'
With Qual at least, we aren't striving for statistical significance and the question of reproducibility goes out the window.
Qualitative
Experiment design ✔
Data captured ×
Interpretation ×
So when we capture small data samples and deep dive qualitative data, we don't expect to reproduce the same exact results because PEOPLE
Quantitative
Experiment design ✔
Data captured ✔
Interpretation ✔
Hopefully 🤞
But when we are doing AB tests or data driven tests into engagement, we should theoretically expect to be able to reproduce all aspects of that test
How do we do it better?
Get inspired by the Open Science movement
Within the constraints of our current workplaces...
  See how they're different and plugging the same results in to different tools will tell you different things.
nngroup.com/articles/which-ux-research-methods/
Reminder: we have this big world of research methods! We don't have to have statistical significance to learn something, or to decide what to try next. And thinking about getting better at research will help us navigate with more agility.
Embrace uncertainty
Like a scientist
Avoid speaking in absolutes
Cultivate your curiousity
Reward "I don't know"
Science is Moving towards certainty, but never 100% there.
Define your study before you start
"Preregistration". Is it qual or quant? Are you looking for statistical significance or not?
Plan for no conclusion (unclear results)
a null result is a result without the expected content: that is, the proposed result is absent. Regardless of your study type, sometimes the result will be that you don't know! Even with qual data sometimes you'll have lots of scattered signals but no clear signal from the noise. And just because you can't reject the null hypothesis doesn't mean you've proven it either.
Replication studies
Start by identifying a good candidate study
So replication studies - doing the same study again - helps us be more confident in the results.
Good
expect the effect to be consistent over time
the hypothesis is important to business model functioning
product has been consistent since last study
Poor
don't expect the effect to be consistent
low risk to business model or low business priority
UX or UI in flux; too many variables to control for
Can be qual or quant. Does this effect or assumption have to remain in order for the business model to survive? Most quant testing will be hard to replicate and expect the same results- you might learn new things though. and this won't necessarily debunk the earlier results, you just won't be able to match them because of the changes that have happened.
Qual data
Consider trying synthesis and interpretation with multiple groups of researchers
- interpretation by the people who didn't collect the data
- needs experienced UXR people
- compare summaries / proposed next steps
- mismatch could be an opportunity to learn
Fact check
Learn to read references
Paper abstract is a good start
Develop your sniff test
When you're reading or watching the news, actually look for and check the science citation! Learn to read scientific papers. Tell story about + 40% GDPR - adelaide uni ML brochure - if time allows.
Open UX...?
* open data * open results * open methods * share research templates * FOSS style? Make skill guilds across businesses? Peer review each other's research? Do meta studies? Come talk to me after and let's discuss.
Continuous discovery...?
visualising what we know over time. change points. discovery points. a resource for the entire team and a different way of thinking about building a body of knowledge.
Recommendations
Build culture for continuous learning
Embrace uncertainty
Replication studies (maybe)
Spend more time on research design & analysis
Uncertain results are ok


Gecode::Set::SingletonView Class Reference
[Set views]
Singleton set view. More...
#include <view.hpp>
Static Protected Member Functions | |
| static PropCond | pc_settoint (PropCond pc) |
| Convert set variable PropCond pc to a PropCond for integer variables. | |
| static ModEvent | me_inttoset (ModEvent me) |
| Convert integer variable ModEvent me to a ModEvent for set variables. | |
| static ModEvent | me_settoint (ModEvent me) |
| Convert set variable ModEvent me to a ModEvent for integer variables. | |
Related Functions | |
(Note that these are not member functions.) | |
| template<class Char , class Traits > | |
| std::basic_ostream< Char, Traits > & | operator<< (std::basic_ostream< Char, Traits > &os, const SingletonView &x) |
| Print singleton set view. | |
Constructors and initialization | |
|
| |
| SingletonView (void) | |
| Default constructor. | |
| SingletonView (Gecode::Int::IntView &y) | |
| Initialize with integer view y. | |
| SingletonView (const Gecode::IntVar &y) | |
| Initialize with integer variable y. | |
Value access | |
|
| |
| unsigned int | cardMin (void) const |
| Return minimum cardinality. | |
| unsigned int | cardMax (void) const |
| Return maximum cardinality. | |
| int | lubMin (void) const |
| Return minimum of the least upper bound. | |
| int | lubMax (void) const |
| Return maximum of the least upper bound. | |
| int | lubMinN (unsigned int n) const |
| Return n-th smallest element of the least upper bound. | |
| int | glbMin (void) const |
| Return minimum of the greatest lower bound. | |
| int | glbMax (void) const |
| Return maximum of the greatest lower bound. | |
| unsigned int | glbSize (void) const |
| Return the number of elements in the greatest lower bound. | |
| unsigned int | lubSize (void) const |
| Return the number of elements in the least upper bound. | |
| unsigned int | unknownSize (void) const |
| Return the number of unknown elements. | |
Domain tests | |
|
| |
| bool | contains (int i) const |
| Test whether i is in the greatest lower bound. | |
| bool | notContains (int i) const |
| Test whether i is not in the least upper bound. | |
Domain update by value | |
|
| |
| ModEvent | cardMin (Space &home, unsigned int m) |
| Restrict cardinality to be greater than or equal to m. | |
| ModEvent | cardMax (Space &home, unsigned int m) |
| Restrict cardinality to be less than or equal to m. | |
| ModEvent | include (Space &home, int i, int j) |
| Update greatest lower bound to include all elements between and including i and j. | |
| ModEvent | exclude (Space &home, int i, int j) |
| Restrict least upper bound to not contain all elements between and including i and j. | |
| ModEvent | include (Space &home, int i) |
| Update greatest lower bound to contain i. | |
| ModEvent | exclude (Space &home, int i) |
| Restrict least upper bound to not contain i. | |
| ModEvent | intersect (Space &home, int i, int j) |
| Update least upper bound to contain at most all elements between and including i and j. | |
| ModEvent | intersect (Space &home, int i) |
| Update least upper bound to contain at most the element i. | |
Domain update by range iterator | |
|
| |
| template<class I > | |
| ModEvent | excludeI (Space &home, I &i) |
| Remove range sequence described by i from least upper bound. | |
| template<class I > | |
| ModEvent | includeI (Space &home, I &i) |
| Include range sequence described by i in greatest lower bound. | |
| template<class I > | |
| ModEvent | intersectI (Space &home, I &iter) |
| Intersect least upper bound with range sequence described by i. | |
Dependencies | |
|
| |
| void | subscribe (Space &home, Propagator &p, PropCond pc, bool schedule=true) |
| Subscribe propagator p with propagation condition pc to view. | |
| void | cancel (Space &home, Propagator &p, PropCond pc) |
| Cancel subscription of propagator p with propagation condition pc to view. | |
| void | subscribe (Space &home, Advisor &a) |
| Subscribe advisor a to view. | |
| void | cancel (Space &home, Advisor &a) |
| Cancel subscription of advisor a. | |
Delta information for advisors | |
|
| |
| int | glbMin (const Delta &d) const |
| Return minimum value just pruned from glb. | |
| int | glbMax (const Delta &d) const |
| Return maximum value just pruned from glb. | |
| bool | glbAny (const Delta &d) const |
| Test whether arbitrary values got pruned from glb. | |
| int | lubMin (const Delta &d) const |
| Return minimum value just pruned from lub. | |
| int | lubMax (const Delta &d) const |
| Return maximum value just pruned from lub. | |
| bool | lubAny (const Delta &d) const |
| Test whether arbitrary values got pruned from lub. | |
| static ModEvent | modevent (const Delta &d) |
| Return modification event. | |
View-dependent propagator support | |
|
| |
| static void | schedule (Space &home, Propagator &p, ModEvent me) |
| Schedule propagator p with modification event me. | |
| static ModEvent | me (const ModEventDelta &med) |
| Return modification event for view type in med. | |
| static ModEventDelta | med (ModEvent) |
| Translate modification event me to modification event delta for view. |
Detailed Description
Singleton set view.
A singleton set view for an integer view provides operations such that behaves like the singleton set .
Definition at line 589 of file view.hpp.
Constructor & Destructor Documentation
| Gecode::Set::SingletonView::SingletonView | ( | void | ) | [inline] |
Default constructor.
Definition at line 45 of file singleton.hpp.
| Gecode::Set::SingletonView::SingletonView | ( | Gecode::Int::IntView & | y | ) | [inline] |
Initialize with integer view y.
Definition at line 48 of file singleton.hpp.
| Gecode::Set::SingletonView::SingletonView | ( | const Gecode::IntVar & | y | ) | [inline] |
Initialize with integer variable y.
Definition at line 52 of file singleton.hpp.
Member Function Documentation
Convert set variable PropCond pc to a PropCond for integer variables.
Definition at line 56 of file singleton.hpp.
Convert integer variable ModEvent me to a ModEvent for set variables.
Definition at line 68 of file singleton.hpp.
Convert set variable ModEvent me to a ModEvent for integer variables.
Definition at line 84 of file singleton.hpp.
| unsigned int Gecode::Set::SingletonView::cardMin | ( | void | ) | const [inline] |
Return minimum cardinality.
Definition at line 118 of file singleton.hpp.
| unsigned int Gecode::Set::SingletonView::cardMax | ( | void | ) | const [inline] |
Return maximum cardinality.
Definition at line 121 of file singleton.hpp.
| int Gecode::Set::SingletonView::lubMin | ( | void | ) | const [inline] |
Return minimum of the least upper bound.
Definition at line 124 of file singleton.hpp.
| int Gecode::Set::SingletonView::lubMax | ( | void | ) | const [inline] |
Return maximum of the least upper bound.
Definition at line 127 of file singleton.hpp.
| int Gecode::Set::SingletonView::lubMinN | ( | unsigned int | n | ) | const |
Return n-th smallest element of the least upper bound.
| int Gecode::Set::SingletonView::glbMin | ( | void | ) | const [inline] |
Return minimum of the greatest lower bound.
Definition at line 130 of file singleton.hpp.
| int Gecode::Set::SingletonView::glbMax | ( | void | ) | const [inline] |
Return maximum of the greatest lower bound.
Definition at line 134 of file singleton.hpp.
| unsigned int Gecode::Set::SingletonView::glbSize | ( | void | ) | const [inline] |
Return the number of elements in the greatest lower bound.
Definition at line 98 of file singleton.hpp.
| unsigned int Gecode::Set::SingletonView::lubSize | ( | void | ) | const [inline] |
Return the number of elements in the least upper bound.
Definition at line 103 of file singleton.hpp.
| unsigned int Gecode::Set::SingletonView::unknownSize | ( | void | ) | const [inline] |
Return the number of unknown elements.
Definition at line 106 of file singleton.hpp.
| bool Gecode::Set::SingletonView::contains | ( | int | i | ) | const [inline] |
Test whether i is in the greatest lower bound.
Definition at line 111 of file singleton.hpp.
| bool Gecode::Set::SingletonView::notContains | ( | int | i | ) | const [inline] |
Test whether i is not in the least upper bound.
Definition at line 115 of file singleton.hpp.
Restrict cardinality to be greater than or equal to m.
Definition at line 138 of file singleton.hpp.
Restrict cardinality to be less than or equal to m.
Definition at line 143 of file singleton.hpp.
Update greatest lower bound to include all elements between and including i and j.
Definition at line 181 of file singleton.hpp.
Restrict least upper bound to not contain all elements between and including i and j.
Definition at line 186 of file singleton.hpp.
Update greatest lower bound to contain i.
Definition at line 148 of file singleton.hpp.
Restrict least upper bound to not contain i.
Definition at line 176 of file singleton.hpp.
Update least upper bound to contain at most all elements between and including i and j.
Definition at line 158 of file singleton.hpp.
Update least upper bound to contain at most the element i.
Definition at line 153 of file singleton.hpp.
Remove range sequence described by i from least upper bound.
Definition at line 204 of file singleton.hpp.
Include range sequence described by i in greatest lower bound.
Definition at line 209 of file singleton.hpp.
| ModEvent Gecode::Set::SingletonView::intersectI | ( | Space & | home, | |
| I & | iter | |||
| ) | [inline] |
Intersect least upper bound with range sequence described by i.
Definition at line 225 of file singleton.hpp.
| void Gecode::Set::SingletonView::schedule | ( | Space & | home, | |
| Propagator & | p, | |||
| ModEvent | me | |||
| ) | [inline, static] |
Schedule propagator p with modification event me.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 250 of file singleton.hpp.
| ModEvent Gecode::Set::SingletonView::me | ( | const ModEventDelta & | med | ) | [inline, static] |
Return modification event for view type in med.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 254 of file singleton.hpp.
| ModEventDelta Gecode::Set::SingletonView::med | ( | ModEvent | me | ) | [inline, static] |
Translate modification event me to modification event delta for view.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 258 of file singleton.hpp.
| void Gecode::Set::SingletonView::subscribe | ( | Space & | home, | |
| Propagator & | p, | |||
| PropCond | pc, | |||
| bool | schedule = true | |||
| ) | [inline] |
Subscribe propagator p with propagation condition pc to view.
In case schedule is false, the propagator is just subscribed but not scheduled for execution (this must be used when creating subscriptions during propagation).
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 230 of file singleton.hpp.
| void Gecode::Set::SingletonView::cancel | ( | Space & | home, | |
| Propagator & | p, | |||
| PropCond | pc | |||
| ) | [inline] |
Cancel subscription of propagator p with propagation condition pc to view.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 235 of file singleton.hpp.
Subscribe advisor a to view.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 240 of file singleton.hpp.
Cancel subscription of advisor a.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 244 of file singleton.hpp.
Return modification event.
Reimplemented from Gecode::DerivedView< Gecode::Int::IntView >.
Definition at line 272 of file singleton.hpp.
| int Gecode::Set::SingletonView::glbMin | ( | const Delta & | d | ) | const [inline] |
Return minimum value just pruned from glb.
Definition at line 277 of file singleton.hpp.
| int Gecode::Set::SingletonView::glbMax | ( | const Delta & | d | ) | const [inline] |
Return maximum value just pruned from glb.
Definition at line 280 of file singleton.hpp.
| bool Gecode::Set::SingletonView::glbAny | ( | const Delta & | d | ) | const [inline] |
Test whether arbitrary values got pruned from glb.
Definition at line 283 of file singleton.hpp.
| int Gecode::Set::SingletonView::lubMin | ( | const Delta & | d | ) | const [inline] |
Return minimum value just pruned from lub.
Definition at line 286 of file singleton.hpp.
| int Gecode::Set::SingletonView::lubMax | ( | const Delta & | d | ) | const [inline] |
Return maximum value just pruned from lub.
Definition at line 289 of file singleton.hpp.
| bool Gecode::Set::SingletonView::lubAny | ( | const Delta & | d | ) | const [inline] |
Test whether arbitrary values got pruned from lub.
Definition at line 292 of file singleton.hpp.
Friends And Related Function Documentation
| std::basic_ostream< Char, Traits > & operator<< | ( | std::basic_ostream< Char, Traits > & | os, | |
| const SingletonView & | x | |||
| ) | [related] |
The documentation for this class was generated from the following files:
- gecode/set/view.hpp (Revision: 12318)
- gecode/set/view/singleton.hpp (Revision: 12318)


Tencent COS is a famous object storage system provided by Tencent Corp. Hadoop-COS is a client that makes the upper computing systems based on HDFS be able to use the COS as its underlying storage system. The big data-processing systems that have been identified for support are: Hadoop MR, Spark, Alluxio and etc. In addition, Druid also can use COS as its deep storage by configuring HDFS-Load-Plugin integerating with HADOOP-COS.
Support Hadoop MapReduce and Spark write data into COS and read from it directly.
Implements the interfaces of the Hadoop file system and provides the pseudo-hierarchical directory structure same as HDFS.
Supports multipart uploads for a large file. Single file supports up to 19TB
High performance and high availability. The performance difference between Hadoop-COS and HDFS is not more than 30%.
Notes:
Object Storage is not a file system and it has some limitations:
Object storage is a key-value storage and it does not support hierarchical directory naturally. Usually, using the directory separatory in object key to simulate the hierarchical directory, such as “/hadoop/data/words.dat”.
COS Object storage can not support the object’s append operation currently. It means that you can not append content to the end of an existing object(file).
Both delete and rename operations are non-atomic, which means that the operations are interrupted, the operation result may be inconsistent state.
Object storages have different authorization models:
Directory permissions are reported as 777.
File permissions are reported as 666.
File owner is reported as the local current user.
File group is also reported as the local current user.
Supports multipart uploads for a large file(up to 40TB), but the number of part is limited as 10000.
The number of files listed each time is limited to 1000.
Bucket: A container for storing data in COS. Its name is made up of user-defined bucketname and user appid.
Appid: Unique resource identifier for the user dimension.
SecretId: ID used to authenticate the user
SecretKey: Key used to authenticate the user
Region: The region where a bucket locates.
CosN: Hadoop-COS uses cosn as its URI scheme, so CosN is often used to refer to Hadoop-COS.
If you plan to use COS as the default file system for Hadoop or other big data systems, you need to configure fs.defaultFS as the URI of Hadoop-COS in core-site.xml. Hadoop-COS uses cosn as its URI scheme, and the bucket as its URI host. At the same time, you need to explicitly set fs.cosn.userinfo.region to indicate the region your bucket locates.
NOTE:
For Hadoop-COS, fs.defaultFS is an option. If you are only temporarily using the COS as a data source for Hadoop, you do not need to set the property, just specify the full URI when you use it. For example: hadoop fs -ls cosn://testBucket-125236746/testDir/test.txt.
fs.cosn.userinfo.region is an required property for Hadoop-COS. The reason is that Hadoop-COS must know the region of the using bucket in order to accurately construct a URL to access it.
COS supports multi-region storage, and different regions have different access domains by default. It is recommended to choose the nearest storage region according to your own business scenarios, so as to improve the object upload and download speed. You can find the available region from https://intl.cloud.tencent.com/document/product/436/6224
The following is an example for the configuration format:
<property> <name>fs.defaultFS</name> <value>cosn://<bucket-appid></value> <description> Optional: If you don't want to use CosN as the default file system, you don't need to configure it. </description> </property> <property> <name>fs.cosn.bucket.region</name> <value>ap-xxx</value> <description>The region where the bucket is located</description> </property>
Each user needs to properly configure the credentials ( User’s secreteId and secretKey ) properly to access the object stored in COS. These credentials can be obtained from the official console provided by Tencent Cloud.
<property> <name>fs.cosn.credentials.provider</name> <value>org.apache.hadoop.fs.auth.SimpleCredentialsProvider</value> <description> This option allows the user to specify how to get the credentials. Comma-separated class names of credential provider classes which implement com.qcloud.cos.auth.COSCredentialsProvider: 1.org.apache.hadoop.fs.auth.SimpleCredentialsProvider: Obtain the secret id and secret key from fs.cosn.userinfo.secretId and fs.cosn.userinfo.secretKey in core-site.xml 2.org.apache.hadoop.fs.auth.EnvironmentVariableCredentialsProvider: Obtain the secret id and secret key from system environment variables named COS_SECRET_ID and COS_SECRET_KEY If unspecified, the default order of credential providers is: 1. org.apache.hadoop.fs.auth.SimpleCredentialsProvider 2. org.apache.hadoop.fs.auth.EnvironmentVariableCredentialsProvider </description> </property> <property> <name>fs.cosn.userinfo.secretId</name> <value>xxxxxxxxxxxxxxxxxxxxxxxxx</value> <description>Tencent Cloud Secret Id </description> </property> <property> <name>fs.cosn.userinfo.secretKey</name> <value>xxxxxxxxxxxxxxxxxxxxxxxx</value> <description>Tencent Cloud Secret Key</description> </property>
You need to explicitly specify the A and B options in order for Hadoop to properly integrate the COS as the underlying file system
Only correctly set fs.cosn.impl and fs.AbstractFileSystem.cosn.impl to enable Hadoop to integrate COS as its underlying file system. fs.cosn.impl must be set as org.apache.hadoop.fs.cos.CosFileSystem and fs.AbstractFileSystem.cosn.impl must be set as org.apache.hadoop.fs.cos.CosN.
<property> <name>fs.cosn.impl</name> <value>org.apache.hadoop.fs.cosn.CosNFileSystem</value> <description>The implementation class of the CosN Filesystem</description> </property> <property> <name>fs.AbstractFileSystem.cosn.impl</name> <value>org.apache.hadoop.fs.cos.CosN</value> <description>The implementation class of the CosN AbstractFileSystem.</description> </property>
Hadoop-COS provides rich runtime properties to set, and most of these do not require custom values because a well-run default value provided for them.
It is important to note that:
Hadoop-COS will generate some temporary files and consumes some disk space. All temporary files would be placed in the directory specified by option fs.cosn.tmp.dir (Default: /tmp/hadoop_cos);
The default block size is 8MB and it means that you can only upload a single file up to 78GB into the COS blob storage system. That is mainly due to the fact that the multipart-upload can only support up to 10,000 blocks. For this reason, if needing to support larger single files, you must increase the block size accordingly by setting the property fs.cosn.block.size. For example, the size of the largest single file is 1TB, the block size is at least greater than or equal to (1 * 1024 * 1024 * 1024 * 1024)/10000 = 109951163. Currently, the maximum support file is 19TB (block size:<PHONE_NUMBER>)
<property> <name>fs.cosn.tmp.dir</name> <value>/tmp/hadoop_cos</value> <description>Temporary files would be placed here.</description> </property> <property> <name>fs.cosn.buffer.size</name> <value>33554432</value> <description>The total size of the buffer pool.</description> </property> <property> <name>fs.cosn.block.size</name> <value>8388608</value> <description> Block size to use cosn filesysten, which is the part size for MultipartUpload. Considering the COS supports up to 10000 blocks, user should estimate the maximum size of a single file. For example, 8MB part size can allow writing a 78GB single file. </description> </property> <property> <name>fs.cosn.maxRetries</name> <value>3</value> <description> The maximum number of retries for reading or writing files to COS, before throwing a failure to the application. </description> </property> <property> <name>fs.cosn.retry.interval.seconds</name> <value>3</value> <description>The number of seconds to sleep between each COS retry.</description> </property>
| properties | description | default value | required |
|---|---|---|---|
| fs.defaultFS | Configure the default file system used by Hadoop. | None | NO |
| fs.cosn.credentials.provider | This option allows the user to specify how to get the credentials. Comma-separated class names of credential provider classes which implement com.qcloud.cos.auth.COSCredentialsProvider: 1. org.apache.hadoop.fs.cos.auth.SimpleCredentialsProvider: Obtain the secret id and secret key from fs.cosn.userinfo.secretId and fs.cosn.userinfo.secretKey in core-site.xml; 2. org.apache.hadoop.fs.auth.EnvironmentVariableCredentialsProvider: Obtain the secret id and secret key from system environment variables named COSN_SECRET_ID and COSN_SECRET_KEY. If unspecified, the default order of credential providers is: 1. org.apache.hadoop.fs.auth.SimpleCredentialsProvider; 2. org.apache.hadoop.fs.auth.EnvironmentVariableCredentialsProvider. |
None | NO |
| fs.cosn.userinfo.secretId/secretKey | The API key information of your account | None | YES |
| fs.cosn.bucket.region | The region where the bucket is located. | None | YES |
| fs.cosn.impl | The implementation class of the CosN filesystem. | None | YES |
| fs.AbstractFileSystem.cosn.impl | The implementation class of the CosN AbstractFileSystem. | None | YES |
| fs.cosn.tmp.dir | Temporary files generated by cosn would be stored here during the program running. | /tmp/hadoop_cos | NO |
| fs.cosn.buffer.size | The total size of the buffer pool. Require greater than or equal to block size. | 33554432 | NO |
| fs.cosn.block.size | The size of file block. Considering the limitation that each file can be divided into a maximum of 10,000 to upload, the option must be set according to the maximum size of used single file. For example, 8MB part size can allow writing a 78GB single file. | 8388608 | NO |
| fs.cosn.upload_thread_pool | Number of threads used for concurrent uploads when files are streamed to COS. | CPU core number * 3 | NO |
| fs.cosn.read.ahead.block.size | The size of each read-ahead block. | 524288 (512KB) | NO |
| fs.cosn.read.ahead.queue.size | The length of readahead queue. | 10 | NO |
| fs.cosn.maxRetries | The maxium number of retries for reading or writing files to COS, before throwing a failure to the application. | 3 | NO |
| fs.cosn.retry.interval.seconds | The number of seconds to sleep between each retry | 3 | NO |
Command format: hadoop fs -ls -R cosn://bucket-appid/<path> or hadoop fs -ls -R /<path>, the latter requires the defaultFs option to be set as cosn.
Use CosN as the underlying file system to run the WordCount routine:
bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-x.x.x.jar wordcount cosn://example/mr/input.txt cosn://example/mr/output
If setting CosN as the default file system for Hadoop, you can run it as follows:
bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-x.x.x.jar wordcount /mr/input.txt /mr/output
To test CosN filesystem, the following two files which pass in authentication details to the test runner are needed.
These two files need to be created under the hadoop-cloud-storage-project/hadoop-cos/src/test/resource directory.
COS credentials can specified in auth-key.xml. At the same time, it is also a trigger for the CosN filesystem tests. COS bucket URL should be provided by specifying the option: test.fs.cosn.name.
An example of the auth-keys.xml is as follow:
<configuration> <property> <name>test.fs.cosn.name</name> <value>cosn://testbucket-12xxxxxx</value> </property> <property> <name>fs.cosn.bucket.region</name> <value>ap-xxx</value> <description>The region where the bucket is located</description> </property> <property> <name>fs.cosn.userinfo.secretId</name> <value>AKIDXXXXXXXXXXXXXXXXXXXX</value> </property> <property> <name>fs.cosn.userinfo.secretKey</name> <value>xxxxxxxxxxxxxxxxxxxxxxxxx</value> </property> </configuration>
Without this file, all tests in this module will be skipped.
This file pre-exists and sources the configurations created in auth-keys.xml. For most cases, no modification is needed, unless a specific, non-default property needs to be set during the testing.
All configurations related to support contract tests need to be specified in contract-test-options.xml. Here is an example of contract-test-options.xml.
<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <configuration> <include xmlns="http://www.w3.org/2001/XInclude" href="auth-keys.xml"/> <property> <name>fs.contract.test.fs.cosn</name> <value>cosn://testbucket-12xxxxxx</value> </property> <property> <name>fs.cosn.bucket.region</name> <value>ap-xxx</value> <description>The region where the bucket is located</description> </property> </configuration>
If the option fs.contract.test.fs.cosn not definded in the file, all contract tests will be skipped.
The IO performance of COS is lower than HDFS in principle, even on virtual clusters running on Tencent CVM.
The main reason can be attributed to the following points:
HDFS replicates data for faster query.
HDFS is significantly faster for many “metadata” operations: listing the contents of a directory, calling getFileStatus() on path, creating or deleting directories.
HDFS stores the data on the local hard disks, avoiding network traffic if the code can be executed on that host. But access to the object storing in COS requires access to network almost each time. It is a critical point in damaging IO performance. Hadoop-COS also do a lot of optimization work for it, such as the pre-read queue, the upload buffer pool, the concurrent upload thread pool, etc.
File IO performing many seek calls/positioned read calls will also encounter performance problems due to the size of the HTTP requests made. Despite the pre-read cache optimizations, a large number of random reads can still cause frequent network requests.
On HDFS, both the rename and mv for a directory or a file are an atomic and O(1)-level operation, but in COS, the operation need to combine copy and delete sequentially. Therefore, performing rename and move operations on a COS object is not only low performance, but also difficult to guarantee data consistency.
At present, using the COS blob storage system through Hadoop-COS occurs about 20% ~ 25% performance loss compared to HDFS. But, the cost of using COS is lower than HDFS, which includes both storage and maintenance costs.


Version: {{docversion}}
Slamby Insight is an open-source project under Apache 2.0 license. Please find it at github.com/slamby/slamby-insight
Download and install Slamby Insight from https://insight.slamby.com
Supported operating systems
Automated Update:
Slamby Insight checks updates when it starts. When updates available a popup dialog displays and request permission for updates.
When Insight starts login window comes first. Here you can select or add your Slamby Server to work with.
To use Slamby Insight you need to have a working Slamby API server. If you don't have one, you can try Insight using our public demo server.
Manage servers
To add, edit servers click the Manage Endpoints button.
Demo Server Data:
The demo server is available in the server list as default.
This is a Slamby hosted demo server in our European cloud
| Name | Default Value |
|---|---|
| ApiBaseEndpoint | https://europe.slamby.com/demo/ |
| ApiSecret | s3cr3t |
| ParallelLimit | 0 |
| BulkSize | 1000 |
When you log in your server the first panel you see is the welcome screen. Here you can check the software versions and find a quick link to our developer's site for more detailed information.
Insight has a simple design structure. You can find the main menu panel icons on the left side as a vertical menu. To open one, use double click. When you open a menu panel it pops up as a tab. You can check the tabs in the tab section in the top middle section.
To close a tab click the x
sign or press middle mouse button on it. When you have more tabs open that can be displayed horizontally, a horizontal scrollbar shows.
In the top dark header lane you can find you Insight version in the top left corner, then the selected server address. In the right header side you can find three buttons:
Notification button,
Refresh button,
Settings button.
When you server responses such as successful service activation, you can find the available notifications in under the notification panel.
For update check, you can click the middle button.
For server settings click the settings button.
This is the main panel for dataset management. List, create and edit and open your datasets. When you open this panel you see your available dataset list, a few information about them and an Add New Dataset
button.
To create a new dataset click the Add New Dataset
button. In the popup form, you need to provide a few information about the name and the required structure of the new dataset.
Available fields:
| Field name | Description |
|---|---|
| Name | Name of the new dataset. a-Z, 0-9 accepted. |
| NGram Count | Datasets using ngram model for text analysis. The suggested number is 3 |
| Id Field | As you can set any field in your sample/schema, then we need to know which field is the id field. The id field is a must. |
| Tag Field | In each dataset a tag field is a must. Tag field means the document related tags that we are going to use for text-analysis and category prediction. Slamby API manages categories as tags. |
| Interpreted Fields | For text analysis we need to know which fields contain text. For that, you need to set those field names here that contain text and you are going to use those text for analysis. |
| Sample document or Schema | To define which fields, data types and structure you wish to use in your dataset you have two options: using a JSON sample document, or use Schema. |
For more information please visit our developer's site developers.slamby.com
Available dataset management options:
Rename
Delete
Clone
Show sample document
To rename a dataset click the dataset options button on the right side. In the drop-down menu click the rename option.
Type the new name and click Ok.
When you want to copy a dataset with all the details but data; you can use the clone options. It copies all the settings and structure of a dataset, your only job is to name it.
To clone a dataset click the Clone option in the drop-down menu.
When you need to now the available fields and types inside a dataset you can check the structure it by clicking the Show Sample button in the drop-down dataset menu.
To remove a dataset click the remove button in the drop-down dataset menu. You can delete a dataset when there is no related active service running.
Important!
Removing a dataset cause data loss, there is no way for recovery.
To import documents or tags into a dataset you can use our built-in import panel. To open the import panel double click it on the left menu.
At first select the target dataset, then select the import file on your computer. Currently the supported file formats CSV
(both for documents and tags) and JSON
(just for tags).
Please find this sample CSV content to test the document import process. Copy and save it as slamby-demo-import.csv.
"id","title","desc","tag"
"1","A","A","1"
"2","B","B","1"
"3","C","C","2"
"4","D","D","2"
"5","E","E","3"
You can use the import panel to import both documents and tags. To select the required one use the selector.
When everything ready click the import button.
When you use CSV as a file format a delimiter field pops up. Here please provide the required delimiter.
When it's done, click the import button for start.
Important!
In the source file using CSV, a header row is a must. Your source file should contain each dataset field and it should have the same field names.
To manage your documents inside a dataset use the document panel. First, open dataset panel, select the required one and double-click it, or select the open menu item in the drop-down menu.
Basic window structure
After opening documents tab you can see a bit complex window. In the header part, you can switch between the document or tag view.
Before the sub-selector, there is a helper panel with filter, sample, and field selector. To use it click the panel and it drops down.
Here you can see three columns. The first section is the field selector. Here you can see the available dataset fields, and you can filter them to display.
The second section is a Filter panel, where you can filter your documents by tag or by search query. The search results will be displayed in the document list.
The third section is the sampling module. You can use it to create statistical samples from your dataset. You can set the sampling mode, size, and the tags.
The second biggest section is the document list. This list displays the selected documents. Here you can manage the documents by one, or as bulk.
Managing a document you can use the drop-down menu by documents.
Available menu options
| Menu Option | Description |
|---|---|
| Preview | Open the document in the pop-up window. |
| Open | Open document in a new tab. |
| Edit | Open the document to edit. |
| Copy to | Copy document to a selected dataset. |
| Move to | Move document to a selected dataset. |
| Add tags | Add tags to the document from the dataset list. |
| Remove tags | Remove the selected tags from the document. |
| Clear tags | Remove all the tags from the document. |
| Delete | Delete the document. There is no recovery option! |
There are two bulk options available:
Copy all documents to another dataset,
Move all documents to another dataset.
To manage it click the Copy All To
or Move All To
button. After clicking them a tag selector pops up, here you can select the target dataset.
Important!
the target dataset must have the same data structure than the source one. To create one easily you can use dataset clone.
To create a new document manually, click the Add new document
button. A document editor pops up with the sample document of the dataset. You can copy and paste your document here, or re-write the sample document to the required data.
Important!
document must have a valid JSON format.
This is the panel where you can list, add and edit your available tags in a dataset.
Here you can see all of your available tags. To filter them use the built-in filter in the table header.
To add a new tag click the Add new tag
button. Here provide the tag id, name and the parent id. When you use a category tree, then you can organize your tags into a hierarchy by child-parent relations. When you manage a tag cloud instead, just leave the parent id as empty.
To export all the words from your database for further analysis, click the
Export Words
button; a long-term process starts.
To copy the tags to another dataset, click the Copy To All
button.
Select the target dataset and click the Select
button. This process copies all the available tags to the target dataset.
To export the available tags into a CSV file, click the Export Tags
button.
Select the destination to save the CSV file, and click the Save
button.
Tip:
you can use the exported tags in the import process.
Built-in usage statistics panel. Open by double click the Statistics menu. In this panel, you can see the total request number and the detailed request numbers by API endpoints.
The statistics are displayed by month. To select the required month, use the Selected Period
selector.
Main panel for service management. List, create and manage your available services. Currently, Slamby supports the following type of services:
Classifier,
PRC,
Search.
Classifier service
is a text-classification service with high accuracy level and language independence. Specialized for e-commerce text-classification and category-recommendation for thousands of categories.
PRC service
is a text-based matchmaking service for matchmaking, keyword extraction, and duplicate finding.
Search service
is a smart search service, creating powerful search engine. Elastic Search engine, built-in typo fixing, category recommendation, wide-range of customization.
To create a service click the add new service button by selecting the required service type.
Each service has 3 state depends on the preparation and activation status:
New,
Prepared,
Activated.
Meaning of different service status
| Status | Description |
|---|---|
| New | When a service is just created it has a name, description, and an alias. The first status is new . This service has no settings provided, it's not prepared, you cannot activate it. To use it you need to continue with a preparation process. |
| Prepared | This is a status when a service is prepared , all the settings and background machine-learning process done. For preparation click the prepared menu and provide the required settings for the training such as the source dataset name, and needed tags. When the status is prepared, the service is ready for use, however, you need to activate it first. |
| Activated | Just the activated services are callable. When a service is prepared you can start the activation process by clicking the activate menu. During the activation process, all the required files and settings are loading into the machine memory. When a service is activated you can use it by id or by alias. |
Using Slamby Insight a service can be cloned anytime. Cloneable settings: preparation settings, activation settings.
Clone steps:
first create a new service with the same service type,
click the preparation/activation button in the actions dropdown and then select the clone option in the top right corner. Select the source service. Now the settings are cloned.
Click the Ok button and finalize the process.
Example activation settings clone
To add a classifier service, click the Add Classifier
button. For start provide the required name, alias, and description.
What to know about the input parameters?
| Field | Description |
|---|---|
| Name | Name of the service. Human readable name for better management. You cannot modify it in the future. |
| Alias | Service alias for flexible integration. You can set and modify it in the future. |
| Description | Human readable description for better management. |
When you need a Classifier Service, the second step is the preparation process. This is the process when based on the provided settings the machine-learning process starts.
Available settings
| Field | Description |
|---|---|
| Dataset | Dataset selector. Choose the source dataset that you want to use for the training process. |
| NGramCount | Default value is 3, or the maximum ngram number of the dataset. |
| TagIdList | Popup tag selector window where you can pick the required tags. If you want to create a classifier service that can use just the first level categories from the tree, then select just the first level tags. |
| CompressLevel | Built-in compress engine settings. Set it 1 as a default value, it will compress the results by analyzing the unnecessary words, remaining lower resource need at the same accuracy level. |
| Compress Settings | Custom compress settings. For more information visit the developers site. |
When a Classifier Service is prepared activation available. For activation, you can use custom settings to specify you usage criteria.
Available Classifier activation service
| Field | Description |
|---|---|
| NGramCount | Ngram model that you want to use for your activated service. The default value is the maximum prepared ngram value. |
| TagIdList | Tag id filter from the available prepared tag list. You can filter which tags you want to use for category recommendation. |
To test an activated Classifier service, click the recommend menu. Here you can set the text for analysis, the required response count. When you want a detailed response click true the NeedTagsInResult.
Parent tag filter
: if you need to get the category recommendation just from the children of a selected parent category, then use the Parent Tags
filter. Click the Select Tags
button, select the parent tags then click the Ok
button.
Classifier Recommend Response
After sending a recommend query to the selected service, the response pops up immediately. In the response the following parameters available:
To create a PRC Service 3 parameter required: name
as a human readable text, alias
for flexible integration and description
for more detailed human-readable text for better service management.
For preparation the required fields:
| Field | Description |
|---|---|
| Dataset | Select the source dataset for training. |
| TagIdList | Tag selector for training. When there is no tag selected, by default all the lead tags are selected. |
| CompressLevel | Built-in compress engine, recommended value is 1. |
| Compress Settings | Custom compress settings, for more details visit the developers site. |
For activation please check which field you want to use as a recommendation / matchmaking source. When you check a dataset field, during the text-analysis the PRC service will provide the matched items based on the selected fields.
To try your activated PRC service, click the Recommend menu. The available options:
| Field | Description |
|---|---|
| Text | Text for analysis |
| Count | Response item number |
| Filter | PRC filter as a pre-filter before matchmaking. For more information please check the API documentation. |
| NeedDocumentsInResult | When it's true response contains full document objects. |
| TagId | The target tag id, in which the matchmaking will be processing. When it's empty, the API will predict a suitable one. |
| Weights | Weight object to boost the results. For more information please check the API documentation. |
You can extract keywords from text with this function. The available options:
| Field | Description |
|---|---|
| Text | Text for analysis |
| TagId | The target tag id, in which the matchmaking will be processing. When it's empty, the API will predict a suitable one. |
| Strict mode | If it's enabled then you will get lesser keywords. The score limit is stricter. |
To create a new search service, open the services tab and click the Add Search
button at the top.
Now you can provide the name, alias and a short description for the service.
Tip: These settings can be modified in the future.
The second step is to prepare the search service. During this step, we need to select which dataset we want to use as the search engine database.
After selecting the source dataset, the search engine will analyze it, and a new search service will be available.
This is the last step before start using the Slamby Search service. During this step, we can provide the default search settings, that we want to use after activation as a default setting.
For Slamby Search currently there are three settings groups:
Tip: In this step, we can provide the default settings, but using the search we can overwrite these settings anytime.
For the settings details please check the developer's site at https://developers.slamby.com/docs/API/v1.5.0/service#activate-search-service
Autocomplete settings
Classifier service settings
Search engine settings
Using Search you can use the activation default settings, and type your search query, or provide your custom search settings right now.
When you typed your search query, and/or set your custom settings, then click the Ok button.
Now your search result appears.
Using Slamby API server all the long-term jobs are organized into background processes. Such as dataset copy or classifier service training are managed using background processes.
Open processes double click on the processes menu.
Here you can see all the active processes: result, timing details, status, description and other details. To check the historical, not active processes check the Show inactive processes
Notification panel for Insight and API messages. Here you can list all the historical notifications received during your session.
Panel for better resource management. Here you can check the available server resources.
Resource information
| name | Description |
|---|---|
| API version | Current API version number. |
| Number of CPU core(s) | Available core number. |
| CPU usage | CPU usage in percentage. |
| Available free disk space | Free disk space in MB. |
| Free memory / total memory | Memory data in MB. |


Kahoots is an iOS app that shares professional service contacts with your personal network.
Our process
As a UX lead, I led our team of UX and visual designers through user research to information architecture to wireframes. I also supported the visual design through creating moodboards and style tiles.
The final deliverable
Designed and developed by two teammates Michael and Angie.
Knosey Mobile App
Knosey is a hypothetical mobile app that captures, saves and replays smells. The instagram of smells, Knosey enables users to share their favorite smells. I conceived and designed the brand identity and mockup screens.
Logo Sketches
Logo Sketches
Final Mockups
Rich Seas Website
A friend from Richs Seas LLC asked for a simple, corporate logo and Weebly.com website to attract investors.
A homage to some of my favorite artists, "Gift Rap" was a contribution to the "Gift Wrap"-themed postcard exchange hosted by New York-based arts collective Chainmail Club.


The Academy disqualifies another international feature film submission, this time from Austria
Cape Town – The Academy of Motion Pictures and Sciences has disqualified another best international feature Oscar consideration.
This comes after it barred Nigeria's first-ever Oscar submission, Lionheart, last week because it is a predominantly English language film.
According to The Hollywood Reporter, Austria's submission, Joy has now been ruled ineligible for the same reason.
The film written and directed by Sudabeh Mortezai centres Joy a Nigerian woman caught in the cycle of sex trafficking.  She has to mentor a new teenage girl from Nigeria about to go down the same path as her.
The film premiered at the Venice Film Festival in 2018 and is available to stream on Netflix. In 2018 it won the Best Film Award at the London Film Festival.
WATCH THE TRAILER HERE:
A spokesperson for the Academy said in a statement that "the film was reviewed and found ineligible because only 33 percent of the dialogue is non-English", reports Variety.
According to The Hollywood Reporter, the Austrian selection committee was notified of the decision on Monday morning.
Director and academy member Ava Duvernay spoke out about the latest disqualification on Twitter.
She wrote: "Another one. How about letting countries submit the film they feel best represents its cinematic work in any given year? I'm really asking. There has to be a good reason for not. I want to understand, @TheAcademy. I know when the no English rule originated. But why? Please share."
Oscar nominations will be announced on Monday, 13 January 2020. The ceremony will take place on Sunday, 9 February.
Compiled by Leandra Engelbrecht. (Sources: The Hollywood Reporter , Variety , Twitter)


Clothing
{% include "garments_dropdown.html" with context %}
wear
wash
Show short sleeves
Events list
Wear history
Recommendations


I enjoy working with technology, especially programming and mobile development. I have been programming for 10 years and continue to learn new languages and frameworks. This page is mostly to try out Code School's project segment for the free weekend.
I enjoy working with the following:


The Role of Algorithms
Driven by booming enrollments in Computer Science, the first theoretical class that the majors usually take, “Introduction to Algorithms”, is also experiencing unprecedented growth. At top schools this is evidenced by the fact that dozens of TAs are now employed to teach this class to several hundreds of students each year. There are multiple reasons making “Introduction to Algorithms” one of the cornerstones of the Computer Science curriculum. One of the key roles that it plays for many students is serving as their first introduction into fully rigorous analysis of the performance of computer programs. It teaches the students how to use the rigorous mathematical lens to see abstract structure behind the data that they haven’t seen before.
Furthermore, it introduces a basic set of tools that can be used to process large amounts of data regardless of any assumptions about the generation process used to create it (worst-case analysis). Unlike other popular approaches to algorithm design such as machine learning and its newest incarnation called “deep learning”, the core algorithms curriculum gives solutions which use no training data and behave robustly under any changes in their input.
What Should the “Introduction to Algorithms” Look Like?
The question asked here is provocative and doesn’t have a hard and fast answer for multiple reasons. First, the answers vary quite a bit depending on who you ask. I will illustrate this point later by comparing the curricula used at some of the top schools. Hence, I will stress first that all ideas expressed below are a matter of my personal taste. From this point on all opinions expressed in this post are about how I would teach introduction to algorithms rather than suggesting the reader to do the same. In fact, I believe that in the U.S. and all over the world we are very lucky to have enough diversity to create curricula which look quite different from each other thus giving students more options. While the most fundamental basics are roughly the same, the choice of advanced topics is often driven by the instructor’s research interests. For those interested in pursuing a research career this gives an opportunity to get involved in research early on.
Second, unlike more traditional subjects such as maths and physics, the subject itself is rapidly evolving. My rough estimate from looking at the history would be that once every 10-15 years a significant part of the curriculum has to undergo a shake-up. This is another reason why having an instructor who is an active researcher in the area is critical for keeping up with developments in the field. Stale curricula can even sometimes create room for doubt in whether algorithms are still relevant or some other class can be used as a replacement. While there is hardly any doubt that rigorous analysis of algorithms will be relevant for many years to come, concerns such as the one above can be seen as a call for action.
Despite the two fundamental challenges discussed above, I believe that there are some guiding principles that can be used to determine the choice of topics for the introductory classes. The first one is simplicity and clarity of the underlying ideas. The second one is them passing the test of time and being implemented and used in a variety of software packages. This process serves as a “natural selection” for algorithmic ideas. A 10-15 year period is usually enough for the hype around hot topics to settle down. Finally, universality and robustness to the choice of a particular model or architecture also play an important role. This is probably the hardest principle to use since it involves predicting the future.
The Shoulders of Giants
Books
Now let’s briefly discuss the existing literature and curricula at the top schools.
Probably the most canonical textbook on algorithms is the MIT book known as CLRS (first published in 1990, the most recent third edition came out in 2009). I’ve got my first edition in high school back in 2003. At the time this book was quite a breakthrough compared to the previous generation of textbooks such as Aho-Hopcroft-Ullman’s and Sedgewick’s. I was heavily influenced by CLRS, subsequently using it to teach introductory classes for high school students in mid-late 00’s.
The fact that almost all algorithms from CLRS can be implemented as is using general purpose programming languages (C++, Java, Python) also made it very popular in the programming community including the competitive part of it. E.g. in the Russian summer camps for high school students CLRS formed the core of the B/C-level classes while A/B-level classes cover topics roughly similar to Erik Demaine’s Advanced Algorithms and Advanced Data Structures. I don’t have the data but will be very surprised if CLRS didn’t sell more copies than any other algorithms textbook ever published. A recent testament to the popularity of CLRS is the fact that its first author Thomas Cormen is about as popular on Quora as the President of the United States (this fact probably tells more about the kind of people who are active on Quora though).
Over years multiple alternatives have emerged, among which I would like to mention two: the Berkeley-UCSD “Algorithms” by Dasgupta, Papadimitriou and Vazirani and the Cornell’s “Algorithm Design” by Kleinberg and Tardos. Both books were published in 2005-06 and to the best of my knowledge second editions aren’t available yet. One of the main differences between these newer books and CLRS is their concise style and focus on high-level ideas rather than low-level details. However, all the books discussed above are starting to show their age. A litmus test is the fact that they either don’t mention Chernoff bounds at all or mention them as an exercise or in one of the last chapters where they are barely used. I would expect a modern algorithms textbook to introduce concentration bounds early on and then use them heavily throughout the course.
Recently among textbooks I haven’t seen any strong newcomers, which might be partly due to the fact that books are somewhat passe these days (the only notable exception off the top of my head is a recent book “Foundations of Data Science” by Hopcroft and Kannan which is very interesting but has a somewhat different goal so I don’t see how an introductory algorithms class can be based solely on it).
Courses
In search for a modern algorithms curriculum let’s now turn to the classes taught recently at some of the schools in the U.S. whose class pages are publicly available. At some schools different instructors teach the class in different years, so here I just picked one at random to save space. Certain topics appear consistently in all of these classes (sorting/median, hashing, dynamic programming, greedy algorithms, cuts and flows, BFS/DFS, union-find, MST, FFT, shortest paths, etc.) so I will focus on the differences which make these classes unique.
- At MIT the “Design and Analysis of Algorithms” class is taught by Erik Demaine. Here is the most recent page. Erik is one of the best living experts on data structures. No surprise his class is a little heavy on cool data structures, including Van Emde Boas trees, Skip Lists and Range Trees which aren't usually present in a typical algorithms curriculum.
- At CMU the “Algorithms” class was recently taught by Anupam Gupta and Danny Sleator, page here. This is a very interesting class where the instructors made a great effort including some modern topics such as linear programming, zero-sum games, streaming algorithms for big data, online algorithms, machine learning, gradient descent together with some advanced data structures (splay trees and segment trees).
- At Berkeley the class was recently taught by David Wagner, page here. The class is based on the DPV book and also serves as an introduction into Theoretical Computer Science (primarily because it discusses in detail NP-completeness, which is either not present in other classes or only mentioned briefly). The non-standard topics include an intro to machine learning, streaming algorithms (CountMin sketch) and PageRank.
- At Cornell the class was recently taught by Eva Tardos and David Steurer, page here. Not surprisingly, the class is heavily KT-based. Among unusual topics there is a lot of NP-hardness and computability (Turing machines, Church-Turing, undecidability, etc.) + a large module on approximation algorithms. Modern topics include Nash equilibria, best expert algorithm (multiplicative weights) and stable matching. Overall, this class has a strong bias towards foundations and approximation algorithms + an AGT/learning spin to it.
- At Stanford the class is taught this semester by Virginia Williams, page here. This is a traditional CLRS-based class. Since Stanford is on a quarter system this class is shorter than others. For more advanced algorithms courses at Stanford see CS168, CS261, CS267 and CS367. In particular, CS168, "The Modern Algorithmic Toolbox" is a great example of an advanced modernized algorithms class. According to private channels a modernized version of the algorithms curriculum is currently under construction at Stanford.
- At Harvard the Data Structures and Algorithms class is taught by Jelani Nelson, page here. This is also a fairly traditional CLRS/KT-based class with a touch of linear programming and approximation algorithms.
- At UIUC the class is taught by Jeff Erickson whose lecture notes basically form a book. Non-standard topics include matroids, heavy emphasis of randomized algorithms and amortized data structures,
The Brave New O of the Big N
Finally, I would like to suggest some ideas for a modern algorithms curriculum. As I mentioned in the motivational discussion above I believe that there are three fundamental guidelines: simplicity, implementability / test of time and potential for the future. None of the proposed topics is particularly new and all of them have been tested in advanced graduate level classes at different schools with accessible expositions available. Petabytes of data are getting crunched daily using these techniques and most of them have been implemented in a variety of software packages.
- Randomized and approximation algorithms. Concentration bounds and tail inequalities early on. Examples of simple randomized and approximation algorithms that are actually used in practice, e.g PageRank, Set Cover, etc. There is a lot of mileage in these basic algorithms.
- Linear programming. LP basics/duality + approximation algorithms. Since this topic has already made it into a large number of courses discussed above, I won't discuss it in much detail. Considering LP-solvers as a solution that is available for a wide class of problems is an implicit goal achieved here.
- Basics of machine learning and learning theory. Core learning ideas: perceptron, boosting, VC-dimension, multiplicative weights. In order to strengthen connections with machine learning one can emphasize clustering problems in other parts of the course (SVD, k-means, single-linkage clustering, nearest neighbor, etc.)
- Linear sketching. This is probably the most recent topic (see these two surveys by Andrew McGregor and David Woodruff), but I strongly believe that by now the field is mature enough to be covered in the intro class. A good example of a linear sketch is the CountMin data structure. It is a stronger version of the Bloom filter which is one of the most widely used data structures. The basic philosophy here is surprisingly powerful: CountMin allows to maintain an approximate version of the most basic data structure, an array, using space which is independent of the array's size. Taking this further, linear sketching is a very powerful tool for designing algorithms for massive data regardless of the computational model. Whether it is streaming, MapReduce or take your pick, linear sketches are often the best solution known and/or proved to be optimal. They can also be implemented using basic linear algebraic primitives (see next bullet).
- Algorithms based on linear algebraic primitives. I think that avoiding combinatorial magic is the key to making algorithms robust to the choice of the computational model and also more parallel (see next bullet). Whenever, there is a solution which only uses basic linear algebra, it might be a good idea to prefer it over a combinatorial algorithm even if the latter is a little bit faster and/or easier to implement from scratch. Regardless of the computational model one can expect linear algebraic primitives to be already implemented there (e.g. MatLab). A good example here is the All-Pairs-Shortest-Paths problem (see Uri Zwick's slides for details). Other examples are PageRank, applications of SVD and linear sketching algorithms described above.
- Parallel algorithms and data structures. When faced with multiple algorithmic alternatives it might be a good idea to pick one that is parallelizable. E.g. among the Prim's, Kruskal's and Boruvka's algorithm for MST Boruvka's is the winner here because it is the only one that is not sequential. This fact is used in a variety of parallel MST algorithms. Linear sketching is again going to be handy here. Algorithms based on sorting and hash tables are good since these primitives are often very efficiently implemented in parallel systems (e.g. Hadoop, DHT).
- Data structures and NP-completeness => Advanced classes. In order to make some room for the suggestions described above I would suggest to reduce discussion of these topics to the bare minimum that is necessary in order to cover the core algorithmic ideas. I believe that each of them by itself deserves to be covered in a separate class. With hundreds of students enrolled these topics start to feel too specialized for an introductory algorithms class. NP-completeness can be combined with other topics in computational complexity and automata theory to make it a semester long course. Data structures seem to go naturally with advanced algorithms as another course. To spice things up one can even add purely functional data structures. This may sound a little controversial but there seems to be a general tendency towards moving away from data structues among the books and curricula discussed above. As for NP-completeness, I think it depends on whether a separate class on the theory of computing is offered which for any good school I really believe should be the case.


{{< layout}} {{$main-content}}
Get a friend to take one with a mobile or digital camera
Go to a photo shop and get one on a USB stick or CD


Coding Era is one of the leading online platform for learning courses and enhance your skills
Join NowWorks as a full time web-developrs
working as a data scientist
working as a journalist.
working as a data analyst
Works as Coding Tutor
Working as IT professional..


WhDB
Active
Completed
Closed
People
Create a Ticket
search
close
Create a Ticket Here!
First Name
Last Name
Company
Title
Choose your option
File Cabinet
Office Desk
Office Chair
Office Stand
Standing Desk
Toner Cartridge
Item
Building Designation
Room #
Email
Description
Choose your option
Delivery
Warehouse Pickup
Delivery Options
Date Due
Initial your ticket here:
Initials
Submit


{% extends "templates.jinja/base.page-with-navbar.html" %} {% block title %} Hesperian - Saving Mothers' Lives{% endblock %} {% block id %}If_she_has_a_bladder_infection{% endblock %} {% block content %}
If the woman has a bladder infection, she should drink 1 glass of liquid every hour while she is awake to help wash the infection out of her body. Cranberry juice, cornsilk tea, or other home remedies often work.
If she does not start to improve quickly, or if she has any signs of a kidney infection, give antibiotics.
Antibiotics for bladder and kidney infection:
Give 500 mg amoxicillin by mouth 3 times a day for 7 days. If she is allergic to amoxicillin or penicillin give 960 mg cotrimoxazole by mouth 2 times a day for 7 days. But do not give cotrimoxazole in the last 3 months of pregnancy.
Prevention:
Wipe from front to back after urinating or passing stool to keep germs away from the pee hole. Remind women's partners to clean their hands and genitals before sex. Women should also urinate right after having sex.


Keeping this general until the machine is retired:
Ensure you have the latest "up-to-date" information regarding wordlists. Default or otherwise.
War files need to be unzipped when they are deployed, and you need to know where to go. If using msfvenom, make sure to:
jar -xvf your_war.war
and make note of the shell.jsp page (msfvenom makes it a random generated file name). Navigate there once your war is deployed and started.
Machine is now retired, but nothing really 'out of the ordinary' on this box.


Abstract class that provides a game loop. Extend to provide behaviour.
Starts the game loop. Calls Init before the loop and <Update> once every loop.
Terminates the game loop.
Implement initialization code for your game here.
Run
Implement update logic for your game here.


Short dates are written with an "MM/DD/YYYY" syntax like this:
Long dates are most often written with a "MMM DD YYYY" syntax like this:
Month and day can be in any order:
And, month can be written in full (January), or abbreviated (Jan):
Commas are ignored. Names are case insensitive:
JavaScript will accept date strings in "full JavaScript format":
JavaScript will ignore errors both in the day name and in the time parentheses:


What's in the Keg?
Favorites
History
About
What is this
What's in the Keg?
Favorites
History
What is this
What's in the Keg?
Tech
Loading...
Edit
Loading...
JackThreads
Loading...