Collecting posts and tags on jekyll websites

Booking calenders and web intergration

Including calenders and other dynamic content can be as simple as using <iframe>s

Booking calender google

Following the “embed” code from google the iframe looks like so:

It is possible to modify this in several different ways.

I work with R and Rstudio and in this blog site I practise intergating R with Jekyll in RMarkdown for blog publishing on github pages. This means that some of the challenging parts of web deployment and development are shortened at the cost of other aspects. Working in the open science community allows me to develop these tools for future researchers at little future costs.

Button with space Button

Button with more space Button

google maps iframe code

Within a iframe snippit there are several attributes that can be quickly modified, these include:

width

height

frameborder

style

These can apply style to the iframe using css. It is best to keep the css in a different file to html and markdown documents.

Jekyll metadata

One of the great things about github pages and jekyll websites for users of RMarkdown is that the metadata and the information about the contents of the file is stored in the same way as RMarkdown with a yaml header at the start of the document containing the additional information and parameters needed for the file to render.

I have developed this website using a jekyll template called “Beautiful Jekyll” developed by Dean Attali (github here).

Supported parameters {.tabset .tabpills}

Below is a list of the parameters that Beautiful Jekyll supports (any of these can be added to the YAML front matter of any page). Remember to also look in the _config.yml file to see additional site-wide settings.

Main parameters

These are the basic YAML parameters that you are most likely to use on most pages.

These are the main parameters you can place inside a page’s YAML front matter that Beautiful Jekyll supports.

title Page or blog post title

subtitle Short description of page or blog post that goes under the title

bigimg Include a large full-width image at the top of the page. You can either give the path to a single image, or provide a list of images to cycle through (see my personal website as an example).

comments If you want do add Disqus comments to a specific page, use comments: true. Comments ar automatically enabled on blog posts; to turn comments off for a specific post, use comments: false. Comments only work if you set your Disqus id in the _config.yml file.

show-avatar If you have an avatar configured in the _config.yml but you want to turn it off on a specific page, use show-avatar: false. If you want to turn it off by default, locate the line show-avatar: true in the file _config.yml and change the true to false; then you can selectively turn it on in specific pages using show-avatar: true. image If you want to add a personalized image to your blog post that will show up next to the post’s excerpt and on the post itself, use image: /path/to/img.

share-img: If you want to specify an image to use when sharing the page on Facebook or Twitter, then provide the image’s full URL here.

social-share: If you don’t want to show buttons to share a blog post on social media, use social-share: false (this feature is turned on by default). use-site-title If you want to use the site title rather than page title as HTML document title (ie. browser tab title), use use-site-title: true. When set, the document title will take the format Site Title - Site Description (eg. My website - A virtual proof that name is awesome!). By default, it will use Page Title if it exists, or Site Title otherwise.

layout What type of page this is (default is blog for blog posts and page for other pages. You can use minimal if you don’t want a header and footer) js List of local JavaScript files to include in the page (eg. /js/mypage.js)

Code snippits that help

