tiredlizard's Guide to Nothing of Import

Definitely Gaming for Scientific Reasons, Part 2: Electric Boogaloo

Wed, 04 Dec 2024 00:00:00 +0000

Welcome back, unfortunate souls. Last time (...on Avatar), we gallivanted through the gathering and cleaning of some data from Moby Games, a website purely for collecting and managing game information. We did some basic EDA and thought a few things looked mildly interesting. Now, onto part two of this thrilling saga.

Key Insights?

Honestly, there wasn’t anything jaw-dropping or super amazing in the data, at least not that I found. I mean, here’s a boxplot if you want it.

Figure 1. - Look, geometry.

A majority of the games were rated in the 7.9-8.2 range. Since these games are the top 550 from the Moby list of Nintendo Switch games, that doesn’t surprise me. Action seems to have the most outliers, though none of the genres have a Moby score (a “number based on a bayesian scale critic and plater ratings”) above 9.4. But we all know what critics are like, so again, that isn’t a shocking development.

Unsurprisingly, fantasy seemed to be the most popular genre among the games. The most common perspectives among the genres were third-person and side view. (So, not Minecraft.)

Figure 2. - I am aware that the labels are weird. 'East' was supposed to be Middle-East, 'North' was North America, etc... until Data Cleaning attacked. But who knows, maybe you wouldn't have noticed if I hadn't pointed it out.

In my previous post, I mentioned that there was a noticeable dip where there weren’t as many games being released in 2020. Take a guess as to why. (Oddly enough, the one gambling game I have in my dataset was released in 2020. Go figure?) This is easily seen in the ‘Explore’ tab of my streamlit app, specifically the first graph. But that’s a topic for… now, actually.

(N)App Time

I present to you… Playing with Game Data, the app. I know, the name’s so clever. Hilarious. It makes for a lot less work to filter the data set (if you didn’t code it, at least) and see cool graphs with the click of a button.

Tab 1

It’s relatively self-explanatory. The first tab is just a few widgets for people to mess around with to their heart’s content, aka for ten seconds. For the first plot, you select a genre and it displays a simple graph depicting the number of games released per year in that genre.

Figure 3. - Those aren't mountains...

As the title says, I selected ‘Role-playing (RPG)’ from the genre list and got this lovely little curve back.

The second plot is a stacked bar graph. You can select multiple game settings (as in world setting, not interface settings) and they’ll show up on the bar graph, stacked on top of one another. If you hover your cursor over a bar, it’ll tell you the exact count of each setting per year.

Figure 4. - ...those are waves! Very rectangular ones.

I selected my favorite settings and got this lovely thing.

Then there’s release month, which isn’t particularly useful… but is kinda fun to slide the dot around. As I mentioned previously, April has the least amount of releases, with only 26/550 games being released on the Switch that month.

Tab 2

This one’s my favorite. You select a genre, one or more gameplay options, a setting, and a minimum critic score to see a dataframe of all the games that match your criteria. Since my dataset is pretty limited, it’s not as cool as it seemed in my head. Oh well.

Tab 3

Unfortunately, this widget ended up being difficult to use considering how case sensitive it is. If you miss an apostrophe or space, it’s over (for a second). If you know the exact name, though, it’s not too bad.

As for you…

I wanted to keep this a little shorter for ease of finals week peer reviewing. (It has nothing to do with a lack of creativity.) Hopefully it wasn’t as boring as your 9 A.M. history class.

Anyways, the interactive widgets on the app provide for a bit of personal analysis, should you wish to waste your time doing so. I’d be curious to know if there’s any kind of association between gameplay and critic rating, as an example. Or which settings and genres go together the most often. It’s not like I could go do that myself; obviously, you have to go check it out.

Go find a genre that interests you and take a look at some of the games you might be interested in once you have more than a minute of downtime. Good luck with finals, everyone.

Links

Github

Shameful Self-Promotion

