iEVA arguments¶
A full list of iEVA tool arguments with a short description can be accessed by typing in your command line -h
[- -help] option:
$ iEVA -h [--help]
usage: iEVA [-h] [-v] -I path/to/input -Ref path/to/fasta -O path/to/outfile
[-L path/to/bamlist] [-WS [20-600]] [-SR]
[-SRList path/to/SampleRepeatList.txt] [-SRL] [-SRU] [-PNC] [-RM]
[-GC] [-VC] [-SBR] [-UnMap] [-MMQ] [-MQ0] [-NPA] [-SA] [-NP]
[-NPP] [-AS] [-TDR] [-iNDR] [-iNDA] [-iDR] [-iDA] [-iDDup] [-TDP]
[-SNVmbq [0-66]] [-SNVmmq [0-60]] [-INDELmbq [0-66]]
[-INDELmmq [0-60]] [-iDP] [-iAD] [-iRR] [-iRA] [-iQR] [-iQA]
[-iRMQ] [-iAMQ] [-iNCR] [-iNCA] [-iCR] [-iCA]
iEVA: identification and Extraction of Variant Attributes.
optional arguments:
-h, --help show this help message and exit
-v, --verbose Increase output verbosity. Enable iEVA extraction
progress information
Required arguments
-I path/to/input, --input path/to/input
Input file in vcf format.
-Ref path/to/fasta, --reference path/to/fasta
Reference file in fasta format.
-O path/to/outfile, --outfile path/to/outfile
Output vcf file.
-L path/to/bamlist, --list path/to/bamlist
REQUIRED ONLY TO EXTRACT FEATURES FROM BAM FILE. Bam
list file, including path, one for each raw. Sample
name in vcf genotype field has to be the same of Read
Group Sample Name (SM) tag in bam file header. Bam
Index file required in same path of bam file.
Reference.fasta extraction arguments
-WS [20-600], --WindowSize [20-600]
Set window size for -SR -SRL -GC and -PNC command.
Default=40, Min=20, Max=600
-SR, --SimpleRepeat Enable Simple Repeat Finder. Check if a variant fall
in a Simple Repeated Sequence. 0 for None, 1 for
Simple Repeat Sequence, 2 for Homopolymer.
-SRList path/to/SampleRepeatList.txt, --SimpleRepeatList path/to/SampleRepeatList.txt
path to list containing simple repeated sequence (one
for each raw) to extract with iEVA. If enabled, only
reported sequences in file will be extracted. -SR
option is required.
-SRL, --SimpleRepeatLength
Length of repeated sequence (expressed as number of
nucleotides) in -SR option
-SRU, --SimpleRepeatUnit
Repeated sequence unit composing simple repeated
sequence
-PNC, --PseudoNucleotidesComposition
Describe nucleotide sequence using Pseudo Nucleotide
Composition with Kmer size of 2. Values reported as:
AA,AC,AG,AT,CA,CC,CG,CT,GA,GC,GG,GT,TA,TC,TG,TT
-RM, --RepeatMasker Check from fasta reference if a variant falls in a
sequence flagged as repeated sequence by RepeatMasker
tool.
-GC, --gcContent Percentage of sequence GC content.
-VC, --VariantClass Annotated variant class: SNV (snv), Insertion (Ins),
Deletion (Del), Sequence Alteration (Alt)
Bam extraction arguments
-SBR, --StrandBiasReads
Fisher's exact test based on read orientation
(R1+,R1-,R2+,R2-) to detect strand bias. Only for
paired-end sequencing experiments.
-UnMap, --UnMappedReads
Fraction of unmapped reads for variant position.
-MMQ, --MeanMappingQuality
Mean mapping quality for reads mapping variant
position
-MQ0, --MappingQualityZero
Fraction of reads with Mapping Quaility=0.
-NPA, --NotPrimaryAlignment
Fraction of reads mapping position flagged as not
primary alignment.
-SA, --SupplementaryAlignment
Fraction of reads mapping position flagged as
supplementary alignment.
-NP, --NotPairedReads
Fraction of reads mapping position flagged as not
paired.
-NPP, --NotProperPairedReads
Fraction of reads mapping position flagged as not
proper paired.
-AS, --AlignmentScore
Mean Alignment Score of reads mapping position.
-TDR, --TotalDupReads
Fraction of total reads mapping position marked as
duplicate.
Genotype extraction arguments
-iNDR, --NumberReadDupRef
Number of reads mapping position marked as duplicate
on REF allele.
-iNDA, --NumberReadDupAlt
Number of reads mapping position marked as duplicate
on ALT allele.
-iDR, --DuplicateReference
Fraction of reads mapping position marked as duplicate
on REF allele.
-iDA, --DuplicateAlternate
Fraction of reads mapping position marked as duplicate
on ALT allele.
-iDDup, --DeltaDuplicate
Difference between fraction duplicate reads in REF and
ALT alleles (REF-ALT). Negative values show preference
in duplicate for REF allele, positive for ALT.
-TDP, --TotalDPUnfilter
Total read depth. No filter applied, include duplicate
reads. Look at -iDP option for filtered iDP.
-SNVmbq [0-66], --SNVMinBaseQuality [0-66]
Minimum Base Quality threshold for base supporting SNV
position. Used on allele specific annotation.
Default=12
-SNVmmq [0-60], --SNVMinMappingQuality [0-60]
Minimum Mapping Quality threshold for reads supporting
SNV position. Used on allele specific annotation.
Default=30
-INDELmbq [0-66], --IndelMinBaseQuality [0-66]
Minimum Base Quality threshold for base supporting
InDel position. Used on allele specific annotation.
Default=10
-INDELmmq [0-60], --IndelMinMappingQuality [0-60]
Minimum Mapping Quality threshold for reads supporting
InDel position. Used on allele specific annotation.
Default=20
-iDP, --iEvaDepth iEVA read depth for variant position. Only proper
paired, proper mapped and not duplicate reads are
included.
-iAD, --iAlleleDepth iEVA Allele Depth reported as Ref,Alt
-iRR, --ReadRef Number of reads mapping REF allele.
-iRA, --ReadAlt Number of reads mapping ALT allele.
-iQR, --MeanRefQscore
Mean Q-score for REF allele.
-iQA, --MeanAltQscore
Mean Q-score for ALT allele.
-iRMQ, --RefMeanMappingQuality
Mean mapping quality for reads supporting REF allele.
-iAMQ, --AltMeanMappingQuality
Mean mapping quality for reads supporting ALT allele.
-iNCR, --NumberClippedReadsRef
Number of clipped reads mapping REF allele.
-iNCA, --NumberClippedReadsAlt
Number of clipped reads mapping ALT allele.
-iCR, --ClippedReadsRef
Fraction of clipped reads mapping REF allele.
-iCA, --ClippedReadsAlt
Fraction of clipped reads mapping ALT allele.
Required arguments¶
-I, –input
Path to input vcf file
-Ref, –reference
Path to reference file in fasta format
-O, –outfile
Path to output vcf file
-L, –list
REQUIRED ONLY TO EXTRACT ATTRIBUTES FROM BAM FILE.
Path to Bam list file, one file for each raw, as explained in Usage.Sample name in vcf genotype field has to be the same of Read Group Sample NameRG:SM
tag in bam file header. Bam Index file required in the same path of bam file.
Reference extraction arguments¶
Attributes extracted from reference.fasta
file will be reported in vcf INFO column.
-SR, –SimpleRepeat¶
Enable Simple Repeat Finder. -SR
option checks if a variant in POS field of input vcf file falls into a repeated sequence for a specific window size.
iEVA is able to identify two class of repetitions:
- Simple Repeat Sequence: in -SR we defined 3 simple rules, BY DEFAULT, in order to identify a tandem simple repeated sequence:
- Number of repetitions (N) >= 3. e.g 3(CG) = CGCGCG
- Nucleotides composing repeating unit (dY) = 2. For example, given a number of repetitions N=3, 3(ATT) is a SR sequence. 3(AATC), instead, is not a SR sequence because of 3 different nucleotides composing repeating unit.
- Max length of repeating unit (L) = 6. By default, -SR option extracts only repeated sequences with L=6. For example, N(ATTAATT) is not considered a SR sequence
We selected these rules by default with -SR
option in iEVA because these repeated sequences mostly influence base-calling and sequencing quality metrics [1]. However, if you need to find more complex repetitions (or implementing your own rules for repeated sequences) look at -SRList, –SimpleRepeatList option.
- Homopolymer Sequence: it is defined as:
- Number of repetitions (N) > 3
- Number of nucleotides composing single repeated sequence unit (dY) = 1. e.g 4(A)
For example, GAGAGAGA is a Repeated Sequence of a GA dinucleotide with N = 4. Instead, AAAAAAA is an Homopolymer of A nucleotide with N = 7.
Note
-SR
argument has three output values: SR=0
for None, SR=1
for Repeated Sequence and SR=2
for Homopolymer Sequence.
iEVA does not extract all repeated sequence in window size but only verify if a variant falls into it: only in this case, iEVA report repeated sequence class, otherwise SR=0.
A complete list of Simple Repeat Sequence extracted by iEVA can be found in iEVA package at ./iEVA/Supplementary/Simple-Repeated-Sequence-list.txt
-SRList, –SimpleRepeatList¶
Path to list containing simple repeated sequence (one for each raw) to extract with iEVA. Enabling -SRList
command, you ask to iEVA to check if a variant falls in a repeated sequence reported in list, neglecting previously explained rules for simple repeated sequences in -SR, –SimpleRepeat option.
User can choose to find any type of repeated sequence only if provides single repeating unit in file. Compared to -SR, –SimpleRepeat option, you can define your own rules, using also sequences composed by more than two nucleotides (dY >= 2) and with a max length of repeating unit greater than 6 (L >= 6). For example, try to create a RepSeq.txt
file as follow:
CTT
ACG
ACCTG
In this case, iEVA finds all repeated sequences with number of repetitions > 3 like CTTCTTCTTCTTCTT, ACGACGACGACG or ACCTGACCTGACCTG
Warning
Using -SRList
command iEVA will not extract the default repetitions reported in ./iEVA/Supplementary/Simple-Repeated-Sequence-list.txt
file but only those given in file list. However, iEVA always finds homopolymer sequences.
If you want to extract also default repetitions, you can add your repeating unit of interest in that file and use it to extract all requested repeated sequences.
-SRL, –SimpleRepeatLength¶
Total length, as number of nucleotides, of repeated sequence in SR
option in which variant falls.
Note
GAGAGAGA, for example, has SRL=8
.
-SRU, –SimpleRepeatUnit¶
Report simple repeat unit composing simple repeated sequence. For axample, ATTATTATT has a saimple repeat unit SRU=ATT
.
-PNC, –PseudoNucleotidesComposition¶
In order to achieve an accurate description of a sequence around a variant in vcf input file, we implemented in iEVA a Pseudo nucleotide composition or PseKNC for a specific window size.
PseKNC allows to enclose nucleotide sequence composition using a number of attributes depending on kmer size. In iEVA we choosed a dinucleotide profile (kmer size of 2), resulting in 16 attributes: AA,AC,AG,AT,CA,CC,CG,CT,GA,GC,GG,GT,TA,TC,TG,TT. Each dinucleotide combination is represented by a float number.
See also
Further details about Pseudo nucleotide composition at [2].
Note
-PNC
is reported in vcf as a list of 16 values: PNC=AA,AC,AG,AT,CA,CC,CG,CT,GA,GC,GG,GT,TA,TC,TG,TT
.
-RM, –RepeatMasker¶
Check if variant falls in a lower case sequence on reference.fasta
file for a specific window size.
Sequence in lower case is used for sequences identified by RepeatMasker as low-complexity or repetitive elements as reported in Fasta format specification
Note
-RM
argument has two possible values. RM=0
if fasta sequence is upper case, RM=1
if fasta sequence is lower case.
-GC, –gcContent¶
GC content of a sequence for a specific window size.
-VC, –VariantClass¶
Verify if variant class is SNV, Insertion or Deletion. Other variant classes (e.g InDel) are reported as Sequence Alteration.
Note
-VC
argument has 4 possible values. VC=snv
for SNV, VC=Ins
for Insertion, VC=Del
for Deletion and VC=Alt
for Sequence Alteration
Bam extraction arguments¶
These arguments extract several information about reads mapping sample variant position. Attributes are extracted from flag field in .bam
file and will be annotated in vcf genotype field for bam reported in -L option.
See also
Look at bam specifications for details about bam format.
-SBR, –StrandBiasReads¶
Fisher’s exact test based on read orientation (R1+,R1-,R2+,R2-) to detect strand bias. Only for paired-end sequencing experiments. This option excludes reads flagged as duplicates and unmapped.
-UnMap, –UnMappedReads¶
Fraction of unmapped reads for a variant position.
-MMQ, –MeanMappingQuality¶
Mean mapping quality for reads mapping variant position.
-MQ0, –MappingQualityZero¶
Fraction of reads mapping variant position with Mapping Quaility MQ=0.
-NPA, –NotPrimaryAlignment¶
Fraction of reads mapping variant position and flagged as not primary alignment.
-SA, –SupplementaryAlignment¶
Fraction of reads mapping variant position and flagged as supplementary alignment.
-NP, –NotPairedReads¶
Fraction of reads mapping variant position and flagged as not paired.
-NPP, –NotProperPairedReads¶
Fraction of reads mapping variant position and flagged as not proper paired.
-AS, –AlignmentScore¶
Mean Alignment Score for reads mapping variant position. Tested on bam obtained with BWA
-TDR, –TotalDupReads¶
Fraction of total reads mapping variant position and marked as duplicate.
Genotype extraction arguments¶
Genotype extraction arguments allow to extract information about sample genotype analyzing .bam
file.
Most of the command line options in this section start with -i
because are computed by iEVA and are affected by -SNVmbq, -SNVmmq, -INDELmbq and -INDELmmq arguments. They set SNV/InDels mapping quality and base quality threshold for all reads supporting variant position. All reads below threshold are filtered.
-TDP, –TotalDPUnfilter¶
Total read depth for a variant position. No filter applied, including duplicate reads. Look at -iDP
option for filtered read depth.
-SNVmbq, –SNVMinBaseQuality¶
Minimum base quality threshold for base supporting SNV position.
SNVmbq=[0-66], Default=12
-SNVmmq, –SNVMinMappingQuality¶
Minimum mapping quality threshold for reads supporting SNV.
SNVmmq=[0-60], Default=30
-INDELmbq, –IndelMinBaseQuality¶
Minimum base quality threshold for base supporting Insertions and Deletions.
INDELmbq=[0-66], Default=10
-INDELmmq, –IndelMinMappingQuality¶
Minimum mapping quality threshold for reads supporting Insertions and Deletions.
INDELmmq=[0-60], Default=20
-iNDR, –NumberReadDupRef¶
Number of reads mapping variant position and marked as duplicate on REF allele in vcf REF column.
-iNDA, –NumberReadDupAlt¶
Number of reads mapping variant position and marked as duplicate on ALT allele in vcf ALT column.
-iDR, –DuplicateReference¶
Fraction of reads mapping variant position and marked as duplicate on REF allele in vcf REF column.
-iDA, –DuplicateAlternate¶
Fraction of reads mapping variant position and marked as duplicate on ALT allele in vcf ALT column.
-iDDup, –DeltaDuplicate¶
Difference between fraction of duplicate reads for REF and ALT alleles (%REF - %ALT). A negative value shows preference in duplicate for REF allele, positive for ALT.
-iDP, –iEvaDepth¶
iEva read depth for variant position counted as reads supporting REF allele + ALT allele. Only reads flagged as proper paired, proper mapped and not duplicate are used to extract iDP
. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
-iAD, –iAlleleDepth¶
iEVA allele depth as number of reads supporting REF and ALT allele reported as iAD=iRR,iRA
-iRR, –ReadRef¶
Number of reads supporting REF allele. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
-iRA, –ReadAlt¶
Number of reads supporting ALT allele. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
-iQR, –MeanRefQscore¶
Mean Q-score for base supporting REF allele. iEVA extracts iQR
for reads supporting ref allele depending on Variant Class attribute as follow:
- SNV: Mean Q-score for all bases supporting REF allele
- Insertion: Mean Q-score for all inserted bases supporting REF allele
- Deletion: Mean Q-score for the base before and after deletion.
-iQA, –MeanAltQscore¶
Mean Q-score for base supporting ALT allele. iEVA extracts QA
for reads supporting alt allele depending on Variant Class attribute as follow:
- SNV: Mean Q-score for all bases supporting ALT allele
- Insertion: Mean Q-score for all inserted bases supporting ALT allele
- Deletion: Mean Q-score for the base before and after deletion.
-iRMQ, –RefMeanMappingQuality¶
Mean mapping quality for reads supporting REF allele. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
-iAMQ, –AltMeanMappingQuality¶
Mean mapping quality for reads supporting ALT allele. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
-iCR, –ClippedReadsRef¶
Fraction of clipped reads mapping REF allele in -iRR. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
-iCA, –ClippedReadsAlt¶
Fraction of clipped reads mapping ALT allele in -iRA. iEVA filters all reads flagged as unmapped, secondary alignment, supplementary alignment or marked as duplicate.
References¶
| [1] | Kieleczawa J. Fundamentals of Sequencing of Difficult Templates—An Overview. Journal of Biomolecular Techniques : JBT. 2006;17(3):207-217. PubMed PMID: 16870712 |
| [2] | Chen W, Lin H, Chou KC. Pseudo nucleotide composition or PseKNC: an effective formulation for analyzing genomic sequences. Mol Biosyst. 2015 Oct;11(10):2620-34. PubMed PMID: 19505943 |


