Winogradsky Columns!

For anyone who’s been following the Seagrass Microbiome Project you’ll know that we’ve had a long-running Winogradsky column side project running, courtesy of Jenna Morgan Lang who first had the idea to incorporate them into Seagrass Microbiome project and leverage the power of citizen scientists. Working with the columns over the past year has turned me into a die-hard Winogradsky fan.  Even though I’ve just changed labs for graduate school my Winogradsky adventures are just beginning.

At this point, you may be asking, “What exactly are these super-useful, super-cool Winogradsky column things?”

Sergei Winogradsky, one of the founders of microbial ecology possessed both a great brain and a great mustache. (Some people have it all).

Sergei Winogradsky, one of the founders of microbial ecology possessed both a great brain and a great mustache. (Some people have it all). (Photo credit: Wikimedia Commons)

A Winograsky column is an experimental tool invented by Sergie Wiongradsky in the late 1800s. Winogradsky was studying how microbes interact in communities and he developed these columns while studying microbial metabolism. Since their invention, Winogradsky columns have been used in numerous experiments to study microbial community interactions or to try to isolate unruly microbes through a process called enrichment culturing.

For all their usefulness, the columns are surprisingly simple. The general recipe to make one is:

  1. Fill a clear, seal-able container with a substrate (traditionally this is mud).
  2. Add some nutrients
  3. Add some microbes from the environment (these are already along for the ride if you use mud as your substrate).
  4. Top off the container with water and seal it.
  5. Wait for the microbes to grow.

That’s it!

A schematic of a typical* Winogradsky column. The sunlight bar only applies to the center core of the column since the edges are exposed to light if the container is clear. *In real life, colors may vary.