Definitely Gaming for Scientific Reasons: Exploring Game Data

Wed, 06 Nov 2024 00:00:00 +0000

If there's one thing I love more than refusing to defeat the final boss in the games I play, it's analyzing data about those games. (Alright, that's a lie; nothing can beat procrastinating in a fictional world.) So, here's my not-so-scientific adventure in game data exploration. Sit back, grab a controller and/or caffeinated drink, and join me as I dig into the questions no one asked - like, "Which month hates game releases the most?" and "Are action games truly the best?"

(I’m sorry, but there’s no synonyms for ‘game’ in this sense that I can find. So bear with me.)

The Question

I wouldn’t consider myself a Gamer™ (derogatory), but I do love playing video games. My Nintendo Switch and I have spent quite a bit of time together. (I’m a fan of Pokémon, LoZ: BotW, Celeste, and Omori in particular. Not that you asked.)

When I was looking for datasets to collect, I came across the Moby Games website (a site for collecting and managing game information) and thought ‘why not?’. I was curious to see what attributes give games higher ratings than others; does the type of genre or interface make a difference? Were there more popular games released in a particular year? What impact did COVID-19 have on games (if any)? And the like. Not anything I think about on a daily basis, but worth looking into.

The Ethics

Before you ask - yes, I did check the robots.txt file. It allowed me to access all the content I needed. Since I didn’t extract any names or personal info, I figured it’d be alright to share my data on the GitHub repository. If you happen to be the esteemed Moby of Moby Games and would like me to terminate my repo, email me.

And don’t worry, I was very nice with my scraping. I set a 3-5 second delay with every url my program followed, so it took about an hour to collect everything. I do appreciate and respect your website, Moby Games.

The Steps

Grabbing the first part of the data was easy, especially since it was a table - just same basic BeautifulSoup coding and I had it. But the second part was quite a nuisance. It was technically a grid object, but the find functions could not fulfill their one purpose in life. <dd> and <dl> tags don’t like cooperating, apparently. So ChatGPT and I talked over dinner, and breakfast, and lunch… we chatted (well, mostly I pleaded for help and it patiently responded) for hours to figure out how to extract the data I wanted.

Once that was figured out, I had to do something even worse: clean the data. Honestly, it was a nightmare. Whitespace, parentheses, commas, slashes, lions, tigers, and bears - I needed to clear out almost everything. Simple, right? Yes, but I also needed to turn each value in most of my columns into lists. Rather than ‘Fantasy, Sci-fi / futuristic”, I wanted [Fantasy, Sci-fi / futuristic] so I could properly analyze the data.

This is what that code looked like:

games_df_clean = games_df.copy()

#Clean specific columns using .apply()
games_df_clean['Released'] = games_df['Released'].apply(clean_released_date)
games_df_clean['Critics'] = games_df['Critics'].apply(clean_value).apply(clean_critics)
games_df_clean['Gameplay'] = games_df['Gameplay'].apply(lambda x: clean_and_split(x) if isinstance(x, str) else x)
games_df_clean['Setting'] = games_df['Setting'].apply(lambda x: clean_and_split(x) if isinstance(x, str) else x)
games_df_clean['Perspective'] = games_df['Perspective'].apply(lambda x: clean_and_split(x) if isinstance(x, str) else x)
games_df_clean['Interface'] = games_df['Interface'].apply(lambda x: clean_and_split(x) if isinstance(x, str) else x)

#Split the 'Genre' column based on commas and remove extra spaces
basic_games_df['Genre'] = basic_games_df['Genre'].apply(clean_genres)

Where clean_and_split, clean_released_date, clean_date are functions previously defined to, unsurprisingly, clean the data. You can find those in my code in Github.

I’ll spare you the rest of those details. Luckily for you, if you’re interested in scraping a similar website, you have (stupidly complicated) code in the repo linked at the bottom. Congrats.

Then the still-hard-but-not-as-bad part: EDA. Gotta say, it’s incredibly annoying that R is so similar to Python but has different syntax - I can create plots just fine in R, but I struggle a bit in Python. With the help of my dear friend ChatGPT, I eventually got through it.

So, without further ado: the dataset.

The Dataset

Unfortunately, my dataset is only games from the Nintendo Switch, and I couldn’t exactly grab the 11,774 games on the master list before Moby drop-kicked me out of their servers. So I ended up with 550 games and collected 12 features:

Title
Release year
Release date
Moby Score (Ranking)
Critics Score (Percentage)
Genre
- Puzzle, Racing/Driving…
Perspective
- 1st-Person, Behind view…
Gameplay
- RPG, Platform…
Interface
- Point and Select, Direct control…
Setting
- Fantasy, Western…
ESRB Rating
Multiplayer Options

After checking for missing values, I dropped the last two columns - they were missing 361 and 444 values, respectively, out of 550 total.

Why did I keep ‘Release year’ and ‘Release date’? Well, I collected the year before finding out about the date variable. I also wanted months, so I just grabbed the release date as well.

Having retrieved the dataset, I moved on to the summary stuff.

The Stats

Now for the exciting part: summary statistics.

The Numerical Stuff

The only numeric variables I had were the Moby Score and the Critics rating.

all_combined_df.describe()

            Score     Critics
count  550.000000  550.000000
mean     8.023273   84.336364
std      0.257217    3.365087
min      7.800000   77.000000
25%      7.900000   82.000000
50%      7.900000   84.000000
75%      8.100000   86.000000
max      9.400000   96.000000

Not particularly interesting, besides the sheer number of 0’s the function felt the need to add. The relatively high scores are par for the course, seeing as I took the top 550 games from the list, which was organized by Moby Score.

The Categorical Stuff

Now for our first categorical variable: release year!

Figure 1. - I'm sure you can... figure it out.

Well, that was underwhelming. The counts of the rest of the categorical variables look very similar to this, as can be expected. Instead of just inserting the count plot for every variable, I wanted to show you a couple comparison graphs. (Honestly, I just wanted to actually compare some of the variables I looked at because I spent a heckin’ long time on data collection.)

This one is fun. I’ll include the code for it as well:

##Stacked DataFrame

#Group the data and create a stacked DataFrame
exploded_df = all_combined_df.explode('Genre').reset_index(drop = True) #.explode is used to separate out cells with multiple values into new rows
data = exploded_df.groupby(['Year', 'Genre']).size().reset_index(name='Count')

#Create the stacked area chart
fig = px.area(data, x='Year', y='Count', color='Genre', 
              title='Games Released by Genre over Time',
              labels={'Year': 'Year', 'Count': 'Number of Games'},
              template='plotly')

fig.update_layout(margin=dict(l=0, r=0, t=40, b=40))
fig.show()

Figure 2. - A cool stacked plot of games released per genre per year.

If you’re unfamiliar with stacked area plots, they’re pretty simple - the one with the largest area has the most counts. In this case, ‘Action’ (the blue one) has the most games of all the genres. Then each other genre is stacked on top of it until the total count for the year is reached. For example, in 2018 in this dataset, there were approximately 50 Action games released, 10 Adventure games released, etcetera.

(Note the substantial dip in 2020 from both of these graphs. Unsurprising, but still neat to look at.)

I actually made six plots to use in the post, but I figured that might be too much. So here’s the last one:

Figure 3. - Not sure why I'm even putting a caption here. The image is pretty self-explanatory.

It seems like April is just a lame month for game releases in my dataset.

Anyways, that was a little bit of EDA for you to snack on. By all means, if you’re curious, go check out the dataset on my GitHub.

The Finish (The Flag, if you will)

In the end, while my glance into the world of Nintendo Switch game data didn’t turn me into a data wizard or an official Gamer™, it did give me a peek into the patterns behind the games I (and many others) love. From genre trends over time to release schedules that avoid April like the plague, every stat and visualization helped paint a bigger picture of what’s happening in gaming. So, while this may not be groundbreaking scientific research, it was pretty entertaining (and incredibly frustrating - just like a platformer). And if anyone asks, I was just gaming… for science. Wow, that was incredibly cheesy.

As for you - go take a look at the data and see if your favorite game (or just a game you know) made it on the list. Or maybe try making a plot of Setting versus Perspective and see if there’s anything interesting. I dunno, have a smidgen of fun with it.

(Like, Comment, and Subscribe?)

Links (& Zeldas)

Moby Games! GitHub :(

Putting the SCE in... 'Sceince': A Rushed Introduction to Single Cell Experiments

Wed, 02 Oct 2024 00:00:00 +0000

So, you woke up this morning and wondered "what in the heck is an SCE object?". Just kidding, no one does that. That's why I'm here to tell you about something you've never even heard about. My fellow students, don't be too alarmed by the '11 Minute Read'; you can skim it in, like, two minutes. (I'm very sorry.)

SCE Questions

Take a shot (of water!) every time I say ‘SCE object’.

What is the SCE object?

I’ll start with the basics. SCE stands for Single-Cell Experiment. So an SCE object, you guessed it, contains biological data for cells. “Why would you want to work with biological data?” you ask. “Because I’m a masochist,” I answer. No, I’m a biostatistican, but same difference. At least I’m not an actuary. Those guys really are masochists. (I’m joking!)

Anyways, the main assay, which is essentially a data frame of raw counts, is made up of thousands of rows representing certain genes and columns representing certain (biological) cells. The data I’m playing with here has 6,260 gene expressions (rows) and 65,246 individual cells (columns), meaning I have a grand total of a whopping 408,439,960 (table) cells. Yeah, it’s a lot. In fact, it has to use a sparse matrix - a matrix that collapses all cells with ‘0’ into commas - to save space. Even then, this particular object is about 1.3 gigabytes.

Where is the SCE object?

BiocManager is my best friend. You can’t have it.

Ugh, fine. Here’s how you’d install it:

install.packages("BiocManager", repos = "https://cloud.r-project.org")
BiocManager::install('SingleCellExperiment') # SCE objects are part of this package.

Of course, I have my actual SCE data given to me from my professor. Good luck finding some on your own!

Why is the SCE object?

(Yes, I’m ignoring proper grammar for the joke.)

The SCE object is a smaller part of something called single cell RNA sequencing (or scRNA-seq for short). In scRNA-seq, we capture the gene expression of individual cells, which helps us understand cellular differences in complex tissues or conditions like cancer. For example, my dataset is part of a larger one involving Renal Cell Carcinoma and identifying gene expressions that are more common in cells found in the cancerous regions than in cells found in the adjacent normal regions… what a mouthful. So, essentially, SCE objects serve as containers to store all this incredibly complex data.

Long story short: RNA tells us important stuff, we put the important stuff into Single-Cell Experiment objects.

How is the SCE object?

It’s doing well; thanks for asking.

Alright, I admit, this is getting old. But the structure of the Single-Cell Experiment is very important, and probably one of the most difficult things to explain.

Figure 1. - Thanks to Bioconductor for their well-informed guide to SCE objects. Go check that out if you want a professional explanation.

Oh, nevermind. It was pretty easy!

In all seriousness, an SCE object has an odd format. The primary assay, as mentioned before, is made of counts - it’s essentially a matrix of mostly 0s that shows which cells express which genes. But then we have… the metadata.

The metadata contains information about each cell. This is what happens when you load the column metadata on the first three cells.

load("sce.Rdata")
first.3 <- sce[,1:3]
colData(first.3)
#=> prints: 
DataFrame with 3 rows and 8 columns
                       nGene      nUMI      sample percent_mito doublet_score       batch        type       stage
                   <integer> <numeric> <character>    <numeric>     <numeric> <character> <character> <character>
AAACCTGAGAGCTTCT-9      1655      5721       S14_N 1.15962e-212    0.00133505           4           N      locAdv
AAACCTGAGTCGTTTG-9      1547      4883       S14_N  6.30512e-16    0.51172545           4           N      locAdv
AAACCTGGTGCATCTA-9      1349      2237       S14_N  5.01866e-15    0.00000000           4           N      locAdv

Where (you can skim this if you want):

nGene: number of unique genes detected in each cell
nUMI: number of Unique Molecular Identifiers (UMI)
sample: indicates sample each cell belongs to
percent_mito: percentage of UMIs that map to mitochondrial genes in each cell
doublet_score: score estimating the likelihood that a cell is a “doublet”, meaning two cells were captured as one during sequencing
batch: which batch the cell belongs to
type: indicates condition of the cell (normal or tumor)
stage: refers to stage of disease (early, locally advanced, metastatic)

Wow, I didn’t even understand most of that, and I spent six weeks with this data.

Who is the – okay, I’ll stop now.

I know, I’m hilarious. …this is probably why no one will hire me, huh. Moving on!

So now you want to analyze data.

Since I have to include some form of data science in this post, I suppose I will go over the basic things you can do with the SCE object. I am so sorry to my classmates in Stat 386. (Hopefully this counts as data science? Since it’s science… using data?)

Normalization

Unfortunately, since this is biological data, it is very much not normal. In order to perform any kind of analysis, you’re going to want to normalize it. (Sorry Python users - I’m working in R and I will not cater to your needs.)

scaled <- t(t(assay(sce, "counts")) / colSums(assay(sce,"counts"))) # Takes counts assay and divides each table cell by the sum of the column counts to scale it.
logcounts <- log1p(scaled * 10000) # Create a matrix called 'logcounts' by multiplying the scaled matrix by 10000 and performing a log transformation.
assay(sce, "logcounts") <- logcounts # Inserts the new logcounts matrix as an assay in the SCE.

The transposition stuff is just because R is whiny and doesn’t like performing operations on assays that are too tall. Me too, pal. The scaling factor isn’t set in stone, though 10,000 is a common choice in single-cell RNA sequencing since it makes the data more interpretable. It also makes it more manageable for log transformations.

Et voilà, you have a normalized count assay.

Highly Variable Genes

As you might’ve noticed, there are a lot of genes in your assay. What you can do now is simplify a bit more to only have the most variable gene expressions, which are basically just the most interesting ones to researchers (they differ the most between samples, meaning that they may be important when distinguishing cell types).

In my dataset, the most variable genes represented the most likely cells to have differences between tumorous samples and non-tumorous samples. This could provide crucial information that might be used to identify cancerous cells.

BiocManager::install("scran")
library(scran) # For the rowVars function.
rv <- rowVars(assay(sce, "logcounts")) # Calculate row variances for the logcounts assay.
highest_variance_index <- which(rv > sort(rv)[length(rv) - 5000]) # Index the top 5,000 most variable genes.
sce <- sce[highest_variance_index,] # Use that index to simplify the SCE object.

Now you can cry a little less every time you look at it.

PCA (Pretty Cool Algebra)

Figure 2. - Thanks to ResearchGate for unknowingly letting me borrow this image.

If you don’t already know, PCA stands for Principal Component Analysis. Imagine a 3D scatter plot filled with dots representing your data points. The goal of PCA is to find the best axis (or direction) that captures the most variance in that data. You can think of it as spinning the scatter plot around to identify this axis, and then squishing everything down to a 2D line along that axis. In practice, this means you’re transforming high-dimensional data (like a 65,000-dimensional space for scRNA-seq data) into a lower-dimensional space while retaining as much information as possible. It’s an eigenvector-filled way to simplify your data and visualize complex relationships.

BiocManager::install("BiocSingular") # For the fixedPCA function.
BiocManager::install("scater") # For the plotReducedDim function.
library(BiocSingular); library(scater)
sce <- fixedPCA(sce, assay.type = "logcounts")
plotReducedDim(sce, dimred = "PCA", colour_by = "type")

Figure 3. - How exciting! Blobs!

This is quite an abrupt cut-off, but I’m already running far too long and my creativity is also long gone. If you want to know more, like, comment, and subscr - no, that’s the wrong platform.

To be continued… maybe, if I’m bored enough.

And you’ve finally made it through, thank heavens.

Congratulations! You’re probably feeling pretty dang hydrated, if you followed my instructions at the beginning. I know the topic isn’t one a lot of you data science people will be using in the future, but I hope it was at least more interesting than watching paint dry on a snail.

To summarize: in this exceedingly long post, I forcibly took you on a whirlwind tour through Single-Cell Experiment (SCE) objects in R, exploring their structure, how they store complex biological data, and ways to wrangle that data into something manageable. We covered normalization techniques to make the data usable, identified highly variable genes to focus our analysis, and briefly dunked our toes into Principal Component Analysis (PCA) to visualize it all. Hopefully, this introduction gave you a basic understanding of SCE objects and how they can be used to make sense of cellular gene expression data.

If you are morbidly curious about SCEs and their applications, this link will take you to a much better guide to scRNA-seq data analysis. If you have any questions, feel free to ask, though I unfortunately am young and inexperienced and thus have many gaps in my knowledge.

Now, you have my permission to depart and never return to this post. Ciao!

Links…

…to avoid being copyrighted, sent to prison for ten years, and then returning to find my college education is obsolete and I have $200,000 in student loans to pay back but then instead of doing that I just jump off a bridge but then I survive and have to pay the medical bills as well and so I end up homeless and penniless under that same bridge in a cruel twist of fate and resort to talking about SCE objects as my busking method which somehow leads to me giving any money I have to the poor souls who walk by me and then I perish

Figure 1 Figure 2

How to create a blog post

Mon, 05 Feb 2024 00:00:00 +0000

This post will describe how to create a blog post with the proper naming conventions, as well as tips for including images and links. At the end there is a troubleshooting guide that can help with the most common problems .

Steps for creating a new post.

Create a new file in the _posts folder called YYYY-MM-DD-post-name.md, where YYYY is the year (2024), MM numeric month (01-12), and DD is the numeric day of the month (01-31). The post-name is a short name for the new post with - between words. You must use this name convention for all new posts.
Make the YML heading. All pages in the site need to start with a YML heading. For posts you should use the following header:
```
---
layout: post
title:  "Post Name"
description: Short yet informative description
image: /assets/img/blog-image.jpg
---
```
For this theme, the layout should stay as post. All the other fields should be updated with the information for your particular blog post.
If you add an image to the header information, the top banner picture will change for this post. You can also add an optional field display_image: true if you want to display a larger image just below the header image. If this happens, the banner image will return to the default.
- The blog image should be a .jpg or .png file that can be found in assets/img. Don’t make it too large or the page will take longer to load (500-800 KB is a good size). Leave the file path as /assets/ing/ in the header area.*
- Adding a post image will also display the image in the “next” or “previous” post location.
Write the body of the blog using markdown. There are a lot of references for markdown available. I like the Markdown Guide because many of the examples show both the markdown and the html code. There are separate pages for basic syntax, extended syntax, and a cheatsheet for quick reference.

Links

To create a link (internal or external), enclose the link text in brackets (e.g., [Statistics Department]) and then follow it immediately with the URL in parentheses (e.g., (https://statistics.byu.edu)).

For example:

My favorite department at BYU is the [Statistics Department](https://statistics.byu.edu).

My favorite department at BYU is the Statistics Department

If you want external links to open in a separate window, you will need to use html code with target="_blank" inside the a tag.

For example:

My favorite department at BYU is the <a href="https:statistics.byu.edu" target="_blank">Statistics Department</a>

My favorite department at BYU is the Statistics Department

Internal Links and Files

If you want to have a link that points to another location on your site or if you want to include a file (such as an image or video) you must use the site.url and site.baseurl variables when making the link reference. For example, this link to pointing to the About page is coded as:

[About]({{site.url}}/{{site.baseurl}}/about)

Paths to files should also be referenced with the site.url and site.baseurl variables (see the section on Adding Images).

Adding Images

In the examples below, if your image ends with .png or .JPEG, use the appropriate extension instead of .jpg.

Images for the blog will generally but put into the assets/img folder. (You can also create a subfolder for images, but you will need to include the subfolder name in the reference link.)

Markdown syntax for including images is ![Fig Name](path/to/image). For example:

![Figure]({{site.url}}/{{site.baseurl}}/assets/img/image_name.jpg)

Resizing images

The image I added in the previous section seems a bit large for this post. Unfortunately, there isn’t a good way to resize images with markdown, so if you need to resize an image, use html instead of markdown and specify the width in the style parameter as follows:

<img src="{{site.url}}/{{site.baseurl}}/assets/img/image_name.jpg" alt="" style="width:300px;"/>

(Example with width set to 300 pixels)

(Example with width set to 100 pixels)

Troubleshooting

Here are some things to keep in mind if your blog appearance isn’t going as you planned:

Problem: The blog post that I created isn’t appearing

Possible Solutions:

Check your date. GitHub pages won’t display blog posts with future dates
Check the name of the post file. It must be in the form “YYYY-MM-DD-title.md”. Make sure that you included the .md extension
Check the yaml header. If there are any special characters in any of the fields, you need to use quotes around the entire field entry. The most common culprit is the description. If you’re having trouble, try putting quotes around the entire description

Problem: I know that I made changes to a blog post but the changes aren’t appearing

Possible Solution:

Check the header. If there are any special characters in any of the fields, you need to use quotes around the entire field entry. The most common culprit is the description. If you’re having trouble, try putting quotes around the entire description.

Problem: My entire blog has weird formatting

Possible Solution:

Usually this is an address problem. Double check your url and baseurl in the _config file

Example Post Formatting

Mon, 15 Dec 2014 00:00:00 +0000

Curabitur blandit tempus porttitor. Nullam quis risus eget urna mollis ornare vel eu leo. Vestibulum id ligula porta felis euismod semper. Donec sed odio dui. Aenean lacinia bibendum nulla sed consectetur.

Heading 1

Heading 2

Heading 3

Heading 4

Heading 5

Heading 6

Aenean lacinia bibendum nulla sed consectetur. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. Cras mattis consectetur purus sit amet fermentum. Nulla vitae elit libero, a pharetra augue. Curabitur blandit tempus porttitor. Donec sed odio dui. Cras mattis consectetur purus sit amet fermentum.

Nullam quis risus eget urna mollis ornare vel eu leo. Cras mattis consectetur purus sit amet fermentum. Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit. Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor.

Unordered List

List Item
Longer List Item
- Nested List Item
- Nested Item
List Item

Ordered List

List Item
Longer List Item
1. Nested OL Item
2. Another Nested Item
List Item

Definition List

Coffee: Black hot drink
Milk: White cold drink

Donec id elit non mi porta gravida at eget metus. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Maecenas faucibus mollis interdum. Donec sed odio dui. Cras justo odio, dapibus ac facilisis in, egestas eget quam.

Table

Syntax	Description
Header	Title
Paragraph	Text
Header	Title
Paragraph	Text

Code Snippet

def print_hi(name):
  print("Hi" + name)
print_hi('Tom')
#=> prints 'Hi, Tom'.

Figure with Caption

Figure 1. - This is an example figcaption

<figure>
	<img src="{{site.url}}/{{site.baseurl}}/assets/img/touring.jpg" alt="">
	<figcaption>Figure 1. - This is an example figcaption</figcaption>
</figure>