Personal details
First Name
Last Name
Address
Pincode
Gender
Male
Female
Others
Please select food
Indian Cuisine
Italian Cuisine
Chinese Cuisine
French Cuisine
Thai Cuisine
State
Country
Submit
S No
First Name
Last Name
Address
Pincode
Gender
Food
State
Country


Definition
Average growing degree-days above 5°C for barley
Method of calculation
Sum of average daily GDD from GDD2Start and STOPBarley.
Daily GDD = Tmean -5.0 where Tmean is the average mean daily air temperature (°C); if Tmean is < 5.0, Daily GDD=0.0


Ra.js is a one for all js library that aims to avoid npm dependency hell for browser javascript.
const elem1 = $("#test");
const elem2 = $(".test")[0];
Ra.js provides a simple interface to access cookies on the frontend side. Refresh this page and check the value of the box:
Code:
Alternatively:
Cookies.set("name", "value");
Cookies.get("name", "default_value");
Ra.js provides a Color class that has a lot of tricks!


From remote deserts to frigid steppes
Young boys race horses at the annual Nadaam festival, a midsummer celebration of nomadic athleticism that also includes wrestling and archery competitions. Hundreds of children-both boys and girls-participate as jockeys in the horse racing event.
A woman prepares dozens of traditional meat dumplings called buuz, one of Mongolia's most popular dishes. In a land poorly suited to agriculture, meat and dairy make up a large portion of the diet.
Bactrian camels make their way across dunes in the Gobi desert, a vast expanse between southern Mongolia and northern China. The world's third largest "hot" desert, the Gobi is home to some of Earth's largest dunes, as well as unique wildlife like the endangered Gobi bear.
Here, a boy ropes a Bactrian camel as he and his family prepare to move on from their camp. The only truly wild camels that still exist, these two-humped herbivores are still found in the Gobi desert in Mongolia and China but number less than a thousand.


Daily bookings With M-pesa
Weekly bookings With M-pesa
Monthly bookings With M-pesa
Daily bookings with Cash
Weekly bookings With Cash
Monthly bookings With Cash
Daily Reception M-pesa payments
Weekly Reception M-pesa payments
Monthly Reception M-pesa payments
Daily Payments with Cash
Weekly Payments with Cash
Monthly Payments with Cash


Contact information:
- Department
of Electronics and Computer Engineering
- Technical
University of Crete
- Chania, 731 00
- Crete, Greece
- Email: potam@ NO SPAM telecom.tuc.gr
- Tel: +30-28210-37221
- Fax: +30-28210-37542
-
-     Research
interests:
-
-
Speech and Natural Language Processing
Multi-Modal Man-Machine Interaction
Spoken Dialogue Systems for Children Users
Robust Speech Recognition
Distributional Semantic Models
Affective Analysis of Text and Multimedia
|