A schematic of a typical* Winogradsky column. The sunlight bar only applies to the center core of the column since the edges are exposed to light if the container is clear. *In real life, colors may vary. (Image credit: NASA Ames: http://quest.arc.nasa.gov/projects/astrobiology/fieldwork/ed.html)

The coolest part about Winogradsky columns is how those microbes grow. The bottle becomes divided into many mini-habitats based on an oxygen gradient formed from the water and oxygen. A sulfur gradient also forms, since the microbes at the bottom of the column use sulfur as a substitute for oxygen. Microbes grow only in the habitats most favorable to their particular lifestyle. Over the course of a couple of weeks, layers or patches of colorful microbes begin to grow. Ideally, each successive layer eats the waste products of the layers surrounding it and a perfectly sustainable ecosystem is established.

Since Winogradsky columns are so important and because they’re so easy to make, the outreach coordinators for my department and I decided to host a teacher workshop to train teachers to make these columns in their classrooms.

One of the perks of helping with the workshop is that I get to make example columns. Here are some pictures from our columns as they’ve established.

 

The mud columns on their first day. Each column has a different combination of nutrients, paper for a carbon source or egg yolk for a sulfur source. One is a control column which we didn't add anything to.

The mud columns on their first day. Each column has a different combination of nutrients, paper for a carbon source or egg yolk for a sulfur source. One is a control column which we didn’t add anything to.

Instead of mud, these columns have diatomaceous earth as a substrate. This will make it easier to see the microbes growing. We had two treatments, one with three times as many nutrients as the other. We used stream water mixed with stream mud to seed the columns.

Instead of mud, these columns have diatomaceous earth as a substrate. This will make it easier to see the microbes growing. We had two treatments, one with three times as many nutrients as the other. We used stream water mixed with stream mud to seed the columns.

 

 

 

 

 

 

 

We have two sets of columns, fast-growing, nutrient spiked diatomaceous earth columns and slow-growing, traditional mud columns. We added extra nutrients to the fast-growing columns, they were also in a form directly usable to the microorganisms since we were hoping to jump-start the growth process before our workshop.

The higher-nutrient column after almost 3 weeks. Layering is beginning to show on the surface.

The higher-nutrient column after almost 3 weeks. Layering is beginning to show on the surface.

The lower-nutrient column after almost 3 weeks. Layers have yet to form on the top, but the salt-and-pepper growth in the base has established.

The lower-nutrient column after almost 3 weeks. Layers have yet to form on the top, but the salt-and-pepper growth in the base has established.

The diatomaceous earth makes it easy to see the changes taking place. In mud columns, it’s often difficult to see what’s happening until quite far along in the process.

The mud columns we created are much slower to show their growth. Instead of adding the chemical compounds directly, we added common items that contain those nutrients. For carbon, we added paper scraps, for sulfur we added an egg yolk.

The mud columns are also less homogenous than the diatomaceous earth columns. Because it’s hard to completely compact mud into the water bottles, our mud columns have little pockets of empty space (and possibly oxygen) trapped at different levels in the column. These pockets are additional micro-habitats and will probably be colonized by different organisms than the surrounding soil.

The mud columns after about 5 weeks of growth. It's impossible to see in this picture but the columns show very tiny smudges of red microbes growing on the edges.

The mud columns after about 5 weeks of growth. It’s impossible to see in this picture but the columns show very tiny smudges of red microbes growing on the edges.

We know the mud columns were growing because they were producing large amounts of noxious-smelling gas, but it took a good 5 weeks for anything visible to show up. After 8 weeks of growth, the mud columns are finally beginning to show some larger visible signs of life and the microhabitats are turning green (probably with cyanobacteria).

At 8 weeks we can finally begin to see green around the edges of each pocket in the mud.

At 8 weeks we can finally begin to see green around the edges of each pocket in the mud.

At 8 weeks, the red smudges on the side of the columns have grown big enough that a cell-phone camera can capture them.

At 8 weeks, the red smudges on the side of the columns have grown big enough that a cell-phone camera can capture them.

 

 

After 6 weeks the diatomaceous earth columns have completely changed. The top of the higher-nutrient column has become dominated by red organism. The layer of green we saw at 3 weeks has completely disappeared and there is a neon-green microbe growing in a pocket partway down the column.

 

The high-nutrient column at 6 weeks.

The high-nutrient column at 6 weeks.

The low-nutrient column after 6 weeks.

The low-nutrient column after 6 weeks.

 

The low-nutrient column after 6 weeks looks like it’s on its way to the same fate. Stay tuned for more pictures as the columns mature!

 

 

 

 

 

If, after reading this, you’ve decided that you agree with me and that Winogradsky columns are the coolest, here are a couple of links explaining how you can make your own. If you make a column, don’t forget to send me pictures in the comments or on Twitter!

http://quest.arc.nasa.gov/projects/astrobiology/fieldwork/lessons/Winogradsky_5_8.pdf

http://www.scientificamerican.com/article/bring-science-home-soil-column/

http://www.ncbi.nlm.nih.gov/pmc/articles/PMC4416514/

 

Advertisements
Posted in Blog | Tagged , | Leave a comment

Visualizing Microbiome Data: Choropleth Style

Recently I’ve needed to visualize spatial changes in my microbiome data that are easily interpretable by other people. The best solution I’ve come across is simply projecting the data onto a drawing of my organism. Like this:

Zostera marina high resolution

Alpha diversity of samples from pieces of a seagrass plant projected onto a drawing of that plant.

I’ve used SitePainter to produce these in the past, and in some ways it’s great. I got the figure I wanted and I’ve received a lot of positive feedback about it. The only problem is it has a steep learning curve and is the most dysfunctional GUI I’ve ever come across (generating the figure above took several days of my time, the first time). So when it became necessary to produce over forty more images like it I decided to search for a better way.

My first instinct was that there should be an easy way to do it in R, after all people produce pretty colored maps in R all the time. I reasoned it shouldn’t be too hard to feed the program an SVG file instead of a map and project my data onto that. It turns out I was wrong. Making a choropleth (the fancy name for a map colored by data) is incredibly difficult if your image file does not have latitude and longitude coordinates.

After many hours of searching the internet I was starting to wonder whether I should give up when I found this great tutorial about creating choropleths in python from an SVG file. It was super helpful and I’ve used my dubious python “skills” to modify it slightly to produce many maps instead of just one. If all you need is one map, I highly encourage you to use the original script from the tutorial, it’s a great little script and a lot less messy than my own. If you need to loop through many columns of data and produce many maps at once, my script may be more useful.

So without further ado, I’ll take you through my process to go from this…

zosteramarina3 and this…              Screenshot from 2015-05-06 15:00:21

…to this:
k00390


The first thing you’ll need is an SVG file. A lot of clipart comes in this format and some vector-editing programs (like Adobe Illustrator or the open source option, Inkscape) will even convert images into vector format. When you’re creating your picture, you’ll need to make sure that every unit you want colored is represented by a single polygon (an object you can “fill” in the program).

Once you’ve finished producing your graphic you’ll need to make sure that each of the polygon paths has a name that corresponds to the sample name you want to color it by. In Inkscape you can do this by editing the ID field of the Object Properties window (to see the Object Properties dialog press Shift+Ctrl+O). As with anything that involves coding it’s probably a good idea to avoid strange characters in the names you choose it’s also important that each ID in your picture is unique.

Naming objects with sample IDs in Inkscape.

Naming objects with sample IDs in Inkscape.

The next thing you’ll need is a data file. The file should be a tab delimited text file. Each row should be a different sample and columns should represent the data you want to project onto the image. In my case, I’m projecting predicted KEGG ortholog counts onto an image of seagrass. The first column of this file should be the IDs you used to name the polygons and should be titled “SVGID”.

Screenshot from 2015-06-04 15:05:37_redbox

With your data file and your SVG file in hand you’re ready to color your picture. Let’s take a look at the script:

#/usr/bin/python
### color_map.py

from BeautifulSoup import BeautifulSoup
import pandas as pd

##Map Options:

#Map color Options:

#greens
#colors = ["#f7fcf5", "#e5f5e0", "#c7e9c0", "#a1d99b", "#74c476", "#41ab5d", "#238b45", "#006d2c", "#00441b"]

#blues
colors = ["#fff7fb", "#ece7f2", "#d0d1e6", "#a6bddb", "#74a9cf", "#3690c0", "#0570b0", "#045a8d", "#023858"]

#blue-purple color-brewer palette
#colors = ["#f7fcfd", "#e0ecf4","#bfd3e6", "#9ebcda","#8c96c6", "#8c6bb1", "#88419d", "#810f7c", "#4d004b"]

#purple
#colors = ["#fcfbfd", "#efedf5", "#dadaeb", "#bcbddc", "#9e9ac8", "#807dba", "#6a51a3", "#54278f", "#3f007d"]

#Reading in the Metadata CSV file as a pandas data frame:
df = pd.read_csv('/path/to/your/csv/file/here.csv', sep="\t")

#Creating dictionary of IDs and KO values
svgid = df.iloc[:,0]
KO_id = list(df.columns.values)
del KO_id[0:1]
dictionary = df.set_index('SVGID').T.to_dict()

# Load the SVG map
svg = open('path/to/your/svg/file/here.svg', 'r').read()

# Load into Beautiful Soup
soup = BeautifulSoup(svg, selfClosingTags=['defs','sodipodi:namedview'])

# Find polygon paths
paths = soup.findAll('path')

# Number of color increments to be used
groups = 9 

# Polygon style
path_style = 'font-size:12px;fill-rule:nonzero;stroke:#000000;stroke-opacity:1;stroke-width:1.0;\
stroke-miterlimit:4;stroke-dasharray:none;stroke-linecap:butt;marker-start:none;\
stroke-linejoin:bevel;fill:'

# Create SVG for each KO
for i in KO_id:
    # Color the polygons based on KO counts
    min_value = float(min(df.loc[:,i])); max_value = float(max(df.loc[:,i]))
    increment = (max_value - min_value)/float(groups)
    print i
    print "Min = %s" %min_value
    print "Max = %s" %max_value
    print "Increment: %s" %increment

    for p in paths:

        try:
            kegg = dictionary[p["id"]][i]
        except:
            continue

        if kegg > (max_value-increment):
            color_class = 8
        elif kegg > (max_value-increment*2):
            color_class = 7
        elif kegg > (max_value-increment*3):
            color_class = 6
        elif kegg > (max_value-increment*4):
            color_class = 5
        elif kegg > (max_value-increment*5):
            color_class = 4
        elif kegg > (max_value-increment*6):
            color_class = 3
        elif kegg > (max_value-increment*7):
            color_class = 2
        elif kegg > (max_value-increment*8):
            color_class = 1
        else:
            color_class = 0

        color = colors[color_class]
        p['style'] = path_style + color

        #create file to write to:
        svg_name = "/path/to/svg/output/file/choropleth_" + str(i) + ".svg"
        svg_c = open(svg_name,'wt')
        svg_c.write(soup.prettify())
        svg_c.close()

There are a couple of things you’ll need to change and some things you may want to edit.

What you must change:

Your data file:
On the line below you’ll want to put the path to your data file in the first set of single quotes.

#Reading in the Metadata CSV file as a pandas data frame:
df = pd.read_csv('/path/to/your/csv/file/here.csv', sep="\t")

Your SVG file:
On the line below you’ll want to put the path to your SVG file in the first set of single quotes.

# Load the SVG map
svg = open('path/to/your/svg/file/here.svg', 'r').read()

What you might want to change:

The palette:
I have several palettes of different colors commented out at the top of the code. To use one simply change which line is commented out. You can also create your own palettes using the same format. The online tool Color Brewer (http://colorbrewer2.org/) creates palettes for just this kind of use and can be very helpful for finding new palettes.

The number of bins (recommended for more advanced users only):
The data you provide is separated into a number of equally-sized bins for color-coding you can control this number by changing the groups number in this line:

# Number of color increments to be used
groups = my_group_number

The name of the output file:

        #create file to write to:
        svg_name = "/path/to/svg/output/file/choropleth_" + str(i) + ".svg"

I’ve set it at nine but you can set to what you want. Just remember, you must have the same number of colors in your palette as bins for your data and you need to change the loop accordingly.

Once you’re done editing, run your script and enjoy!

Posted in Blog | 1 Comment

Musings from the Davis Undergraduate Research Conference

Last week, I finally experienced the dreaded Poster Presentation. After months of lab work and many frustrating hours tearing my hair out in front of a computer, I faced the most important part of this insane process we call science: sharing my results with others.

I have to admit, up until the day of the conference, I wasn’t really taking it seriously. It was only the undergraduate research conference and no one except myself would care if I messed up (undergraduates are generally assumed to be incompetent until proven capable). If anything, I was vaguely annoyed that my honors program required me to participate because it was a distraction from my research. I should have been working in the lab trying to finish gathering data not talking about the preliminary results!¹ Basically, my attitude leading up to the conference at best ambivalent and at worst annoyed.

I figured that since I was required to participate, I might as well get something useful out of the experience so I chose to present a poster, having never presented one before. I also spent a surprising amount of time working on the poster, partly because I like playing with graphics programs, partly because I hate turning in shoddy work, but mostly because I felt I owed it to my lab to reflect well on them.

The day of the conference finally arrived. The poster was printed, we Eisen lab undergraduates prepared ourselves for potential questions, and showed up on Friday afternoon with hundreds of other undergraduates to pick up badges and abstract books before pinning up our posters.

Overall, I was feeling pretty confident especially after I handled the first couple of casually curious onlookers with ease.

“Could you walk me through your poster, please?”

“What does this picture actually mean?”

“I’ve never heard of alpha diversity, could you please explain it?”

The whole affair still felt very gimmicky, but since I love to talk about my research, I was having a pretty good time.

Then everything changed quite suddenly. In the middle of talking to a former professor about my work I realized I was feeling stupid. Quite stupid. Embarrassingly stupid. My formerly confident responses had turned into:

“That’s something I’ll have to look into…”

“That’s a good idea, I hadn’t considered that…”

and, of course, the most dreaded of all answers:

“I don’t know…”

This particular professor has a well-earned reputation for teaching a challenging course that is universally dreaded by students. He’s incredibly sharp, an excellent scientist and has perfected the ability to expose holes in dubious logic. Talking to him is always an intellectual challenge, but during the poster session, it felt like walking on a tight-rope over a pit of lava. At any minute I would plummet to my death. All of my earlier confidence evaporated, I felt woefully under-prepared and my data seemed inadequate. I dreaded the inevitable pointed question that would expose gaps in my knowledge I hadn’t even known were there.

Needless to say, I was terrified. But at same time the whole experience was strangely exhilarating. Finally, the professor left, and several other people came in to ask me detailed questions before the session ended, but nothing came close to the grueling scrutiny of his questions.

After the poster session the whole lab went out to a celebratory dinner. Throughout the evening, my mind kept returning to the conversation with the professor. Somewhere during that conversation my ambivalence had turned to fearful exhilaration as I saw my work challenged and narrowly pass the close inspection of a knowledgeable outsider. I now understand better than ever before, the importance of his scrutiny. Under its influence, I was forced to consider the problem from other angles. Was my solution really the best? How could I improve it? Why hadn’t I thought of this other interpretation of the data? Sure, I had felt stupid, but that was a small price to pay for the knowledge and awareness I had gained.

As scientists, we are never more scientific than when we are critiquing and being critiqued by others. It forces us to defend our ideas and consider new possibilities, to bend our brains around foreign concepts, and perhaps most importantly, acknowledge our own stupidity and humbly accept the unexpected lessons whenever and wherever they appear.

I’m sure none of this is news to any of the scientists out there, nor to my research mentors, nor to the people who decided honors students needed to present at the research conference but I’m glad I’ve had the chance to discover it organically.

I guess the Undergraduate Research Conference turned out to be pretty educational after all. And now, like any scientist, I’d like acknowledge everyone who helped me: all of my mentors in the Eisen Lab, those who took time to stop by and be curious about my poster, and of course the professor who questioned me so thoroughly, you have all been excellent teachers.


 

¹This is possibly a symptom of a larger problem: I may be spending too much time with jaded graduate students.

Aside | Posted on by | Leave a comment

“A leaf is not a petri dish” (a lesson from Steven Lindow)

Earlier this quarter I had the fortune to attend a guest lecture by Steven Lindow of UC Berkeley. Lindow is a renowned expert in plant-microbiology who has worked on some pretty cool projects over the years (he was one of the first to work with ice-causing bacteria).

His lecture to us focused on his research with bacterial communities on leaves. One of the most surprising messages of the presentation was how inhospitable leaves are to microbes. Unlike microbes grown in labs that live on moist, nutrient-rich petri dishes, microbes living on exposed leaves face unique environmental challenges, most prominently the lack of water and the exposure to sunlight.

It turns out that to a bacterium, a leaf is much like the Saharan desert, mostly uninhabitable, except for small “oases” around which they cluster in aggregates and produce an extracellular, polysaccharide matrix (i.e. they make sugar slime) to protect themselves from the sun and dehydration. Because of these challenges, bacteria living on leaves tend to gather around the edges, veins and pores of the leaf where nutrient and water concentrations are highest.

image

A microscopic view of a leaf and stoma (pore). Bacteria often build up around pores and other moist and nutrient-rich areas on the surface of leaves.
Source: http://en.wikipedia.org/wiki/File:Tomato_leaf_stomate_1-color.jpg

In many cases, competition with local well-adapted wildlife can discourage a newly introduced species from establishing itself. But paradoxically if you’re a bacterium falling through the air onto a leaf, your best bet is actually to move into a crowded neighborhood. Sure, you might have to fight for a meal but at least with other bacteria around you’ll have a better chance against the environment.

So if your goal is to reduce the number of human pathogens on leaf surfaces (a big problem in the fresh fruit and vegetable industry), you might actually want to try targeting the non-pathogenic bacteria as well as the pathogenic ones, because without the work and special adaptations of native plant bacteria, there is very little chance that a pathogen that is well-adapted to the human gut will survive the dry environment of a leaf.

All of this discussion of bacterial leaf communities left me pondering my own project which will involve studying the microbes on an aquatic plant system. After hearing about the moisture-based limitations of land plant leaves I wondered: if water is the limiting factor in land-plant bacterial growth, what is the limiting factor in a water-dwelling plant? I asked Professor Lindow and he thought that an aquatic environment might face pressure in the form of predation from larger planktonic organisms. Although by the end of my project, we’ll still be far away from having enough data to answer such questions, it’s an interesting area of exploration to save for later.

Posted in Blog | Leave a comment

JContextExplorer 2.0

So about a month ago, Phillip Seitzer, a member of the Facciotti Lab (just next-door to the Eisen Lab) was taking aside undergraduates to test drive his newest piece of software. I ended up being one of those undergraduates and had the privilege to get a personal tour of JContextExplorer 2.0.

JContextExplorer is a java-based program that allows you to compare genes and their neighboring regions across different organisms. But best of all, unlike many of the free software tools available to biologists, JContextExplorer is a GUI (graphical user interface).

Look at the GUI, isn't it shiny?

Look at the GUI, isn’t it shiny?

Although it’s becoming more and more common for biologists to have a strong computing background, many do not which makes it difficult for them to take full advantage of many of the analysis tools available to them. JContextExplorer aims to change that by providing a user-friendly non-command line-based interface that allows researchers to explore and interpret their genomic data. Furthermore, Seitzer is passionate about making his software user-friendly and has even gone so far as to create video tutorials demonstrating the use of his software.

At the moment, none of my research projects require a tool for exploring genetic contexts, but that didn’t stop me from having fun playing around. If you have any interest in Biology or Genetics, I suggest you do the same. It’s fun and you may find yourself inadvertently learning (which is the best type of learning).

Posted in Blog | Tagged , , | Leave a comment

Adventures With Qiime Part 1

So I’m in the process of learning how to use Qiime (pronounced ‘Chime,’ don’t ask me why). Qiime is a powerful program that can do many, many things, but I’m primarily using it to sort 16s reads and assign them to taxonomic groups. If that sentence made very little sense to you, think of it like this: Qiime is sorting genetic information into ‘buckets’ based on which organism it thinks the genes (specifically the 16s gene) belongs to. Qiime’s a really useful tool because, among other things, a)it can often sort better than humans could and b)it’s definitely faster than humans would be.

