Ariel Marcus Rosenberg (born June 24, 1978), better known by his stage name Ariel Pink, is an American singer-songwriter, multi-instrumentalist, and record producer based in Los Angeles, California. He is known for his musical eclecticism, influenced by 1970s and 1980s pop radio and cassette culture. He first gained recognition after signing to Animal Collective's Paw Tracks label in 2003, where several of his limited-edition home recordings were first reissued. He has since signed to 4AD and released three studio albums on the label.
Ariel Marcus Rosenberg (born June 24, 1978), better known by his stage name Ariel Pink, is an American singer-songwriter, multi-instrumentalist, and record producer based in Los Angeles, California. He is known for his musical eclecticism, influenced by 1970s and 1980s pop radio and cassette culture. He first gained recognition after signing to Animal Collective's Paw Tracks label in 2003, where several of his limited-edition home recordings were first reissued. He has since signed to 4AD and released three studio albums on the label.
Check his works here
FrankJavCee is the online handle of musician and vlogger Francisco Jav Contreras, who is best known for posting YouTube instructional videos for creating various types of web content, most notably related to aesthetics and vaporwave.
In January 2010, Contreras launched the @frankjavcee Twitter feed, gaining over 14,000 followers in the next seven years. In May 2011, he created the FrankJavCee SoundCloud page. On December 19th, 2011, Contreras uploaded a chiptune remix of the 2011 dubstep song “First of the Year (Equinox)” by Skrillex to his FrankJavCee YouTube channel. On May 4th, 2012, he posted a “caffeinestep” remix of the 2012 Lana Del Ray track “Off to the Races”.
Visit his Tumblr by clicking here


{% include "location/tab-general.html" %}
{% if body.secex_year is not none %}
{% include "location/tab-trade-partner.html" %}
{% endif %}
{% if body.rais_year is not none %}
{% include "location/tab-wages.html" %}
{% include "location/tab-opportunities.html" %}
{% endif %}
{% if body.university_year is not none %}
{% include "location/tab-education.html" %}
{% else %}
{% include "location/tab-basic-education.html" %}
{% endif %}
{% include "location/tab-health.html" %}


SUSAN HARRISON
Home
About
Twitter
Linkedin
Git Hub
-- Filter by Categories --
Some of my intrests:
Coding
Sharing what I've learned
Hanging with my Famiily


RT @kevindente: Oh how I dream of the day I can walk through the house without the fear of crunching a Cheerio under my foot. #parenting
5/2/2010, 8:22:54 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @kevindente: Oh how I dream of the day I can walk through the house without the fear of crunching a Cheerio under my foot. #parenting
5/2/2010, 8:22:54 PM
Favs: 0
Retweets: 0
link


--- layout: post date: 2010-01-24 time: "09:00:00" authors: ["Greg Wilson"] title: It Seems That Everyone Cares tags: ["Noticed", "Opinion"] ---
Ars Technica isn't primarily a science site, but even they are now worried about reproducibility in computational science. I think it no longer matters how important this "crisis" actually is—sooner or later, major funding agencies are going to mandate adoption of something like the Open Provenance Model. Problem is, given the current skill set of the average scientist, that will almost certainly translate into burden without benefit.