7) Git for good programming practices, cont.¶
Last class, we went over many basics of Git, including the main concept of staging and committing. Questions?
Ignoring Things¶
What if we have files that we do not want Git to track for us, like backup files created by our editor or intermediate files created during data analysis? Let’s create a few dummy files:
$ mkdir results
$ touch a.dat b.dat c.dat results/a.out results/b.out
and see what Git says:
$ git status
On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
a.dat
b.dat
c.dat
results/
nothing added to commit but untracked files present (use "git add" to track)
Putting these files under version control would be a waste of disk space. What’s worse, having them all listed could distract us from changes that actually matter, so let’s tell Git to ignore them.
We do this by creating a file in the root directory of our project
called .gitignore
:
and adding ~~~ *.dat results/ ~~~
These patterns tell Git to ignore any file whose name ends in .dat
and everything in the results
directory. (If any of these files were
already being tracked, Git would continue to track them.)
Once we have created this file, the output of git status
is much
cleaner:
On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
.gitignore
nothing added to commit but untracked files present (use "git add" to track)
The only thing Git notices now is the newly-created .gitignore
file.
You might think we wouldn’t want to track it, but everyone we’re sharing
our repository with will probably want to ignore the same things that
we’re ignoring. Let’s add and commit .gitignore
:
$ git add .gitignore
$ git commit -m "Ignore data files and the results folder."
$ git status
# On branch master
nothing to commit, working directory clean
As a bonus, using .gitignore
helps us avoid accidentally adding to
the repository files that we don’t want to track:
$ git add a.dat
The following paths are ignored by one of your .gitignore files:
a.dat
Use -f if you really want to add them.
If we really want to override our ignore settings, we can use
git add -f
to force Git to add something. For example,
git add -f a.dat
.
We can also always see the status of ignored files if we want:
$ git status --ignored
On branch master
Ignored files:
(use "git add -f <file>..." to include in what will be committed)
a.dat
b.dat
c.dat
results/
nothing to commit, working directory clean
Branches!¶
When you first start your project you will by default be on a branch
called master
. Check for yourself with the following command, which
will show you all your branches.
$ git branch -a
If I now want to start adding a new feature, best practice is to start a new branch.
$ git checkout -b mercury
Switched to a new branch 'mercury'
The -b
flag created the new branch and switched to it. At any time,
we can confirm that there are now two branches, master
and
mercury
, with git branch -a
, which also highlights which branch
you are on.
Now let’s make changes to the branch.
$ echo "Mercury is the closest planet to our sun" > mercury.txt
$ git status
$ git add .
$ git commit -m 'Added first note re Mercury'
We can create multiple branches to work on different features, so let’s do that:
$ git checkout -b saturn
$ echo "Saturn is my favorite planet because of its beautiful rings" > saturn.txt
$ git status
$ git add .
$ git commit -m 'Added first note re Saturn'
FYI: by default, branches will be made based on master. You can base a
new branch off an existing branch with the command
git checkout -b <new-branch> <existing-branch>
.
When I’m done with my changes on my local branch, I’m going to merge my master into my local branch. In this case, it is not strictly necessary because I know that I didn’t change the master.
$ git merge master
$ git checkout master
$ git branch -a
$ git merge saturn
$ git branch -d saturn
$ git branch -a
It is a good idea to clean up branches when you have finished making and then merging in the new feature.
Remotes in GitHub¶
Version control really comes into its own when we begin to collaborate with other people. We already have most of the machinery we need to do this; the only thing missing is to copy changes from one repository to another.
Systems like Git allow us to move work between any two repositories. In practice, though, it’s easiest to use one copy as a central hub, and to keep it on the web rather than on someone’s laptop. Most programmers use hosting services like GitHub, BitBucket or GitLab to hold those master copies; we’ll explore the pros and cons of this in the final section of this lesson.
Let’s start by sharing the changes we’ve made to our current project
with the world. Log in to GitHub, then click on the icon in the top
right corner to create a new repository called planets
:
Name your repository “planets” and then click “Create Repository”:
As soon as the repository is created, GitHub displays a page with a URL and some information on how to configure your local repository:
This effectively does the following on GitHub’s servers:
$ mkdir planets
$ cd planets
$ git init
If you remember back when we added and commited our earlier work on
mars.txt
, we had a diagram of the local repository which looked like
this:
Now that we have two repositories, we need a diagram like this:
Note that our local repository still contains our earlier work on
mars.txt
, but the remote repository on GitHub appears empty as it
doesn’t contain any files yet.
The next step is to connect the two repositories. We do this by making the GitHub repository a remote for the local repository. The home page of the repository on GitHub includes the string we need to identify it:
Click on the ‘HTTPS’ link to change the protocol from SSH to HTTPS.
FYI: HTTPS vs. SSH¶
We use HTTPS here because it does not require additional configuration. Later you may want to set up SSH access, which is a bit more secure, by following one of the great tutorials from GitHub, Atlassian/BitBucket and GitLab (this one has a screencast).
Back to the remote¶
Copy the the URL above from the browser, go into the local planets
repository, and run this command:
$ git remote add origin https://github.com/vlad/planets.git
Make sure to use the URL for your repository rather than Vlad’s: the
only difference should be your username instead of vlad
.
We can check that the command has worked by running git remote -v
:
origin https://github.com/vlad/planets.git (push)
origin https://github.com/vlad/planets.git (fetch)
The name origin
is a local nickname for your remote repository. We
could use something else if we wanted to, but origin
is by far the
most common choice.
Once the nickname origin
is set up, this command will push the
changes from our local repository to the repository on GitHub:
$ git push origin master
Counting objects: 9, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (6/6), done.
Writing objects: 100% (9/9), 821 bytes, done.
Total 9 (delta 2), reused 0 (delta 0)
To https://github.com/vlad/planets
* [new branch] master -> master
Branch master set up to track remote branch master from origin.
The git branch -a
command from earlier will display both your local
and remote branches.
FYI: Network Proxies¶
If the network you are connected to uses a proxy, there is a chance that your last command failed with “Could not resolve hostname” as the error message. To solve this issue, you need to tell Git about the proxy:
$ git config --global http.proxy<EMAIL_ADDRESS>$ git config --global https.proxy<EMAIL_ADDRESS>When you connect to another network that doesn’t use a proxy, you will need to tell Git to disable the proxy using:
$ git config --global --unset http.proxy
$ git config --global --unset https.proxy
FYI on Password Managers¶
If your operating system has a password manager configured, git push
will try to use it when it needs your username and password. For
example, this is the default behavior for Git Bash on Windows. If you
want to type your username and password at the terminal instead of using
a password manager, type:
$ unset SSH_ASKPASS
in the terminal, before you run git push
. Despite the name, git
uses ``SSH_ASKPASS` for all credential
entry <https://git-scm.com/docs/gitcredentials#_requesting_credentials>`__,
so you may want to unset SSH_ASKPASS
whether you are using git via
SSH or https.
You may also want to add unset SSH_ASKPASS
at the end of your
~/.bashrc
to make git default to using the terminal for usernames
and passwords.
Back to our local and remote repositories¶
They are now in this state:
We can pull changes from the remote repository to the local one as well:
$ git pull origin master
From https://github.com/vlad/planets
* branch master -> FETCH_HEAD
Already up-to-date.
Pulling has no effect in this case because the two repositories are already synchronized. If someone else had pushed some changes to the repository on GitHub, though, this command would download them to our local repository.
Collaborating¶
For the next step, get into pairs. One person will be the “Owner” and the other will be the “Collaborator”. The goal is that the Collaborator add changes into the Owner’s repository. We will switch roles at the end, so both persons will play Owner and Collaborator.
If you’re working through this lesson on your own, you can carry on by opening a second terminal window. This window will represent your partner, working on another computer. You won’t need to give anyone access on GitHub, because both ‘partners’ are you.
If you do have a partner, the Owner needs to give the Collaborator access. On GitHub, click the settings button on the right, then select Collaborators, and enter your partner’s username.
To accept access to the Owner’s repo, the Collaborator needs to go to https://github.com/notifications. Once there she can accept access to the Owner’s repo.
Next, the Collaborator needs to download a copy of the Owner’s
repository to her machine. This is called “cloning a repo”. To clone the
Owner’s repo into her Desktop
folder, the Collaborator enters:
$ git clone https://github.com/vlad/planets.git ~/Desktop/vlad-planets
Replace ‘vlad’ with the Owner’s username.
The Collaborator can now make a change in her clone of the Owner’s repository, exactly the same way as we’ve been doing before. It is best practice to only make changes to a new branch:
$ cd ~/Desktop/vlad-planets
$ git checkout -b pluto
$ echo 'It is so a planet!' > pluto.txt
$ git add pluto.txt
$ git commit -m "Add notes about Pluto"
1 file changed, 1 insertion(+)
create mode 100644 pluto.txt
Then push the change to the Owner’s repository on GitHub, but as a new branch:
$ git push --set-upstream origin pluto
Take a look to the Owner’s repository on its GitHub website now (maybe you need to refresh your browser). You should be able to see that there is a new branch available. If you wish, you request that the branch be merged to master.
Now, you can describe the features that you added (optional) or any other note for the owner to see before reviewing the request. You can also see what has changed.
If there are no conflicts (e.g. someone else already made a different file with the same name), you can review and accept.
We can delete the remote branch now, and the Collaborator can delete the
local branch pluto
as well, if desired.
On the Owner’s local computer, to download the Collaborator’s changes from GitHub, the Owner now enters:
$ git pull origin master
Now the three repositories (Owner’s local, Collaborator’s local, and Owner’s on GitHub) are back in sync.
A Basic Collaborative Workflow¶
In practice, it is good to be sure that you have an updated version of
the repository you are collaborating on, so you should git pull
before making our changes. The basic collaborative workflow would be:
- update your local repo with
git pull origin master
- create a branch on which to make changes
git checkout -b <new-feature>
- make your changes and stage them with
git add
- commit your changes with
git commit -m
- check if there will be any conflicts with the master with
git merge master
and resolve if necessary (see below) - upload the changes to GitHub with
git push --set-upstream origin <new-feature>
- request that the new branch it push origin master
- delete remote and local branches
It is better to make many commits with smaller changes rather than of one commit with massive changes: small commits are easier to read and review.
Comment Changes in GitHub¶
The Collaborator has some questions about one line change made by the Owner and has some suggestions to propose.
With GitHub, it is possible to comment the diff of a commit. Over the line of code to comment, a blue comment icon appears to open a comment window.
The Collaborator posts its comments and suggestions using GitHub interface.
Conflicts¶
As soon as people can work in parallel, they’ll likely step on each other’s toes. This will even happen with a single person: if we are working on a piece of software on both our laptop and a server in the lab, we could make different changes to each copy. Version control helps us manage these conflicts by giving us tools to resolve overlapping changes.
To see how we can resolve conflicts, we must first create one. The file
mars.txt
currently looks like this in both partners’ copies of our
planets
repository:
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
Let’s add a line to one partner’s copy only:
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
This line added to Wolfman's copy
and then push the change to GitHub:
$ git add mars.txt
$ git commit -m "Add a line in our home copy"
[master 5ae9631] Add a line in our home copy
1 file changed, 1 insertion(+)
$ git push origin master
Counting objects: 5, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 352 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To https://github.com/vlad/planets
29aba7c..dabb4c8 master -> master
Now let’s have the other partner make a different change to their copy without updating from GitHub:
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
We added a different line in the other copy
We can commit the change locally:
$ git add mars.txt
$ git commit -m "Add a line in my copy"
[master 07ebc69] Add a line in my copy
1 file changed, 1 insertion(+)
but Git won’t let us push it to GitHub:
$ git push origin master
To https://github.com/vlad/planets.git
! [rejected] master -> master (non-fast-forward)
error: failed to push some refs to 'https://github.com/vlad/planets.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Merge the remote changes (e.g. 'git pull')
hint: before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
Git rejects the push because it detects that the remote repository has new updates that have not been incorporated into the local branch. What we have to do is pull the changes from GitHub, merge them into the copy we’re currently working in, and then push that. Let’s start by pulling:
$ git pull origin master
remote: Counting objects: 5, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 1), reused 3 (delta 1)
Unpacking objects: 100% (3/3), done.
From https://github.com/vlad/planets
* branch master -> FETCH_HEAD
Auto-merging mars.txt
CONFLICT (content): Merge conflict in mars.txt
Automatic merge failed; fix conflicts and then commit the result.
The git pull
command updates the local repository to include those
changes already included in the remote repository. After the changes
from remote branch have been fetched, Git detects that changes made to
the local copy overlap with those made to the remote repository, and
therefore refuses to merge the two versions to stop us from trampling on
our previous work. The conflict is marked in in the affected file:
$ cat mars.txt
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
<<<<<<< HEAD
We added a different line in the other copy
=======
This line added to Wolfman's copy
>>>>>>> dabb4c8c450e8475aee9b14b4383acc99f42af1d
Our change is preceded by <<<<<<< HEAD
. Git has then inserted
=======
as a separator between the conflicting changes and marked
the end of the content downloaded from GitHub with >>>>>>>
. (The
string of letters and digits after that marker identifies the commit
we’ve just downloaded.)
It is now up to us to edit this file to remove these markers and reconcile the changes. We can do anything we want: keep the change made in the local repository, keep the change made in the remote repository, write something new to replace both, or get rid of the change entirely. Let’s replace both so that the file looks like this:
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
We removed the conflict on this line
To finish merging, we add mars.txt
to the changes being made by the
merge and then commit:
$ git add mars.txt
$ git status
On branch master
All conflicts fixed but you are still merging.
(use "git commit" to conclude merge)
Changes to be committed:
modified: mars.txt
$ git commit -m "Merge changes from GitHub"
[master 2abf2b1] Merge changes from GitHub
Now we can push our changes to GitHub:
$ git push origin master
Counting objects: 10, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (6/6), done.
Writing objects: 100% (6/6), 697 bytes, done.
Total 6 (delta 2), reused 0 (delta 0)
To https://github.com/vlad/planets.git
dabb4c8..2abf2b1 master -> master
Git keeps track of what we’ve merged with what, so we don’t have to fix things by hand again when the collaborator who made the first change pulls again:
$ git pull origin master
remote: Counting objects: 10, done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 6 (delta 2), reused 6 (delta 2)
Unpacking objects: 100% (6/6), done.
From https://github.com/vlad/planets
* branch master -> FETCH_HEAD
Updating dabb4c8..2abf2b1
Fast-forward
mars.txt | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
We get the merged file:
Cold and dry, but everything is my favorite color
The two moons may be a problem for Wolfman
But the Mummy will appreciate the lack of humidity
We removed the conflict on this line
We don’t need to merge again because Git knows someone has already done that.
Git’s ability to resolve conflicts is very useful, but conflict resolution costs time and effort, and can introduce errors if conflicts are not resolved correctly. If you find yourself resolving a lot of conflicts in a project, consider these technical approaches to reducing them:
- Pull from upstream more frequently, especially before starting new work
- Use topic branches to segregate work, merging to master when complete
- Make smaller more atomic commits
- Where logically appropriate, break large files into smaller ones so that it is less likely that two authors will alter the same file simultaneously
Conflicts can also be minimized with project management strategies:
- Clarify who is responsible for what areas with your collaborators
- Discuss what order tasks should be carried out in with your collaborators so that tasks expected to change the same lines won’t be worked on simultaneously
- If the conflicts are stylistic churn (e.g. tabs vs. spaces),
establish a project convention that is governing and use code style
tools (e.g.
htmltidy
,perltidy
,rubocop
, etc.) to enforce, if necessary
FYI: If you want to add to a project on which you are not a
collaborator, you can instead
`fork
<https://help.github.com/articles/fork-a-repo/>`__ the repo,
and eventually even ask the original project owner if they want to
incorporate your changes.
Note: you can still copy any public repo even if you are not listed as a collaborator. Case in point, this class!
All ipynb for this course, except for solved assignments, will be publicly available at: https://github.com/team-mayes/che_696
I work on my local computer, make commits as desired, and when ipynbs
are in a mostly final stage, I push them to this public repository. The
easiest way for you to get copies of these notebooks are for you to
clone
the repo, e.g.:
git clone https://github.com/team-mayes/che_696.git che_696_mayes
Then, shortly before each class make sure you are up-to-date with recent edits by using:
git pull
Open Science¶
The opposite of “open” isn’t “closed”. The opposite of “open” is “broken”.
—John Wilbanks
Free sharing of information might be the ideal in science, but the reality is often more complicated. Normal practice today looks something like this:
- A scientist collects some data and stores it on a machine that is occasionally backed up by her department.
- She then writes or modifies a few small programs (which also reside on her machine) to analyze that data.
- Once she has some results, she writes them up and submits her paper. She might include her data—a growing number of journals require this—but she probably doesn’t include her code.
- Time passes.
- The journal sends her reviews written anonymously by a handful of other people in her field. She revises her paper to satisfy them, during which time she might also modify the scripts she wrote earlier, and resubmits.
- More time passes.
- The paper is eventually published. It might include a link to an online copy of her data, but the paper itself will be behind a paywall: only people who have personal or institutional access will be able to read it.
For a growing number of scientists, though, the process looks like this:
- The data that the scientist collects is stored in an open access repository like figshare or Zenodo, possibly as soon as it’s collected, and given its own Digital Object Identifier (DOI). Or the data was already published and is stored in Dryad.
- The scientist creates a new repository on GitHub to hold her work.
- As she does her analysis, she pushes changes to her scripts (and possibly some output files) to that repository. She also uses the repository for her paper; that repository is then the hub for collaboration with her colleagues.
- When she’s happy with the state of her paper, she posts a version to arXiv or some other preprint server to invite feedback from peers.
- Based on that feedback, she may post several revisions before finally submitting her paper to a journal.
- The published paper includes links to her preprint and to her code and data repositories, which makes it much easier for other scientists to use her work as starting point for their own research.
This open model accelerates discovery: the more open work is, the more widely it is cited and re-used.
However, people who want to work this way need to make some decisions about what exactly “open” means and how to do it. You can find more on the different aspects of Open Science in this book.
This is one of the (many) reasons we teach version control. When used diligently, it answers the “how” question by acting as a shareable electronic lab notebook for computational work:
- The conceptual stages of your work are documented, including who did what and when. Every step is stamped with an identifier (the commit ID) that is for most intents and purposes unique.
- You can tie documentation of rationale, ideas, and other intellectual work directly to the changes that spring from them.
- You can refer to what you used in your research to obtain your computational results in a way that is unique and recoverable.
- With a version control system such as Git, the entire history of the repository is easy to archive for perpetuity.
Licensing¶
When a repository with source code, a manuscript or other creative works
becomes public, it should include a file LICENSE
or LICENSE.txt
in the base directory of the repository that clearly states under which
license the content is being made available. This is because creative
works are automatically eligible for intellectual property (and thus
copyright) protection. Reusing creative works without a license is
dangerous, because the copyright holders could sue you for copyright
infringement.
A license solves this problem by granting rights to others (the licensees) that they would otherwise not have. What rights are being granted under which conditions differs, often only slightly, from one license to another. In practice, a few licenses are by far the most popular, and choosealicense.com will help you find a common license that suits your needs. Important considerations include:
- Whether you want to address patent rights.
- Whether you require people distributing derivative works to also distribute their source code.
- Whether the content you are licensing is source code.
- Whether you want to license the code at all.
Choosing a license that is in common use makes life easier for contributors and users, because they are more likely to already be familiar with the license and don’t have to wade through a bunch of jargon to decide if they’re ok with it. The Open Source Initiative and Free Software Foundation both maintain lists of licenses which are good choices.
This article provides an excellent overview of licensing and licensing options from the perspective of scientists who also write code.
At the end of the day what matters is that there is a clear statement as to what the license is. Also, the license is best chosen from the get-go, even if for a repository that is not public. Pushing off the decision only makes it more complicated later, because each time a new collaborator starts contributing, they, too, hold copyright and will thus need to be asked for approval once a license is chosen.
Citation¶
You may want to include a file called CITATION
or CITATION.txt
that describes how to reference your project; the one for Software
Carpentry
states:
To reference Software Carpentry in publications, please cite both of the following:
Greg Wilson: "Software Carpentry: Getting Scientists to Write Better
Code by Making Them More Productive". Computing in Science &
Engineering, Nov-Dec 2006.
Greg Wilson: "Software Carpentry: Lessons Learned". arXiv:1307.5448,
July 2013.
@article{wilson-software-carpentry-2006,
author = {Greg Wilson},
title = {Software Carpentry: Getting Scientists to Write Better Code by Making Them More Productive},
journal = {Computing in Science \& Engineering},
month = {November--December},
year = {2006},
}
@online{wilson-software-carpentry-2013,
author = {Greg Wilson},
title = {Software Carpentry: Lessons Learned},
version = {1},
date = {2013-07-20},
eprinttype = {arxiv},
eprint = {1307.5448}
}
More detailed advice, and other ways to make your code citable can be found at the Software Sustainability Institute blog and in:
Smith AM, Katz DS, Niemeyer KE, FORCE11 Software Citation Working Group. (2016) Software citation principles. PeerJ Computer Science 2:e86 https://doi.org/10.7717/peerj-cs.86
There is also an
`@software{…
<https://www.google.de/search?q=git+citation+%22%40software%7B%22>`__
BibTeX entry type in case no
“umbrella” citation like a paper or book exists for the project you want
to make citable.
Hosting¶
The second big question for groups that want to open up their work is where to host their code and data. One option is for the lab, the department, or the university to provide a server, manage accounts and backups, and so on. The main benefit of this is that it clarifies who owns what, which is particularly important if any of the material is sensitive (i.e., relates to experiments involving human subjects or may be used in a patent application). The main drawbacks are the cost of providing the service and its longevity: a scientist who has spent ten years collecting data would like to be sure that data will still be available ten years from now, but that’s well beyond the lifespan of most of the grants that fund academic infrastructure.
Another option is to purchase a domain and pay an Internet service provider (ISP) to host it. This gives the individual or group more control, and sidesteps problems that can arise when moving from one institution to another, but requires more time and effort to set up than either the option above or the option below.
The third option is to use a public hosting service like GitHub, GitLab,or BitBucket. Each of these services provides a web interface that enables people to create, view, and edit their code repositories. These services also provide communication and project management tools including issue tracking, wiki pages, email notifications, and code reviews. These services benefit from economies of scale and network effects: it’s easier to run one large service well than to run many smaller services to the same standard. It’s also easier for people to collaborate. Using a popular service can help connect your project with communities already using the same service.
As an example, Software Carpentry is on GitHub where you can find the source for this page. Anyone with a GitHub account can suggest changes to this text.
GitHub repositories can also be assigned DOIs, by connecting its
releases to
Zenodo. For
example, `10.5281/zenodo.57467
<https://zenodo.org/record/57467>`__
is the DOI that has been “minted” for the Software Carpentry
introduction to Git.
Using large, well-established services can also help you quickly take advantage of powerful tools. One such tool, continuous integration (CI), can automatically run software builds and tests whenever code is committed or pull requests are submitted. Direct integration of CI with an online hosting service means this information is present in any pull request, and helps maintain code integrity and quality standards. While CI is still available in self-hosted situations, there is much less setup and maintenance involved with using an online service. Furthermore, such tools are often provided free of charge to open source projects, and are also available for private repositories for a fee.
Institutional Barriers¶
Sharing is the ideal for science, but many institutions place restrictions on sharing, for example to protect potentially patentable intellectual property. If you encounter such restrictions, it can be productive to inquire about the underlying motivations and either to request an exception for a specific project or domain, or to push more broadly for institutional reform to support more open science.
Summary of key points from this notebook¶
- Version control is like an unlimited ‘undo’.
- Version control also allows many people to work in parallel.
git init
initializes a repository.- Git stores all of its repository data in the .git directory. Be really careful before deleting such a directory!
git status
shows the status of a repository.git add
puts files in the staging area.git commit
saves the staged content as a new commit in the local repositorygit diff
displays differences between commits.git checkout
recovers old versions of files and switches between branches.git log --oneline
displays one line describing each commit in the repo.- The
.gitignore
file tells Git what files to ignore. git branch -a
shows all branches, both local and remote.git clone
copies a remote repository to create a local repository with a remote calledorigin
automatically set up.- Conflicts occur when two or more people change the same file(s) at the same time.
- The version control system does not allow people to overwrite each other’s changes blindly, but highlights conflicts so that they can be resolved.
- Open scientific work is more useful and more highly cited than closed.
- People who are not lawyers should not try to write licenses from scratch.
- Add a CITATION file to a repository to explain how you want your work cited.
- Projects can be hosted on university servers, on personal domains, or on public forges.