ext-js List of external JavaScript files to include in the page (eg. //cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.2/underscore-min.js). External JavaScript files that support Subresource Integrity (SRI) can be specified using the href and sri parameters eg.

href: “//code.jquery.com/jquery-3.1.1.min.js”

sri: “sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8=”

css List of local CSS files to include in the page

ext-css List of external CSS files to include in the page. External CSS files using SRI (see ext-js parameter) are also supported.

googlefonts List of Google fonts to include in the page (eg. [“Monoton”, “Lobster”])

Parameters for SEO and social media sharing

These parameters let you control what information shows up when a page is shown in a search engine (such as Google) or gets shared on social media (such as Twitter/Facebook).

Less commonly used parameters

These are parameters that you may not use often, but can come in handy sometimes.

Advanced parameters

These are advanced parameters that are only useful for people who need very fine control over their website.

Page types

• post - To write a blog post, add a markdown or HTML file in the _posts folder. As long as you give it YAML front matter (the two lines of three dashes), it will automatically be rendered like a blog post. Look at the existing blog post files to see examples of how to use YAML parameters in blog posts.
• page - Any page outside the _posts folder that uses YAML front matter will have a very similar style to blog posts.
• home - The home layout is meant to act as the homepage of your blog posts - it will display all your blog posts, sorted from newest to oldest. A file using the home layout must be named index.html (not index.md or anything else!).
• minimal - If you want to create a page with minimal styling (ie. without the bulky navigation bar and footer), assign layout: minimal to the YAML front matter.
• If you want to completely bypass the template engine and just write your own HTML page, simply omit the YAML front matter. Only do this if you know how to write HTML!

A lot of cooool resources for R

There are many great things that can be done with bookdown projects and one of these developing resources using gitbooks and github. Here are a few interesting books for using R.

• https://crumplab.github.io/programmingforpsych/

Ignoring Build Files Correctly In R

ignoring defined build files

There are different ways to ignore files depending on the workflow and software being used. When working in RStudio the two core ignore files are:

.gitignore

This is used when working with git version control. If files are defined in this file they will not be tracked on git and github and therefore will be lost if deleted or needed on a different computer.

This is my current template:

[coming soon]

Rbuildignore

This file reflects the aspects of a package repository (folder). It is possible to hash out statements you do not want to run. Here is my current template.

[coming soon]

Code chunks in RMarkdown

chunks

In an RMarkdown document there are several aspects of the structure that help make many of the reproducible leverage points achievable. chunks are one of these aspects.

A chunk is incapsulated in $$ and $$ where the language that will be exucted being wrapped in {} as below for a R chunk:

Option 1

var foo = function(x) {
  return(x + 5);
}
foo(3)

Option 2

var foo = function(x) {
  return(x + 5);
}
foo(3)

Option 3

And here is the same code yet again but with line numbers:

1
2
3
4
var foo = function(x) {
  return(x + 5);
}
foo(3)

Maths online

Interactive maths

As the development of free interactive web apps has become more common recently. These really cool maths tools use similar graphical tools as many of the apps developed to understand different types applications in mathmatics. Here are a few quick links to the ones I have found so far:

• Desmos webapp here
  • API help guide here

• Geoebra: https://www.geogebra.org/m/mPwa7SKk

• Shiny database and publication here

Desmos

This is an online graphics calculator and graphical visualisation program. It is possible to generate examples and embedd them into webpages and othe html documents using iframe.

Good youtubers’

Here are some good content about simple maths topics that I have used to develop my understanding of core mathmatics.

• one blue three brown website
• mathologer youtube channel

Flip cards and other learning tools

Another way I have found it possible to learn some of the more labourous facts of the world, such as the rules of trigonometry and calculus. I haven’t found many free tools for this but there are plently of “trials” and other free aspects of many platforms. The one I have used the most for flipcards is called https://quizlet.com/.

Working with Wolframalpha api

Enter text in Markdown. Use the toolbar above, or click the ? button for formatting help.

Using Gists

Hopefully, there are bits of code below for tricky bits of R and other like programs I am using.

Shiny gist

Test gist

Yui’s scrape Rviews

github website gist

Background

gists are short code snippits that can be helpful to store and be able to access within R from remote computers and other peoples code. Now that github repositories have any free options to do this now. It is still a nice simple way to share code snippits that you have control over when they are accessed. What I mean is that within R it is possible to run the following commands:

This will result in a script being imported and run however if you remove or change the code the user running the above command will use the code attached to the gists.

How to convert files in github repo to a gist

First of all, note that Gist doesn’t support directories. To import a repository into a gist follow the next steps:

1. Create a new gist and clone it locally (replace the dummy id with your Gist id):

   git clone git@gist.github.com:792bxxxxxxxxxxxxxxx9.git
       
   

2. cd to that gist directory

3. Pull and merge from your GitHub repository:

   git pull git@github.com:<user>/<repo>.git
       
   

4. Push your changes

   git push
       
   

Again, note that if you have directories, you have to delete and commit them:

rm -rf some-directory
git commit -m 'Removed some-directory' .

Using the steps above, the project history will be kept. If you don’t care about history, you can always push files in your gist. Let’s say you have a repository containing multiple folders and you want for each folder to create a gist. You will repeat the next steps (or a script could do that):

git clone git@gist.github.com:<gist-id>.git
cd <gist-id>
cp ../path/to/your/github/repository/and/some/folder/* .
git add .
git commit -m 'Added the Gist files' .
git push

gist is different than how GitHub works:

gist is a simple way to share snippets and pastes with others. All gists are Git repositories, so they are automatically versioned, forkable and usable from Git.

However, if you try to push directories in gists you will get errors from remote:

$ git push
Counting objects: 32, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (21/21), done.
Writing objects: 100% (32/32), 7.35 KiB | 0 bytes/s, done.
Total 32 (delta 10), reused 0 (delta 0)
remote: Gist does not support directories.
remote: These are the directories that are causing problems:
remote: foo
To git@gist.github.com:792.....0b79.git
 ! [remote rejected] master -> master (pre-receive hook declined)
error: failed to push some refs to 'git@gist.github.com:79.......9.git'

Using R And Github Course Outline 2021

Using R and GitHub: reproducibility in research

Note on version control (git)

Please install Git before installing R Studio. This allows seamless integration between the two programs because R Studio looks for Git on your computer, but Git does not look for R Studio. In the past, installation in the opposite order has been known to create issues. If you already installed R Studio and Git, but do not see the Git Tab in R Studio then you can follow this support page to troubleshoot.

Learning new tools (how to learn how to do things in R).

• GitHub (for tracking and documenting your work)
• RMarkdown (to easily build webpages and pdfs with or without R code)
• Beamer (pdf slides that blow away Powerpoint presentations)
• Regular Expressions (find-and-replace on steroids)
• LaTeX (for type-setting equations and improving your slides)
• Git (version control)

UoC.Git.2018-11-27

• info

• Github

• Rstudio

• Reports

• Websites

Get Tickets

[eventbight link coming soon here]

General Information

Statistical software that are also programming languages, such as R, are excellent tools for conducting analyses of biological data. However, many users are not taking full advantage of their capabilities. This workshop is an introduction to some of the resources that are available to R users that have been developed and implemented in the larger programming community. No prior knowledge of R will be necessary, but this workshop will not be an introduction to R basics. Instead, we will focus on using R Studio and Github to easily sync your data and analyses online. Within this workshop we will explore how to maximize reproducibility, collaborate internationally on statistical analyses, present data summaries, data management, and the promotion of open science

Who: The course is aimed at R beginners and novice to intermediate analysts. You do not need to have previous knowledge of R.

Where: [coming soon]

Requirements: Participants should bring a laptop with a Mac, Linux, or Windows operating system (not a tablet, Chromebook, etc.) with administrative privileges. If you want to work along during tutorial, you must have both Git, R and RStudio installed on your own computer (See below for instructions). However, you are still welcome to attend because all examples will be presented via slides in the classroom and on github.

Contact: Please contact anthony.davidson@canberra.edu.au for more information.

Schedule

I have developed this course from an program hosted on github from https://afilazzola.github.io

#input timetable from csv here....

Software

Please install Git before installing R Studio. This allows seamless integration between the two programs because R Studio looks for Git on your computer, but Git does not look for R Studio. In the past, installation in the opposite order has been known to create issues. If you already installed R Studio and Git, but do not see the Git Tab in R Studio then you can follow this support page to troubleshoot.

Git

Git is a version control system that lets you track who made changes to what when and has options for easily updating a shared or public version of your code on github.com. You will need a supported web browser (current versions of Chrome, Firefox or Safari, or Internet Explorer version 9 or above).

You will need an account at github.com for parts of the Git lesson. Basic GitHub accounts are free and premium accounts are free to students. We encourage you to create a GitHub account if you don’t have one already. Please consider what personal information you’d like to reveal. For example, you may want to review these instructions for keeping your email address private provided at GitHub.

Information on how to install Git for each OS is provided by Software Carpentry and can be found here

R

R is a programming language that is especially powerful for data exploration, visualization, and statistical analysis. To interact with R, we use RStudio.

Other workshops

If you are interested in undertaking courses like this I am currently based in Australia and enjoy developing and working alongside njoyed this workshop and were interested in learning more, I also run a workshop on R-basics and Introduction to Generalized Linear Modelling (GLM) found here. I also have a short introduction on using Functions in R.

You can find similar style workshops, usually that are longer and go into more detail, with Software Carpentry. They have teachers available globally and cover all forms of programming beyond R.

`github` pages setup 2021

Publishing on GitHub using github pages

GitHub Pages is available in public repositories with GitHub Free, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see “GitHub’s products.”

You can configure GitHub Pages to publish your site’s source files from master, gh-pages, or a /docs folder on your master branch for Project Pages and other Pages sites that meet certain criteria.

If your site is a User or Organization Page that has a repository named <username>.github.ioor <orgname>.github.io, you cannot publish your site’s source files from different locations. User and Organization Pages that have this type of repository name are only published from the master branch.

For more information about the different types of GitHub Pages sites, see “User, Organization, and Project Pages.”

/docs folder on your master branch

To publish your site’s source files from a /docs folder on your master branch, you must have a master branch and your repository must:

• have a /docs folder in the root of the repository

• not follow the repository naming scheme <username>.github.ioor <orgname>.github.io

GitHub Pages will read everything to publish your site, including the CNAME file, from the /docs folder. For example, when you edit your custom domain through the GitHub Pages settings, the custom domain will write to /docs/CNAME.

1. On GitHub, navigate to your GitHub Pages site’s repository.

2. Create a folder in the root of your repository on the master branch called /docs.

3. Under your repository name, click Settings.

1. Use the Select source drop-down menu to select master branch /docs folder as your GitHub Pages publishing source.

Tip: The master branch /docs folder source setting will not appear as an option if the /docs folder doesn’t exist on the master branch.

1. Click Save.

Further Reading

• Viewing branches in your repository
• https://www.codecademy.com/article/f1-u3-github-pages

  GitHub

• Contact GitHub
• Pricing
• API
• Training
• Blog
• About

Adding links in Jekyll websites

There are many many great resources on the web but linking them to a website can be hard, nont to mention boring task. Here are my notes to try and reduce the instatbility of external web links within webpages and other online content.

Page or post link

I am still not sure how this works exactly but here are some resources for this content.

[General tools](https://davan690.github.io/general-statistics.md)
# or
[General tools](./general-statistics.md)

Content (page) links

Direct and indirect links??!

<div class="list-filters">
  <a href="/general-statistics" class="list-filter">Statistics</a>
  <a href="/ecological-statistics" class="list-filter">Ecology</a>
  <a href="/invasive-species-research" class="list-filter">PhD</a>
  <a href="https://www.ssnhub.com/beech-publication-wr" class="list-filter">Draft manuscript v1</a>
</div>

Image links

![Landing page for Reproducible Scientific Journal](/assets/img/ReScienceScreenshot1.png)

Additional information

A journal for open science `ReScienceC`

ReScience C

ReScienceC is a open source journal hosted and curated entirely on github. This journal has been active for over three years and is a interesting concept were computational reproducibility is reached and documented in a totally transparent and reproducible manner.

Article submission process

I have been looking into this for some time with the hope that some of New Zealands amazing

Reviewing submissions

All this has been done on github commits and actions that allow for some of the editor tasks and curation to be done automatically.

Typora text editor

There are many different markdown editors to pick from but generally they range from raw txt to a “what you see is what you get” type of editor. One option for this type of editor I like is called typora.

Quick NOTE: The configuration of image file locations can be hard to get configured correctly if, in my case you don’t have a good grip of the relationship between relative and absolute paths when configuring image paths.

Additional information

Invasive Species Modelling

There was lots of press focus at the time (e.g. How NZ might make PFNZ happen;Enviroment guide; NZ geographic PFNZ plan) and academic interest too (extended info coming but most of the journal articles reference Russell et. al 2015 paper here)

Media release in 2016 announcing New Zealands Predator Free 2050 “apollo” shot.

Although I am unsure if this is even a good idea I do know from parts of my PhD research that it will be essential that New Zealands previous research, knowledge and data will be pivotal to achieving such a goal. This research has been produced in a reproducible workflow for national-scale predator control programs.

With the continued development of my PhD work I hope to be able to connect community groups with the statistical models needed to gain the timely ecological knowledge needed to response to pest control at a national scale. I believe that this will be vital for a on-going national monitoring needed for a PFNZ by 2050.

News

Github shiny app

github packages

It is possible to host a R package on github and many authors have done this. There are a collection of functions that can access packages on github by using

install.library("devtools")
library(devtools)
install.github("package_here")
library(package_here)

Here is a great package from github to look at the leading github packages:

Backup files for Jabref

Jabref backup files

The .bib file and the .bak file can be moved around, but the directory to the file links have to be defined accordingly. In the menu File -> Database properties, set the General file directory using a relative path, such as ./MyFiles (or .\MyFiles depending of your operating system). Afterward, you should be able to move your database and your files around.

More details here: https://help.jabref.org/en/DatabaseProperties from comment https://discourse.jabref.org/t/linked-files-cant-be-opened-after-moving-the-bak-file/211

Image sizes

Generating web content from different visual content types and sizes has been a challenging aspect of working with RMarkdown and document generation. I found myself saying too many times recently that I hate working with images! Image size, projection dimensions, and printing dimensions all seem to change differently at different times when working with these different image types. To break this down I have divided the different aspects and rules under each of the different content types available in RStudio using packages like rmarkdown and bookdown vs websites using jekyll.

Web images

The file location of the images matters. For different website generators and other document generators (parsers) the location of the associated files is different meaning that if images can not be found the locations defined the rendered object will no longer have an image even though you know where it is. The jekyll template

On top of this the code for accessing images and other content varies between programing languages. This means that if you do not want to use the setup I have describing here much of the content could be much more confusing than nessaracry. The tools I am using are:

• Pandoc
• RMarkdown
• HTML5 templates
• github hosting
• git version control

For jekyll this works

Overview

Currently I am working in a dynamic HTML5 template and rendering different aspects of the original template into RMarkdown workflow for html_documents. As I have little background in such matters before now I have tried to work with existing packages and framework I manage to find in the open source community. I find it very challenging to frame up images for different blog posts, images and presentations without the following cheat guides and “work arounds”.

Logos and avatars

I thought hard and long about generating logos and other image content in R using packages like ImageMagic and others. Indeed I have opted for using a simple online editor to layout images and setting up content sizing etc for printing. For business cards and other image content it works well enough…

Glossary of terms

Size:

Pixels

Scale

Web apps/software

Other software

R packages

ImageMagic is accessed through a package called imageMagic. Working

Powerpoint

[coming]

A open source project setup

Dynamic CV and development page

Over the past few months I have developed a a concept of intergrating html templates with RMarkdown to generate custom landing pages. I have used a collection of open source HTML5 templates and modified the code to include aspects of RMarkdown using $ <...> $ and custom YAML headeres associated with each of the new aspects. I have generated a template here for a dynamic CV and in the future I will extend this for other projects.

New Application

coming soon….

News

Mendeley setup

Mendeley is ….. [descriptions coming soon…..]

A concept …

I have now, after what seems like a lifetime, found a nice conceptial way of capturing pdf files and other resources when searching for literature. The software and tools I use are open-source and reproducible. This also means that the cost is overall very low and many of the aspects of science achievable without large cororation software such as windows, mac and other lisenced software.

[Manual coming soon….]

Tools, software, hardware, its a lot to take in but dont try and separate them anymore (cite cloud status of the world).

• learning new tools (how to learn how to do things in R)

Tips and tricks

Video recording of walkthough

Local vs remote folders and files

Organisation is key….

## Local vs remote

Downloads needed

These are the bits that help me once I got my head around the underlying concepts:

Hardware

Windows and mac so far. The linux learning curve is coming for me soon I think but I have not worked extensively in lunix yet.

Software

These are the extensions or almost shorthand names for the applications and uses we are applying using the software. In an opensource enviroment there are alot of tools but only a few decent Software frameworks to achieve these tasks in the optonial manner (for the computer or the human as it turns out). I just think of these as the actual programs or files you have to add to your local/personal operating system to make the code or program you want to work (before packages for specific projects are added).

R

R is a programming language that is especially powerful for data exploration, visualization, and statistical analysis. To interact with R, we use RStudio.

Github R Vscode

Using R and GitHub

I have now, after what seems like a lifetime, found a nice conceptial way of working with the scientific workflow. The software and tools I use are open-source and reproducible. This comes at some costs, the main one that comes to mind is a general aspect of humanity that we can never actually get away from….if your spelling isn’t right or you math doesn’t match the current proof then its you not us….

This works for 99% of projects. The real challenge is knowning when 1% of the projects are coming up to support. Use these tools and you will work out how.

[Manual coming soon….]

Overview

Tools, software, hardware, its a lot to take in but dont try and separate them anymore (cite cloud status of the world).

• learning new tools (how to learn how to do things in R)

Generalised options

Computational Tools

These are the extensions or almost shorthand names for the applications and uses we are applying using the software. In an opensource enviroment there are alot of tools but only a few decent Software frameworks to achieve these tasks in the optonial manner (for the computer or the human as it turns out).

• GitHub (for tracking and documenting your work)
• RMarkdown (to easily build webpages and pdfs with or without R code)
• Beamer (pdf slides that blow away Powerpoint presentations)
• Regular Expressions (find-and-replace on steroids)
• LaTeX (for type-setting equations and improving your slides)

Software

I just think of these as the actual programs or files you have to add to your local/personal operating system to make the code or program you want to work (before packages for specific projects are added)

• Git
• LaTeX

Hardware

Windows and mac so far. The linux learning curve is coming for me soon I think

Resources

Learning new tools (how to learn how to do things in R)

Tips and tricks

These are the bits that help me once I got my head around the underlying concepts:

Local vs remote

## Local vs remote

Other external Resources

This blog was build off many other researchers work but these are the ones that have come out of the woodwork as great resources for my applications:

UoC.Git.2018-11-27

• info
• Github
• Rstudio
• Reports
• Websites

Using R and GitHub: reproducibility in research

Nov 27, 2018

Get Tickets

General Information

Statistical software that are also programming languages, such as R, are excellent tools for conducting analyses of biological data. However, many users are not taking full advantage of their capabilities. This workshop is an introduction to some of the resources that are available to R users that have been developed and implemented in the larger programming community. No prior knowledge of R will be necessary, but this workshop will not be an introduction to R basics. Instead, we will focus on using R Studio and Github to easily sync your data and analyses online. Within this workshop we will explore how to maximize reproducibility, collaborate internationally on statistical analyses, present data summaries, data management, and the promotion of open science

Who: The course is aimed at R beginners and novice to intermediate analysts. You do not need to have previous knowledge of R.

Where: University of Cincinnati: 2600 Clifton Ave, Cincinnati. 713 Rieveschl hall Map

Requirements: Participants should bring a laptop with a Mac, Linux, or Windows operating system (not a tablet, Chromebook, etc.) with administrative privileges. If you want to work along during tutorial, you must have both Git & R studio installed on your own computer (See below for instructions). However, you are still welcome to attend because all examples will be presented via a projector in the classroom.

Contact: Please contact alex.filazzola@outlook.com for more information.

Schedule

LiveNotepad

Software

Please install Git before installing R Studio. This allows seamless integration between the two programs because R Studio looks for Git on your computer, but Git does not look for R Studio. In the past, installation in the opposite order has been known to create issues. If you already installed R Studio and Git, but do not see the Git Tab in R Studio then you can follow this support page to troubleshoot.

Git

Git is a version control system that lets you track who made changes to what when and has options for easily updating a shared or public version of your code on github.com. You will need a supported web browser (current versions of Chrome, Firefox or Safari, or Internet Explorer version 9 or above).

You will need an account at github.com for parts of the Git lesson. Basic GitHub accounts are free and premium accounts are free to students. We encourage you to create a GitHub account if you don’t have one already. Please consider what personal information you’d like to reveal. For example, you may want to review these instructions for keeping your email address private provided at GitHub.

Information on how to install Git for each OS is provided by Software Carpentry and can be found here

R

R is a programming language that is especially powerful for data exploration, visualization, and statistical analysis. To interact with R, we use RStudio.

Other workshops

If you enjoyed this workshop and were interested in learning more, I also run a workshop on R-basics and Introduction to Generalized Linear Modelling (GLM) found here. I also have a short introduction on using Functions in R.

You can find similar style workshops, usually that are longer and go into more detail, with Software Carpentry. They have teachers available globally and cover all forms of programming beyond R.

Rstudio Addins

RStudio add-ins

Dean again has made my life a lot easier than I expected. Addins are an interesting little addition to the additonal coding avaliable under the RStudio platform.

#include html readme here...
#devtools::install_github("rstudio/addinexamples", type = "source")

A good basic readme document and webpage can be found at https://rstudio.github.io/rstudioaddins/#overview.

Personal add-in package?

I have been thinking about this as a good way to manage the risk associated with using other peoples addins without understanding the functions they are implmenting in your local enviroment…. a blog extension will be coming soon…..

Other helpful packages

iframes

#using knitr

gists

Repository magic

[coming]

Other helpful packages

#list packages

Github content editor

Overview

Prose.io is a web app that allows the user to access there github content. In other words prose is “a content editor for GitHub”.

Prose is very similar to the visual editor included in older versions of WordPress that many people have used for writing blog posts. The offical documentation is here.

NOTE: One thing prose does really well is it the user the ability to update their own github websites, especially those who don’t have the time and energy to learn how to write code. While there is plenty of great technical resources for working with Prose on GitHub, there is very little documentation for people who don’t code. Here are some of the key aspects of prose that I use as a researcher.

Prose.io

Prose allows simple draft post creation for github (and jekyll) through a web app/interface for simple markdown. Markdown is very easy to learn as it is ment to be read as plain text as well as rendered as a document like word or html. See my early post for some basics

Prose for jekyll blogs

I really just use it to enter the text and ideas for blogs. It makes it easier to sit in a cafe and write an idea down that then can be included as a blog post or documentation for a project I am working on. I like using it at the moment because I have been able to test the effectiveness of my markdown code to render the posts and information I use regularly in R. A couple of key points that make prose good:

1. Makes automatic commit lines when you save

2. Shortcut for saving in windows ctrl s works as a automatic commit making it easy to update draft after you have made comments

3. Easy for short passages of text == good for a blog

4. Uses markdown which results in much easier inclusion in other markdown flavours such as RMarkdown

Maybe in the future this will be a good tool to get simple ideas from the notepad to the publication level quicker?

Prose workflow

Here is a simple step-by-step guide to editting blogs using github and prose online.

1. Open web browser and navigate to: https://prose.io/

2. Authenticate your github account associated with the blog site you want to work on.

3. Navigate to the repository where your blog is kept.

4. Generate a new post. NOTE: this will be saved in the _drafts folder until published.

This is a nice quick way to generate a new blog template and file.

Side flows :)

• For editing old posts navigate to the ./_posts/ folder of your blogs repository.

Ala Observations

Observations from the ALA of koalas

There are a collection of functions and packages I have been using recently to access the citizen science data repository of Koala observations (the amazing ALA).

There are many tools that access and use the data associated with the ALA. To find an updated list of them in all their glory see the ALA website website here.

In particular I have been using the spatial portal to visualise the data and then think about the best way to capture this information directly from the API (through a package like galah is great). There are some challenges with this workflow but I have managed to make it work for the first few pieces of work now and I hope it will get quicker.

Quickest way

I have found that the galah package is very easy to capture and investigate particular sections of the database. Here are a few snippets of code that I have been using:

[rcode here]

Inserting an social media post

There are several ways that it is possible to generate static html content that includes aspects of different social media posts and pages. Here are a few quick notes about how I work with these file formats.

iframe

The iframe function can be used for many of these aspects as so…..

[insert table of options]

Embedding a google location

Google has a huge wealth of location data. It is possible to access and use this data in a range of ways. Here is some information on using iframe in a markdown or rmarkdown document. Here is the beginning of what I hope will be a collection of R scripts and notes on how to deal with google location data in R. Mostly because I have found this hard and I hope by writing a bunch of blog posts about it I will become more accustom to working with this sort of data.

Background iframe

iframe is one of the easiest way to embed an interactive web application inside a html webpage. In short, put maps in your documents from other applications online such as the my-maps map I have created below:

<iframe src="<YOUR_LINK HERE>" width="600" height="450" style="border:0;" allowfullscreen="" loading="lazy"></iframe>

A function for use

I have been trying to use and write functions instead of loops in R and this is what I have for a customised iframe function for jekyll posts below. I ahve tried to make it as simple as possible as a function example too.

#parameters
urladd <- "https://www.google.com/maps/embed?pb=!1m18!1m12!1m3!1d102728.53602889985!2d149.96889269268158!3d-36.42693204654719!2m3!1f0!2f0!3f0!3m2!1i1024!2i768!4f13.1!3m3!1m2!1s0x6b3e721c18d3ea21%3A0x40609b4904406a0!2sBermagui%20NSW%202546!5e0!3m2!1sen!2sau!4v1625880170565!5m2!1sen!2sau"

##function
#iframeFUNC <- 
#function(urladd){
#how to include html snippet in function call RMD?
#<iframe src=urladd width="600" height="450" style="border:0;" allowfullscreen="" loading="lazy"></iframe>
#}

Shiny apps can be used with iframe

The same iframe code can be used for a shiny app hosted on the rstudio shiny server (5 free apps as of June 2021). There is also a package to make uploading and publishing your shiny app much easier here These resources are great tools for accessing and communicating early development of RShiny apps over the web. Additional, if you feel bold golem is great for shiny development as a package here.

<iframe 
	src=<"YOUR-SHINY-APP">
	width=<"MEASUREMENT"> 
    height=<"MEASUREMENT"> 
    style="border:0;" 
    allowfullscreen="" 
    loading="lazy">
 </iframe> # finish code

And then it can look something like this:

Covid19 in the ACT

Projects

usefulR

---

A collection of scripts, code and vignettes for doing research in ecology and general research.

---

reproducible-guidebook

---

Building on the British Ecological Society guidebook on reporducible code.

---

davan690.github.io

---

The beginnings of a interactive PhD thesis using Markdown.

---

</div>

Working with TROVE notes

The trove database is a amazing resource that is configured using a simple API. There is a tool called QueryPic that can be used from within an online jupyter notebook that makes working with the overall data from TROVE much easier.

Trove using GLAM tools

The credit I can find so far goes to WraggeLabs: Tim Sherratt and GLAM workbench. Let me know if I have missed key contributors please. :)

include info here from page??

Vectorisation Starter

Vectorising code

In a perfect world I could be able to write all my code as vectorised functions. This is a helpful tutorial for the overall concept.

Resources to understand reproducibility

During the first 6 months of 2021 I was lucky enough to help out with a course called “Big Questions in Biology”. I have broken up a lot of the resources I used in the class and added them as smaller blog posts to this site for now. Any feedback is great. :).

• Using R and RStudio [link coming]
• Looking into the ALA [link coming]
• R and the ALA [link coming]
• galah package [link coming]
• Occurance data from the ALA [link coming]

Future developments

• GIT and github
• prose.io for editing github pages
• more coming …

Worldwide covid19 curves

Overall general covid19 cases/trends

The overall world data has been curated by (“Our World in Data”](https://ourworldindata.org/). The tabs on the bottom of the window below navigate the original site here: https://ourworldindata.org/grapher/covid-confirmed-cases-since-100th-case?country=NZL+KOR+AU

Mapping national parks in the US

I found this great shiny app that I have managed to reproduce on my shiny server. The next step is to recreate it with some new or different data. Link here.

[iframe here]

Similar github projects

I have been slowly working on the development of a similar approach to some of the data I work with. I have added this information in combination with other open repositories and resources.

News

Here are some other posts associated with this work.

My notes

| <div>

mastering-shiny

---

Building on the British Ecological Society guidebook on reporducible code.

---

</div> | This repository is a combination of several shiny tutorials and and the framework from the US parks shiny app here … | | Personal draft resources | Hosted on github |

Please excuse any ‘404’ errors as I am learning and working as I go. Using version control and git means that I am able to use other coders templates and test things out before committing.

Creating maps in R and on the web

</html>

GIS in R

GIS is an area of R coding I have kept away from hoping that I would work it out at a later date. Sadly, it has got to the point where I want to be able to build more complex maps in shiny applications towards the end of my PhD and need to create a base of code to go from. Luckily, the text book “Spatial Analysis in R” has just come out in its second edition and is available in as a bookdown repository including the full text here.

This page is a outline of the current resources I am working on and using for my publication and website maps. I have begun by using my normal reproducible workflow and file structure. The full set of resources is currently on a private repository where the resources can be found in the following layout:

Resources

• The whole bookdown guide for a start: its good but it just seems that an independent blog or a stack-overflow feed is easier to find the answers in. A good start to begin to build RMarkdown documents quickly.

In jekyll

• MAPS
• MOre maps
• git jekyll maps

Videos

• video suprise 1

• video suprise 2

• video suprise 3

• video suprise 4

Written tutorials

• Tutorial suprise 1

• GIThub jekyll page

• Geospatial analysis in R

DOCx fun!

I hate to think currently but there are many options around this using a range of workflows. The final copy will render to ‘PDF’ and each chapter draft will be edited etc in docx files. This is all possible however rendering the entire thesis as one in word is likely to have issues. IF this will be a problem I will need to sort this as soon as possible.

Sample blog post

This is a demo post to show you how to write blog posts for jekyll websites using markdown. I strongly encourage you to take 5 minutes to learn how to write in markdown - it’ll teach you how to transform regular text into bold/italics/headings/tables/etc. For a more detailed guide see https://www.markdownguide.org/.

Text

Markdown is a plain text language meaning that

Here is some bold text

Here is a secondary heading

Here’s a useless table:

How about a yummy crepe?

It can also be centered!

Here’s a code chunk:

var foo = function(x) {
  return(x + 5);
}
foo(3)

And here is the same code with syntax highlighting:

var foo = function(x) {
  return(x + 5);
}
foo(3)

And here is the same code yet again but with line numbers:

1
2
3
4
var foo = function(x) {
  return(x + 5);
}
foo(3)

Boxes

You can add notification, warning and error boxes like this:

Notification

Note: This is a notification box.

Warning

Warning: This is a warning box.

Error

Error: This is an error box.

Flake it till you make it

Under what circumstances should we step off a path? When is it essential that we finish what we start? If I bought a bag of peanuts and had an allergic reaction, no one would fault me if I threw it out. If I ended a relationship with a woman who hit me, no one would say that I had a commitment problem. But if I walk away from a seemingly secure route because my soul has other ideas, I am a flake?

The truth is that no one else can definitively know the path we are here to walk. It’s tempting to listen—many of us long for the omnipotent other—but unless they are genuine psychic intuitives, they can’t know. All others can know is their own truth, and if they’ve actually done the work to excavate it, they will have the good sense to know that they cannot genuinely know anyone else’s. Only soul knows the path it is here to walk. Since you are the only one living in your temple, only you can know its scriptures and interpretive structure.

At the heart of the struggle are two very different ideas of success—survival-driven and soul-driven. For survivalists, success is security, pragmatism, power over others. Success is the absence of material suffering, the nourishing of the soul be damned. It is an odd and ironic thing that most of the material power in our world often resides in the hands of younger souls. Still working in the egoic and material realms, they love the sensations of power and focus most of their energy on accumulation. Older souls tend not to be as materially driven. They have already played the worldly game in previous lives and they search for more subtle shades of meaning in this one—authentication rather than accumulation. They are often ignored by the culture at large, although they really are the truest warriors.

A soulful notion of success rests on the actualization of our innate image. Success is simply the completion of a soul step, however unsightly it may be. We have finished what we started when the lesson is learned. What a fear-based culture calls a wonderful opportunity may be fruitless and misguided for the soul. Staying in a passionless relationship may satisfy our need for comfort, but it may stifle the soul. Becoming a famous lawyer is only worthwhile if the soul demands it. It is an essential failure if you are called to be a monastic this time around. If you need to explore and abandon ten careers in order to stretch your soul toward its innate image, then so be it. Flake it till you make it.

A very basic description of github projects and forks

Fork	Branch	Notes
	master	This is the branch I am currently working on
	master
	master

Bookdown hosting

You can host your book on GitHub for free via GitHub Pages (https://pages.github.com). GitHub supports Jekyll (http://jekyllrb.com), a static website builder, to build a website from Markdown files. That may be the more common use case of GitHub Pages, but GitHub also supports arbitrary static HTML files, so you can just host the HTML output files of your book on GitHub. The key is to create a hidden file .nojekyll that tells GitHub that your website is not to be built via Jekyll, since the bookdown HTML output is already a standalone website.

# assume you have initialized the git repository,
# and are under the directory of the book repository now

# create a hidden file .nojekyll
touch .nojekyll

# add to git here because will not show up in RStudio
git add .nojekyll

If you are on Windows, you may not have the touch command, and you can create the file in R using file.create('.nojekyll').

One approach is to publish your book as a GitHub Pages site from a /docs folder on your masterbranch as described in GitHub Help. First, set the output directory of your book to be /docs by

1. adding the line output_dir: "docs"

2. to the configuration file _bookdown.yml.

3. Then, after pushing your changes to GitHub,

4. go to your repository’s settings and

5. under “GitHub Pages” tab

6. change the “Source”

7. to be “master branch /docs folder”.

In this case, the .nojekyll file has to be in the /docs folder.

#create.file("docs/", ".nojekyll")

Embedding maps easily

The interesting thing about this post is that this is not exactly what I am hoping for as an end product. only possible because of these tools (leaflet; wiki on the matter and shiny info).

Extra resources

To begin with check this is working in your local RStudio enviroment

1. Install the required packages. You need a recent version of the GDAL, GEOS, Proj.4, and UDUNITS libraries installed for this to work on Mac and Linux. More information on that at https://github.com/r-spatial/sf.

devtools::install_github("robinlovelace/geocompr")

1. Load the ones we need:

library(spData)library(dplyr)library(sf)

1. Check it’s all working, e.g. with this command:

world %>%  plot()

And some blogging on the matter here.

Content below from leaflet github account

Using Basemaps

Leaflet supports basemaps using map tiles, popularized by Google Maps and now used by nearly all interactive web maps.

Default (OpenStreetMap) Tiles

The easiest way to add tiles is by calling addTiles() with no arguments; by default, OpenStreetMap tiles are used.

```{r fig.height=2.5} m <- leaflet() %>% setView(lng = -71.0589, lat = 42.3601, zoom = 12) m %>% addTiles()

### Third-Party Tiles

Alternatively, many popular free third-party basemaps can be added using the `addProviderTiles()` function, which is implemented using the [leaflet-providers plugin](https://github.com/leaflet-extras/leaflet-providers). See [here](http://leaflet-extras.github.io/leaflet-providers/preview/index.html) for the complete set.

As a convenience, leaflet also provides a named list of all the third-party tile providers that are supported by the plugin. This enables you to use auto-completion feature of your favorite R IDE (like RStudio) and not have to remember or look up supported tile providers; just type `providers$` and choose from one of the options. You can also use `names(providers)` to view all of the options.

```{r fig.height=1.25}
m %>% addProviderTiles(providers$Stamen.Toner)
m %>% addProviderTiles(providers$CartoDB.Positron)
m %>% addProviderTiles(providers$Esri.NatGeoWorldMap)

Note that some tile set providers require you to register; see the project page for more information. You can pass access tokens/keys, and other options, to the tile provider by populating the options argument with the providerTileOptions() function.

Custom Tile URL Template

If you happen to have a custom map tile URL template to use, you can provide it as an argument to addTiles().

WMS Tiles

You can use addWMSTiles() to add WMS (Web Map Service) tiles. The map below shows the Base Reflectivity (a measure of the intensity of precipitation occurring) using the WMS from the Iowa Environmental Mesonet :

```{r fig.height=2.5} leaflet() %>% addTiles() %>% setView(-93.65, 42.0285, zoom = 4) %>% addWMSTiles( “http://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0r.cgi”, layers = “nexrad-n0r-900913”, options = WMSTileOptions(format = “image/png”, transparent = TRUE), attribution = “Weather data © 2012 IEM Nexrad” )

### Combining Tile Layers

You aren't restricted to using a single basemap on a map; you can stack them by adding multiple tile layers. This generally only makes sense if the front tiles consist of semi transparent tiles, or have an adjusted opacity via the `options` argument.

```{r fig.height=1.75}
m %>% addProviderTiles(providers$MtbMap) %>%
  addProviderTiles(providers$Stamen.TonerLines,
    options = providerTileOptions(opacity = 0.35)) %>%
  addProviderTiles(providers$Stamen.TonerLabels)

Choropleths

Making choropleths with leaflet is easy. In this example, we’ll duplicate the step-by-step choropleth tutorial from the Leaflet.js website.

The final result will look like this (scroll to the end to see the completed code):

```{r fig.height = 4.75, echo = FALSE}

From http://leafletjs.com/examples/choropleth/us-states.js

Data Referenced from https://github.com/rstudio/leaflet/tree/master/docs/json/

states <- geojsonio::geojson_read(“./json/us-states.geojson”, what = “sp”) bins <- c(0, 10, 20, 50, 100, 200, 500, 1000, Inf) pal <- colorBin(“YlOrRd”, domain = states$density, bins = bins) labels <- sprintf( “%s
%g people / mi<sup>2</sup>”, states$name, states$density ) %>% lapply(htmltools::HTML) leaflet(states) %>% setView(-96, 37.8, 4) %>% addProviderTiles(“MapBox”, options = providerTileOptions( id = “mapbox.light”, accessToken = Sys.getenv(‘MAPBOX_ACCESS_TOKEN’))) %>% addPolygons( fillColor = ~pal(density), weight = 2, opacity = 1, color = “white”, dashArray = “3”, fillOpacity = 0.7, highlight = highlightOptions( weight = 5, color = “#666”, dashArray = “”, fillOpacity = 0.7, bringToFront = TRUE), label = labels, labelOptions = labelOptions( style = list(“font-weight” = “normal”, padding = “3px 8px”), textsize = “15px”, direction = “auto”)) %>% addLegend(pal = pal, values = ~density, opacity = 0.7, title = NULL, position = “bottomright”)

### Data source

We'll start by loading the data from JSON. While the Leaflet.js example loads the JSON directly into JavaScript, with the Leaflet R package we instead want to load the data into R.

In this case, we'll use the `geojsonio` package to load the data into `sp` objects, which will let us easily manipulate the geographic features, and their properties, in R.

```{r}
states <- geojsonio::geojson_read("json/us-states.geojson", what = "sp")
class(states)
names(states)

As you can see, we now have a SpatialPolygonsDataFrame with name (state name) and density (population density in people/mi<sup>2</sup>) columns from the GeoJSON.

Basic states map

Next, let’s make a basic map with just the outline of the states. For our basemap, we’ll use the same "mapbox.light" MapBox style that the example does; if you don’t have a MapBox account, you can just use addTiles() in place of the addProviderTiles call, or choose a free provider.

m <- leaflet(states) %>%
  setView(-96, 37.8, 4) %>%
  addProviderTiles("MapBox", options = providerTileOptions(
    id = "mapbox.light",
    accessToken = Sys.getenv('MAPBOX_ACCESS_TOKEN')))

We’ve saved the basic basemap as a separate variable m so we can easily iterate on the addPolygons call as we work through the rest of the tutorial.

To add uniform polygons with default styling, just call addPolygons with no additional arguments.

m %>% addPolygons()

Adding some color

Now, let’s color the states according to their population density. You have various options for mapping data to colors; for this example we’ll match the Leaflet.js tutorial by mapping a specific set of bins into RColorBrewer colors.

First, we’ll define the bins. This is a numeric vector that defines the boundaries between intervals ((0,10], (10,20], and so on).

Then, we’ll call colorBin to generate a palette function that maps the RColorBrewer "YlOrRd" colors to our bins.

Finally, we’ll modify addPolygons to use the palette function and the density values to generate a vector of colors for fillColor, and also add some other static style properties.

bins <- c(0, 10, 20, 50, 100, 200, 500, 1000, Inf)
pal <- colorBin("YlOrRd", domain = states$density, bins = bins)
m %>% addPolygons(
  fillColor = ~pal(density),
  weight = 2,
  opacity = 1,
  color = "white",
  dashArray = "3",
  fillOpacity = 0.7)

Adding interaction

The next thing we’ll want is to make the polygons highlight as the mouse passes over them. The addPolygon function has a highlight argument that makes this simple.

m %>% addPolygons(
  fillColor = ~pal(density),
  weight = 2,
  opacity = 1,
  color = "white",
  dashArray = "3",
  fillOpacity = 0.7,
  highlight = highlightOptions(
    weight = 5,
    color = "#666",
    dashArray = "",
    fillOpacity = 0.7,
    bringToFront = TRUE))

(The Leaflet.js tutorial also adds an event handler that zooms into a state when it’s clicked. This isn’t currently possible with the Leaflet R package, except with either custom JavaScript or using Shiny, both of which are outside the scope of this example.)

Custom info

Now let’s expose the state names and values to the user.

The Leaflet.js tutorial shows the hovered-over state’s information in a custom control. Again, that’s possible by adding custom JavaScript or using Shiny, but for this example we’ll use the built-in labels feature instead.

We’ll generate the labels by handcrafting some HTML, and passing it to lapply(htmltools::HTML) so that Leaflet knows to treat each label as HTML instead of as plain text. We’ll also set some label options to improve the style of the label element itself.

labels <- sprintf(
  "<strong>%s</strong><br/>%g people / mi<sup>2</sup>",
  states$name, states$density
) %>% lapply(htmltools::HTML)
m <- m %>% addPolygons(
  fillColor = ~pal(density),
  weight = 2,
  opacity = 1,
  color = "white",
  dashArray = "3",
  fillOpacity = 0.7,
  highlight = highlightOptions(
    weight = 5,
    color = "#666",
    dashArray = "",
    fillOpacity = 0.7,
    bringToFront = TRUE),
  label = labels,
  labelOptions = labelOptions(
    style = list("font-weight" = "normal", padding = "3px 8px"),
    textsize = "15px",
    direction = "auto"))
m

This is the final version of our polygon layer, so let’s save the result back to the m variable.

Legend

As our final step, let’s add a legend. Because we chose to color our map using colorBin, the addLegend function makes it particularly easy to add a legend with the correct colors and intervals.

m %>% addLegend(pal = pal, values = ~density, opacity = 0.7, title = NULL,
  position = "bottomright")

Complete code

```{r results = ‘hide’}

From http://leafletjs.com/examples/choropleth/us-states.js

states <- geojsonio::geojson_read(“json/us-states.geojson”, what = “sp”) bins <- c(0, 10, 20, 50, 100, 200, 500, 1000, Inf) pal <- colorBin(“YlOrRd”, domain = states$density, bins = bins) labels <- sprintf( “%s
%g people / mi<sup>2</sup>”, states$name, states$density ) %>% lapply(htmltools::HTML) leaflet(states) %>% setView(-96, 37.8, 4) %>% addProviderTiles(“MapBox”, options = providerTileOptions( id = “mapbox.light”, accessToken = Sys.getenv(‘MAPBOX_ACCESS_TOKEN’))) %>% addPolygons( fillColor = ~pal(density), weight = 2, opacity = 1, color = “white”, dashArray = “3”, fillOpacity = 0.7, highlight = highlightOptions( weight = 5, color = “#666”, dashArray = “”, fillOpacity = 0.7, bringToFront = TRUE), label = labels, labelOptions = labelOptions( style = list(“font-weight” = “normal”, padding = “3px 8px”), textsize = “15px”, direction = “auto”)) %>% addLegend(pal = pal, values = ~density, opacity = 0.7, title = NULL, position = “bottomright”) ```

Making stickers and business cards

https://www.canva.com/design/DAE47TyDc_s/LkWFUEh_Wmtod7HqSh58ww/view?utm_content=DAE47TyDc_s&utm_campaign=designshare&utm_medium=link&utm_source=shareyourdesignpanel

As I am finishing up my PhD and working out how to build a career in academia I have ran out of money and resources in the long drawn-out finishing line.

I have also been noticing that I am losing connections (both for work and by not having a business card to direct people to the website when suites them. We have little support in these sorts of areas as graduate students and even less funding . As a graduate student I got the generic card when I asked and since our institute has been incorporated into the universities science department I don’t even dear ask.

So instead I have built this website but now I still don’t have cash for business cards (really just networking tools here) yet even though I have the resource.

This is my solution to business cards with an quirky edge or, as some would say, a student budget.

Create a basic design

I have put together a very rough logo in the center and added my contact details to a single label template. I found this one below with a very quick google search so I’m sure there are better solutions with some more time however this one:

• doesnt request sign-up before producing content as of June 2019

• this one matches the company stickers I brought = so that the printing will be guaranteed to line up??

I then printed the image which gave me a pdf to download or print. Which leads to a pdf of 36 labels ready to print for 50c in colour printing.

I am not sure if I can just stick these onto politicians wasted junk mail or not?

<–image of cards being used as card for stickers–>

The labels are expensive but it still works out to be less than …. cents a card and since we are recycling and saving $$.

I figure its a win or at least a stop-gap until I find another funding source.

Jekyll in RStudio

As with all github projects there always seems to be someone else who has managed to explain and write a blog about what you need, just when you need it… I wish :)

This is an collection of resources I have used to make this happen. I think this is a massive leap for reproducible workflow and in particular, science commumication but I will build on this thoughout the website.

Tutorials and Blogs

• emily zabor
• emitanaka
• yinting chou
• Another fellow students examples

I found this blog explaining how Jacob Fiksel steps through the process very helpful.

My notes

These are my take home points and things I found hard.

1. Need all the basics to begin with (GIThub, Jekyll, R, RStudio).

2. Key run code

??bundle gem install jekyll??

bundle exec jekyll build

bundle exec jekyll serve --watch

1. View/run in RStudio

> servr::jekyll()

Serving the directory C:\GIT\davan690.github.io at http://127.0.0.1:5652

1. Stop server

servr::daemon_stop(3)

ERRORs

1. missing jekyll

Warning message: In system2("jekyll", "build"): '"jekyll"' not found NULL

I found I needed to install ruby gems for jekyll using the following code snippits:

??bundle gem install jekyll??

Using compareGroups function

The compareGroups package (Subirana, Sanz, and Vila 2014) allows users to create tables displaying results of univariate analyses, stratified or not by categorical variable groupings.

Tables can easily be exported to CSV, LaTeX, HTML, PDF, Word or Excel, or inserted in R-markdown files to generate reports automatically.

This package can be used from the R prompt or from a user-friendly graphical user interface for non-R familiarized users.

The compareGroups package is available on CRAN repository. To load the package using the R prompt, enter:

library(compareGroups)

My notes

I have developed this slightly in my notes as function used for quick descriptive statistics using R and a GUI. For now these notes are on this page. At some stage I plan to move these to there own repository.

GUI

To access the GUI there are several additional packages that are needed so that a interactive window can be opened by RStudio. However, these packages will already be running if you have other similar functions within your library already.

# compareGroups::cGroupsGUI(mtcars)

Tutorials

There is a very good vignette for this package here. This document provides an overview of the usage of the compareGroups package with a real examples, both using the R syntax and the graphical user interface. It is structure as follows: Overall, there is a introduction of the package (section 2) and the data used as example (section 3), Instructions to perform descriptive tables and exploration plots using R syntax are explained (section 4), and Usage of graphical user interface based on tcl-tk (section 5) and based on Shiny (section 6) are shown.

KMZ files are just...

A KMZ file is just a zipped KML file, possibly with associated embedded images, icons, etc. So any program that supports KMZ files internally unzips them to access their KML files. That may be a reason why many open source programs do not bother supporting KMZ once KML support is implemented: you just need to use an additional unzipping library of your choice, to convert the KMZ to KML. The linked posts give some JavaScript-based solutions for unzipping.

Extracting data from my-maps data

I like the idea of sticking with this process so that “google” will manage the security of the data instead of any open-source tools with security issues.

Resources

We need to convert the my-maps data from a zipped kml file that is stored as the kmz file downloaded from mymaps data.

kmz conversion

Follow these steps:

1. Download data

1. Add .zip to .kml file
2. Unzip renamed file (as per normal in windows)
3. Change the file extention to kmz
4. Import correct file sections using the following code:

##librares needed
library(rgdal)
library(tidyverse)
library(ggplot2)

```{r kmzKml} nc <- st_read(system.file(“shape/nc.shp”, package=”sf”), quiet = TRUE)

limit to first 2 counties

nc <- nc[1:2,]

convert to SpatialPolygonsDataFrame

nc_sp <- as(nc, “Spatial”)

file <- “data/Canberra-Transit.kmz/doc.kml”

?readOGR SST_start = readOGR(file)

OGR data source with driver: LIBKML

Source: “Burrows_et_al_Nature_traj_ocean_NH1.kmz”, layer: “SST_start”

with 42205 features

It has 12 fields

SST_1 = readOGR(file,”SST_1”) OGR data source with driver: LIBKML Source: “Burrows_et_al_Nature_traj_ocean_NH1.kmz”, layer: “SST_1” with 7719 features It has 12 fields ```

My notes

Found in stack comments here

Tracking a github website using google analytics

Somehow a few months ago I managed to add google analytics to both my blog website here and my first publication but I am unsure how I managed it.

I have now come back to this as I need to set up google analytics for a custom html website with a single landing page.

My notes

I was hesitant to get this all working due to having to get involved with google and things like google adwords. For now I only have inserted the single google analytics code for my personal site. It is not much harder to add additional tracking tags using google’s tag tracker.

Resources

I have collected a few resources to setup another page with google analytics. It is helpful to therefore have a google account setup for the project. There are limitations to the use of google however it can be helpful to upgrade if projects get bigger or more security savvy.

• A stack overflow discussion on the matter

KMZ files are just...

A KMZ file is just a zipped KML file, possibly with associated embedded images, icons, etc. So any program that supports KMZ files internally unzips them to access their KML files. That may be a reason why many open source programs do not bother supporting KMZ once KML support is implemented: you just need to use an additional unzipping library of your choice, to convert the KMZ to KML. The linked posts give some JavaScript-based solutions for unzipping.

Resources

These resources are very basic but they may be helpful for me later.

• Found in stack comments here

• KMZ files are just… (21 May 2019)

My notes

Example states for shiny-salesman app….

# From http://leafletjs.com/examples/choropleth/us-states.js
# Data Referenced from https://github.com/rstudio/leaflet/tree/master/docs/json/

states <- geojsonio::geojson_read("./json/us-states.geojson", what = "sp")
bins <- c(0, 10, 20, 50, 100, 200, 500, 1000, Inf)
pal <- colorBin("YlOrRd", domain = states$density, bins = bins)
labels <- sprintf(
  "<strong>%s</strong><br/>%g people / mi<sup>2</sup>",
  states$name, states$density
) %>% lapply(htmltools::HTML)
leaflet(states) %>%
  setView(-96, 37.8, 4) %>%
  addProviderTiles("MapBox", options = providerTileOptions(
    id = "mapbox.light",
    accessToken = Sys.getenv('MAPBOX_ACCESS_TOKEN'))) %>%
  addPolygons(
    fillColor = ~pal(density),
    weight = 2,
    opacity = 1,
    color = "white",
    dashArray = "3",
    fillOpacity = 0.7,
    highlight = highlightOptions(
      weight = 5,
      color = "#666",
      dashArray = "",
      fillOpacity = 0.7,
      bringToFront = TRUE),
    label = labels,
    labelOptions = labelOptions(
      style = list("font-weight" = "normal", padding = "3px 8px"),
      textsize = "15px",
      direction = "auto")) %>%
  addLegend(pal = pal, values = ~density, opacity = 0.7, title = NULL,
    position = "bottomright")

Markdown syntax

This is an extension of the demo post from Dean’s website that demostrates some key markdown syntax to use in markdown blog posts for this site (and many other great tools).

Simple syntax

There are many resources and blogs about how to use markdown. Here is a 5 minutes guide to writing in markdown - it’ll teach you how to transform regular text into bold/italics/headings/tables/etc. Here are some quick notes.

Text modifications

Bold text is defined by **: Here is some bold text

Headings are defined by the number of # before a line of text. For example ##### Here is a fifth level heading is needed and then the rendered document will have a fifth level heading as below.

Heading (Here is a secondary heading (##))

and a sixth heading by ######. This is the max level for a heading by the way…

Here is a third heading

Including code

One of the greatest strengths of markdown extensions such as RMarkdown is the ability to include code chunks within normal text as below:

var foo = function(x) {
  return(x + 5);
}
foo(3)

And here is the same code with syntax highlighting:

var foo = function(x) {
  return(x + 5);
}
foo(3)

And here is the same code yet again but with line numbers:

1
2
3
4
var foo = function(x) {
  return(x + 5);
}
foo(3)

Boxes

You can add notification, warning and error boxes like this:

Notification, warning and error boxes

{: .box-note} ; {: .box-warning}; {: .box-error} demos below:

Note: This is a notification box.

Working with images

You can set following yaml variables: layout: post; tags: <tagg_label>

Images

Images live in the ./assets/img/ folder following the same rules as the beautiful jekyll template. Overall jekyll uses liquid tags to and these usually found in the assets folder.

Classic markdown image syntax

How about a yummy crepe? Here are two sections of code for working with markdown syntax (code). It can also be centered using {: .mx-auto.d-block :}

Tables

Tables can be directly written using markdown syntax or can be built in code and rendered to markdown using a package like knitr in R.

Markdown tables

Markdown tables can be difficult to keep formatted. Here’s a demo markdown table:

RMarkdown tables

An advantage of RMarkdown is that you can build autogenerating markdown tables using a range of packages including knitr.

Site concept

Overview

Although this site is just a collection of blog posts and notes about working with open science frameworks it can also be something else. I think that there are a collection of additional aspects to the same workflow and tools I am using here to produce reproducible graduate research. With the combination of comments, notes and live editting it should be possible to add and work on content in a dynamic and collaborative way using version control, R and the associated tools within these frameworks for computer software development.

To test this concept I have begin by working online as much as I can and submitting or “publishing” content that is still in draft/uncompleted form so that as I intergrate the key tools needed in the future, I can begin to add comments and extend content in a more community driven manner.