Qiime is run from the command line which can be daunting at first but is a little bit fun as well because playing with the command line always makes me feel powerful. 🙂 Unfortunately, because it is run from the command line it can also be an incredibly frustrating process because the smallest typo can result in an error.

The data set I’m using to familiarize myself with Qiime comes from seagrass samples, but I’m not looking at the seagrass DNA. I’m actually looking at the DNA of the microbes (specifically the bacteria) that live in and on the seagrass.

The first thing I did was install Qiime. This went pretty well, and because I have Linux on my computer I didn’t have to install a virtual box to run it for me. Then I followed the helpful tutorial on the Qiime website. Some of the steps in the tutorial aren’t applicable to my data because it’s the result of Illumina sequencing, not 454 sequencing but the general steps are the same.

Overall things have gone pretty smoothly except for the time component being a lot longer than I expected. The second script I ran (
pick_de_novo_otus.py -i split_library_output/seqs.fna -o otus
) took all night and a good portion of the day to finish.

Now I’m in the process of cleaning up the output of that script. The script produces a table of OTUs (Operational Taxonomic Units; you can think of them as the buckets I mentioned earlier). The table contains a lot of interesting information about the bacterial communities on the plants but at this point in the process, it’s still too messy to analyze. Since I’m working with plant samples, I have to be careful about chloroplast data showing up along with the bacterial data. The chloroplasts from the seagrass and bacteria both have the 16s gene and because I’m not interested in the chloroplasts I have to filter them out before I begin to interpret the data. (If you want to know more about why this would happen check out the very cool Endosymbiotic theory).