Upcoming Goals
Aside from making this portfolio look way more professional than it currently does, my main goals are relatively simple:
- Finish this coding course.
- Find an internship and/or job that utilizes my skills.
- Contine to grow as both a coder and an individual.
This page, as in life, is a constant work in progress. There will no doubt be more projects to come and I am certain they will showcase far more skill and ability than they do right now.


Oh No
There seems to be an unexpected error!
Click this line to go back to the websites homepage.
The admin of this site has been notified of this error and a log has been made.
Click this line to go back to the websites homepage.
The admin of this site has been notified of this error and a log has been made.


§79. High sheriff. That there shall be a high sheriff and deputies, who shall have the powers and duties of the marshal and deputies of the Republic of Hawaii under the laws of Hawaii, except as changed by this Act, and subject to modification by the legislature.
Referred to in 14 H. 283; 15 H. 367, 494; 16 H. 245.


interface GroupManagerRPCOps : RPCOps
Exposes Membership Group management operations to the client. Only Group Manager nodes have this interface installed on node start up.
activate |
Activates membership of the given name or re-activates suspended member of the group. abstract fun activate(name: CordaX500Name): Unit |
suspend |
Suspends membership of the given name which temporarily prevents it to participate in Membership Group. abstract fun suspend(name: CordaX500Name): Unit |