Learning to Program
with Ruby
Dessy Daskalov
@dess_e
Dessy Daskalov
@dess_e
Ruby is a programming language.
Wait ... what's a programming language?
Let's backtrack a bit.
There are two things you should know about your computer.
This is how your computer wishes you could speak to it:
A programming language is easy for you to learn, and your computer also understands it.
It's the half-way point between English and the language that your computer speaks.
Your computer can only do what you tell it to if you give it step-by-step instructions.
Imagine you have to teach a friend to make a peanut butter sandwich.
What would you tell your friend?
|
Let's try teaching Ruby Robot to make a peanut butter sandwich. |
People can understand GENERAL instructions.
Computers need EXACT instructions.
Programming is writing out step-by-step instructions to speak to your computer.
You can speak to your computer through Terminal.
irb
irb(main):001:0>
IRB is like text messaging with Ruby Robot.
Let's ask Ruby Robot to do something.
> 1 + 1
=> 2
> 462 * 86
=> 39732
Ruby can do math very quickly.
> "Girls" + "Learning" + "Code"
=> "GirlsLearningCode"
Ruby Robot knows the difference between a number and a word.
Just like in our world, there are many objects in Ruby Robot's world.
Every object has a barcode. |
Ruby Robot scans the barcode to find out what type of object it is.
In Ruby Robot's world ...
Numbers are called INTEGERS.
Letters, words, and sentences are called STRINGS. A String always has quotes around it.
Ruby Robot has a book full of instructions.
Each page tells Ruby Robot what to do with each type of Object.
> "girlslearningcode".capitalize
=> "Girlslearningcode"
> "girlslearningcode".upcase
=> "GIRLSLEARNINGCODE"
> "girlslearningcode".reverse
=> "edocgninraelslrig"
Find your String sheet, and try playing with each of the instructions.
> 99.next
=> 100
> 99.odd?
=> true
> 99.even?
=> false
Find your Integer sheet, and try playing with each of the instructions.
What if we could type in "girlslearningcode" only once? We can!
> glc = "girlslearningcode"
=> "girlslearningcode"
glc is called a variable. It's like a nickname for the String.
A variable is called just that because it can change.
> glc = "learning to code with ruby robot"
=> "learning to code with ruby robot"
Now let's ask for glc.
> glc
=> "learning to code with ruby robot"
Let's try some more
> glc = 99
=> 99
Let's ask for glc once again.
> glc
=> 99
Let's introduce another variable.
> copycat = glc
=> 99
> glc
=> 99
> copycat
=> 99
Now set glc back to "girlslearningcode"
> glc = "girlslearningcode"
=> "girlslearningcode"
You can use this variable like you would have used "girlslearningcode" before.
> glc.capitalize
=> "Girlslearningcode"
> glc.upcase
=> "GIRLSLEARNINGCODE"
> glc.reverse
=> "edocgninraelslrig"
Find your Variable sheet, and try playing with each of the instructions.
Integer
String
Variable
> glc.length
=> 17
You're probably starting to get a sense of how Twitter knows how many characters you've typed in.
> tweet = "I'm coding!"
=> "I'm coding!"
> tweet.length
=> 11
Try writing some tweets of your own, and check if they're too long!
From your text editor, open the file code.rb in your ruby-girls directory and add the following:
tweet = "I'm coding with Ruby Robot!"
puts tweet.length
To run your program, type quit to exit from IRB, and then type:
ruby code.rb
IRB is like back-and-forth text messaging.
A program has to be told when to output something with puts.
Let's try a few more examples together.
Open puzzle.rb and write down the output you expect to see if you were to run the program.
If you're not sure of something, remember that you can type irb again and try it out.
(Answers in answers/puzzle_answer.txt, but don't look!)
The real Twitter...
Asks you to type something.
Tells you how many characters you're working with.
So far, we've just been putting our tweet directly into the program.
The puts method is used for output, and the gets.chomp method is used for input.
Let's go back to our program:
puts "Write your tweet:"
tweet = gets.chomp
puts tweet.length
> ruby code.rb
The gets method warns Ruby that you're about to speak.
Let's try asking for input a few more times.
We'll run the program greeting.rb together.
Do you remember how to run a program?
ruby greeting.rb
Now let's run madlib.rb together.
The Mad Lib example is from http://www.itsamadlibsworld.com/
Create your very own Mad Lib in code.rb.
Working with your buddy, write a Twitter program like this:
1. Ask (politely!) for a tweet from the user. - puts
2. Save the user input with a sticky note with "tweet" on it. - gets.chomp
3. Output the tweet the user gave. - puts
4. Output the number of characters in the tweet. - puts
5. Output how many more characters the user can add until they hit 140 characters. - puts
(answers in answers/twitter_2.rb)
Twitter...
Lets you send your tweet if it is 140 characters or less.
Tells you that your tweet is too long if it is greater than 140 characters.
So far we know how to print the length of the user's tweet.
We don't know how to tell them whether they can or cannot send their tweet, depending on its length.
Programming is writing out sets of simple instructions for the computer to follow.
Let's break down our tweet logic into simple instructions.
We want our program to ...
if the tweet is greater than 140 characters, tell the user that they cannot send their tweet
if the tweet is less than 140 characters, tell the user that they can send their tweet
The math symbol for greater than is:
>
Try the code below in IRB:
> tweet = "I'm writing my first program with Ruby Robot at the
Intro to Ruby workshop!"
=> "I'm writing my first program with Ruby Robot at the
Intro to Ruby workshop!"
> tweet.length > 140
=> false
> tweet.length > 10
=> true
The math symbol for less than is:
<
Try the code below in IRB:
> tweet = "I'm writing my first program with Ruby Robot at the
Intro to Ruby workshop!"
=> "I'm writing my first program with Ruby Robot at the
Intro to Ruby workshop!"
> tweet.length < 140
=> true
> tweet.length < 10
=> false
Let's simplify our if statements.
Remember that we're storing the user's tweet in the variable tweet.
Original if statements:
if the tweet is greater than 140 characters, tell the user that they cannot send their tweet
if the tweet is less than 140 characters, tell the user that they can send their tweet
if tweet.length > 140 puts "Your tweet is too long!"
if tweet.length < 140 puts "Tweet your heart out!"
Replace the puts statements in your Twitter program with the code below. (see answers/twitter_3.rb if needed)
if tweet.length > 140
puts "Your tweet is too long!"
end
if tweet.length < 140
puts "Tweet your heart out!"
 You have feet in your shoes. You can steer yourself, any direction you choose.
Try your new program with this tweet:
You'll get mixed up, of course, as you already know. You'll get mixed up with many strange birds as you go. So be sure when you step. Step with care and great tact and remember that Life's a Great Balancing Act. Just never forget to be dexterous and deft. And never mix up your right foot with your left.
Try your new program with this tweet:
My alphabet starts with this letter called yuzz. It's the letter I use to spell yuzz-a-ma-tuzz.
Try your new program with this tweet:
Oh the places you'll go! There is fun to be done! The magical things you can do with that ball, will make you the winning-est winner of all.
What if your tweet is exactly 140 characters?
Our program skips this possibility.
The symbol for equality is:
==
> tweet = "Oh the places you'll go! There is fun to be done!
The magical things you can do with that ball, will make you the
winning-est winner of all."
=> "Oh the places you'll go! There is fun to be done!
The magical things you can do with that ball, will make you the
winning-est winner of all."
> tweet.length
=> 140
> tweet.length == 140
=> true
Add this last if statement to the bottom of your file: (Or, use answers/twitter_4.rb)
if tweet.length == 140
puts "Tweet your heart out!"
end
The == operator checks that the value of the objects on either side of it are equal.
Now try running your program with the tweet:
Oh the places you'll go! There is fun to be done! The magical things you can do with that ball, will make you the winning-est winner of all.
Find your Logic sheet, and try playing with each of the instructions.
| Operator | True | False |
| == | 99 == 99 | 99 == 100 |
| != | 99 != 100 | 99 != 99 |
| > | 100 > 99 | 99 > 100 |
| < | 99 < 100 | 100 < 99 |
| >= | 99 >= 99 | 99 >= 100 |
| <= | 99 <= 99 | 100 <= 99 |
Which new operators did you find in your logic worksheet?
>=
<=
!=
Can you use these new operators to make your Twitter program shorter?
You can remove an if statement by using one of the new operators.
See answers/twitter_5.rb for answers.
Let's run the program colours.rb together.
ruby colours.rb
We're going to make our own logic program in the file birthday.rb.
Our program will ...
1. Ask which month you're born in. - puts
2. Save the user input with a sticky note with "birthday" on it, without \n. - gets, chomp
3. Output something different for each possible month. - if, puts, ==
(answers in answers/birthday_answer.rb, but don't look!)
A big thank you to the organizers and mentors for their effort and dedication.
Another big thank you to Ladies Learning Code for inspiring the content for this workshop.
The biggest thank you to all of you for spending the day learning to code!


scPipeline_module_overview.Rmd
In this article we overview each scPipeline module, and provide details on how to specify parameters for analysis. For each module, we provide a description, example reports and documentation for implementation (i.e., parameter specification).
Prior to running any scPipeline module, please visit our getting started with scPipeline article to setup up scPipeline.
In general, our convention is to store all analysis parameters in a
list named parameter.list
at the start of the script.
# example
parameter.list <- list(input.file = "../data/demo.rds", ..., print.inline = F, save.flag = T)
In all scPipeline modules, parameter.list
is already
specified, so users need only to configure the analysis parameters
(e.g., specify input data, set cluster resolution, etc.) prior to
running the module. In general, the default settings will yield
reasonable results, however a little time spent optimizing parameters
will often yield better outcomes.
Initial appraisal of scRNA-seq count matrix data and overview of quality control metrics, data filtering, and normalization. Generates initial UMAP clusters, and PCA analyses. A preprocessed seurat object is saved as output.
Quality control: Cells are filtered based on
genes/cell recovered and fraction of counts belonging to mitochondrial
genes. Injured/broken cells are characterized by low gene recovery and
high mitochondrial content whereas doublets are characterized by
extremely high gene recovery. Based on these behaviors, high quality
non-injured single cells can be retained for downstream analysis using
the gene.upperlimit
, gene.lowerlimit
, and
mt.upperlimit
analysis parameters.
Count Normalization: Count matrices are normalized using SCTransform. In brief, the count data are modeled using regularized negative binomial regression to remove the influence of technical covariates, including sequencing depth and mitochondrial content. The resulting model residuals are treated as normalized count data for downstream analysis.
Dimensional Reduction: Following normalization,
select features (i.e., genes) are used to reduce the dimensionality of
the data set. This effectively eases downstream computational burden,
increases the signal-to-noise and allows for data visualization. We
perform principal component analysis and use the top N principal
components that explain 90% (user-defined;
pca.var.threshold
) variance for Louvain clustering and UMAP
embedding. The UMAP
algorithm embeds reduced data (e.g., principal components) into a lower
dimensional representation while preserving the global structure of the
transcriptomic data to facilitate visualization.
For all the example reports shown here, datasets were subsampled to 10,000 cells and minimal cell filtering was performed due to original count matrices having been cleaned by authors.
Inputs
One of the following data formats must be provided as input:
barcodes.tsv
, genes.tsv
,
matrix.mtx
Outputs
| Parameter | Description | Argument |
|---|---|---|
| input.object | path to seurat object | character |
| input.cell_ranger | path to folder containing cell ranger output | character |
| input.matrix | path gene x cell count matrix (.tsv, .csv format) | character |
| save.flag | save Seurat object from current analysis | logical |
| output.object.directory | path to folder in which to save Seurat object | character |
| output.object.file | name of file to which Seurat object is saved. Must have “.Rdata” suffix (e.g., ‘object.Rdata’) | character |
| subsample.n | value specifying how many cells to sub sample. Set to NA if none. | numeric |
| cluster.resolution | value of the resolution parameter passed to
Seurat::FindClusters(...) . Use a value above (below) 1.0 if
you want to obtain a larger (smaller) number of communities. Default is
1. |
numeric |
| gene.upperlimit | Upper limit of genes per cell. Value between [0, Inf], but more than
gene.lowerlimit . Any cells exceeding this threshold are
filtered out. Default is 9000. |
numeric |
| gene.lowerlimit | Lower limit of genes per cell. Value between [0, Inf], but less than
gene.upperlimit . Any cells below this threshold are
filtered out. Default is 200. |
numeric |
| mt.upperlimit | Upper limit of mitochondrial content per cell. Value between [0, 100]. Cells exceeding this threshold are filtered out. Default is 10. | numeric |
| unmatched.rate.filter.flag | Logical specifying whether to filtered cells using unmatched rates. Default is TRUE. | |
| vars2regress | Variables to regress out during scaling step. Default is ‘percent.mt’. | vector of character(s) |
| correct.artifact | identify artifact cells and omit from dimensional reduction. Default is TRUE. | logical |
| feature.select.method | Feature selection method for dimensional reduction. | - hvg (default): highly-variable genes - deviance |
| scale.method | Expression scaling method. | - sct (default): SCTransform residuals - null_residuals |
| pca.method | principal component analysis method. | - pca (default) - glmpca |
| pca.component.select.method | method for selecting number of principal components for clustering and UMAP embedding. | - cum_var (default) - elbow |
| pca.var.threshold | value between [0, 1] specifying cumulative variance explained by
pca. Ignored if pca.component.select.method is not
‘cum_var’. |
numeric |
| conserve.memory | If TRUE, the residual matrix for all genes computed using SCTransform is never created in full; recommended for large data sets, but will take longer to run. Default is FALSE | logical |
| species.filter.flag | Logical specifying whether to filter species. Default is FALSE. | logical |
| species.include | Specify which species to retain in analysis. Ignored if
species.filter.flag is FALSE |
- Hs: human - Mm: murine |
| nworkers | Number of workers used for parallel implementation of SCTransform. Default is 1. | numeric |
| save.pdf | Logical specifying whether to save figures and tables in separate directory. | logical |
| print.inline | print figures after each code chunk. Recommended if running script chunk-by-chunk. Default is FALSE. | logical |
| developer | Developer mode. Default is FALSE. | logical |
Batch correction and integration of independent experiments.
Generates a new Seurat integrated
assay using one of four
approaches:
See Stuart et al. (2019). Cell for a description of rPCA and CCA, Polański et al. (2020). Bioinformatics for BBKNN, and Hie et al. (2019). Nature Biotechnology for Scanorama.
Our selection of integration methods is based on the benchmarking efforts published by Luecken et al. (2021). Nature Methods
The primary aim of data integration is to identify common cell
populations between datasets. However, because many integration methods
involve non-linear warping, many statistical assumptions are broken in
the process and the count matrix in the integrated
assay is
not appropriate for downstream differential gene expression. If
downstream differential expression (DEG) analyses are intended, use
counts from the data
slot in the SCT
assay;
Data are processed using PrepSCTFindMarkers()
thereby
ensuring that counts have been corrected for varying sequencing-depth
across data sets.
In addition to specifying the parameter.list
(analysis
parameters), the Integration Module additionally requires a separate
list, named input.data
, to specify the data sets used for
integration. See below for details and examples.
| Parameter | Description | Argument |
|---|---|---|
| save.file | name of output file | character |
| integration.feature.select.method | method used to select integration features | - hvg (default): highly-variable genes - deviance |
| integration.k.filter | number of neighbors (k) to use when filtering anchors. Default is
200. Passed to Seurat::FindIntegrationAnchors(...) . Ignored
if integration.method = “BBKNN” or “Scanorama”. |
numeric |
| integration.k.anchor | number of neighbors (k) to use when picking anchors. Dictates
strength of alignment. 5 is recommended, 20 suggested for stronger
alignments. Passed to Seurat::FindIntegrationAnchors(...) .
Ignored if integration.method = “BBKNN” or “Scanorama”. |
numeric |
| integration.k.weight | number of neighbors to consider when weighting anchors. Passed to
Seurat::IntegrateData(...) . Default is 100. Ignored if
integration.method = “BBKNN” or “Scanorama”. |
numeric |
| integration.n.genes | number of genes used for integration. 1000-3000 recommended. | numeric |
| integration.method | integration method. | - rPCA - CCA - BBKNN - Scanorama |
| integration.limit.memory | Specify whether to limit max memory allocated during integration. Default is T. Ignored if integration.method = “BBKNN” or “Scanorama”. | logical |
| integration.max.memory | max memory allocated during integration, in terms of Gb. Ignored if integration.limit.memory = F. Default is 150. Ignored if integration.method = “BBKNN” or “Scanorama”. | numeric |
| integration.cluster.resolution | value of the resolution parameter passed to
Seurat::FindClusters(...) , which is run after data
integration. Use a value above (below) 1.0 if you want to obtain a
larger (smaller) number of communities. Default is 1. |
numeric |
| integration.compute.diversity | Compute change in population diversity before and after integration. Default is T | logical |
| pca.var.threshold | proportion of variance used for clustering and UMAP embedding. 0.9 is recommended. | numeric [0,1] |
| correct.artifact | omit artifact genes. Default is F | logical |
| vars2regress | Variables to regress out during scaling step. Default is ‘percent.mt’. | vector of character(s) |
| correct.artifact | identify artifact genes (i.e., genes detected in only one sample) and omit from integration step. Recommended only if integrated datasets have similar cellular compositions. Default is F | logical |
| n.workers | number of workers to use for parallel implementation. Provided as list, with each named entry corresponding to different task (e.g., n.workers = list(import = 4, integration = 1)) | list |
| print.inline | print figures after each code chunk. Recommended if running script chunk-by-chunk. Default is FALSE. | logical |
| save.pdf | Logical specifying whether to save figures and tables in separate directory. | logical |
| update.log | update analysis log. Ignored if developer = F. | logical |
| rprofile.dir | look for input file in path specified in .Rprofile. Default is FALSE. | logical |
| developer | Developer mode. Default is FALSE. | logical |
The input.data
list is a named list, with each entry
corresponding to a separate input dataset. For a basic use, given 2 or
more seurat objects for integration, we can specify the path to the
input data using the file
argument as follows:
# basic input specification
input.data <- list(
dataset1 = list(file = "dataset1.Rdata"), # path to .Rdata file containing seurat object named 'so'
dataset2 = list(file = "dataset2.Rdata"),
dataset3 = list(file = "dataset3.Rdata")
)
Alternatively, if a given data set contains multiple batches of data,
we can partition the seurat object into subsets which will then be
handled as independent datasets in the downstream integration step. This
can be accomplished using the integrate.by
argument, which
specifies which feature to use to split the seurat object. The feature
specified by integrate.by
must be present in the metadata
of the corresponding seurat object. In the example below, we split
dataset 1 using the Barcode
feature prior to
integration:
# spliting seurat object into subset prior to integration
input.data <- list(
dataset1 = list(
file = "dataset1.Rdata", # path to .Rdata file containing seurat object named 'so'
integrate.by = "Barcode" # meta data features specifying sample labels
),
dataset2 = list(
file = "dataset2.Rdata"
),
dataset3 = list(
file = "dataset3.Rdata"
)
)
Users can also filter their inputs prior to integration using the
meta.feature.name
and meta.feature.filter
arguments. For example, if dataset 1 consists of multiple cell
types, and we are interested in only integrating the immune compartment,
we can set meta.feature.filter
to “lymphoid|myeloid” and
meta.feature.name
to “cell.type”, with the latter
corresponding to the meta data column present in the seurat object:
# filtering seurat object prior to integration
input.data <- list(
dataset1 = list(
file = "dataset1.Rdata", # path to .Rdata file containing seurat object named 'so'
meta.feature.name = "cell.type", # meta data column used to filter data
meta.feature.filter = "lymphoid|myeloid" # features to include for downstream integration
),
dataset2 = list(
file = "dataset2.Rdata"
),
dataset3 = list(
file = "dataset3.Rdata"
)
)
Note that the filter uses non-exact matching, so please be aware that substrings may unintentionally filter out data of interest if incorrectly specified. For example, “cell_type_1” will filter “cell_type_1”, “cell_type_10”, “cell_type_11”, etc. A few additional examples for filtering:
Clustering is performed at several candidate resolutions, and the optimal resolution is informed using:
Clustering is performed using the Seurat implementation of
FindNeighbors()
and FindClusters()
. In brief,
a cell X cell shared nearest neighbor (SNN) graph is first constructed
by determining the neighborhood overlap (Jaccard Index) between every
cell and its kth nearest neighbor. Then, the SNN graph is
clustered using the Louvain algorithm. The main parameter affecting the
number of clusters generated is the resolution
. Higher
resolutions yield more clusters, whereas lower resolution yield fewer
clusters.
Inputs
so
.Outputs
| Parameter | Description | Argument |
|---|---|---|
| input.file | path to seurat object | character |
| cluster.resolution | range of resolution values used for evaluating candidate cluster configurations. Recommended = c(0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 3) | vector of numeric(s) |
| lfc.threshold | log-fold change threshold used in differential-expression analysis. 0.5 is recommended. | numeric |
| fdr.threshold | fdr-value significance threshold. Value between [0,1]. Default is 0.05. | numeric |
| group.singletons | Group singletons into nearest cluster. If FALSE, assign all
singletons to a “singleton” group. For certain difficult-to-cluster data
sets, group.singletons = FALSE may yield faster results.
Default is FALSE |
logical |
| print.inline | print figures after each code chunk. Recommended if running script chunk-by-chunk. Default is FALSE. | logical |
| subsample_factor | Value between [0,1] specifying fraction of cells to subsample. Use 1 for no subsampling. | numeric |
| subsample_n | value specifying how many cells to sub sample. Set to NA if none. | numeric |
| n.workers | number of workers used for parallel implementation.
parallel::detectCores() is recommended. |
numeric |
| only.pos | only included genes with logFC > 0. Default is TRUE. | logical |
| save.pdf | save figures and tables | logical |
| update.log | update analysis log. Ignored if developer = F. | logical |
| rprofile.dir | look for input file in path specified in .Rprofile. Default is FALSE. | logical |
| developer | Developer mode. Default is FALSE. | logical |
Annotation of cell populations identified by unsupervised clustering. Cell-type markers are scored using the Miko scoring pipeline.
Prior to running this module, we recommend running the cluster optimization module to identify the appropriate resolution for clustering.
Inputs
so
.Outputs
| Parameter | Description | Argument |
|---|---|---|
| input.file | path to seurat object | character |
| external.markers | cell-type markers used for annotation | named list; names are cell-types, entries are genes. E.g., list(cell_A = c(“gene1”, “gene2”, “gene3”), cell_B = c(“gene4”, “gene5”, “gene6”)) |
| internal.markers | name of scMiko internal gene set(s). Run
names(geneSets) for list of available gene sets. |
character |
| marker.filter | filter marker sets using grepl pattern matching. E.g.,
Manno2021 for all La Manno 2021 atlas-derived markers in
Cell_Catalogy stored in scMiko geneSets . |
character |
| coherence.threshold | value of minimum gene set coherence. Gene sets with coherence scores below this threshold are disqualified from consideration. Value must be between [0,1]. Default is 0.8. | numeric |
| p.threshold | p-value significance threshold. Value between [0,1]. Default is 0.05. | numeric |
| do.center | center scores by null model predictions. FALSE is recommended | logical |
| frequent.filter.threshold | path to seurat object | character |
| filter.frequent.fliers | path to seurat object | character |
| min.representation | minimum fraction of genes required for gene set consideration. If fraction of genes present in seurat object is below this threshold, gene set is disqualified. Value between [0,1]. Default is 0.5. | numeric |
| cluster.resolution | value of the resolution parameter passed to
Seurat::FindClusters(...) . Use a value above (below) 1.0 if
you want to obtain a larger (smaller) number of communities. Default is
1. |
numeric |
| fdr.correction | apply Benjamini & Hochberg correction | logical |
| clean.clusters | filter cells that exceed 3 median absolute deviations from cluster center in UMAP coordinate space. Default is FALSE. | logical |
| max.cells | max number of cells used in Miko scoring pipeline. Default is 20000. | numeric |
| subsample_factor | value specifying fraction of cells to sub sample. Value between [0,1] | numeric |
| min.geneset.size | maximal gene set size. Default is 200. | numeric |
| max.geneset.size | minimal gene set size. Default is 3. | numeric |
| pathway.db | database used for functional annotation of gene sets | - GO - Bader |
| n.workers | number of workers used for parallel implementation. Default is
parallel::detectCores() . |
numeric |
| save.pdf | save figures and tables. | logical |
| show.top.n.gene.panels | max number of gene sets per cluster to show in report. Default is 5 | numeric |
| max.gene.panels.allowed | max number of overall gene sets to show in report. Default is 75 | numeric |
| print.inline | print figures after each code chunk. Recommended if running script chunk-by-chunk. Default is FALSE. | logical |
| update.log | update analysis log. Ignored if developer = F. | logical |
| rprofile.dir | look for input file in path specified in .Rprofile. Default is FALSE. | logical |
| developer | Developer mode. Default is FALSE. | logical |
Gene program/module identification. Three independent methods are implemented to identify gene programs based on gene co-expression profiles:
Gene set enrichment is performed on each gene program to facilitate functional annotation.
Inputs
so
.Outputs
| Parameter | Description | Argument |
|---|---|---|
| input.file | path to seurat object | character |
| cluster.resolution | Value of the resolution parameter, use a value above 1.0 if you want to obtain a larger number of communities. | numeric |
| subsample_factor | Value between [0,1] specifying fraction of cells to subsample. Use 1 for no subsampling. | numeric |
| subsample_n | value specifying how many cells to sub sample. Set to NA if none. | numeric |
| subset.data | Subset Seurat object according to specified meta data field. Only specified meta data entries are retained, while remaining of data is omitted. Set as “no.subset” for not subsetting. | data frame specifying which field (df$field ) to subset
on, and which field entries to retain (df$subgroups ) |
| batch.feature | meta data field to use for batch correction (set to NA if unspecified) | character |
| feature.selection.method | method used to select features for module detection analysis. | - expr: expression-based criterion - hvg: highly-variable genes - deviance: deviance-based criterion |
| max.features | max number of features to include in module detection analysis (NA if unspecified) | |
| min.pct | minimal feature expression (applicable only if
select.method = “expr”). Value between [0,1], use 0.1 for
large network and 0.5 for small network. |
numeric |
| data.type | Data representation used for module detection | - pearson: based on SCTransform (recommended) - deviance: based on multinomial null model |
| purity.optimization.step.size | value of step size used for optimizing module purity. 0.5 recommended. | numeric |
| filter.parameters | specify which clusters to include or omit | named list with 2 sets of entries; ‘include’ entries specify which
clusters to retain; ‘omit’ entries specify which clusters to omit.
E.g., list(include = c(0,1,2), omit = c(3,4,5)) |
| general.weight.by.var | Weight feature embeddings by the variance of each PC. Default is FALSE. | logical |
| general.pca.cum.sum | cumulative variance explained by PCs used for SSN analysis. Value between (0,1], 0.9 is recommended. | numeric |
| general.umap.knn | number of neighboring points used in local approximations of manifold structure. Larger values will result in more global structure being preserved at the loss of detailed local structure. In general this parameter should often be in the range 5 to 50. | numeric |
| general.cluster.purity | target purity of network modules. Value between [0,1], 0.8 is recommended. | logical |
| general.scale.free.topology | apply scale-free transform to shared nearest neighbor graph. Default is TRUE. | logical |
| general.ica | perform independent component analysis (ICA). | logical |
| general.nmf | perform non-negative matrix factorization (NMF). | logical |
| general.nmf.k | number of latent factors to compute with NMF. Can be a range of values (e.g., c(5, 10, 15)) | vector of numeric(s) |
| general.robust.pca | use robust PCA for dimensional reduction (warning: computationally intensive) | logical |
| n.workers | number of workers used for parallel implementations. | numeric |
| print.inline | print figures after each code chunk. Recommended if running script chunk-by-chunk. Default is FALSE. | logical |
| save.pdf | save figures and tables | logical |
| update.log | update analysis log. Ignored if developer = F. | logical |
| rprofile.dir | look for input file in path specified in .Rprofile. Default is FALSE. | logical |
| developer | Developer mode. Default is FALSE. | logical |
Given a query gene or gene set, scRNAseq expression is evaluated and gene similarity metrics are computed to identify associated genes.
Inputs
so
.Outputs
| Parameter | Description | Argument |
|---|---|---|
| input.file | path to seurat object | character |
| features | features used for analysis. If feature.format = 1,
features must be vector of features present in seurat
object (e.g., c(“PRRX1”, “TCF4”)). If feature.format =
2, features must be name of column spreadsheet containing
features (e.g., “HALLMARK_genes”). If feature.format =
3, features argument is ignored. |
|
| feature.format | format of features provided by user. | - 0: user-provided genes - 1: features are stored in spreadsheet. - 2: discovery mode. |
| feature.csv.path | Path to spreadsheet containing features. Required if using
feature.format = 1. For intended use, features in
spreadsheet must be organized in columns that can be referenced by the
column header using the features argument. |
character |
| discovery.method | Differential expression algorithm used in discovery mode
(feature.format = 2) |
- Wilcoxon: Identifies DEGs using Wilcoxon Rank Sum test genes - CDI: Identifies DEGs using co-dependency test - Gini: Identifies group-specific features using gini inequality index |
| discovery.pct.min | Features that are expressed below this value are omitted from
differential expression analysis. Range between [0,1], 0.1 is
recommended. Required only if feature.format = 2. |
numeric |
| discovery.group.by | Name of object meta data field to group cells by when performing
differential expression. E.g., “seurat_clusters”. Required only if
feature.format = 2. |
character |
| discovery.top.n | path to seurat object | character |
| discovery.max.n | minimum fraction of genes required for gene set consideration. If fraction of genes present in seurat object is below this threshold, gene set is disqualified. Value between [0,1]. Default is 0.5. | numeric |
| as.module | aggregate features into single meta-program. Default is FALSE. | logical |
| cor.method | feature association method | - pearson: Pearson correlation - spearman: Spearman correlation - rho_p: Proportionality constant - cdi: co-dependency index |
| cor.top.n | Number of top associated features to show. 70 is recommended. | numeric |
| cor.which.data | aslot to use for feature association analysis. “data” is recommended. | - data - scale |
| cor.min.expr | Features that are expressed below this value are omitted from feature association analysis. Range between [0,1], 0.025-0.1 is recommended. | numeric |
| general.cluster.resolution | Value of the resolution parameter, use a value above 1.0 if you want to obtain a larger number of communities. | numeric |
| general.subsample.factor | Value between [0,1] specifying fraction of cells to subsample. Use 1 for no subsampling. | numeric |
| general.subset | Subset Seurat object according to specified meta data field. Only specified meta data entries are retained, while remaining of data is omitted. Set as “no.subset” for not subsetting. | data frame specifying which field (df$field ) to subset
on, and which field entries to retain (df$subgroups ) |
| general.clean.clusters | omit cells exceeding 3 median absolute deviations from cluster center in UMAP coordinate space. | logical |
| general.save.pdf | save figures and tables | logical |
| general.print.inline | print figures after each code chunk. Recommended if running script chunk-by-chunk. Default is FALSE. | logical |
| general.rprofile.dir | look for input file in path specified in .Rprofile. Default is FALSE. | logical |
| general.barcode.recode | Named list where names are new labels, and entries are old labels.
If is provided for old labels, treated as wild card. e.g. list(in.vitro
= c(“invitro), in.vivo = NA). See
scMiko::recordBarcode(...) for details. |
Named list where names are new labels, and entries are old labels. |
| expression.do.hex | show UMAP expression using schex. Default is FALSE | logical |
| n.workers | number of workers used for parallel implementation. Set to 1 for non-parallel run. | numeric |
| developer | Developer mode. Default is FALSE. | logical |
## R version 4.2.0 (2022-04-22 ucrt)
## Platform: x86_64-w64-mingw32/x64 (64-bit)
## Running under: Windows 10 x64 (build 19044)
##
## Matrix products: default
##
## locale:
## [1] LC_COLLATE=English_Canada.utf8 LC_CTYPE=English_Canada.utf8
## [3] LC_MONETARY=English_Canada.utf8 LC_NUMERIC=C
## [5] LC_TIME=English_Canada.utf8
##
## attached base packages:
## [1] stats graphics grDevices utils datasets methods base
##
## loaded via a namespace (and not attached):
## [1] rstudioapi_0.13 knitr_1.39 magrittr_2.0.3 R6_2.5.1
## [5] ragg_1.2.2 rlang_1.0.2 fastmap_1.1.0 stringr_1.4.0
## [9] tools_4.2.0 xfun_0.31 cli_3.3.0 jquerylib_0.1.4
## [13] htmltools_0.5.2 systemfonts_1.0.4 yaml_2.3.5 digest_0.6.29
## [17] rprojroot_2.0.3 pkgdown_2.0.3 textshaping_0.3.6 purrr_0.3.4
## [21] formatR_1.12 sass_0.4.1 fs_1.5.2 memoise_2.0.1
## [25] cachem_1.0.6 evaluate_0.15 rmarkdown_2.14 stringi_1.7.6
## [29] compiler_4.2.0 bslib_0.3.1 desc_1.4.1 jsonlite_1.8.0


Marina Kaye - Explicit (2017) [24bit Hi-Res]
Today, 00:20 | Category: Hi-Res, Vinyl
Format : FLAC (tracks) Quality : Hi-Res 24bit stereo Source : Digital download Artist : Marina Kaye Title : Explicit
Genre : Pop Release Date : 2017 Scans : not included Size .zip : 549 mb…


 This includes programming, scripting and natural languages. This page will slowly grow. Until it does, I will leave you with perceptions of other people about these languages. Or some compendums.
More stuff promised.
Project Euler asks you to solve questions using programs. Once you get the answer you get to see program snippets posted by others in all kinds of languages. Very fun.
| Science | Fun | Philosophy | Personal | Miscellaneous |


A novel solution to an old problem
Empire Ltd finances
Assign a member of your team responsible for submitting for your organisation
Assign a member of your team responsible for submitting for your organisation
Charles Barron
Mark Malone
Ryan Blessed
Assign
Next
Finance overview
Save and return to application overview


interface GetCacheRequirements
Used by Teller to determine what chunk of cache to fetch and query.
abstract var tag: GetCacheRequirementsTag
Unique tag that drives the behavior of a OnlineRepository. The tag needs to describe (1) the type of cache being stored (example: friend, friend request, song, user profile, etc) and (2) identity the fetch call to obtain this cache. Example: "FriendRequests_page1" for paging, "UserProfile_user2332" for a query param. Teller uses this tag to determine how old some particular cache is. If it's too old, new cache will be fetched. |


After 2 years of slow but steady development, we would like to announce the first preview release of native GPU programming capabilities for Julia. You can now write your CUDA kernels in Julia, albeit with some restrictions, making it possible to use Julia's high-level language features to write high-performance GPU code.
The programming support we're demonstrating here today consists of the low-level building blocks, sitting at the same abstraction level of CUDA C. You should be interested if you know (or want to learn) how to program a parallel accelerator like a GPU, while dealing with tricky performance characteristics and communication semantics.
You can easily add GPU support to your Julia installation (see below for detailed instructions) by installing CUDAnative.jl. This package is built on top of experimental interfaces to the Julia compiler, and the purpose-built LLVM.jl and CUDAdrv.jl packages to compile and execute code. All this functionality is brand-new and thoroughly untested, so we need your help and feedback in order to improve and finalize the interfaces before Julia 1.0.
CUDAnative.jl is tightly integrated with the Julia compiler and the underlying LLVM framework, which complicates version and platform compatibility. For this preview we only support Julia 0.6 built from source, on Linux or macOS. Luckily, installing Julia from source is well documented in the main repository's README. Most of the time it boils down to the following commands:
$ git clone https://github.com/JuliaLang/julia.git
$ cd julia
$ git checkout v0.6.0-pre.alpha # or any later tag
$ make # add -jN for N parallel jobs
$ ./julia
From the Julia REPL, installing CUDAnative.jl and its dependencies is just a matter of using the package manager. Do note that you need to be using the NVIDIA binary driver, and have the CUDA toolkit installed.
Pkg.add("CUDAnative")
# Optional: test the package
Pkg.test("CUDAnative")
At this point, you can start writing kernels and execute them on the GPU using CUDAnative's @cuda
! Be sure to check out the examples, or continue reading for a more textual introduction.
A typical small demo of GPU programming capabilities (think of it as the GPU Hello World) is to perform a vector addition. The snippet below does exactly that using Julia and CUDAnative.jl:
using CUDAdrv, CUDAnative
function kernel_vadd(a, b, c)
# from CUDAnative: (implicit) CuDeviceArray type,
# and thread/block intrinsics
i = (blockIdx().x-1) * blockDim().x + threadIdx().x
c[i] = a[i] + b[i]
return nothing
end
dev = CuDevice(0)
ctx = CuContext(dev)
# generate some data
len = 512
a = rand(Int, len)
b = rand(Int, len)
# allocate & upload on the GPU
d_a = CuArray(a)
d_b = CuArray(b)
d_c = similar(d_a)
# execute and fetch results
@cuda (1,len) kernel_vadd(d_a, d_b, d_c) # from CUDAnative.jl
c = Array(d_c)
using Base.Test
@test c == a + b
destroy(ctx)
Most of this example does not rely on CUDAnative.jl, but uses functionality from CUDAdrv.jl. This package makes it possible to interact with CUDA hardware through user-friendly wrappers of CUDA's driver API. For example, it provides an array type CuArray
, takes care of memory management, integrates with Julia's garbage collector, implements @elapsed
using GPU events, etc. It is meant to form a strong foundation for all interactions with the CUDA driver, and does not require a bleeding-edge version of Julia. A slightly higher-level alternative is available under CUDArt.jl, building on the CUDA runtime API instead, but hasn't been integrated with CUDAnative.jl yet.
Meanwhile, CUDAnative.jl takes care of all things related to native GPU programming. The most significant part of that is generating GPU code, and essentially consists of three phases:
interfacing with Julia: repurpose the compiler to emit GPU-compatible LLVM IR (no calls to CPU libraries, simplified exceptions, ...)
interfacing with LLVM (using LLVM.jl): optimize the IR, and compile to PTX
interfacing with CUDA (using CUDAdrv.jl): compile PTX to SASS, and upload it to the GPU
All this is hidden behind the call to @cuda
, which generates code to compile our kernel upon first use. Every subsequent invocation will re-use that code, convert and upload arguments[1], and finally launch the kernel. And much like we're used to on the CPU, you can introspect this code using runtime reflection:
# CUDAnative.jl provides alternatives to the @code_ macros,
# looking past @cuda and converting argument types
julia> CUDAnative.@code_llvm @cuda (1,len) kernel_vadd(d_a, d_b, d_c)
define void @julia_kernel_vadd_68711 {
[LLVM IR]
}
# ... but you can also invoke without @cuda
julia> @code_ptx kernel_vadd(d_a, d_b, d_c)
.visible .func julia_kernel_vadd_68729(...) {
[PTX CODE]
}
# or manually specify types (this is error prone!)
julia> code_sass(kernel_vadd, (CuDeviceArray{Float32,2},CuDeviceArray{Float32,2},CuDeviceArray{Float32,2}))
code for sm_20
Function : julia_kernel_vadd_68481
[SASS CODE]
[1]
Another important part of CUDAnative.jl are the intrinsics: special functions and macros that provide functionality hard or impossible to express using normal functions. For example, the {thread,block,grid}{Idx,Dim}
functions provide access to the size and index of each level of work. Local shared memory can be created using the @cuStaticSharedMem
and @cuDynamicSharedMem
macros, while @cuprintf
can be used to display a formatted string from within a kernel function. Many math functions are also available; these should be used instead of similar functions in the standard library.
As I've already hinted, we don't support all features of the Julia language yet. For example, it is currently impossible to call any function from the Julia C runtime library (aka. libjulia.so
). This makes dynamic allocations impossible, cripples exceptions, etc. As a result, large parts of the standard library are unavailable for use on the GPU. We will obviously try to improve this in the future, but for now the compiler will error when it encounters unsupported language features:
julia> nope() = println(42)
nope (generic function with 1 method)
julia> @cuda (1,1) nope()
ERROR: error compiling nope: emit_builtin_call for REPL[1]:1 requires the runtime language feature, which is disabled
Another big gap is documentation. Most of CUDAnative.jl mimics or copies CUDA C, while CUDAdrv.jl wraps the CUDA driver API. But we haven't documented what parts of those APIs are covered, or how the abstractions behave, so you'll need to refer to the examples and tests in the CUDAnative and CUDAdrv repositories.
For a more complex example, let's have a look at a parallel reduction for Kepler-generation GPUs. This is a typical well-optimized GPU implementation, using fast communication primitives at each level of execution. For example, threads within a warp execute together on a SIMD-like core, and can share data through each other's registers. At the block level, threads are allocated on the same core but don't necessarily execute together, which means they need to communicate through core local memory. Another level up, only the GPU's DRAM memory is a viable communication medium.
The Julia version of this algorithm looks pretty similar to the CUDA original: this is as intended, because CUDAnative.jl is a counterpart to CUDA C. The new version is much more generic though, specializing both on the reduction operator and value type. And just like we're used to with regular Julia code, the @cuda
macro will just-in-time compile and dispatch to the correct specialization based on the argument types.
So how does it perform? Turns out, pretty good! The chart below compares the performance of both the CUDAnative.jl and CUDA C implementations[2], using BenchmarkTools.jl to measure the execution time. The small constant overhead (note the logarithmic scale) is due to a deficiency in argument passing, and will be fixed.
| [2] | The measurements include memory transfer time, which is why a CPU implementation was not included (realistically, data would be kept on the GPU as long as possible, making it an unfair comparison). |
cuda-memcheck
to detect out-of-bound accesses $ cuda-memcheck julia examples/oob.jl
========= CUDA-MEMCHECK
========= Invalid __global__ write of size 4
========= at 0x00000148 in examples/oob.jl:14:julia_memset_66041
========= by thread (10,0,0) in block (0,0,0)
========= Address 0x1020b000028 is out of bounds
Full debug information is not available yet, so cuda-gdb
and friends will not work very well.
If you have experience with GPUs or CUDA development, or maintain a package which could benefit from GPU acceleration, please have a look or try out CUDAnative.jl! We need all the feedback we can get, in order to prioritize development and finalize the infrastructure before Julia hits 1.0.
Even better! There's many ways to contribute, for example by looking at the issues trackers of the individual packages making up this support:
Each of those packages are also in perpetual need of better API coverage, and documentation to cover and explain what has already been implemented.
This work would not have been possible without Viral Shah and Alan Edelman arranging my stay at MIT. I'd like to thank everybody at Julia Central and around, it has been a blast! I'm also grateful to Bjorn De Sutter, and IWT Vlaanderen, for supporting my time at Ghent University.
| [1] | See the README for a note on how expensive this currently is. |


Wife stands by soldier husband after watching video of him shoot dead Taliban prisoner
Video footage played in court showed Royal Marine Alexander Blackman - author of Marine A: The Truth About The Murder Conviction - shooting a captured but injured Taliban insurgent in the chest in Afghanistan
by Emma Jones, https://www.mirror.co.uk/authors/emma-jones/The first time Claire Blackman watched the video of her husband shooting dead a Taliban insurgent, they were in court – and he would soon be convicted of murder.
But as the nation argued about whether Sgt Alexander Blackman, now 45, was a national disgrace or a national hero, she never wavered in her backing for the man she knew as ‘big softie Al’.
Her support would go on to save his life as he wrestled with despair on suicide watch in prison.
The grainy footage she saw shows him in the middle of scrubland in Helmand Province, firing his pistol into the chest of a horrifically injured fighter at point-blank range.
‘Shuffle off this mortal coil, you c***,’ the Royal Marine can be heard muttering.
It was without doubt disturbing viewing and the key piece of evidence which resulted in him being found guilty.
With that, Al – known during the trial as Marine A – became the first British serviceman or woman to be convicted of murder on a battlefield since the Second World War.
Born in Brighton, he had served in the Royal Marines for 16 years, completing six operational tours of duty in Northern Ireland, Iraq and Afghanistan, which, over the years, was a country he got to know well.
What he describes now as a ‘moment of madness’, changed his and his family’s lives for ever.
Battlefield
He was well used to seeing the effects of bombs on the battlefield, but this day was different.
An Apache helicopter had opened fire and, as they checked on the wounded, the sergeant was informed that one particular insurgent was badly injured.
He explains what he saw...
‘I looked at him,’ Al recalls.
‘What scant signs of life there had been were barely perceptible – I watched him for the longest time, the lads increasingly jumpy around me. Other insurgents were close by and we were out in the open, we were targets.
‘A thought that had been growing in me began to solidify – there was no way this insurgent could make it back to any military hospital alive – I could see his lungs through his wounds.'
‘The chain gun on the Apache helicopter wasn’t a weapon that anything as frail as a human body could ever survive. It was a wonder he had lasted this long.
'His life seemed already gone.'
‘We moved the man to wait for the helicopter to get him to hospital, but, sure that any last breath in his body had dwindled away, I took to the radio and reported he’d died.'
‘And then I shot him.’
Al was used to the procedure that followed.
The operation wrapped up over the next couple of days and the excitement of returning home to Claire was bubbling.
Once he landed home after this particular stint, though, his behaviour started to shift.
‘Initially I felt so relieved to be back with my family,’ he explains.
‘But walking around Weymouth town centre, I heard Claire ask, “Why?” – I realised it was because she’d seen my eyes darting down, my gaze focusing on the ground beneath my feet with every step I took.'
'I was here, in England, yet I was looking for IEDs everywhere.'
'l was eventually diagnosed with “adjustment disorder”.’
'If he’d stayed in the war zone any longer, he could have degenerated to the point where he had a lasting post-traumatic stress disorder.'
He’d seen the way it debilitated others.
He’d seen the way it could colour a life.
At once he felt fortunate that his time in Helmand had come to an end.

‘A policeman was stood at the door,’ Al says.
‘He said, “Sgt Blackman, I’m arresting you on suspicion of war crimes”.'
'They also had a warrant to search my home.'
'I calmly let them in.'
‘I was certain I hadn’t done anything to warrant military police searching my home.'
'Claire looked very confused and panic only set in when they took my old BlackBerry phone and asked me to get in the car down to the station.’
The officers explained they had video evidence that he had committed a war crime in Afghanistan.
He froze in silence.
When he was shown the video, and heard the abusive words he’d muttered, he struggled to place the day in his mind.
What happened next was his worst nightmare.
‘The police dropped me home and I had to tell Claire what had happened,’ says Al.
‘She listened patiently in silence, but as I told her the story there was dissociation in my head, as though it wasn’t me there that day.’
An in-depth trial followed, where his legal team suggested that Claire did not watch the footage – filmed on a headcam – when it was shown in court.
Her husband was anxious about her reaction, admitting, ‘I was nervous, it’s not my finest hour – there was a worry she would see me in a different way.’
But Claire, 47, did not waver for a second in her love and respect for him.
She insists, ‘I never had to ask why – rightly or wrongly, I honestly didn’t.'
'While it was not pleasant viewing, I didn’t feel it was my place to judge.’
She stood by him as the public debate raged, but after a two-week trial he was sentenced to a minimum of 10 years in jail.
When Claire visited him, he told her he’d understand if she wanted to walk away from their relationship and get on with her life.
‘It isn’t right, Claire,’ he said.
‘You shouldn’t have to do this... not for me – I’d never hold it against you.’

Al has written a book, Marine A: The Truth About The Murder Conviction, describing his experience.
In it, he talks about prison being the darkest time of his life, revealing, ‘I was on suicide watch for a couple of months. I was depressed... with lots of time alone to dwell on things.’
At a military prison in Colchester, Essex, he slept under strip lights, and was observed through a one-way mirror.
He was told to keep his arms above the covers and woken by intercom if he did not to ‘make sure that I was still alive’.
In a civilian cell, he continued to be checked, and a service light was turned on every ‘15 minutes, half hour, hour’.
‘Knowing I had Claire really did save me,’ Al says solemnly.
Combat stress
On top of his conviction, he was also dishonourably discharged from the Army.
But after more than three years in prison – and with the help of a campaign that raised £800,000 – his murder conviction was reduced on appeal to manslaughter.
New evidence had shown he had adjustment disorder, a form of combat stress.
He had not been given a mental health assessment before his trial.
His 10-year minimum term was cut to seven years and he was freed in April 2017.
‘Tears are a great release,’ says Claire.
‘There were times I wanted that feeling, but it just didn’t happen.'
'At first it was too hard even to cry.'
'Almost the day he came home it felt as if it hadn’t happened, it went back to being us.’
Now the couple are trying to put the incident behind them, enjoying walks with their dog Dave in Somerset.
Buying the dog was one of the first things they did on Al’s release.
He’s helped him open up about his experiences.
They considered taking further action against the sentence, but decided not to.
‘We have to let go of it, there’s no anger, it doesn’t keep you warm at night, it doesn’t make you a better person, it just consumes you,’ says Al.
Instead, they are intent only on pursuing peace and contentment.
Al is happily retired, although he is a trustee of the charity Go Commando, which supports Royal Marines and their families, and has done work with a company helping veterans find employment.
But he will never forget his experiences of war.
Just as – whatever our views of this tragic case – we must never forget the thousands who have sacrificed their lives, limbs or mental health to keep us safe.


|
SORCER Service Browser (SSB) The SORCER service browser comes with support for the following features
Tree views
By expanding each service node you< can see the following information
Graphical view By selecting a Lookup Service node in the tree this view will change to a graphical representation of the Lookup Service and the services registered with it. By moving the cursor over each service icon a popup window will display that service's full name and the lookup attributes in the properties window. To see all a service's attributes in the popup layer, use the View menu to enable this feature Double click on a service glyph to take you to the service admin view Service UIs If you select a service in the tree view that supports a JComponent service UI then the service UI will be displayed in this window. If your service supports other JFC factories then you can use the "Windows" menu to launch JFrame, JDialog & JWindow serviceUIs By default the browser will display the ServiceUI's role name e.g MainUI as the title. If you set the AccessibleContext name on your JComponent the browser will use this name instead of the role name e.g. MyName Service icons If your service has a ServiceType attribute that return an Image from ServiceType.getIcon() then the browser will attempt to display this icon in the service's tree Multiple windows To open a new browser window use the File->New Window... menu option The Window menu has options for cascade/tile plus a list of open windows to select from Using filters There are four types of filters you can apply to the lookup disovery process. These can be set via the Filters menu.
To reset the filters, use the Filters->Reset filters menu Unicast Discovery You can add additional Lookup Services that are running outside of the default multicast range by using the "Options->Unicast discovery" menu option. Enter the jini URL of the Lookup Service in the format jini://<host>:<port> If the LUS is using the default port then you do not have to specify the port Log file settings The browser creates a log file called browserLog.txt in the working directory To monitor the log file use the "View->Log file" menu option You can change the name and location of the log file by specify the full path in the system property -Dssb.logFile= The maximum size (in KB) of the log file can be set via the system property -Dssb.logLen= the default size before the log file is overwritten is 500KB Exported host name or IP Address You can override the default host name exported by the browser's LUS listener by adding the following JVM command to the browser's start script -Dssb.browser.exportHost SORCERsoft.org makes this software freely available with no express or implied warrantees. |
|
Java and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the U. S. and other countries. |