How can Album help you?

Motivation

Often, researchers are confronted with the problem of how to solve a certain problem for which they know a solution exists. Unfortunately finding the correct tool/app/workflow and then installing and learning how to use it sometimes takes much time, if possible at all.

This is why we developed Album, a decentralized tool for sharing solutions to specific problems across tools, languages and scales. But not only enables it sharing and categorizing solutions, moreover installation and usage is made possible without spending effort into learning yet another UI or yet another commandline handling.

Specific solutions, developed in various programing languages, live in a catalog which can be accessed publicly. These catalogs are visualized and can be browsed through from (almost) all over the world. Thereby, not only simply listing solutions but providing rich metadata and documentation. With Album, solutions can then directly be installed and executed.

What does it look like to use Album in practice?

So, up to know we know there is a framework dealing with solutions of any kind and there are catalogs that enable access to solutions including meta information, documentation and more.

OK, but how would you use it in a daily manner?

You would...

• build solutions for your daily tasks
• use solutions to execute your daily routines
• share solutions with others in the lab
• register solutions in a public catalog to distribute it beyond your lab
• update old solutions
• set up a specific catalog for specific use cases

How do we make solutions findable?

Nice, working with Album seems practical, but I still don't understand how to make them available?

OK! This is where a catalog comes into play.

A catalog can have a web view that lists all available solutions. So you can simply browse them online. When devoting a catalog a certain topic, you could even find solutions faster.

That is how solutions are findable.

You can look at this page to get a feeling for a web representation.

Why should we care about reproducibility?

By now you should know what solutions are, where they live and how they can be used. But a short but very important question remains: Why?

Well, imagine the following scenario: You execute these lines of python code

import matplotlib.pyplot as plt
import numpy as np
from skimage.transform import rotate

image = np.ones((20, 20))
image[5:-5, 5:-5] = 2

fig, axs = plt.subplots(1, 6, figsize=(13, 2))

for i in range(6):
    axs[i].set_title(f'order={i}')
    axs[i].imshow(rotate(image, 30, order=i, cval=0, resize=True, clip=True), vmin=0, vmax=3)

plt.show()

Now you look at the results and see this:

Now imagine someone else is using the exact same code - but his results look like this:

What happened?

Simply said, these code was run each with different dependency versions installed (in this case scikit-image).

Since there is no specification of any versions of the used packages in the code above known bugs like this change the results. Sometimes even drastically!

And something like this happens. And it is not uncommon. So to make sure the scientific results you produced can be used by someone else without introducing errors simply because old versions or faulty libraries were used - we should care about reproducibility!

So it would be better to specify with the code what requirements are needed. In pseudocode something like this:

with python==’3.8.8’,matplotlib==’3.5.3’, scikit-image==’0.19.2’:
    import libraries

    create_or_load_image()
        
    for number "i" 1 to 6:
        plot_rotated_image_with_interpolation_order(i)
    

Throughout this course you will learn how to use Album and solve the problem from above.

Technical concepts [optional]

OK, How would something like this framework even work?

If you are interested in the technical concept have a look at the following schema.

Here is what you need to take away from that:

• the collection gathers all catalogs and their solutions at one place
• catalogs hold solutions and are git repositories that can exist on github/gitlab or anywhere on a (network)-drive
• each solution has its own environment (or inherits its environment from another solution)