[Full Paper] Qingsong Wen, Ren Chen, Lifeng Nai, Li Zhou and Yinglong Xia, Finding top K shortest simple paths with improved space efficiency, ACM SIGMOD/PODS Workshop on Graph Data-management Experiences and Systems (GRADES 2017), Chicago, IL, May 2017.
[Full Paper] Q. Wen, R. Chen, Y. Xia, L. Zhou, J. Deng, J. Xu, and M. Xia, Big-Data helps SDN to verify integrity of control/data planes, in Big-Data and Software Defined Networking, IET Book Series on Big Data, Sep. 2017
[Full Paper] Ren Chen and Viktor K. Prasanna, Optimal Circuits for Parallel Bit Reversal, ACM/SIGDA Design Automation Conference (DAC '17)
2016
[Full Paper] Ren Chen and Viktor K. Prasanna, Optimizing interconnection complexity for realizing fixed permutation in data and signal processing algorithms, IEEE International Conference on Field Programmable Logic and Applications (FPL '16, Acceptance ratio: 22%)
[Full Paper] Ren Chen, Shreyas Singapura and Viktor K. Prasanna, Optimal Dynamic Data Layouts for 2D FFT on 3D Memory Integrated FPGA, Journal of Supercomputing (SUPE), March 2016
[Full Paper] Ren Chen and Viktor K. Prasanna, Acclerating Equi-Join on a CPU-FPGA Heterogeneous Platform, IEEE 24th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM '16, acceptance rate: 19%), March 2016
[Full Paper] Chi Zhang, Ren Chen and Viktor K. Prasanna, High Throughput Large Scale Sorting on a CPU-FPGA Heterogeneous Platform, 23nd Reconfigurable Architectures Workshop (RAW), 30th Annual International Parallel & Distributed Processing Symposium (IPDPS), Feb 2016.(IPDPS RAW '15, Best Paper Candidate)
2015
[Full Paper] Ajitesh Srivastava, Ren Chen and Viktor K. Prasanna, A Hybrid Design for High Performance Large-scale Sorting on FPGA, IEEE International Conference on ReConFigurable Computing and FPGAs (ReConFig '15), December 2015
[Full Paper] Ren Chen and Viktor K. Prasanna, Automatic Generation of High Throughput Energy Efficient Architectures for Permutation on Streaming Data, IEEE International Conference on Field Programmable Logic and Applications (FPL '15, Acceptance ratio: 24%)
[Full Paper] Ren Chen, Shreyas Singapura and Viktor K. Prasanna, Optimal Dynamic Data Layouts for 2D FFT on 3D Memory Integrated FPGA, International Conference on Parallel Computing Technologies (PaCT '15)
[Short Paper] Ren Chen and Viktor K. Prasanna, DRAM Row Activation Energy Optimization for Stride Memory Access on FPGA-based Systems, 11th International Symposium on Applied Reconfigurable Computing (ARC '15), Best poster award (top 5 among 30 posters), April 2015
[Full Paper] Ren Chen and Viktor K. Prasanna, Energy and Memory Efficient Bitonic Sorting on FPGA, ACM/SIGDA International Conference on Field-Programmable Gate Arrays (FPGA '15, acceptance rate: 20.6%), February 2015
2014
[Full Paper] Ren Chen and Viktor K. Prasanna, Energy Optimizations for FPGA-based 2-D FFT architecture, IEEE 18th International Conference on High Performance Extreme Computing (HPEC '14), September 2014
[Short Paper] Ren Chen and Viktor K. Prasanna, Algorithmic Optimizations for Energy-efficient Throughput-oriented FFT architecture, IEEE Green Computing Conference (IGCC '14), November 2014
[Poster] Ren Chen and Viktor K. Prasanna, Energy-Efficient Architecture for Permutation on Streaming Data, Ph.D forum on IEEE Parallel & Distributed Processing Symposium (IPDPS '14)
[Full Paper] Sanmukh R. Kuppannagari, Shreyas G. Singapura, Ren Chen, Andrea Sanny, Geoffrey Phi C. Tran, Shijie Zhou, Yusong Hu, Stephen P. Crago, Viktor K. Prasanna, Energy Performance of FPGAs on PERFECT Suite Kernels, IEEE 18th International Conference on High Performance Extreme Computing (HPEC '14), September 2014
2013
[Full Paper] Ren Chen and Viktor K. Prasanna, Energy-Efficient Architecture for Stride Permutation on Streaming Data, IEEE International Conference on ReConFigurable Computing and FPGAs (ReConFig '13, Acceptance ratio: 35.2%), December 2013
[Full Paper] Ren Chen, Neungsoo Park and and Viktor K. Prasanna, High Throughput Energy Efficient Parallel FFT Architecture on FPGAs, IEEE High Performance Extreme Computing Conference (HPEC '13), September 2013
[Full Paper] Ren Chen, Hoang Le and Viktor K. Prasanna, Energy Efficient Parameterized FFT Architecture, IEEE International Conference on Field Programmable Logic and Applications (FPL '13, Acceptance ratio: 23%), August 2013
2012~
[Full Paper] Ren Chen, Lu Ma, Du Yue, Wen Wen, Zhi Qi, Hierarchy Modeling and Co-simulation of a Dynamically Coarse-Grained Reconfigurable Architecture, Informatics in Control, Automation and Robotics. Springer Berlin Heidelberg, 2012. 589-598.
About
Research Activities
Paper reviewer for IEEE Conference on Field-Programmable Custom Computing Machines (FCCM)
Paper reviewer for IEEE Conference on ReConFigurable Computing and FPGAs (ReConFig)
Paper reviewer for IEEE Conference on High Performance Extreme Computing (HPEC)
Paper reviewer for IEEE Conference on ParaFPGA
Coordinator of Parallel Computing Group at USC
Poster presenter in the Ming Hsieh Institue Research Festival 2013 at USC


Shaney Waris
Resume Builder
Logout
Main
Dashboard
Jobs
Recommended Jobs
Available Jobs
Interviews
Start your Meeting


This is a remake of Uncharted Waters: New Horizons, an open-world role-playing game released in 1994. Set during the Age of Exploration, you sail around the world, trading goods and fighting pirates.
It’s a side project of mine that I started in 2017 when I was working for the game publisher Paradox Interactive. Being a web developer, I decided to make a game that could run in the browser.
Every now and then, I post updates to my personal website.
1552.
The Age of Exploration.
Six brave voyagers are each about to begin a life of adventure...


Reports
DashBoard
Corpus Change
Change in Grading
Count of OverDue & NPA Loans
OverDue & NPA Loan Amount
Count of Activity Based Lending Members
Total Activity Based Lending Loan Amount
Ratio of income generating loans to consumption loans
% of Unutilized CCL
% of Loans for Income Generation purpose
Amount Borrowed for Income Generation Purpose
% of Amount Borrowed for Income Generation Purpose
% of Eligible SGH for VLR drillable by district to Mandal to VO, etc.
% of Eligible SHG for VLR by Bank and Branch wise
% of Eligible Loan Accounts for VLR by Bank and Branch wise
Count of Loan accounts against “Ineligibility Reasons” Bank and Branch wise
% of Eligible Loan Accounts for VLR Drillable By District, Mandal to Vo, etc.
Count of Loan accounts against “Ineligibility Reasons” drillable by district to Mandal to VO, etc.


Releases Archive
- IMPORTANT notes
- This release drops support for JDK6 runtime and works with JDK 7+ only.
- This release is not yet ready for production use. Critical issues are being ironed out via testing and downstream adoption. Production users should wait for a 2.7.1/2.7.2 release.
- Hadoop Common
- HADOOP-9629 - Support Windows Azure Storage - Blob as a file system in Hadoop.
- Hadoop HDFS
- HDFS-3107 - Support for file truncate
- HDFS-7584 - Support for quotas per storage type
- HDFS-3689 - Support for files with variable-length blocks
- Hadoop YARN
- YARN-3100 - Make YARN authorization pluggable
- YARN-1492 - Automatic shared, global caching of YARN localized resources (beta)
- Hadoop MapReduce
- MAPREDUCE-5583 - Ability to limit running Map/Reduce tasks of a job
- MAPREDUCE-4815 - Speed up FileOutputCommitter for very large jobs with many output files.
Release 2.6.5 available
2016 Oct 8
A point release for the 2.6 line.
Please see the Hadoop 2.6.5 Release Notes for the list of 79 critical bug fixes and since the previous release 2.6.4.
Release 3.0.0-alpha1 available
2016 Sep 3
This is the first alpha in a series of planned alphas and betas leading up to a 3.0.0 GA release. The intention is to “release early, release often” to quickly iterate on feedback collected from downstream users.
Please note that alpha releases come with no guarantees of quality or API stability, and are not intended for production use.
Users are encouraged to read the overview of major changes coming in 3.0.0. The full set of release notes and changelog detail all the changes since the previous minor release 2.7.0.
Release 2.7.3 available
2016 Aug 26
Please see the Hadoop 2.7.3 Release Notes for the list of 221 bug fixes and patches since the previous release 2.7.2.
Release 2.6.4 available
2016 Feb 11
A point release for the 2.6 line.
Please see the Hadoop 2.6.4 Release Notes for the list of 46 bug fixes and patches since the previous release 2.6.3.
Release 2.7.2 (stable) available
2016 Jan 25
A point release for the 2.7 line.
Please see the Hadoop 2.7.2 Release Notes for the list of 155 bug fixes and patches since the previous release 2.7.1.
Release 2.6.3 available
2015 Dec 17
Apache Hadoop 2.6.3 is a point release in the 2.6.x release line, and fixes a few critical issues in 2.6.2.
Please see the Hadoop 2.6.3 Release Notes for details.
Release 2.6.2 available
2015 Oct 28
Apache Hadoop 2.6.2 is a point release in the 2.6.x release line, and fixes a few critical issues in 2.6.1.
Please see the Hadoop 2.6.2 Release Notes for details.
Release 2.6.1 available
2015 Sep 23
Apache Hadoop 2.6.1 is a point release in the 2.6.x release line, and fixes a lot of critical issues in 2.6.0.
Please see the Hadoop 2.6.1 Release Notes for details.
Release 2.7.1 (stable) available
2015 Jul 6
A point release for the 2.7 line. This release is now considered stable.
Please see the Hadoop 2.7.1 Release Notes for the list of 131 bug fixes and patches since the previous release 2.7.0. Please look at the 2.7.0 section below for the list of enhancements enabled by this first stable release of 2.7.x.
Release 2.7.0 available
2015 Apr 21
Apache Hadoop 2.7.0 contains a number of significant enhancements. A few of them are noted below.
Please see the Hadoop 2.7.0 Release Notes for details.


{% extends 'base.html' %} {% load crispy_forms_tags static %} {% load i18n %} {% block title %}{{ title }}{% endblock title %} {% block body-class %}registration-pycontw-2016{% endblock body-class %} {% block body %}
{% url 'index' as index_url %} {% url 'password_reset' as password_reset_url %} {% blocktrans trimmed %}
The password reset link was invalid, possibly because it has already been used. You can either
{% endblocktrans %} {% endif %}


Joose.Cookbook.Basics.Recipe1 - The (always classic) Point example.
Class('Point', {
has : {
x : { is : 'rw', required : true },
y : { is : 'rw', required : true }
},
methods : {
clear : function () {
this.setX(0)
this.setY(0)
}
}
})
Class('Point3D', {
isa : Point,
has : {
z : { is : 'rw', required : true }
},
after : {
clear : function () {
this.setZ(0)
}
}
})
var point1 = new Point({ x : 5, y : 7})
var point3d = new Point3D({ x : 5, y : 7, z : -5})
When Joose is loaded, it exports a set of sugar functions into global namespace. This means that we import some functions which serve as Joose "keywords". These aren't real language keywords, they're just JavaScript functions exported into our package.
Joose automatically makes our class a subclass of "Joose.Meta.Object". This class provides us with a constructor that respects our attributes, as well other features.
Now, onto the keywords. The first one we see here is Class
, which starts the declaration of the class.
Class
accepts 1 or 2 arguments - optional class name and a object, describing a class. Each property of that
object is called builder.
Class
converts given class name into constructor. If no class name were provided the anonymous class will be created.
Class
returns a constructor of declared class.
The first builder we see is has
, which defines the attributes in our class:
has : {
x : { is : 'rw', required : true },
y : { is : 'rw', required : true }
}
This will create attributes named x
and y
. The accessors, generated for this attributes will be read-write.
The required : true
parameter means that this attribute must be provided when a new object is created.
A point object without coordinates doesn't make much sense, so we don't allow it.
We have defined our attributes; next we define our methods. In Joose, as with regular JavaScript, a method is just a function.
It should be defined in the methods
builder:
methods : {
clear : function () {
this.setX(0)
this.setY(0)
}
}
That concludes the Point
class.
Next we have a subclass of Point
, Point3D
. To declare our superclass, we use the isa
builder:
isa : Point
Note, that Joose allows you to have only one superclass. As a cleaner alternative for multiple inheritance Joose provides Roles mechanism.
Next we create a new attribute for Point3D
called z
.
has : {
z : { is : 'rw', required : true }
},
This attribute is just like Point
's x
and y
attributes.
The after
builder demonstrates a Joose feature called "method modifiers" (or "advice" for the AOP inclined):
after : {
clear : function () {
this.setZ(0)
}
}
When clear
is called on a Point3D
object, our modifier method gets called as well. Unsurprisingly, the modifier is called after the real method.
In this case, the real clear
method is inherited from Point
. Our modifier method receives the same arguments as those passed to the modified method.
Of course, using the after
modifier is not the only way to accomplish this. You can get the same results with this code:
methods : {
clear : function () {
this.SUPER()
this.setZ(0)
}
}
You could also use another Joose method modifier, override
:
override : {
clear : function () {
this.SUPER()
this.setZ(0)
}
}
The override
modifier allows you to use the this.SUPER
call to dispatch to the superclass's method in a very Ruby-ish style.
The choice of whether to use a method modifier, and which one to use, is often a question of style as much as functionality.
Since Point
inherits from [Joose.Meta.Object][protoobject], it will also inherit the default Joose.Meta.Object
constructor:
var point1 = new Point({ x : 5, y : 7})
var point3d = new Point3D({ x : 5, y : 7, z : -5})
This constructor accepts a named argument pair for each attribute defined by the class. In this particular example, the attributes are required, and calling constructor without them will throw an error.
var point1 = new Point({ x : 5 }) //no y, kaboom!
From here on, we can use point
and point3d
just as you would any other JavaScript object.
This recipe demonstrates some basic Joose concepts, attributes, subclassing, and a simple method modifier.
The concept of method modifiers is directly ripped off from CLOS. A great explanation of them can be found by following this link
Nickolay Platonov<EMAIL_ADDRESS>Based on original Moose::Cookbook content, written by:
Stevan Little<EMAIL_ADDRESS>Dave<EMAIL_ADDRESS>Copyright (c) 2008-2011, Malte Ubl, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.


Pizzaria Pizza Parlor
There is no better feeling in the world than a warm pizza box on your lap.
Size
Small
Medium
Large
Toppings
Olives
Cheese
Pepperoni
Crust
Stuffed
Gluten-Free
Crispy
Order
Order No.
Size
Toppings
Crust
Total
1
Add Another
The total is:
Would you like delivery for an additional
100
?
Your order will be ready after 10 minutes and you can pick it
Your order has been received and will be delivered to
in less than 20minutes
Complete
Yes
No
Checkout


--- layout: post title: Hitchin' Post date: 2015-03-19 22:10:31.000000000 -07:00 type: post background: '/img/posts/bg.jpg' parent_id: '0' published: true password: '' status: publish categories: - travel tags: [] meta: _edit_last: '2' permalink: "/travel/hitchin-post/" ---
I am a badass mammajamma who is so freaked out about towing this rig! I pulled my tailgate. Only took 3 YouTube videos, some forum searches, and actually reading the user manual.
It's heavy. Really heavy. Can't adjust my grip and arms at full extension, slips off the knee when trying to brace for a re-grip, HEAVY. Lugged it over to the shipping container and managed to gently lower it onto the truck bedliner doing me some actual good again.
Just tested out the hitch. Read all of the instructions. Seems pretty clear, but they want the kingpin on the trailer within 1 1/2" of the receiving plate on the hitch. For laughs, I measured the height of the hitch and then the height of my truck bed, added, and I've got to raise the front end of the trailer by at least 12 inches to get under it. This should be very interesting. Very, very, interesting. Not sure my front jacks were made for that kind of action. Makes that bottle jack purchase more useful, but I'm left wondering if I can manage to store a stump for those more-than-14-inches lift jobs.
Why all of the forward motion all of a sudden? I've got a couple of days before I need to move that thing and let some dump trucks dump stuff. Which puts my parking pad on a slightly higher timeline. Which puts my financial situation in the really, really tight category. Taco Bell budget category.
And I'm finally able to function, think, and move after 12 days of being sick and a wickedly difficult bed bug situation. Take it from me, they are resistant to most of the stuff out there supposed to get rid of them.
 Moving it was the plan anyway. Truly it was. And it's still the plan. Time to get over the fear and do this!


| Home | Libraries | People | FAQ | More |
boost::proto::result_of::child_c — A metafunction that returns the type of the N
th
child of a Proto expression.
boost::proto::result_of::child_c — 一个元函数，返回一个Proto表达式第 N
th
个子节点的类型。
template<typename Expr, long N>
struct child_c {
// types typedef typename Expr::proto_child0 value_type;
typedefsee-below
type;
};
A metafunction that returns the type of the N
th
child of a Proto expression. N
must be 0 or less than
Expr::proto_arity::value
.
一个元函数，返回一个Proto表达式第 N
th
个子节点的类型。N
必须是0或小于 Expr::proto_arity::value
.
child_c
public
typestypedef typename Expr::proto_child0 value_type;
The raw type of the N
th child as it is stored
within Expr
. This may be a value or a reference.
保存在 Expr
中的第 N
th 个子节点的原始类型。可能是值也可能是引用。
If Expr
is not a reference type, type
is computed as follows:
如果 Expr
不是引用类型，则 type
按以下方法计算：
T const &
becomes T
T &
becomes T
T
becomes T
If Expr
is a non-const reference type, type
is computed as follows:
如果 Expr
是非常量引用类型，则 type
按以下方法计算：
T const &
becomes T const &
T &
becomes T &
T
becomes T &
If Expr
is a const reference type, type
is computed as follows:
如果 Expr
是常量引用类型，则 type
按以下方法计算：
T const &
becomes T const &
T &
becomes T &
T
becomes T const &


Responsive Web Design
Concepts and Tools
October 11, 2013 - METRO Mobile Computing SIG
Kevin Reiss @kevinreiss
Responsive is A New(ish) Approach to Web Design
- It will give your content strategy a new focus
- It's cost effective: no need for a seperate mobile application
- Front End Web Development is Changing Faster than ever before
- The technology stack required responsive is the tip of the iceberg
First a Word about the Web
The Web is Fluid
It needs a new approach..
...it also requires a different way of thinking. Rather than quarantining our content into disparate, device-specific experiences, we can use media queries to progressively enhance our work within different viewing contexts.
Ethan Marcotte
The Main Idea
We need to embrace uncertainity
The point of creating adaptive sites is to create functional (and hopefully optimal) user experiences for a growing number of
web-enabled devices and contexts.
Courtesy of Brad Frost
What's the Opposite of Uncertainty?
A picture of a webpage
Built With Photoshop
This is how Print Design Works
This is how a lot of Web Design Still Works
This is bad..
For Three Groups:
- Developers - who need to translate it into HTML/CSS.
- Content Strategists/Site Managers - who get locked into a rigid mindset and want to fill up all that space.
- For Administrators - who expect it to look exactly like the picture.
Actually this discussion has been going on awhile...
The web’s greatest strength, I believe, is often seen as a limitation, as a defect. It is the nature of the web to be flexible, and it should be our role as designers and developers to embrace this flexibility, and produce pages which, by being flexible, are accessible to all.
The Dao of Web Desgin - John Alsop, 2000
What can we do about this?
Never Open Photoshop Again and do the following
- Design in the Browser
- Get back to your technical roots
- Build sites using estabilished, common user interface patterns
- Convention over configuration
- Focus on what is unique about your organization
One side benefit:
The new Photoshop is a lot cheaper than the old one.
However, some assembly is required. This photoshop will require to use the command line to work effectively.
You will want to use a computing platform where it is easy to install nodejs and ruby.
Hint: neither of those is fun on Windows
## Give Up On Idea of Being Pixel Perfect
* Build sites and content models to be [Future Friendly](http://futurefriend.ly/)
* You don't know what tomorrow's devices will be.
* But you will want your data to be able to adapt to them.
* Going responsive is an opportunity to focus on what is most important to your organization
## Some Technical Things to Keep in Mind
* When in doubt use a CSS pre-processor: sass or less
* What's good for responsive can be good for preformance
* Responsive websites are generally fast and lightweight
* 90% of a page load happens on the front end after the server has delivered the content
## Finally, Some Examples
1. [News](http://www.npr.org/2011/01/20/133053436/brain-injuries-haunt-football-players-years-later)
2. [Web Design Shops](http://www.senseslab.com/)
3. Drupal 8 - Including the Admin Interface
4. Wordpress - default 2013 theme is responsive
## More Examples
1. [Academic Libraries](http://clio.columbia.edu/)
2. [Public Libraries](http://www.nypl.org/)
3. [Technology Conferences](http://2013.badcamp.net/)
4. [News & Media](http://pri.org/) - Menu, Media examples
What's Missing?
The big e-commerce sites haven't necessary caught on yet - titling
towards highly information sites.
The Responsive Web - Getting Started
## A few words about content strategy
### [Be Mobile First](http://www.lukew.com/resources/mobile_first.asp) - Luke Wroblewski
What do you users really come to your site for?
- Technical Troubleshooting?
- Research Help?
- Connect to subscription resources?
- Renew/Request a Book?
 Period.
Karen McGrane
Don't take away parts of your core service to meet the goal of going responsive.
Foundational Responsive Technologies
## HTML5
* The W3C replacement for XHTML
* Introduces new semantic HTML elements such as section, aside, nav, footer
* [The Video Tag](http://www.html5rocks.com/en/tutorials/video/basics/)
* New semantics can help you and (and your device) organize your responsive strategy
* Don't forget to check for compatibility: [Can I Use?](http://caniuse.com/)
* Allows for "[data](http://webdesign.tutsplus.com/tutorials/htmlcss-tutorials/all-you-need-to-know-about-the-html5-data-attribute/)" attributes, a convention for including local sematics in your html page
CSS 3
- Media Queries
- Web Fonts - See Google Fonts
- Gradients, Rounded Corners
## Javascript
* Provides a bridge for older tools to use HTML5 & CSS3 constructs (selectivzr, modernizr, respond.js)
* Most responsive menu techiques require it.
* Use only what you need
* Avoid page bloat
The Three Basics Construct of Responsive Design
As defined by Ethan Marcotte
- A Fluid Grid
- Fluid Media
- Media Queries
## Grids
1. [An abstraction that divides the page up into discrete, nested regions](http://foundation.zurb.com/grid.php)
2. First there was the Static Grid [960.gs](http://960.gs/)
3. The Fluid Grid - A grid that expands to fit the current screen width
4. [Semantic Grids](http://snugug.github.io/responsive-grids/#/responsive-grids-display)
Getting Started with Grids
Two are wildly popular
- Bootstrap - Now Defaults to "Mobile" first
- Foundation
These Are:
- Great for rapid prototyping
- Provide common web design elements
A Couple Complaints About These Systems
- One complaint: these can become constraining and "Overclassed"
- They can result in cookie cutter sites - sometimes that's okay
- Review the complaints
## Others Advocate for a Sematic Grid
* A semantic Grid (html5/CSS3 over span-xxx div-cccc)
* [Susy](http://susy.oddbird.net/)
* [Zen Grids](http://zengrids.com/)
* [Singularity](http://singularity.gs/)
* These play best when using SASS
## Fluid Media
1. 100% Width/Height: Auto
2. Best Strategy for Now
3. Flexible is the least mature of responsive tools
## Media Queries
* Apply a different set of CSS rules based on screen size
* Operates on: Min/Max Widths
* Orientation: Landscape v. Portrait
* You use them to invoke "breakpoints" - the point at which your content "responds"
* [Example - See the lower righthand corner](http://pul-testbed.princeton.edu/)
* To invoke them you can use generally accepted [defaults](http://twbs.github.io/bootstrap/css/#grid)
* Or - [build your own](http://breakpoint-sass.com/)
The Standard Media Query Strategy
- One base default media Query (In Bootstrap it's the smallest size)
- Styles to be applied when matched by different media queries are wrapped within that query
- Can get rather unwieldy on large projects with a lot of overrides.
## Bootstrap Gives You:
* Grid
* Components
* Ready made in-browser wireframes
* Roll your own colors and themes
* Directly in the web's language
Other Important Tools
Utilites that help you cope in the mobile web.
Resets for the modern web. Used by many common responsive grid systems
Detct HTML5/CSS3 Features in the current Browser
Feature Detection over User Agent Sniffing
The "Shims"
Make Older Browsers Do New Things
- HTML5shiv - Make Older Browsers provide default styling for HTML5 semantic elements
- Respond.js - Make IE8 & Earlier understand media queries
- Selectivzr - Make older browsers understand many CSS3 pseudo-classes
Better Icons Through CSS3
Like all the previous tools?
Manage all of the above through the command line
Requires a functional node.js environment
## CSS Pre-Processors
1. Compile your CSS automatically
2. [SASS](http://sass-lang.com/)
3. [Less](http://lesscss.org/)
4. Just use one or the other
5. I'll talk about SASS
You Will Need A Functional Ruby Environment
Sass is a ruby gem
> gem install sass
SASS Features
- Variables
- Functions - built-in helpers for common CSS tasks
- Nesting Groups of Selectors
- Reusable Components of CSS - Mixins
- Low learning curve - Syntax is very similar to CSS
- .scss file extension
SASS Benefits
Four big wins
- Large projects become more maintainable and readable
- Re-use of CSS can go beyond copy and paste
- Repetitive and verbose tasks become simple (think image sprites)
- Leverage the power of a full programming language to manage grids and breakpoint calculations
- Compass is also a ruby gem. See config.rb in a SASS project directory
- > gem install compass
- Compass compiles your SASS to CSS for use in the browser
- Provides many extensions for common styling, typography, and CSS features
- Never write a vendor prefix (webkit-,-ms, etc.) again
- Zen-grids is a compass extension and a Ruby Gem
- > gem install zen-grids
- It allows you to define complex, "semantic" grids
- Some Examples
- When integrated with the breakpoint compass extension it can easily support complex media queries.
Set up your SASS project directory
> compass create (my project name)
Review the config.rb file
Add Zen-grids, breakpoint, and other extensions
Zen Grids Example
- Barebones HTML Example
- Include the mixims for zen-grids and breakpoint
- Let's define our grid
- Have Compass watch our sass directory
- CSS will be compiled on the fly
- Let's define our breakpoints
Add Another Library: Buttons
- > gem install sassy-buttons
- Example the partial file - _sassybuttons.scss
- Define some of our own buttons in style.scss
Responsive Support in Tools We Use
## Drupal Responsvie Themes
* [Zen](http://drupal.org/project/zen)
* [Omega](http://drupal.org/project/omega)
* [Bootstrap for Drupal](http://drupal.org/project/bootstrap)
## Responsive Use Cases in Libraries
1. [Northeastern Search](http://onesearch.northeastern.edu/primo_library/libweb/action/dlSearch.do?dscnt=1&onCampus=true&primoQueryTemp=wild+sheep+chase&op=Search&query=any%2Ccontains%2Cwild+sheep+chase&displayMode=full&dstmp=1381375475096&search_scope=everything_scope&group=GUEST&vid=NU&institution=NEU&fromLogin=true)
2. [Princeton Library](http://library.princeton.edu)
3. [Link Resolver](http://findit.library.jhu.edu/go/24972981)
## Are we ahead of our audience?
* Only 5% of our current Princeton Library traffic is from mobile users today
* Remember: **Be Future friendly**
* Can you afford to miss out on hundreds of millions of new smartphone users a year?
##Some More Opinions about Responsive Design
* [Sam Richard](http://snugug.com/presentations)
* [Team Sass](https://github.com/Team-Sass)
* [John Albin - Drupal 8 Mobile Initiative Lead and Author of Zen Theme](https://www.lullabot.com/who-we-are/john-albin-wilkins)
###Some More Reading
* [Designing For the Web](http://designingfortheweb.co.uk/)
* [CSS3: The Manual](http://www.amazon.com/CSS3-Missing-David-Sawyer-McFarland/dp/1449325947)
* And listening, [The Web Ahead](http://5by5.tv/webahead)
### Conferences
* Almost any mobile/responsive talk at recent Drupalcons
* [Sass Conf](http://sassconf.com/)


Ideal Weight Calculator
Enter the required data in the following entry boxes and let us do the rest
Name
Height (cm)
Gender
Gender
Male
Female


Take Action
Laudio's Recommendation
Recommendation Type
- .
- Time & Attendance
- .
- Expires Dec 31st, 2019
Jared Bullock picked up an extra shift 2 times this past month (when in OT and not on-call) ...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
- .
- Professional development
- .
- Expires Dec 31st, 2019
- .
- Added By You
Anastasia Mosley did a 4+ hour training session this past week - how did it go. What did they learn...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
- .
- Professional development
- .
- Expires Dec 31st, 2019
Adilynn Madden was the only 7+ year experienced team member with everyone else new-to-practice on 12 shifts in the past month...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
- .
- Time & Attendance
- .
- Expires Dec 31st, 2019
Shiloh Garner was charge nurse for 43% of their shifts in the past month...see more
- Send Message
- Add Note
-
Jessica
- Add Task
- More
- .
- Time & Attendance
- .
- Expires Dec 31st, 2019
Rebecca Stone missed a punch-in in 2 consecutive pay periods...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
- .
- Burnout
- .
- Expires Dec 31st, 2019
Jared Bullock worked 3 pair of shifts with <24 hours between a day/night shift change in the last month...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
- .
- Time & Attendance
- .
- Expires Dec 31st, 2019
Rebecca Stone worked >60 hours in a calendar week 2 times in the past month...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
- .
- Procurement
- .
- Expires Dec 31st, 2019
Relates to Jared Bullock: Shower curtains are not standard and do not cover the bottom of the shower to prevent water leakage...see more
- Send Message
- Add Note
-
Assign
- Add Task
- More
See More Recommendation
Workflows
- .
- Rounding
- .
- Last updated on Jan 23rd, 2020
You have team members that are due for employee rounding.
- Go to quarterly rounding workflow
- .
- Mandetories
- .
- Last updated on Jan 23rd, 2020
3 team member(s) have mandatories overdue or due soon
- Go to mandatories workflow
- .
- Time & Attendance
- .
- Last updated on Jan 23rd, 2020
New time & attendance occurrences available for review
- Go to time & attendance workflow
Workflows
- .
- Burnout
- .
- Expires Dec 31st, 2019
Scarlet Gonzalez clocked out >7 mins late in 38% of shifts in the last 2 months...see more
Activity
Actions Taken vs. Target
Past rolling 90 days


The problem. The 8-puzzle is a sliding puzzle that is played on a 3-by-3 grid with 8 square tiles labeled 1 through 8, plus a blank square. The goal is to rearrange the tiles so that they are in row-major order, using as few moves as possible. You are permitted to slide tiles either horizontally or vertically into the blank square. The following diagram shows a sequence of moves from an initial board (left) to the goal board (right).
Board data type.
To begin, create a data type that models an n-by-n
board with sliding tiles.
Implement an immutable data type Board
with the following API:
public class Board { // create a board from an n-by-n array of tiles, // where tiles[row][col] = tile at (row, col) public Board(int[][] tiles) // string representation of this board public String toString() // board dimension n public int dimension() // number of tiles out of place public int hamming() // sum of Manhattan distances between tiles and goal public int manhattan() // is this board the goal board? public boolean isGoal() // does this board equal y? public boolean equals(Object y) // all neighboring boards public Iterable<Board> neighbors() // a board that is obtained by exchanging any pair of tiles public Board twin() // unit testing (not graded) public static void main(String[] args) }
Constructor. You may assume that the constructor receives an n-by-n array containing the n2 integers between 0 and n2 − 1, where 0 represents the blank square. You may also assume that 2 ≤ n < 128.
String representation.
The toString()
method returns a string composed of n + 1 lines.
The first line contains the board size n; the remaining n lines contains
the n-by-n grid of tiles in row-major order,
using 0 to designate the blank square.
Hamming and Manhattan distances. To measure how close a board is to the goal board, we define two notions of distance. The Hamming distance betweeen a board and the goal board is the number of tiles in the wrong position. The Manhattan distance between a board and the goal board is the sum of the Manhattan distances (sum of the vertical and horizontal distance) from the tiles to their goal positions.
Comparing two boards for equality.
Two boards are equal if they are have the same size and their corresponding tiles are in the same positions.
The equals()
method is inherited from java.lang.Object
,
so it must obey all of Java’s requirements.
Neighboring boards.
The neighbors()
method returns an iterable containing the neighbors of the board.
Depending on the location of the blank square, a board can have 2, 3, or 4 neighbors.
Unit testing.
Your main()
method should call each public method directly and
help verify that they works as prescribed (e.g., by printing results to standard output).
Performance requirements.
Your implementation should support all Board
methods in time
proportional to n2 (or better) in the worst case.
A* search. Now, we describe a solution to the 8-puzzle problem that illustrates a general artificial intelligence methodology known as the A* search algorithm. We define a search node of the game to be a board, the number of moves made to reach the board, and the previous search node. First, insert the initial search node (the initial board, 0 moves, and a null previous search node) into a priority queue. Then, delete from the priority queue the search node with the minimum priority, and insert onto the priority queue all neighboring search nodes (those that can be reached in one move from the dequeued search node). Repeat this procedure until the search node dequeued corresponds to the goal board.
The efficacy of this approach hinges on the choice of priority function for a search node. We consider two priority functions:
To solve the puzzle from a given search node on the priority queue, the total number of moves we need to make (including those already made) is at least its priority, using either the Hamming or Manhattan priority function. Why? Consequently, when the goal board is dequeued, we have discovered not only a sequence of moves from the initial board to the goal board, but one that makes the fewest moves. (Challenge for the mathematically inclined: prove this fact.)
Game tree. One way to view the computation is as a game tree, where each search node is a node in the game tree and the children of a node correspond to its neighboring search nodes. The root of the game tree is the initial search node; the internal nodes have already been processed; the leaf nodes are maintained in a priority queue; at each step, the A* algorithm removes the node with the smallest priority from the priority queue and processes it (by adding its children to both the game tree and the priority queue).
For example, the following diagram illustrates the game tree after each of the first three steps of running the A* search algorithm on a 3-by-3 puzzle using the Manhattan priority function.
Solver data type.
In this part, you will implement A* search to solve n-by-n slider puzzles.
Create an immutable data type Solver
with the following API:
public class Solver { // find a solution to the initial board (using the A* algorithm) public Solver(Board initial) // is the initial board solvable? (see below) public boolean isSolvable() // min number of moves to solve initial board public int moves() // sequence of boards in a shortest solution public Iterable<Board> solution() // test client (see below) public static void main(String[] args) }
Implementation requirement.
To implement the A* algorithm,
you must use the
MinPQ
data type for the priority queue.
Corner case.
Throw an IllegalArgumentException
in the constructor if the argument is
null
.
Test client. The following test client takes the name of an input file as a command-line argument and prints the minimum number of moves to solve the puzzle and a corresponding solution.
The input file contains the board size n, followed by the n-by-n grid of tiles, using 0 to designate the blank square.public static void main(String[] args) { // create initial board from file In in = new In(args[0]); int n = in.readInt(); int[][] tiles = new int[n][n]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) tiles[i][j] = in.readInt(); Board initial = new Board(tiles); // solve the puzzle Solver solver = new Solver(initial); // print solution to standard output if (!solver.isSolvable()) StdOut.println("No solution possible"); else { StdOut.println("Minimum number of moves = " + solver.moves()); for (Board board : solver.solution()) StdOut.println(board); } }
~/Desktop/8puzzle> cat puzzle04.txt 3 0 1 3 4 2 5 7 8 6 ~/Desktop/8puzzle> java-algs4 Solver puzzle04.txt Minimum number of moves = 4 3 0 1 3 4 2 5 7 8 6 3 1 0 3 4 2 5 7 8 6 3 1 2 3 4 0 5 7 8 6 3 1 2 3 4 5 0 7 8 6 3 1 2 3 4 5 6 7 8 0 |
~/Desktop/8puzzle> cat puzzle3x3-unsolvable.txt 3 1 2 3 4 5 6 8 7 0 Unsolvable puzzle |
Two optimizations. To speed up your solver, implement the following two optimizations:
Detecting unsolvable boards. Not all initial boards can lead to the goal board by a sequence of moves, including these two:
To detect such situations, use the fact that boards are divided into two equivalence classes with respect to reachability:
Web submission.
Submit a .zip file containing only
Board.java
and Solver.java
(with the Manhattan priority).
We will supply algs4.jar
.
You may not call any library functions other those in
java.lang
, java.util
, and algs4.jar
.
You must use
MinPQ
for the priority queue(s).


| Country | Result | Country | Group | Place A Bet | |||
|---|---|---|---|---|---|---|---|
| Brasil | 1 - 3 | Mexico | A | Brasil | Mexico | ||
| Spain | 1 - 5 | Netherlands | B | Spain | Netherlands | ||
| Italy | 2 - 1 | England | C | Italy | England | ||
| Argentina | - | Bosnia and Herz | F | Argentina | Bosnia and Herz | ||
| Germany | - | Portugal | E | Germany | Portugal | Bet |