Once the cleaning process is done I’ll be able to visualize the data.

Posted in Lab Notebook | Tagged , , | Leave a comment

Hello!

Well, time to get this show on the road!

Hello, I’m Hannah. I’m a fourth year undergraduate studying Biochemistry, Bioinformatics and History (for fun!) at the University of California, Davis. I’m currently working in the Eisen lab so you can expect to see a lot of posts related to my work there. Once classes start up again in the fall I’ll also be blogging about anything interesting and science-y that happens to come up there as well. One of my favorite things to do (besides learning the information in the first place) is to talk about the interesting things that I’ve learned with other people. If you’re like me and like hearing and discussing new, exciting science we should get along swimmingly! (Such a great word, ‘swimmingly.’)

To give you a little bit of background before I start blogging, here’s what’s going on for me at the moment:

  • I’ve just returned from studying abroad for a year and at the moment I’m still unattached to any specific project at the lab.
  • Though my hope is to spend the upcoming year carrying out an independent research project.
  • Before I decided to abandon the country for a year, I was working on the Undergraduate Genome Project. In which several other undergraduates and I collected samples from a variety of built-environment locations and chose an organism to take through the sequencing process.
  • Currently I’m helping out on a variety of lab projects but recently I’ve spent most of my time working with samples from a second undergraduate project, the Undergraduate Aquarium Project, which focuses more on the metagenomics of  aquariums.
  • I’m also trying to familiarize myself with a number of common bioinformatics tools and teach myself a bit about scripting because I always feel pretty lost when it comes to that side of the research.

That’s most of it for now, read and enjoy. Oh, and please feel welcome to comment! I’d love to hear from you!

Posted in Blog | Leave a comment